// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

import {AccessControlEnumerable} from "@openzeppelin/contracts/access/extensions/AccessControlEnumerable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {
    PurchasePermitWithAllocation,
    PurchasePermitWithAllocationLib
} from "sales/permits/PurchasePermitWithAllocation.sol";

/// @title  MegaSale
/// @notice Public sale contract for the token offering by MegaETH
///
/// @dev
/// The sale is designed to raise funds in USDT through a competitive English auction.
/// This contract functions solely as an escrow for user commitments: it records deposits, enforces limits, and handles refunds and withdrawals at the end of the sale.
/// Auction mechanics, including clearing price determination and token allocations, take place entirely offchain, with final results provided to the contract by the settlement process.
///
/// # Sale Stages
///
/// The sale progresses through several stages:
///
/// 1. **PreOpen**: Initial state, no commitments allowed
/// 2. **Auction**: Any user can submit bids with price, amount, and lockup preferences
/// 3. **Closed**: Auction automatically closes after 30 minutes of inactivity
/// 4. **Cancellation**: Potentially winning entities can cancel their bids and definite non-winners can claim their refunds
/// 5. **Settlement**: Offchain auction clearing, allocation computation and onchain allocation setting
/// 6. **Done**: Processing refunds and withdrawing proceeds
///
/// ## Auction Phase
///
/// The auction phase allows any user with a valid purchase permit (issued by Sonar) to participate by submitting bids that include price,
/// amount, and lockup preferences.
/// Each new bid replaces the previous bid for the same entity, and bids follow a monotonic constraint where amounts and prices can only increase.
/// Lockup preferences can be enabled but cannot be disabled once set, and forced lockup can be required for specific entities as specified on the purchase permit.
///
/// Total commitment per entity cannot exceed the max amount specified on the purchase permit (expected to be 186,282 USDT).
/// Bid prices are constrained by the maximum price specified on the purchase permit, this price is determined offchain, dynamically
/// from the current clearing price to ensure that bid prices remain within bounds.
/// The auction automatically closes after 30 minutes of inactivity, though admins can manually override this mechanism if needed.
///
/// ## Cancellation Phase
///
/// Allocations are computed offchain following an English auction clearing mechanism based on the submitted bids, and the current clearing price is posted to the contract.
/// Any entity with a bid price greater than or equal to the threshold price (potential winners in the later settlement) can cancel their bid and claim their refund.
/// Any entity with a bid price less than the threshold price (definite non-winners) can claim their refund ahead of the settlement.
/// The practical difference between a cancellation and a refund is that a cancellation can only be triggered by the entity themselves, whereas a refund can also be triggered by addresses with the REFUNDER role.
///
/// ## Settlement Process
///
/// Allocations are computed offchain based on the submitted bids and offchain user data.
/// The settler role is responsible for setting allocations for each participating entity onchain.
///
/// ## Refund and Withdrawal
///
/// Refunds are calculated as the difference between total commitment and allocated amount, processed in USDT directly to the entity's address.
/// Refunds can be triggered by anyone for any entity, providing flexibility in the refund process.
/// The total allocated USDT is withdrawn to the proceeds receiver.
///
/// # Token Distribution
///
/// The distribution of tokens purchased through the allocated amounts is outside the scope of this contract and will be handled separately by the project team.
///
/// # Technical Notes
///
/// All prices throughout the contract are in units of the price tick of the English auction, i.e. 0.0001 USDT / Token.
/// The maximum price and amount a user can bid are specified offchain and are passed to the contract as part of the purchase permit.
///
/// @custom:security-contact [email protected]
contract MegaSale is AccessControlEnumerable {
    using SafeERC20 for IERC20;
    using SafeERC20 for IERC20Metadata;
    using EnumerableSet for EnumerableSet.Bytes32Set;

    /// @notice The role allowed to recover tokens from the contract.
    /// @dev This not intended to be granted by default, but will be granted manually by the DEFAULT_ADMIN_ROLE if needed.
    bytes32 public constant TOKEN_RECOVERER_ROLE = keccak256("TOKEN_RECOVERER_ROLE");

    /// @notice The role allowed to sign purchase permits.
    bytes32 public constant PURCHASE_PERMIT_SIGNER_ROLE = keccak256("PURCHASE_PERMIT_SIGNER_ROLE");

    /// @notice The role allowed to set the manual stage and stage related parameters.
    bytes32 public constant SALE_MANAGER_ROLE = keccak256("SALE_MANAGER_ROLE");

    /// @notice The role allowed to set allocations for auction clearing.
    bytes32 public constant SETTLER_ROLE = keccak256("SETTLER_ROLE");

    /// @notice The role allowed to pause the sale.
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    /// @notice The role allowed to refund entities.
    bytes32 public constant REFUNDER_ROLE = keccak256("REFUNDER_ROLE");

    error InvalidSaleUUID(bytes16 got, bytes16 want);
    error PurchasePermitExpired();
    error InvalidSender(address got, address want);
    error UnauthorizedSigner(address signer);
    error BidBelowMinAmount(uint256 newBidAmount, uint256 minAmount);
    error BidExceedsMaxAmount(uint256 newBidAmount, uint256 maxAmount);
    error BidLockupCannotBeUndone();
    error BidMustHaveLockup();
    error EntityTiedToAnotherAddress(address got, address existing, bytes16 entityID);
    error AddressTiedToAnotherEntity(bytes16 got, bytes16 existing, address addr);
    error ZeroAmount();
    error InvalidStage(Stage);
    error ZeroAddress();
    error ZeroEntityID();
    error BidAmountCannotBeLowered(uint256 newAmount, uint256 previousAmount);
    error BidPriceCannotBeLowered(uint256 newPrice, uint256 previousPrice);
    error ZeroPrice();
    error AllocationAlreadySet(bytes16 entityID, uint256 acceptedAmount);
    error AlreadyRefunded(bytes16 entityID);
    error AlreadyWithdrawn();
    error AllocationExceedsCommitment(bytes16 entityID, uint256 allocation, uint256 commitment);
    error SalePaused();
    error BidPriceExceedsMaxPrice(uint256 bidPrice, uint256 maxPrice);
    error UnexpectedTotalAllocatedUSDT(uint256 expected, uint256 actual);
    error BidAlreadyCancelled(bytes16 entityID);
    error BidIsNonWinner(bytes16 entityID, uint256 bidPrice, uint256 nonWinnerPriceThreshold);
    error BidIsPotentialWinner(bytes16 entityID, uint256 bidPrice, uint256 nonWinnerPriceThreshold);
    error BidHasAcceptedAmount(bytes16 entityID, uint256 acceptedAmount);
    error SenderWithoutRegisteredEntity(address addr);
    error EntityWithoutBid(bytes16 entityID);
    error SenderDoesNotOwnEntity(address sender, bytes16 entityID);

    event EntityInitialized(bytes16 indexed entityID, address indexed addr);
    event BidPlaced(bytes16 indexed entityID, Bid bid);
    event BidCancelled(bytes16 indexed entityID, address indexed addr, uint256 amount);
    event AllocationSet(bytes16 indexed entityID, uint256 acceptedAmountUSDT);
    event Refunded(bytes16 indexed entityID, address indexed addr, uint256 amount);
    event SkippedRefundedEntity(bytes16 indexed entityID);
    event ProceedsWithdrawn(address indexed receiver, uint256 amount);

    /// @notice The state of an entity in the sale.
    /// @dev This tracks the entity's address, the amount of USDT they have committed, etc.
    /// @param addr The address of the entity.
    /// @param entityID The entity ID of the entity.
    /// @param acceptedAmount The amount of USDT that has been accepted from the entity to purchase tokens after clearing the sale.
    /// The accepted amount will be withdrawn as proceeds at the end of the sale.
    /// The difference, i.e. `activeBid.amount - acceptedAmount`, will be refunded to the entity.
    /// @param refunded Whether the entity was refunded according to the formula above.
    /// @param cancelled Whether the entity cancelled their bid during the withdrawal stage. This is tracked mostly for audit purposes and is not used for any logic.
    /// @param activeBid The active bid of the entity in the auction part of the sale.
    /// @param bidTimestamp The timestamp of the last bid placed by the entity.
    struct EntityState {
        address addr;
        bytes16 entityID;
        uint64 acceptedAmount;
        uint32 bidTimestamp;
        bool refunded;
        bool cancelled;
        Bid activeBid;
    }

    /// @notice A bid in the auction.
    /// @param price The willing to pay price normalized to the price tick of the English auction.
    /// @param amount The amount of USDT that the entity is willing to spend.
    /// @param lockup Whether the purchased tokens will be locked up.
    struct Bid {
        uint64 price;
        uint64 amount;
        bool lockup;
    }

    /// @notice The stages of the sale.
    enum Stage {
        PreOpen,
        Auction,
        Closed,
        Cancellation,
        Settlement,
        Done
    }

    /// @notice The additional payload on the purchase permit issued by Sonar.
    /// @param forcedLockup Whether the purchased tokens for a specific entity must be locked up.
    /// @param maxPrice The maximum price that the entity is allowed to bid at.
    struct PurchasePermitPayload {
        bool forcedLockup;
        uint64 maxPrice;
    }

    /// @notice The allocation of USDT to an entity.
    /// @param entityID The entity ID of the entity.
    /// @param amountUSDT The amount of USDT that has been accepted from the entity to purchase tokens after clearing the sale.
    struct Allocation {
        bytes16 entityID;
        uint64 amountUSDT;
    }

    /// @notice The Sonar UUID of the sale.
    bytes16 public immutable saleUUID;

    /// @notice The USDT token used to fund the sale.
    IERC20Metadata public immutable usdt;

    /// @notice Whether the sale is paused.
    /// @dev This is intended to be used in emergency situations and will disable the main external functions of the contract.
    bool public paused;

    /// @notice The manually set stage of the sale.
    /// @dev This can differ from the actual stage of the sale (as returned by `stage()`) if this is set to `Auction`
    /// and `closeAuctionAtTimestamp` or `auctionInactivityDuration` are set.
    Stage public manualStage;

    /// @notice The duration of the auction inactivity window after which the auction should be closed automatically.
    /// @dev Automatic closing based on inactivity is disabled if set to 0
    uint64 public auctionInactivityDuration;

    /// @notice The timestamp at which the auction will be closed automatically.
    /// @dev Automatic closing based on timestamp is disabled if set to 0
    /// @dev This is intended to be used as an alternative to the inactivity closing mechanism if we detect griefing,
    /// since we're intentionally not enforcing a minimum bid amount.
    uint64 public closeAuctionAtTimestamp;

    /// @notice The timestamp of the last bid placed.
    /// @dev This will be set on each bid submission and is used to determine when the auction should be closed automatically.
    uint64 public lastBidTimestamp;

    /// @notice The total amount of USDT that has been committed to the auction part of the sale.
    /// @dev This is the sum of all `EntityState.activeBid.amount`s across all entities, tracked when bids are placed.
    /// Note: It is monotonically increasing and will not decrease on refunds/cancellations. Those are tracked separately by `totalRefundedAmount`.
    uint64 public totalActiveBidAmount;

    /// @notice The total amount of USDT that has been refunded to entities.
    /// @dev This is the sum of all `EntityState.activeBid.amount - EntityState.acceptedAmount`s across all refunded entities.
    uint64 public totalRefundedAmount;

    /// @notice The total amount of USDT that has been allocated to receive tokens.
    /// @dev This is the amount that will be withdrawn to the proceedsReceiver at the end of the sale.
    /// @dev This is the sum of all `EntityState.acceptedAmount`s across all entities.
    uint64 public totalAllocatedUSDT;

    /// @notice The price threshold for non-winners.
    /// @dev Users with bids less than this price are considered definite non-winners. Users with bids greater than or equal to this price are considered potential winners.
    /// Non-winners and potential winners can claim their refunds or cancel their bids during the `Cancellation` stage, respectively.
    /// @dev The value will be set when transitioning from the auction close stage to the `Cancellation` stage and will be determined offchain (based on the clearing price of an English auction).
    /// @dev The price is normalized to the tick of the English auction.
    uint64 public nonWinnerPriceThreshold;

    /// @notice The address that will receive the proceeds of the sale.
    address public proceedsReceiver;

    /// @notice Whether the proceeds have been withdrawn.
    /// @dev This is used to prevent the proceeds from being withdrawn multiple times.
    bool public withdrawn;

    /// @notice The set of all entities that have participated in the sale.
    /// @dev The actual entity IDs are bytes16, but we're using a standard bytes32 set here for convenience.
    /// Standard bytes16 <-> bytes32 casts can be used to convert between the two.
    EnumerableSet.Bytes32Set internal _entities;

    /// @notice The mapping of entity IDs to entity states.
    /// @dev This is used to track the state of each entity.
    mapping(bytes16 => EntityState) internal _entityStateByID;

    /// @notice The mapping of addresses to entity IDs.
    /// @dev This is used to track the entity ID for each address to prevent multiple entities from using the same address.
    mapping(address => bytes16) internal _entityIDByAddress;

    /// @notice The initialization parameters for the sale.
    struct Init {
        bytes16 saleUUID;
        address admin;
        IERC20Metadata usdt;
        address purchasePermitSigner;
        address proceedsReceiver;
        address pauser;
    }

    constructor(Init memory init) {
        saleUUID = init.saleUUID;
        usdt = init.usdt;
        auctionInactivityDuration = 30 minutes;
        proceedsReceiver = init.proceedsReceiver;

        _grantRole(DEFAULT_ADMIN_ROLE, init.admin);
        _grantRole(PURCHASE_PERMIT_SIGNER_ROLE, init.purchasePermitSigner);
        _grantRole(PAUSER_ROLE, init.pauser);
    }

    /// @notice Returns the current stage of the sale.
    /// @dev The stage is either computed automatically if `manualStage` is set to `Automatic`,
    /// or just returns the `manualStage` otherwise. This allows the contract to automatically
    /// move between active sale stages, while still allowing the admin to manually override
    /// the stage if needed.
    function stage() public view returns (Stage) {
        if (manualStage != Stage.Auction) {
            return manualStage;
        }

        if (closeAuctionAtTimestamp > 0 && block.timestamp >= closeAuctionAtTimestamp) {
            return Stage.Closed;
        }

        if (
            auctionInactivityDuration > 0 && lastBidTimestamp > 0
                && block.timestamp >= lastBidTimestamp + auctionInactivityDuration
        ) {
            return Stage.Closed;
        }

        return Stage.Auction;
    }

    /// @notice Moves the sale to the `Auction` stage, allowing any user to submit bids.
    function openAuction() external onlyRole(SALE_MANAGER_ROLE) onlyStage(Stage.PreOpen) {
        manualStage = Stage.Auction;
    }

    /// @notice Resets the last bid timestamp, allowing the auction to be reopened.
    /// @dev This is not intended to be used during regular operation, but useful if the auction stalled for some reason.
    function resetLastBidTimestamp() external onlyRole(SALE_MANAGER_ROLE) {
        lastBidTimestamp = 0;
    }

    /// @notice Tracks entities that committed funds to the sale (deposits and/or bids).
    /// @dev Ensures that entities can only use a single address and addresses can only be tied to a single entityID.
    function _trackEntity(bytes16 entityID, address addr) internal {
        if (entityID == bytes16(0)) {
            revert ZeroEntityID();
        }

        if (addr == address(0)) {
            revert ZeroAddress();
        }

        // Ensure that addresses can only be tied to a single entityID
        bytes16 existingEntityIDForAddress = _entityIDByAddress[addr];
        if (existingEntityIDForAddress != bytes16(0) && existingEntityIDForAddress != entityID) {
            revert AddressTiedToAnotherEntity(entityID, existingEntityIDForAddress, addr);
        }

        EntityState storage state = _entityStateByID[entityID];

        // Ensure that entities can only use a single address
        address existingAddrForEntity = state.addr;
        if (existingAddrForEntity != address(0) && existingAddrForEntity != addr) {
            revert EntityTiedToAnotherAddress(addr, existingAddrForEntity, entityID);
        }

        if (existingAddrForEntity == address(0)) {
            // new entity so we track them
            state.entityID = entityID;
            state.addr = addr;
            _entities.add(entityID);
            _entityIDByAddress[addr] = entityID;
            emit EntityInitialized(entityID, addr);
        }
    }

    /// @notice Allows any wallet to bid during the `Auction` stage using a valid purchase permit.
    /// @dev When a new bid is submitted, it fully replaces any previous bid for the same entity.
    /// Only the difference in bid amount (if positive) is transferred from the bidder to the sale contract.
    function replaceBidWithApproval(
        Bid calldata bid,
        PurchasePermitWithAllocation calldata purchasePermit,
        bytes calldata purchasePermitSignature
    ) external onlyStage(Stage.Auction) onlyUnpaused {
        uint64 amountDelta = _processBid(bid, purchasePermit, purchasePermitSignature);
        if (amountDelta > 0) {
            usdt.safeTransferFrom(msg.sender, address(this), amountDelta);
        }
    }

    /// @notice Processes a bid during the `Auction` stage, validating the purchase permit and updating the bid.
    /// @dev The maximum amount of USDT, the maximum price and whether a bid must be locked are specified on the purchase permit (`maxAmount`, `maxPrice` and `forcedLockup`, respectively).
    function _processBid(
        Bid calldata newBid,
        PurchasePermitWithAllocation calldata purchasePermit,
        bytes calldata purchasePermitSignature
    ) internal returns (uint64) {
        _validatePurchasePermit(purchasePermit, purchasePermitSignature);

        if (newBid.price == 0) {
            revert ZeroPrice();
        }

        if (newBid.amount == 0) {
            revert ZeroAmount();
        }

        PurchasePermitPayload memory payload = abi.decode(purchasePermit.permit.payload, (PurchasePermitPayload));
        if (payload.forcedLockup && !newBid.lockup) {
            revert BidMustHaveLockup();
        }

        if (newBid.price > payload.maxPrice) {
            revert BidPriceExceedsMaxPrice(newBid.price, payload.maxPrice);
        }

        EntityState storage state = _entityStateByID[purchasePermit.permit.entityID];
        // additional safety check: to avoid any bookkeeping issues, we disallow new bids for entities that have already been refunded.
        // this can theoretically happen if the auction was reopened after already refunding some entities.
        if (state.refunded) {
            revert AlreadyRefunded(purchasePermit.permit.entityID);
        }

        Bid memory previousBid = state.activeBid;

        if (newBid.amount < previousBid.amount) {
            revert BidAmountCannotBeLowered(newBid.amount, previousBid.amount);
        }

        if (newBid.price < previousBid.price) {
            revert BidPriceCannotBeLowered(newBid.price, previousBid.price);
        }

        if (newBid.amount < purchasePermit.minAmount) {
            revert BidBelowMinAmount(newBid.amount, purchasePermit.minAmount);
        }

        if (newBid.amount > purchasePermit.maxAmount) {
            revert BidExceedsMaxAmount(newBid.amount, purchasePermit.maxAmount);
        }

        if (previousBid.lockup && !newBid.lockup) {
            revert BidLockupCannotBeUndone();
        }

        _trackEntity(purchasePermit.permit.entityID, msg.sender);

        uint64 amountDelta = newBid.amount - previousBid.amount;

        state.activeBid = newBid;
        state.bidTimestamp = uint32(block.timestamp);
        lastBidTimestamp = uint64(block.timestamp);
        totalActiveBidAmount += amountDelta;
        emit BidPlaced(purchasePermit.permit.entityID, newBid);

        return amountDelta;
    }

    /// @notice Validates a purchase permit.
    /// @dev This ensures that the permit was issued for the right sale (preventing the reuse of the same permit across sales),
    /// is not expired, and is signed by the purchase permit signer.
    function _validatePurchasePermit(PurchasePermitWithAllocation memory permit, bytes calldata signature)
        internal
        view
    {
        if (permit.permit.saleUUID != saleUUID) {
            revert InvalidSaleUUID(permit.permit.saleUUID, saleUUID);
        }

        if (permit.permit.expiresAt <= block.timestamp) {
            revert PurchasePermitExpired();
        }

        if (permit.permit.wallet != msg.sender) {
            revert InvalidSender(msg.sender, permit.permit.wallet);
        }

        address recoveredSigner = PurchasePermitWithAllocationLib.recoverSigner(permit, signature);
        if (!hasRole(PURCHASE_PERMIT_SIGNER_ROLE, recoveredSigner)) {
            revert UnauthorizedSigner(recoveredSigner);
        }
    }

    /// @notice Moves the sale to the `Cancellation` stage, allowing non-winners to claim refunds and potential winners to cancel their bids.
    /// @param nonWinnerPriceThresholdInTicks The price threshold for non-winner (strictly less than this price) in units of the price tick of the English auction.
    function openCancellation(uint64 nonWinnerPriceThresholdInTicks)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
        onlyStage(Stage.Closed)
    {
        nonWinnerPriceThreshold = nonWinnerPriceThresholdInTicks;
        manualStage = Stage.Cancellation;
    }

    /// @notice Cancels a bid during the `Cancellation` stage, allowing potential winners to cancel their bids.
    /// @dev This differs from a refund for non-winners in that it can only be triggered by the entity themselves and additionally markes the bid as cancelled.
    function cancelBid() external onlyStage(Stage.Cancellation) onlyUnpaused {
        bytes16 entityID = _entityIDByAddress[msg.sender];
        if (entityID == bytes16(0)) {
            revert SenderWithoutRegisteredEntity(msg.sender);
        }

        EntityState storage state = _entityStateByID[entityID];

        // this is not expected since we don't allow zero bids
        if (state.activeBid.amount == 0) {
            revert EntityWithoutBid(entityID);
        }

        if (state.cancelled) {
            revert BidAlreadyCancelled(entityID);
        }

        // we only allow potential winners to cancel their bids
        if (state.activeBid.price < nonWinnerPriceThreshold) {
            revert BidIsNonWinner(entityID, state.activeBid.price, nonWinnerPriceThreshold);
        }

        state.cancelled = true;
        emit BidCancelled(entityID, msg.sender, state.activeBid.amount);

        _refund(entityID);
    }

    /// @notice Moves the sale to the `Settlement` stage, allowing the settler to set allocations.
    function openSettlement() external onlyRole(DEFAULT_ADMIN_ROLE) onlyStage(Stage.Cancellation) {
        manualStage = Stage.Settlement;
    }

    /// @notice Interface for the settler to set allocations for the entities that participated in the sale.
    /// @dev Allocations are computed offchain.
    function setAllocations(Allocation[] calldata allocations, bool allowOverwrite)
        external
        onlyRole(SETTLER_ROLE)
        onlyStage(Stage.Settlement)
    {
        for (uint256 i = 0; i < allocations.length; i++) {
            _setAllocation(allocations[i], allowOverwrite);
        }
    }

    /// @notice Sets an allocation for an entity, ensuring that the allocation is not greater than their commitment.
    function _setAllocation(Allocation calldata allocation, bool allowOverwrite) internal {
        EntityState storage state = _entityStateByID[allocation.entityID];

        // we cannot grant more allocation than a user committed
        // this also ensures that we can only set allocations for entities that have participated in the sale
        uint64 totalCommitment = state.activeBid.amount;
        if (allocation.amountUSDT > totalCommitment) {
            revert AllocationExceedsCommitment(allocation.entityID, allocation.amountUSDT, totalCommitment);
        }

        if (state.refunded) {
            revert AlreadyRefunded(allocation.entityID);
        }

        uint64 prevAcceptedAmount = state.acceptedAmount;
        if (prevAcceptedAmount > 0) {
            if (!allowOverwrite) {
                revert AllocationAlreadySet(allocation.entityID, state.acceptedAmount);
            }

            totalAllocatedUSDT -= prevAcceptedAmount;
        }

        state.acceptedAmount = allocation.amountUSDT;
        totalAllocatedUSDT += allocation.amountUSDT;

        emit AllocationSet(allocation.entityID, allocation.amountUSDT);
    }

    /// @notice Moves the sale to the `Done` stage, allowing users to claim refunds and the admin to withdraw the proceeds.
    /// @dev This is intended to be called after the settler has set allocations for all entities.
    function finalizeSettlement(uint256 expectedTotalAllocatedUSDT)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
        onlyStage(Stage.Settlement)
    {
        if (totalAllocatedUSDT != expectedTotalAllocatedUSDT) {
            revert UnexpectedTotalAllocatedUSDT(expectedTotalAllocatedUSDT, totalAllocatedUSDT);
        }

        manualStage = Stage.Done;
    }

    /// @notice Refunds an entity their unallocated USDT.
    /// @dev The refund amount is computed as their commitment minus their allocation.
    /// @dev Refunds can be triggered by addresses with the REFUNDER role or by entities themselves.
    /// @param entityIDs The IDs of the entities to refund.
    /// @param skipAlreadyRefunded Whether to skip already refunded entities. If this is false and an entity is already refunded, the transaction will revert.
    function processRefunds(bytes16[] calldata entityIDs, bool skipAlreadyRefunded)
        external
        onlyStages(Stage.Cancellation, Stage.Done)
        onlyUnpaused
    {
        // we only allow non-winners to claim refunds during the `Cancellation` stage
        if (stage() == Stage.Cancellation) {
            _ensureNonWinners(entityIDs);
        }

        _ensureSenderIsAllowedRefunder(entityIDs);

        for (uint256 i = 0; i < entityIDs.length; i++) {
            EntityState storage state = _entityStateByID[entityIDs[i]];
            if (skipAlreadyRefunded && state.refunded) {
                emit SkippedRefundedEntity(entityIDs[i]);
                continue;
            }

            _refund(entityIDs[i]);
        }
    }

    /// @notice Ensures that the entities are non-winners.
    /// @dev This is used to ensure that only non-winners can claim refunds during the `Cancellation` stage.
    function _ensureNonWinners(bytes16[] calldata entityIDs) internal view {
        uint256 nonWinnerPriceThreshold_ = nonWinnerPriceThreshold;

        for (uint256 i = 0; i < entityIDs.length; i++) {
            EntityState storage state = _entityStateByID[entityIDs[i]];
            if (state.activeBid.price >= nonWinnerPriceThreshold_) {
                revert BidIsPotentialWinner(entityIDs[i], state.activeBid.price, nonWinnerPriceThreshold_);
            }

            // additionally sanity check since we never expect non-winners to have accepted amounts
            if (state.acceptedAmount > 0) {
                revert BidHasAcceptedAmount(entityIDs[i], state.acceptedAmount);
            }
        }
    }

    /// @notice Ensures that the sender is allowed to refund the given entities.
    /// @dev The sender either has to have the REFUNDER role or be the owner of the entities.
    function _ensureSenderIsAllowedRefunder(bytes16[] calldata entityIDs) internal view {
        if (hasRole(REFUNDER_ROLE, msg.sender)) {
            return;
        }

        for (uint256 i = 0; i < entityIDs.length; i++) {
            EntityState storage state = _entityStateByID[entityIDs[i]];
            if (state.addr != msg.sender) {
                revert SenderDoesNotOwnEntity(msg.sender, entityIDs[i]);
            }
        }
    }

    /// @notice Refunds an entity their unallocated USDT.
    /// @dev The refund amount is computed as their commitment minus their allocation.
    function _refund(bytes16 entityID) internal {
        EntityState storage state = _entityStateByID[entityID];

        if (state.activeBid.amount == 0) {
            revert EntityWithoutBid(entityID);
        }

        if (state.refunded) {
            revert AlreadyRefunded(entityID);
        }

        uint64 refundAmount = state.activeBid.amount - state.acceptedAmount;
        state.refunded = true;
        emit Refunded(entityID, state.addr, refundAmount);

        if (refundAmount > 0) {
            totalRefundedAmount += refundAmount;
            usdt.safeTransfer(state.addr, refundAmount);
        }
    }

    /// @notice Withdraws the proceeds of the sale to the proceeds receiver.
    /// @dev This is intended to be called after the sale is finalized.
    function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) onlyStage(Stage.Done) {
        if (withdrawn) {
            revert AlreadyWithdrawn();
        }

        withdrawn = true;
        emit ProceedsWithdrawn(proceedsReceiver, totalAllocatedUSDT);
        usdt.safeTransfer(proceedsReceiver, totalAllocatedUSDT);
    }

    /// @notice Sets the manual stage of the sale.
    /// @dev This is not intended to be used during regular operation (use `openAuction` and `openSettlement` instead),
    /// but only for emergency situations.
    function setManualStage(Stage s) external onlyRole(DEFAULT_ADMIN_ROLE) {
        manualStage = s;
    }

    /// @notice Sets the auction inactivity window.
    /// @dev Setting this to 0 will disable the automatic closing of the auction on inactivity.
    function setAuctionInactivityWindow(uint64 window) external onlyRole(SALE_MANAGER_ROLE) {
        auctionInactivityDuration = window;
    }

    /// @notice Sets the timestamp at which the auction will be closed automatically.
    /// @dev Setting this to 0 will disable the automatic closing of the auction at a specific timestamp.
    function setCloseAuctionAtTimestamp(uint64 timestamp) external onlyRole(SALE_MANAGER_ROLE) {
        closeAuctionAtTimestamp = timestamp;
    }

    /// @notice Sets the address that will receive the proceeds of the sale.
    function setProceedsReceiver(address newproceedsReceiver) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (newproceedsReceiver == address(0)) {
            revert ZeroAddress();
        }

        proceedsReceiver = newproceedsReceiver;
    }

    /// @notice Pauses the sale.
    /// @dev This is intended to be used in emergency situations.
    function pause() external onlyRole(PAUSER_ROLE) {
        paused = true;
    }

    /// @notice Sets whether the sale is paused.
    /// @dev This is intended to unpause the sale after a pause.
    function setPaused(bool isPaused) external onlyRole(DEFAULT_ADMIN_ROLE) {
        paused = isPaused;
    }

    /// @notice Returns the number of entities that have participated in the sale.
    function numEntities() public view returns (uint256) {
        return _entities.length();
    }

    /// @notice Returns the entity ID at a given index.
    function entityAt(uint256 index) public view returns (bytes16) {
        return bytes16(_entities.at(index));
    }

    /// @notice Returns the entity IDs in given index range.
    function entitiesIn(uint256 from, uint256 to) external view returns (bytes16[] memory) {
        bytes16[] memory ids = new bytes16[](to - from);
        for (uint256 i = from; i < to; i++) {
            ids[i - from] = entityAt(i);
        }
        return ids;
    }

    /// @notice Returns the entity ID for a given address.
    function entityByAddress(address addr) public view returns (bytes16) {
        return _entityIDByAddress[addr];
    }

    /// @notice Returns the entity IDs for a given addresses.
    function entitiesByAddress(address[] calldata addrs) external view returns (bytes16[] memory) {
        bytes16[] memory ids = new bytes16[](addrs.length);
        for (uint256 i = 0; i < addrs.length; i++) {
            ids[i] = entityByAddress(addrs[i]);
        }
        return ids;
    }

    /// @notice Returns the state of an entity.
    function entityStateByID(bytes16 entityID) public view returns (EntityState memory) {
        return _entityStateByID[entityID];
    }

    /// @notice Returns the states of a given entities.
    function entityStatesByID(bytes16[] calldata entityIDs) external view returns (EntityState[] memory) {
        EntityState[] memory states = new EntityState[](entityIDs.length);
        for (uint256 i = 0; i < entityIDs.length; i++) {
            states[i] = entityStateByID(entityIDs[i]);
        }
        return states;
    }

    /// @notice Returns the states of entities in a given index range.
    function entityStatesIn(uint256 from, uint256 to) external view returns (EntityState[] memory) {
        EntityState[] memory states = new EntityState[](to - from);
        for (uint256 i = from; i < to; i++) {
            states[i - from] = entityStateByID(entityAt(i));
        }
        return states;
    }

    /// @notice Recovers any ERC20 tokens that are sent to the contract.
    /// @dev This can be used to recover any tokens that are sent to the contract by mistake.
    function recoverTokens(IERC20 token, uint256 amount, address to) external onlyRole(TOKEN_RECOVERER_ROLE) {
        token.safeTransfer(to, amount);
    }

    /// @notice Modifier to ensure the sale is in the desired stage.
    modifier onlyStage(Stage want) {
        Stage s = stage();
        if (s != want) {
            revert InvalidStage(s);
        }
        _;
    }

    /// @notice Modifier to ensure the sale is in the desired stage.
    modifier onlyStages(Stage want1, Stage want2) {
        Stage s = stage();
        if (s != want1 && s != want2) {
            revert InvalidStage(s);
        }
        _;
    }

    /// @notice Modifier to ensure the sale is not paused.
    modifier onlyUnpaused() {
        if (paused) {
            revert SalePaused();
        }
        _;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/AccessControlEnumerable.sol)

pragma solidity ^0.8.20;

import {IAccessControlEnumerable} from "./IAccessControlEnumerable.sol";
import {AccessControl} from "../AccessControl.sol";
import {EnumerableSet} from "../../utils/structs/EnumerableSet.sol";
import {IERC165} from "../../utils/introspection/ERC165.sol";

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 role => EnumerableSet.AddressSet) private _roleMembers;

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Return all accounts that have `role`
     *
     * 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 getRoleMembers(bytes32 role) public view virtual returns (address[] memory) {
        return _roleMembers[role].values();
    }

    /**
     * @dev Overload {AccessControl-_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override returns (bool) {
        bool granted = super._grantRole(role, account);
        if (granted) {
            _roleMembers[role].add(account);
        }
        return granted;
    }

    /**
     * @dev Overload {AccessControl-_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override returns (bool) {
        bool revoked = super._revokeRole(role, account);
        if (revoked) {
            _roleMembers[role].remove(account);
        }
        return revoked;
    }
}

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

pragma solidity ^0.8.20;

import {Arrays} from "../Arrays.sol";
import {Math} from "../math/Math.sol";

/**
 * @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.
 * - Set can be cleared (all elements removed) in O(n).
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * The following types are supported:
 *
 * - `bytes32` (`Bytes32Set`) since v3.3.0
 * - `address` (`AddressSet`) since v3.3.0
 * - `uint256` (`UintSet`) since v3.3.0
 * - `string` (`StringSet`) since v5.4.0
 * - `bytes` (`BytesSet`) since v5.4.0
 *
 * [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 Removes all the values from a set. O(n).
     *
     * WARNING: This function has an unbounded cost that scales with set size. Developers should keep in mind that
     * using it may render the function uncallable if the set grows to the point where clearing it consumes too much
     * gas to fit in a block.
     */
    function _clear(Set storage set) private {
        uint256 len = _length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

    /**
     * @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;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) private view returns (bytes32[] memory) {
        unchecked {
            end = Math.min(end, _length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            bytes32[] memory result = new bytes32[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }

    // 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(Bytes32Set storage set) internal {
        _clear(set._inner);
    }

    /**
     * @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;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(AddressSet storage set) internal {
        _clear(set._inner);
    }

    /**
     * @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;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(UintSet storage set) internal {
        _clear(set._inner);
    }

    /**
     * @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;
    }

    /**
     * @dev Return a slice of the 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, uint256 start, uint256 end) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner, start, end);
        uint256[] memory result;

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

        return result;
    }

    struct StringSet {
        // Storage of set values
        string[] _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(string 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(StringSet storage set, string memory value) internal 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(StringSet storage set, string memory value) internal 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) {
                string memory 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(StringSet storage set) internal {
        uint256 len = length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(StringSet storage set, string memory value) internal view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(StringSet storage set) internal 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(StringSet storage set, uint256 index) internal view returns (string memory) {
        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(StringSet storage set) internal view returns (string[] memory) {
        return set._values;
    }

    /**
     * @dev Return a slice of the 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(StringSet storage set, uint256 start, uint256 end) internal view returns (string[] memory) {
        unchecked {
            end = Math.min(end, length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            string[] memory result = new string[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }

    struct BytesSet {
        // Storage of set values
        bytes[] _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(bytes 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(BytesSet storage set, bytes memory value) internal 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(BytesSet storage set, bytes memory value) internal 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) {
                bytes memory 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 Removes all the values from a set. O(n).
     *
     * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the
     * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block.
     */
    function clear(BytesSet storage set) internal {
        uint256 len = length(set);
        for (uint256 i = 0; i < len; ++i) {
            delete set._positions[set._values[i]];
        }
        Arrays.unsafeSetLength(set._values, 0);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(BytesSet storage set, bytes memory value) internal view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(BytesSet storage set) internal 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(BytesSet storage set, uint256 index) internal view returns (bytes memory) {
        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(BytesSet storage set) internal view returns (bytes[] memory) {
        return set._values;
    }

    /**
     * @dev Return a slice of the 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(BytesSet storage set, uint256 start, uint256 end) internal view returns (bytes[] memory) {
        unchecked {
            end = Math.min(end, length(set));
            start = Math.min(start, end);

            uint256 len = end - start;
            bytes[] memory result = new bytes[](len);
            for (uint256 i = 0; i < len; ++i) {
                result[i] = Arrays.unsafeAccess(set._values, start + i).value;
            }
            return result;
        }
    }
}

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

pragma solidity >=0.6.2;

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.3.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

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

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.23;

import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {PurchasePermit} from "./PurchasePermit.sol";

/// @notice A permit that allows a wallet to purchase a certain amount of tokens from a sale.
/// @dev This permits includes an amount which is reserved for the caller and a max amount that the caller can purchase. The
/// max amount could be enforced on a per-wallet or per-entity basis by the sale contract + Sonar backend.
struct PurchasePermitWithAllocation {
    PurchasePermit permit;
    uint256 reservedAmount;
    uint256 minAmount;
    uint256 maxAmount;
}

library PurchasePermitWithAllocationLib {
    function digest(PurchasePermitWithAllocation memory permit) internal pure returns (bytes32) {
        return MessageHashUtils.toEthSignedMessageHash(abi.encode(permit));
    }

    function recoverSigner(PurchasePermitWithAllocation memory permit, bytes calldata signature)
        internal
        pure
        returns (address)
    {
        return ECDSA.recover(digest(permit), signature);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/IAccessControlEnumerable.sol)

pragma solidity >=0.8.4;

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

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC-165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

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

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {IERC165, ERC165} from "../utils/introspection/ERC165.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 AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @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);
        _;
    }

    /// @inheritdoc IERC165
    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) {
        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) {
        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 {
        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) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` from `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) {
        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.4.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.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 ERC165 is IERC165 {
    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.20;

import {Comparators} from "./Comparators.sol";
import {SlotDerivation} from "./SlotDerivation.sol";
import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using SlotDerivation for bytes32;
    using StorageSlot for bytes32;

    /**
     * @dev Sort an array of uint256 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        uint256[] memory array,
        function(uint256, uint256) pure returns (bool) comp
    ) internal pure returns (uint256[] memory) {
        _quickSort(_begin(array), _end(array), comp);
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of uint256 in increasing order.
     */
    function sort(uint256[] memory array) internal pure returns (uint256[] memory) {
        sort(array, Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of address (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        address[] memory array,
        function(address, address) pure returns (bool) comp
    ) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of address in increasing order.
     */
    function sort(address[] memory array) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of bytes32 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        bytes32[] memory array,
        function(bytes32, bytes32) pure returns (bool) comp
    ) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of bytes32 in increasing order.
     */
    function sort(bytes32[] memory array) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Performs a quick sort of a segment of memory. The segment sorted starts at `begin` (inclusive), and stops
     * at end (exclusive). Sorting follows the `comp` comparator.
     *
     * Invariant: `begin <= end`. This is the case when initially called by {sort} and is preserved in subcalls.
     *
     * IMPORTANT: Memory locations between `begin` and `end` are not validated/zeroed. This function should
     * be used only if the limits are within a memory array.
     */
    function _quickSort(uint256 begin, uint256 end, function(uint256, uint256) pure returns (bool) comp) private pure {
        unchecked {
            if (end - begin < 0x40) return;

            // Use first element as pivot
            uint256 pivot = _mload(begin);
            // Position where the pivot should be at the end of the loop
            uint256 pos = begin;

            for (uint256 it = begin + 0x20; it < end; it += 0x20) {
                if (comp(_mload(it), pivot)) {
                    // If the value stored at the iterator's position comes before the pivot, we increment the
                    // position of the pivot and move the value there.
                    pos += 0x20;
                    _swap(pos, it);
                }
            }

            _swap(begin, pos); // Swap pivot into place
            _quickSort(begin, pos, comp); // Sort the left side of the pivot
            _quickSort(pos + 0x20, end, comp); // Sort the right side of the pivot
        }
    }

    /**
     * @dev Pointer to the memory location of the first element of `array`.
     */
    function _begin(uint256[] memory array) private pure returns (uint256 ptr) {
        assembly ("memory-safe") {
            ptr := add(array, 0x20)
        }
    }

    /**
     * @dev Pointer to the memory location of the first memory word (32bytes) after `array`. This is the memory word
     * that comes just after the last element of the array.
     */
    function _end(uint256[] memory array) private pure returns (uint256 ptr) {
        unchecked {
            return _begin(array) + array.length * 0x20;
        }
    }

    /**
     * @dev Load memory word (as a uint256) at location `ptr`.
     */
    function _mload(uint256 ptr) private pure returns (uint256 value) {
        assembly {
            value := mload(ptr)
        }
    }

    /**
     * @dev Swaps the elements memory location `ptr1` and `ptr2`.
     */
    function _swap(uint256 ptr1, uint256 ptr2) private pure {
        assembly {
            let value1 := mload(ptr1)
            let value2 := mload(ptr2)
            mstore(ptr1, value2)
            mstore(ptr2, value1)
        }
    }

    /// @dev Helper: low level cast address memory array to uint256 memory array
    function _castToUint256Array(address[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 memory array to uint256 memory array
    function _castToUint256Array(bytes32[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast address comp function to uint256 comp function
    function _castToUint256Comp(
        function(address, address) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 comp function to uint256 comp function
    function _castToUint256Comp(
        function(bytes32, bytes32) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * NOTE: The `array` is expected to be sorted in ascending order, and to
     * contain no repeated elements.
     *
     * IMPORTANT: Deprecated. This implementation behaves as {lowerBound} but lacks
     * support for repeated elements in the array. The {lowerBound} function should
     * be used instead.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Searches an `array` sorted in ascending order and returns the first
     * index that contains a value greater or equal than `element`. If no such index
     * exists (i.e. all values in the array are strictly less than `element`), the array
     * length is returned. Time complexity O(log n).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/lower_bound[lower_bound].
     */
    function lowerBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value < element) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Searches an `array` sorted in ascending order and returns the first
     * index that contains a value strictly greater than `element`. If no such index
     * exists (i.e. all values in the array are strictly less than `element`), the array
     * length is returned. Time complexity O(log n).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/upper_bound[upper_bound].
     */
    function upperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        return low;
    }

    /**
     * @dev Same as {lowerBound}, but with an array in memory.
     */
    function lowerBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeMemoryAccess(array, mid) < element) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Same as {upperBound}, but with an array in memory.
     */
    function upperBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeMemoryAccess(array, mid) > element) {
                high = mid;
            } else {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        return low;
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes[] storage arr, uint256 pos) internal pure returns (StorageSlot.BytesSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getBytesSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(string[] storage arr, uint256 pos) internal pure returns (StorageSlot.StringSlot storage) {
        bytes32 slot;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).getStringSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(bytes32[] memory arr, uint256 pos) internal pure returns (bytes32 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(bytes[] memory arr, uint256 pos) internal pure returns (bytes memory res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(string[] memory arr, uint256 pos) internal pure returns (string memory res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(address[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(bytes32[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(uint256[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(bytes[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(string[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.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 Return the 512-bit addition of two uint256.
     *
     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.
     */
    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
        assembly ("memory-safe") {
            low := add(a, b)
            high := lt(low, a)
        }
    }

    /**
     * @dev Return the 512-bit multiplication of two uint256.
     *
     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.
     */
    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
        // 512-bit multiply [high low] = 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 = high * 2²⁵⁶ + low.
        assembly ("memory-safe") {
            let mm := mulmod(a, b, not(0))
            low := mul(a, b)
            high := sub(sub(mm, low), lt(mm, low))
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            success = c >= a;
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a - b;
            success = c <= a;
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a * b;
            assembly ("memory-safe") {
                // Only true when the multiplication doesn't overflow
                // (c / a == b) || (a == 0)
                success := or(eq(div(c, a), b), iszero(a))
            }
            // equivalent to: success ? c : 0
            result = c * SafeCast.toUint(success);
        }
    }

    /**
     * @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 {
            success = b > 0;
            assembly ("memory-safe") {
                // The `DIV` opcode returns zero when the denominator is 0.
                result := div(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 {
            success = b > 0;
            assembly ("memory-safe") {
                // The `MOD` opcode returns zero when the denominator is 0.
                result := mod(a, b)
            }
        }
    }

    /**
     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.
     */
    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {
        (bool success, uint256 result) = tryAdd(a, b);
        return ternary(success, result, type(uint256).max);
    }

    /**
     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.
     */
    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {
        (, uint256 result) = trySub(a, b);
        return result;
    }

    /**
     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.
     */
    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {
        (bool success, uint256 result) = tryMul(a, b);
        return ternary(success, result, type(uint256).max);
    }

    /**
     * @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 {
            (uint256 high, uint256 low) = mul512(x, y);

            // Handle non-overflow cases, 256 by 256 division.
            if (high == 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 low / denominator;
            }

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

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

            // Make division exact by subtracting the remainder from [high low].
            uint256 remainder;
            assembly ("memory-safe") {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                high := sub(high, gt(remainder, low))
                low := sub(low, 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 ("memory-safe") {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [high low] by twos.
                low := div(low, 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 high into low.
            low |= high * 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 high
            // is no longer required.
            result = low * 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 Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.
     */
    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {
        unchecked {
            (uint256 high, uint256 low) = mul512(x, y);
            if (high >= 1 << n) {
                Panic.panic(Panic.UNDER_OVERFLOW);
            }
            return (high << (256 - n)) | (low >> n);
        }
    }

    /**
     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.
     */
    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {
        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 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 x) internal pure returns (uint256 r) {
        // If value has upper 128 bits set, log2 result is at least 128
        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
        // If upper 64 bits of 128-bit half set, add 64 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
        // If upper 32 bits of 64-bit half set, add 32 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
        // If upper 16 bits of 32-bit half set, add 16 to result
        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
        // If upper 8 bits of 16-bit half set, add 8 to result
        r |= SafeCast.toUint((x >> r) > 0xff) << 3;
        // If upper 4 bits of 8-bit half set, add 4 to result
        r |= SafeCast.toUint((x >> r) > 0xf) << 2;

        // Shifts value right by the current result and use it as an index into this lookup table:
        //
        // | x (4 bits) |  index  | table[index] = MSB position |
        // |------------|---------|-----------------------------|
        // |    0000    |    0    |        table[0] = 0         |
        // |    0001    |    1    |        table[1] = 0         |
        // |    0010    |    2    |        table[2] = 1         |
        // |    0011    |    3    |        table[3] = 1         |
        // |    0100    |    4    |        table[4] = 2         |
        // |    0101    |    5    |        table[5] = 2         |
        // |    0110    |    6    |        table[6] = 2         |
        // |    0111    |    7    |        table[7] = 2         |
        // |    1000    |    8    |        table[8] = 3         |
        // |    1001    |    9    |        table[9] = 3         |
        // |    1010    |   10    |        table[10] = 3        |
        // |    1011    |   11    |        table[11] = 3        |
        // |    1100    |   12    |        table[12] = 3        |
        // |    1101    |   13    |        table[13] = 3        |
        // |    1110    |   14    |        table[14] = 3        |
        // |    1111    |   15    |        table[15] = 3        |
        //
        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
        assembly ("memory-safe") {
            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
        }
    }

    /**
     * @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 x) internal pure returns (uint256 r) {
        // If value has upper 128 bits set, log2 result is at least 128
        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
        // If upper 64 bits of 128-bit half set, add 64 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
        // If upper 32 bits of 64-bit half set, add 32 to result
        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
        // If upper 16 bits of 32-bit half set, add 16 to result
        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8
        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);
    }

    /**
     * @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.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @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.4.0) (interfaces/IERC1363.sol)

pragma solidity >=0.6.2;

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

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32.
     */
    function toDataWithIntendedValidatorHash(
        address validator,
        bytes32 messageHash
    ) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            mstore(0x00, hex"19_00")
            mstore(0x02, shl(96, validator))
            mstore(0x16, messageHash)
            digest := keccak256(0x00, 0x36)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(
        bytes32 hash,
        bytes memory signature
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly ("memory-safe") {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.23;

import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

/// @notice A permit that allows a wallet to purchase a tokens in a sale.
struct PurchasePermit {
    bytes16 entityID;
    bytes16 saleUUID;
    address wallet;
    uint64 expiresAt;
    bytes payload; // Generic extra data field for future use.
}

library PurchasePermitLib {
    function digest(PurchasePermit memory permit) internal pure returns (bytes32) {
        return MessageHashUtils.toEthSignedMessageHash(abi.encode(permit));
    }

    function recoverSigner(PurchasePermit memory permit, bytes calldata signature) internal pure returns (address) {
        return ECDSA.recover(digest(permit), signature);
    }
}

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

pragma solidity >=0.8.4;

/**
 * @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 to signal 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;

/**
 * @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 Context {
    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.4.0) (utils/introspection/IERC165.sol)

pragma solidity >=0.4.16;

/**
 * @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.1.0) (utils/Comparators.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides a set of functions to compare values.
 *
 * _Available since v5.1._
 */
library Comparators {
    function lt(uint256 a, uint256 b) internal pure returns (bool) {
        return a < b;
    }

    function gt(uint256 a, uint256 b) internal pure returns (bool) {
        return a > b;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Library for computing storage (and transient storage) locations from namespaces and deriving slots
 * corresponding to standard patterns. The derivation method for array and mapping matches the storage layout used by
 * the solidity language / compiler.
 *
 * See https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays[Solidity docs for mappings and dynamic arrays.].
 *
 * Example usage:
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using StorageSlot for bytes32;
 *     using SlotDerivation for bytes32;
 *
 *     // Declare a namespace
 *     string private constant _NAMESPACE = "<namespace>"; // eg. OpenZeppelin.Slot
 *
 *     function setValueInNamespace(uint256 key, address newValue) internal {
 *         _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue;
 *     }
 *
 *     function getValueInNamespace(uint256 key) internal view returns (address) {
 *         return _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {StorageSlot}.
 *
 * NOTE: This library provides a way to manipulate storage locations in a non-standard way. Tooling for checking
 * upgrade safety will ignore the slots accessed through this library.
 *
 * _Available since v5.1._
 */
library SlotDerivation {
    /**
     * @dev Derive an ERC-7201 slot from a string (namespace).
     */
    function erc7201Slot(string memory namespace) internal pure returns (bytes32 slot) {
        assembly ("memory-safe") {
            mstore(0x00, sub(keccak256(add(namespace, 0x20), mload(namespace)), 1))
            slot := and(keccak256(0x00, 0x20), not(0xff))
        }
    }

    /**
     * @dev Add an offset to a slot to get the n-th element of a structure or an array.
     */
    function offset(bytes32 slot, uint256 pos) internal pure returns (bytes32 result) {
        unchecked {
            return bytes32(uint256(slot) + pos);
        }
    }

    /**
     * @dev Derive the location of the first element in an array from the slot where the length is stored.
     */
    function deriveArray(bytes32 slot) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, slot)
            result := keccak256(0x00, 0x20)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, address key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, and(key, shr(96, not(0))))
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bool key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, iszero(iszero(key)))
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bytes32 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, uint256 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, int256 key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            mstore(0x00, key)
            mstore(0x20, slot)
            result := keccak256(0x00, 0x40)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, string memory key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            let length := mload(key)
            let begin := add(key, 0x20)
            let end := add(begin, length)
            let cache := mload(end)
            mstore(end, slot)
            result := keccak256(begin, add(length, 0x20))
            mstore(end, cache)
        }
    }

    /**
     * @dev Derive the location of a mapping element from the key.
     */
    function deriveMapping(bytes32 slot, bytes memory key) internal pure returns (bytes32 result) {
        assembly ("memory-safe") {
            let length := mload(key)
            let begin := add(key, 0x20)
            let end := add(begin, length)
            let cache := mload(end)
            mstore(end, slot)
            result := keccak256(begin, add(length, 0x20))
            mstore(end, cache)
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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;
 *     }
 * }
 * ```
 *
 * 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
        }
    }
}

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

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].
 *
 * _Available since v5.1._
 */
// 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.1.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.4.0) (interfaces/IERC20.sol)

pragma solidity >=0.4.16;

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

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

pragma solidity >=0.4.16;

import {IERC165} from "../utils/introspection/IERC165.sol";

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SafeCast} from "./math/SafeCast.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    using SafeCast for *;

    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;
    uint256 private constant SPECIAL_CHARS_LOOKUP =
        (1 << 0x08) | // backspace
            (1 << 0x09) | // tab
            (1 << 0x0a) | // newline
            (1 << 0x0c) | // form feed
            (1 << 0x0d) | // carriage return
            (1 << 0x22) | // double quote
            (1 << 0x5c); // backslash

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev The string being parsed contains characters that are not in scope of the given base.
     */
    error StringsInvalidChar();

    /**
     * @dev The string being parsed is not a properly formatted address.
     */
    error StringsInvalidAddressFormat();

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            assembly ("memory-safe") {
                ptr := add(add(buffer, 0x20), length)
            }
            while (true) {
                ptr--;
                assembly ("memory-safe") {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
     * representation, according to EIP-55.
     */
    function toChecksumHexString(address addr) internal pure returns (string memory) {
        bytes memory buffer = bytes(toHexString(addr));

        // hash the hex part of buffer (skip length + 2 bytes, length 40)
        uint256 hashValue;
        assembly ("memory-safe") {
            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
        }

        for (uint256 i = 41; i > 1; --i) {
            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
                // case shift by xoring with 0x20
                buffer[i] ^= 0x20;
            }
            hashValue >>= 4;
        }
        return string(buffer);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }

    /**
     * @dev Parse a decimal string and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input) internal pure returns (uint256) {
        return parseUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        uint256 result = 0;
        for (uint256 i = begin; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 9) return (false, 0);
            result *= 10;
            result += chr;
        }
        return (true, result);
    }

    /**
     * @dev Parse a decimal string and returns the value as a `int256`.
     *
     * Requirements:
     * - The string must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input) internal pure returns (int256) {
        return parseInt(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {
        (bool success, int256 value) = tryParseInt(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if
     * the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {
        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);
    }

    uint256 private constant ABS_MIN_INT256 = 2 ** 255;

    /**
     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character or if the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, int256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseIntUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseIntUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, int256 value) {
        bytes memory buffer = bytes(input);

        // Check presence of a negative sign.
        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        bool positiveSign = sign == bytes1("+");
        bool negativeSign = sign == bytes1("-");
        uint256 offset = (positiveSign || negativeSign).toUint();

        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);

        if (absSuccess && absValue < ABS_MIN_INT256) {
            return (true, negativeSign ? -int256(absValue) : int256(absValue));
        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {
            return (true, type(int256).min);
        } else return (false, 0);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input) internal pure returns (uint256) {
        return parseHexUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseHexUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an
     * invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseHexUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseHexUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        // skip 0x prefix if present
        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 offset = hasPrefix.toUint() * 2;

        uint256 result = 0;
        for (uint256 i = begin + offset; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 15) return (false, 0);
            result *= 16;
            unchecked {
                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).
                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.
                result += chr;
            }
        }
        return (true, result);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an `address`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input) internal pure returns (address) {
        return parseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {
        (bool success, address value) = tryParseAddress(input, begin, end);
        if (!success) revert StringsInvalidAddressFormat();
        return value;
    }

    /**
     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly
     * formatted address. See {parseAddress-string} requirements.
     */
    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {
        return tryParseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly
     * formatted address. See {parseAddress-string-uint256-uint256} requirements.
     */
    function tryParseAddress(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, address value) {
        if (end > bytes(input).length || begin > end) return (false, address(0));

        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;

        // check that input is the correct length
        if (end - begin == expectedLength) {
            // length guarantees that this does not overflow, and value is at most type(uint160).max
            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);
            return (s, address(uint160(v)));
        } else {
            return (false, address(0));
        }
    }

    function _tryParseChr(bytes1 chr) private pure returns (uint8) {
        uint8 value = uint8(chr);

        // Try to parse `chr`:
        // - Case 1: [0-9]
        // - Case 2: [a-f]
        // - Case 3: [A-F]
        // - otherwise not supported
        unchecked {
            if (value > 47 && value < 58) value -= 48;
            else if (value > 96 && value < 103) value -= 87;
            else if (value > 64 && value < 71) value -= 55;
            else return type(uint8).max;
        }

        return value;
    }

    /**
     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.
     *
     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.
     *
     * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of
     * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode
     * characters that are not in this range, but other tooling may provide different results.
     */
    function escapeJSON(string memory input) internal pure returns (string memory) {
        bytes memory buffer = bytes(input);
        bytes memory output = new bytes(2 * buffer.length); // worst case scenario
        uint256 outputLength = 0;

        for (uint256 i; i < buffer.length; ++i) {
            bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i));
            if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) {
                output[outputLength++] = "\\";
                if (char == 0x08) output[outputLength++] = "b";
                else if (char == 0x09) output[outputLength++] = "t";
                else if (char == 0x0a) output[outputLength++] = "n";
                else if (char == 0x0c) output[outputLength++] = "f";
                else if (char == 0x0d) output[outputLength++] = "r";
                else if (char == 0x5c) output[outputLength++] = "\\";
                else if (char == 0x22) {
                    // solhint-disable-next-line quotes
                    output[outputLength++] = '"';
                }
            } else {
                output[outputLength++] = char;
            }
        }
        // write the actual length and deallocate unused memory
        assembly ("memory-safe") {
            mstore(output, outputLength)
            mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63)))))
        }

        return string(output);
    }

    /**
     * @dev Reads a bytes32 from a bytes array without bounds checking.
     *
     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the
     * assembly block as such would prevent some optimizations.
     */
    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {
        // This is not memory safe in the general case, but all calls to this private function are within bounds.
        assembly ("memory-safe") {
            value := mload(add(add(buffer, 0x20), offset))
        }
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @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, int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
        }
    }

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
            // taking advantage of the most significant (or "sign" bit) in two's complement representation.
            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
            int256 mask = n >> 255;

            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
            return uint256((n + mask) ^ mask);
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "echo/=src/",
    "sales/=../../../contracts/src/sales/",
    "echo-test/=../../../contracts/test/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "prague",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"bytes16","name":"saleUUID","type":"bytes16"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"contract IERC20Metadata","name":"usdt","type":"address"},{"internalType":"address","name":"purchasePermitSigner","type":"address"},{"internalType":"address","name":"proceedsReceiver","type":"address"},{"internalType":"address","name":"pauser","type":"address"}],"internalType":"struct MegaSale.Init","name":"init","type":"tuple"}],"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":"bytes16","name":"got","type":"bytes16"},{"internalType":"bytes16","name":"existing","type":"bytes16"},{"internalType":"address","name":"addr","type":"address"}],"name":"AddressTiedToAnotherEntity","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint256","name":"acceptedAmount","type":"uint256"}],"name":"AllocationAlreadySet","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint256","name":"allocation","type":"uint256"},{"internalType":"uint256","name":"commitment","type":"uint256"}],"name":"AllocationExceedsCommitment","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"AlreadyRefunded","type":"error"},{"inputs":[],"name":"AlreadyWithdrawn","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"BidAlreadyCancelled","type":"error"},{"inputs":[{"internalType":"uint256","name":"newAmount","type":"uint256"},{"internalType":"uint256","name":"previousAmount","type":"uint256"}],"name":"BidAmountCannotBeLowered","type":"error"},{"inputs":[{"internalType":"uint256","name":"newBidAmount","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"}],"name":"BidBelowMinAmount","type":"error"},{"inputs":[{"internalType":"uint256","name":"newBidAmount","type":"uint256"},{"internalType":"uint256","name":"maxAmount","type":"uint256"}],"name":"BidExceedsMaxAmount","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint256","name":"acceptedAmount","type":"uint256"}],"name":"BidHasAcceptedAmount","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint256","name":"bidPrice","type":"uint256"},{"internalType":"uint256","name":"nonWinnerPriceThreshold","type":"uint256"}],"name":"BidIsNonWinner","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint256","name":"bidPrice","type":"uint256"},{"internalType":"uint256","name":"nonWinnerPriceThreshold","type":"uint256"}],"name":"BidIsPotentialWinner","type":"error"},{"inputs":[],"name":"BidLockupCannotBeUndone","type":"error"},{"inputs":[],"name":"BidMustHaveLockup","type":"error"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"},{"internalType":"uint256","name":"previousPrice","type":"uint256"}],"name":"BidPriceCannotBeLowered","type":"error"},{"inputs":[{"internalType":"uint256","name":"bidPrice","type":"uint256"},{"internalType":"uint256","name":"maxPrice","type":"uint256"}],"name":"BidPriceExceedsMaxPrice","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"got","type":"address"},{"internalType":"address","name":"existing","type":"address"},{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"EntityTiedToAnotherAddress","type":"error"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"EntityWithoutBid","type":"error"},{"inputs":[{"internalType":"bytes16","name":"got","type":"bytes16"},{"internalType":"bytes16","name":"want","type":"bytes16"}],"name":"InvalidSaleUUID","type":"error"},{"inputs":[{"internalType":"address","name":"got","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"InvalidSender","type":"error"},{"inputs":[{"internalType":"enum MegaSale.Stage","name":"","type":"uint8"}],"name":"InvalidStage","type":"error"},{"inputs":[],"name":"PurchasePermitExpired","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"SalePaused","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"SenderDoesNotOwnEntity","type":"error"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"SenderWithoutRegisteredEntity","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"UnauthorizedSigner","type":"error"},{"inputs":[{"internalType":"uint256","name":"expected","type":"uint256"},{"internalType":"uint256","name":"actual","type":"uint256"}],"name":"UnexpectedTotalAllocatedUSDT","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"inputs":[],"name":"ZeroEntityID","type":"error"},{"inputs":[],"name":"ZeroPrice","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"entityID","type":"bytes16"},{"indexed":false,"internalType":"uint256","name":"acceptedAmountUSDT","type":"uint256"}],"name":"AllocationSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"entityID","type":"bytes16"},{"indexed":true,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BidCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"entityID","type":"bytes16"},{"components":[{"internalType":"uint64","name":"price","type":"uint64"},{"internalType":"uint64","name":"amount","type":"uint64"},{"internalType":"bool","name":"lockup","type":"bool"}],"indexed":false,"internalType":"struct MegaSale.Bid","name":"bid","type":"tuple"}],"name":"BidPlaced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"entityID","type":"bytes16"},{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"EntityInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ProceedsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"entityID","type":"bytes16"},{"indexed":true,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Refunded","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":true,"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"SkippedRefundedEntity","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PURCHASE_PERMIT_SIGNER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REFUNDER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SALE_MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SETTLER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_RECOVERER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auctionInactivityDuration","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelBid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"closeAuctionAtTimestamp","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addrs","type":"address[]"}],"name":"entitiesByAddress","outputs":[{"internalType":"bytes16[]","name":"","type":"bytes16[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"}],"name":"entitiesIn","outputs":[{"internalType":"bytes16[]","name":"","type":"bytes16[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"entityAt","outputs":[{"internalType":"bytes16","name":"","type":"bytes16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"entityByAddress","outputs":[{"internalType":"bytes16","name":"","type":"bytes16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes16","name":"entityID","type":"bytes16"}],"name":"entityStateByID","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint64","name":"acceptedAmount","type":"uint64"},{"internalType":"uint32","name":"bidTimestamp","type":"uint32"},{"internalType":"bool","name":"refunded","type":"bool"},{"internalType":"bool","name":"cancelled","type":"bool"},{"components":[{"internalType":"uint64","name":"price","type":"uint64"},{"internalType":"uint64","name":"amount","type":"uint64"},{"internalType":"bool","name":"lockup","type":"bool"}],"internalType":"struct MegaSale.Bid","name":"activeBid","type":"tuple"}],"internalType":"struct MegaSale.EntityState","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes16[]","name":"entityIDs","type":"bytes16[]"}],"name":"entityStatesByID","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint64","name":"acceptedAmount","type":"uint64"},{"internalType":"uint32","name":"bidTimestamp","type":"uint32"},{"internalType":"bool","name":"refunded","type":"bool"},{"internalType":"bool","name":"cancelled","type":"bool"},{"components":[{"internalType":"uint64","name":"price","type":"uint64"},{"internalType":"uint64","name":"amount","type":"uint64"},{"internalType":"bool","name":"lockup","type":"bool"}],"internalType":"struct MegaSale.Bid","name":"activeBid","type":"tuple"}],"internalType":"struct MegaSale.EntityState[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"}],"name":"entityStatesIn","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint64","name":"acceptedAmount","type":"uint64"},{"internalType":"uint32","name":"bidTimestamp","type":"uint32"},{"internalType":"bool","name":"refunded","type":"bool"},{"internalType":"bool","name":"cancelled","type":"bool"},{"components":[{"internalType":"uint64","name":"price","type":"uint64"},{"internalType":"uint64","name":"amount","type":"uint64"},{"internalType":"bool","name":"lockup","type":"bool"}],"internalType":"struct MegaSale.Bid","name":"activeBid","type":"tuple"}],"internalType":"struct MegaSale.EntityState[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"expectedTotalAllocatedUSDT","type":"uint256"}],"name":"finalizeSettlement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMembers","outputs":[{"internalType":"address[]","name":"","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":"lastBidTimestamp","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manualStage","outputs":[{"internalType":"enum MegaSale.Stage","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonWinnerPriceThreshold","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numEntities","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openAuction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"nonWinnerPriceThresholdInTicks","type":"uint64"}],"name":"openCancellation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"openSettlement","outputs":[],"stateMutability":"nonpayable","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":"proceedsReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes16[]","name":"entityIDs","type":"bytes16[]"},{"internalType":"bool","name":"skipAlreadyRefunded","type":"bool"}],"name":"processRefunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"recoverTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"price","type":"uint64"},{"internalType":"uint64","name":"amount","type":"uint64"},{"internalType":"bool","name":"lockup","type":"bool"}],"internalType":"struct MegaSale.Bid","name":"bid","type":"tuple"},{"components":[{"components":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"bytes16","name":"saleUUID","type":"bytes16"},{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint64","name":"expiresAt","type":"uint64"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct PurchasePermit","name":"permit","type":"tuple"},{"internalType":"uint256","name":"reservedAmount","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"uint256","name":"maxAmount","type":"uint256"}],"internalType":"struct PurchasePermitWithAllocation","name":"purchasePermit","type":"tuple"},{"internalType":"bytes","name":"purchasePermitSignature","type":"bytes"}],"name":"replaceBidWithApproval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resetLastBidTimestamp","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":[],"name":"saleUUID","outputs":[{"internalType":"bytes16","name":"","type":"bytes16"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes16","name":"entityID","type":"bytes16"},{"internalType":"uint64","name":"amountUSDT","type":"uint64"}],"internalType":"struct MegaSale.Allocation[]","name":"allocations","type":"tuple[]"},{"internalType":"bool","name":"allowOverwrite","type":"bool"}],"name":"setAllocations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"window","type":"uint64"}],"name":"setAuctionInactivityWindow","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"timestamp","type":"uint64"}],"name":"setCloseAuctionAtTimestamp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum MegaSale.Stage","name":"s","type":"uint8"}],"name":"setManualStage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"isPaused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newproceedsReceiver","type":"address"}],"name":"setProceedsReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stage","outputs":[{"internalType":"enum MegaSale.Stage","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalActiveBidAmount","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocatedUSDT","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRefundedAmount","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"usdt","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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