DegenGoose

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

pragma solidity ^0.8.20;

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

/**
 * @dev This library defines the `Trace*` struct, for checkpointing values as they change at different points in
 * time, and later looking up past values by block number. See {Votes} as an example.
 *
 * To create a history of checkpoints define a variable type `Checkpoints.Trace*` in your contract, and store a new
 * checkpoint for the current transaction block using the {push} function.
 */
library Checkpoints {
    /**
     * @dev A value was attempted to be inserted on a past checkpoint.
     */
    error CheckpointUnorderedInsertion();

    struct Trace224 {
        Checkpoint224[] _checkpoints;
    }

    struct Checkpoint224 {
        uint32 _key;
        uint224 _value;
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into a Trace224 so that it is stored as the checkpoint.
     *
     * Returns previous value and new value.
     *
     * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint32).max` key set will disable the
     * library.
     */
    function push(Trace224 storage self, uint32 key, uint224 value) internal returns (uint224, uint224) {
        return _insert(self._checkpoints, key, value);
    }

    /**
     * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if
     * there is none.
     */
    function lowerLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);
        return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     */
    function upperLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     *
     * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high
     * keys).
     */
    function upperLookupRecent(Trace224 storage self, uint32 key) internal view returns (uint224) {
        uint256 len = self._checkpoints.length;

        uint256 low = 0;
        uint256 high = len;

        if (len > 5) {
            uint256 mid = len - Math.sqrt(len);
            if (key < _unsafeAccess(self._checkpoints, mid)._key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);

        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.
     */
    function latest(Trace224 storage self) internal view returns (uint224) {
        uint256 pos = self._checkpoints.length;
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value
     * in the most recent checkpoint.
     */
    function latestCheckpoint(Trace224 storage self) internal view returns (bool exists, uint32 _key, uint224 _value) {
        uint256 pos = self._checkpoints.length;
        if (pos == 0) {
            return (false, 0, 0);
        } else {
            Checkpoint224 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
            return (true, ckpt._key, ckpt._value);
        }
    }

    /**
     * @dev Returns the number of checkpoint.
     */
    function length(Trace224 storage self) internal view returns (uint256) {
        return self._checkpoints.length;
    }

    /**
     * @dev Returns checkpoint at given position.
     */
    function at(Trace224 storage self, uint32 pos) internal view returns (Checkpoint224 memory) {
        return self._checkpoints[pos];
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,
     * or by updating the last one.
     */
    function _insert(Checkpoint224[] storage self, uint32 key, uint224 value) private returns (uint224, uint224) {
        uint256 pos = self.length;

        if (pos > 0) {
            // Copying to memory is important here.
            Checkpoint224 memory last = _unsafeAccess(self, pos - 1);

            // Checkpoint keys must be non-decreasing.
            if (last._key > key) {
                revert CheckpointUnorderedInsertion();
            }

            // Update or push new checkpoint
            if (last._key == key) {
                _unsafeAccess(self, pos - 1)._value = value;
            } else {
                self.push(Checkpoint224({_key: key, _value: value}));
            }
            return (last._value, value);
        } else {
            self.push(Checkpoint224({_key: key, _value: value}));
            return (0, value);
        }
    }

    /**
     * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`
     * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive
     * `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _upperBinaryLookup(
        Checkpoint224[] storage self,
        uint32 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key > key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

    /**
     * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or
     * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and
     * exclusive `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _lowerBinaryLookup(
        Checkpoint224[] storage self,
        uint32 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key < key) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return high;
    }

    /**
     * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
     */
    function _unsafeAccess(
        Checkpoint224[] storage self,
        uint256 pos
    ) private pure returns (Checkpoint224 storage result) {
        assembly {
            mstore(0, self.slot)
            result.slot := add(keccak256(0, 0x20), pos)
        }
    }

    struct Trace208 {
        Checkpoint208[] _checkpoints;
    }

    struct Checkpoint208 {
        uint48 _key;
        uint208 _value;
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into a Trace208 so that it is stored as the checkpoint.
     *
     * Returns previous value and new value.
     *
     * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint48).max` key set will disable the
     * library.
     */
    function push(Trace208 storage self, uint48 key, uint208 value) internal returns (uint208, uint208) {
        return _insert(self._checkpoints, key, value);
    }

    /**
     * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if
     * there is none.
     */
    function lowerLookup(Trace208 storage self, uint48 key) internal view returns (uint208) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);
        return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     */
    function upperLookup(Trace208 storage self, uint48 key) internal view returns (uint208) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     *
     * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high
     * keys).
     */
    function upperLookupRecent(Trace208 storage self, uint48 key) internal view returns (uint208) {
        uint256 len = self._checkpoints.length;

        uint256 low = 0;
        uint256 high = len;

        if (len > 5) {
            uint256 mid = len - Math.sqrt(len);
            if (key < _unsafeAccess(self._checkpoints, mid)._key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);

        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.
     */
    function latest(Trace208 storage self) internal view returns (uint208) {
        uint256 pos = self._checkpoints.length;
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value
     * in the most recent checkpoint.
     */
    function latestCheckpoint(Trace208 storage self) internal view returns (bool exists, uint48 _key, uint208 _value) {
        uint256 pos = self._checkpoints.length;
        if (pos == 0) {
            return (false, 0, 0);
        } else {
            Checkpoint208 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
            return (true, ckpt._key, ckpt._value);
        }
    }

    /**
     * @dev Returns the number of checkpoint.
     */
    function length(Trace208 storage self) internal view returns (uint256) {
        return self._checkpoints.length;
    }

    /**
     * @dev Returns checkpoint at given position.
     */
    function at(Trace208 storage self, uint32 pos) internal view returns (Checkpoint208 memory) {
        return self._checkpoints[pos];
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,
     * or by updating the last one.
     */
    function _insert(Checkpoint208[] storage self, uint48 key, uint208 value) private returns (uint208, uint208) {
        uint256 pos = self.length;

        if (pos > 0) {
            // Copying to memory is important here.
            Checkpoint208 memory last = _unsafeAccess(self, pos - 1);

            // Checkpoint keys must be non-decreasing.
            if (last._key > key) {
                revert CheckpointUnorderedInsertion();
            }

            // Update or push new checkpoint
            if (last._key == key) {
                _unsafeAccess(self, pos - 1)._value = value;
            } else {
                self.push(Checkpoint208({_key: key, _value: value}));
            }
            return (last._value, value);
        } else {
            self.push(Checkpoint208({_key: key, _value: value}));
            return (0, value);
        }
    }

    /**
     * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`
     * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive
     * `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _upperBinaryLookup(
        Checkpoint208[] storage self,
        uint48 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key > key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

    /**
     * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or
     * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and
     * exclusive `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _lowerBinaryLookup(
        Checkpoint208[] storage self,
        uint48 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key < key) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return high;
    }

    /**
     * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
     */
    function _unsafeAccess(
        Checkpoint208[] storage self,
        uint256 pos
    ) private pure returns (Checkpoint208 storage result) {
        assembly {
            mstore(0, self.slot)
            result.slot := add(keccak256(0, 0x20), pos)
        }
    }

    struct Trace160 {
        Checkpoint160[] _checkpoints;
    }

    struct Checkpoint160 {
        uint96 _key;
        uint160 _value;
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into a Trace160 so that it is stored as the checkpoint.
     *
     * Returns previous value and new value.
     *
     * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint96).max` key set will disable the
     * library.
     */
    function push(Trace160 storage self, uint96 key, uint160 value) internal returns (uint160, uint160) {
        return _insert(self._checkpoints, key, value);
    }

    /**
     * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if
     * there is none.
     */
    function lowerLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);
        return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     */
    function upperLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {
        uint256 len = self._checkpoints.length;
        uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero
     * if there is none.
     *
     * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high
     * keys).
     */
    function upperLookupRecent(Trace160 storage self, uint96 key) internal view returns (uint160) {
        uint256 len = self._checkpoints.length;

        uint256 low = 0;
        uint256 high = len;

        if (len > 5) {
            uint256 mid = len - Math.sqrt(len);
            if (key < _unsafeAccess(self._checkpoints, mid)._key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);

        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.
     */
    function latest(Trace160 storage self) internal view returns (uint160) {
        uint256 pos = self._checkpoints.length;
        return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
    }

    /**
     * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value
     * in the most recent checkpoint.
     */
    function latestCheckpoint(Trace160 storage self) internal view returns (bool exists, uint96 _key, uint160 _value) {
        uint256 pos = self._checkpoints.length;
        if (pos == 0) {
            return (false, 0, 0);
        } else {
            Checkpoint160 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
            return (true, ckpt._key, ckpt._value);
        }
    }

    /**
     * @dev Returns the number of checkpoint.
     */
    function length(Trace160 storage self) internal view returns (uint256) {
        return self._checkpoints.length;
    }

    /**
     * @dev Returns checkpoint at given position.
     */
    function at(Trace160 storage self, uint32 pos) internal view returns (Checkpoint160 memory) {
        return self._checkpoints[pos];
    }

    /**
     * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,
     * or by updating the last one.
     */
    function _insert(Checkpoint160[] storage self, uint96 key, uint160 value) private returns (uint160, uint160) {
        uint256 pos = self.length;

        if (pos > 0) {
            // Copying to memory is important here.
            Checkpoint160 memory last = _unsafeAccess(self, pos - 1);

            // Checkpoint keys must be non-decreasing.
            if (last._key > key) {
                revert CheckpointUnorderedInsertion();
            }

            // Update or push new checkpoint
            if (last._key == key) {
                _unsafeAccess(self, pos - 1)._value = value;
            } else {
                self.push(Checkpoint160({_key: key, _value: value}));
            }
            return (last._value, value);
        } else {
            self.push(Checkpoint160({_key: key, _value: value}));
            return (0, value);
        }
    }

    /**
     * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`
     * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive
     * `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _upperBinaryLookup(
        Checkpoint160[] storage self,
        uint96 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key > key) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

    /**
     * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or
     * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and
     * exclusive `high`.
     *
     * WARNING: `high` should not be greater than the array's length.
     */
    function _lowerBinaryLookup(
        Checkpoint160[] storage self,
        uint96 key,
        uint256 low,
        uint256 high
    ) private view returns (uint256) {
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (_unsafeAccess(self, mid)._key < key) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return high;
    }

    /**
     * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.
     */
    function _unsafeAccess(
        Checkpoint160[] storage self,
        uint256 pos
    ) private pure returns (Checkpoint160 storage result) {
        assembly {
            mstore(0, self.slot)
            result.slot := add(keccak256(0, 0x20), pos)
        }
    }
}

// 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.0.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, RecoverError, bytes32) {
        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.
            /// @solidity memory-safe-assembly
            assembly {
                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[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        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, RecoverError, bytes32) {
        // 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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;

import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _name which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Name() internal view returns (string memory) {
        return _name.toStringWithFallback(_nameFallback);
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _version which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Version() internal view returns (string memory) {
        return _version.toStringWithFallback(_versionFallback);
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

        emit Transfer(from, to, value);
    }

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

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

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

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

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

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

pragma solidity ^0.8.20;

import {ERC20} from "../ERC20.sol";
import {Votes} from "../../../governance/utils/Votes.sol";
import {Checkpoints} from "../../../utils/structs/Checkpoints.sol";

/**
 * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,
 * and supports token supply up to 2^208^ - 1, while COMP is limited to 2^96^ - 1.
 *
 * NOTE: This contract does not provide interface compatibility with Compound's COMP token.
 *
 * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either
 * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting
 * power can be queried through the public accessors {getVotes} and {getPastVotes}.
 *
 * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it
 * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.
 */
abstract contract ERC20Votes is ERC20, Votes {
    /**
     * @dev Total supply cap has been exceeded, introducing a risk of votes overflowing.
     */
    error ERC20ExceededSafeSupply(uint256 increasedSupply, uint256 cap);

    /**
     * @dev Maximum token supply. Defaults to `type(uint208).max` (2^208^ - 1).
     *
     * This maximum is enforced in {_update}. It limits the total supply of the token, which is otherwise a uint256,
     * so that checkpoints can be stored in the Trace208 structure used by {{Votes}}. Increasing this value will not
     * remove the underlying limitation, and will cause {_update} to fail because of a math overflow in
     * {_transferVotingUnits}. An override could be used to further restrict the total supply (to a lower value) if
     * additional logic requires it. When resolving override conflicts on this function, the minimum should be
     * returned.
     */
    function _maxSupply() internal view virtual returns (uint256) {
        return type(uint208).max;
    }

    /**
     * @dev Move voting power when tokens are transferred.
     *
     * Emits a {IVotes-DelegateVotesChanged} event.
     */
    function _update(address from, address to, uint256 value) internal virtual override {
        super._update(from, to, value);
        if (from == address(0)) {
            uint256 supply = totalSupply();
            uint256 cap = _maxSupply();
            if (supply > cap) {
                revert ERC20ExceededSafeSupply(supply, cap);
            }
        }
        _transferVotingUnits(from, to, value);
    }

    /**
     * @dev Returns the voting units of an `account`.
     *
     * WARNING: Overriding this function may compromise the internal vote accounting.
     * `ERC20Votes` assumes tokens map to voting units 1:1 and this is not easy to change.
     */
    function _getVotingUnits(address account) internal view virtual override returns (uint256) {
        return balanceOf(account);
    }

    /**
     * @dev Get number of checkpoints for `account`.
     */
    function numCheckpoints(address account) public view virtual returns (uint32) {
        return _numCheckpoints(account);
    }

    /**
     * @dev Get the `pos`-th checkpoint for `account`.
     */
    function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoints.Checkpoint208 memory) {
        return _checkpoints(account, pos);
    }
}

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

import "./EntropyStructs.sol";

interface EntropyEvents {
    event Registered(EntropyStructs.ProviderInfo provider);

    event Requested(EntropyStructs.Request request);
    event RequestedWithCallback(
        address indexed provider,
        address indexed requestor,
        uint64 indexed sequenceNumber,
        bytes32 userRandomNumber,
        EntropyStructs.Request request
    );

    event Revealed(
        EntropyStructs.Request request,
        bytes32 userRevelation,
        bytes32 providerRevelation,
        bytes32 blockHash,
        bytes32 randomNumber
    );
    event RevealedWithCallback(
        EntropyStructs.Request request,
        bytes32 userRandomNumber,
        bytes32 providerRevelation,
        bytes32 randomNumber
    );

    event ProviderFeeUpdated(address provider, uint128 oldFee, uint128 newFee);

    event ProviderUriUpdated(address provider, bytes oldUri, bytes newUri);

    event ProviderFeeManagerUpdated(
        address provider,
        address oldFeeManager,
        address newFeeManager
    );

    event Withdrawal(
        address provider,
        address recipient,
        uint128 withdrawnAmount
    );
}

// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.0;

contract EntropyStructs {
    struct ProviderInfo {
        uint128 feeInWei;
        uint128 accruedFeesInWei;
        // The commitment that the provider posted to the blockchain, and the sequence number
        // where they committed to this. This value is not advanced after the provider commits,
        // and instead is stored to help providers track where they are in the hash chain.
        bytes32 originalCommitment;
        uint64 originalCommitmentSequenceNumber;
        // Metadata for the current commitment. Providers may optionally use this field to help
        // manage rotations (i.e., to pick the sequence number from the correct hash chain).
        bytes commitmentMetadata;
        // Optional URI where clients can retrieve revelations for the provider.
        // Client SDKs can use this field to automatically determine how to retrieve random values for each provider.
        // TODO: specify the API that must be implemented at this URI
        bytes uri;
        // The first sequence number that is *not* included in the current commitment (i.e., an exclusive end index).
        // The contract maintains the invariant that sequenceNumber <= endSequenceNumber.
        // If sequenceNumber == endSequenceNumber, the provider must rotate their commitment to add additional random values.
        uint64 endSequenceNumber;
        // The sequence number that will be assigned to the next inbound user request.
        uint64 sequenceNumber;
        // The current commitment represents an index/value in the provider's hash chain.
        // These values are used to verify requests for future sequence numbers. Note that
        // currentCommitmentSequenceNumber < sequenceNumber.
        //
        // The currentCommitment advances forward through the provider's hash chain as values
        // are revealed on-chain.
        bytes32 currentCommitment;
        uint64 currentCommitmentSequenceNumber;
        // An address that is authorized to set / withdraw fees on behalf of this provider.
        address feeManager;
    }

    struct Request {
        // Storage slot 1 //
        address provider;
        uint64 sequenceNumber;
        // The number of hashes required to verify the provider revelation.
        uint32 numHashes;
        // Storage slot 2 //
        // The commitment is keccak256(userCommitment, providerCommitment). Storing the hash instead of both saves 20k gas by
        // eliminating 1 store.
        bytes32 commitment;
        // Storage slot 3 //
        // The number of the block where this request was created.
        // Note that we're using a uint64 such that we have an additional space for an address and other fields in
        // this storage slot. Although block.number returns a uint256, 64 bits should be plenty to index all of the
        // blocks ever generated.
        uint64 blockNumber;
        // The address that requested this random number.
        address requester;
        // If true, incorporate the blockhash of blockNumber into the generated random value.
        bool useBlockhash;
        // If true, the requester will be called back with the generated random value.
        bool isRequestWithCallback;
        // There are 2 remaining bytes of free space in this slot.
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {ERC20Votes} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";

import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol";

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

/**
 * @notice Adds support for tracking historical balance on ERC20Votes (not just
 * historical voting power) and adds support for contributing and retrieving
 * incentives pro-rata of historical balanceOf.
 *
 * @notice Uses a timestamp-based clock for checkpoints as opposed to the
 * default OZ implementation that is blocknumber based.
 */
abstract contract HistoricalBalance is ERC20Votes, IHistoricalBalance {
    using Checkpoints for Checkpoints.Trace208;

    mapping(address account => Checkpoints.Trace208) private _balanceOfCheckpoints;

    //////////////////////
    // Past Balance
    //////////////////////

    /// @inheritdoc IHistoricalBalance
    function getPastBalanceOf(address account, uint256 timepoint) public view returns (uint256 balance) {
        uint48 currentTimepoint = clock();
        if (timepoint >= currentTimepoint) {
            revert ERC5805FutureLookup(timepoint, currentTimepoint);
        }
        // cast is safe because of conditional above
        return _balanceOfCheckpoints[account].upperLookupRecent(uint48(timepoint));
    }

    //////////////////////
    // Overrides
    //////////////////////

    function _update(address from, address to, uint256 amount) internal virtual override {
        ERC20Votes._update(from, to, amount);

        if (from != to && amount > 0) {
            if (from != address(0)) {
                __push(_balanceOfCheckpoints[from], __subtract, SafeCast.toUint208(amount));
            }
            if (to != address(0)) {
                __push(_balanceOfCheckpoints[to], __add, SafeCast.toUint208(amount));
            }
        }
    }

    function clock() public view override returns (uint48) {
        return Time.timestamp();
    }

    /**
     * @dev Machine-readable description of the clock as specified in ERC-6372.
     */
    // solhint-disable-next-line func-name-mixedcase
    function CLOCK_MODE() public pure override returns (string memory) {
        return "mode=timestamp";
    }

    //////////////////////
    // Helpers
    //////////////////////

    function __push(
        Checkpoints.Trace208 storage store,
        function(uint208, uint208) view returns (uint208) op,
        uint208 delta
    ) private returns (uint208, uint208) {
        return store.push(clock(), op(store.latest(), delta));
    }

    function __add(uint208 a, uint208 b) private pure returns (uint208) {
        return a + b;
    }

    function __subtract(uint208 a, uint208 b) private pure returns (uint208) {
        return a - b;
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

interface IDistribution {
    error InvalidTick(int32 tick);
    error InvalidBinId(uint32 binId);
    error CurveIndexNotSupported(uint256 curveIndex);

    function lastTick() external returns (int32);

    function binIdToTick(bool tokenIsA, uint32 binId) external pure returns (int32);

    function ticks(bool tokenIsA) external pure returns (int32[] memory _ticks);

    function tickToBinId(bool tokenIsA, int32 _tick) external pure returns (uint32 binId);

    function amount(bool tokenIsA, uint256 k, uint256 curveIndex) external pure returns (uint128);

    function amounts(bool tokenIsA, uint256 curveIndex) external pure returns (uint128[] memory _amounts);

    function quoteBaseline(bool tokenIsA, uint256 k, uint256 curveIndex) external pure returns (uint256 quoteAmount);

    function quoteBaselineAtTick(
        bool tokenIsA,
        int32 tick,
        uint256 curveIndex
    ) external pure returns (uint256 quoteAmount);

    function tailAmounts() external pure returns (uint128[] memory _amounts);
    function swappedTick(bool tokenIsA) external pure returns (int32);
    function amountBaselines() external pure returns (uint256[6] memory baselines);
    function tailBaseline() external pure returns (uint256 baseline);
    function tailTicks(bool tokenIsA) external pure returns (int32[] memory _ticks);
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

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

pragma solidity ^0.8.20;

import {IVotes} from "../governance/utils/IVotes.sol";
import {IERC6372} from "./IERC6372.sol";

interface IERC5805 is IERC6372, IVotes {}

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

pragma solidity ^0.8.20;

interface IERC6372 {
    /**
     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).
     */
    function clock() external view returns (uint48);

    /**
     * @dev Description of the clock
     */
    // solhint-disable-next-line func-name-mixedcase
    function CLOCK_MODE() external view returns (string memory);
}

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

import "./EntropyEvents.sol";

interface IEntropy is EntropyEvents {
    // Register msg.sender as a randomness provider. The arguments are the provider's configuration parameters
    // and initial commitment. Re-registering the same provider rotates the provider's commitment (and updates
    // the feeInWei).
    //
    // chainLength is the number of values in the hash chain *including* the commitment, that is, chainLength >= 1.
    function register(
        uint128 feeInWei,
        bytes32 commitment,
        bytes calldata commitmentMetadata,
        uint64 chainLength,
        bytes calldata uri
    ) external;

    // Withdraw a portion of the accumulated fees for the provider msg.sender.
    // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient
    // balance of fees in the contract).
    function withdraw(uint128 amount) external;

    // Withdraw a portion of the accumulated fees for provider. The msg.sender must be the fee manager for this provider.
    // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient
    // balance of fees in the contract).
    function withdrawAsFeeManager(address provider, uint128 amount) external;

    // As a user, request a random number from `provider`. Prior to calling this method, the user should
    // generate a random number x and keep it secret. The user should then compute hash(x) and pass that
    // as the userCommitment argument. (You may call the constructUserCommitment method to compute the hash.)
    //
    // This method returns a sequence number. The user should pass this sequence number to
    // their chosen provider (the exact method for doing so will depend on the provider) to retrieve the provider's
    // number. The user should then call fulfillRequest to construct the final random number.
    //
    // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value.
    // Note that excess value is *not* refunded to the caller.
    function request(
        address provider,
        bytes32 userCommitment,
        bool useBlockHash
    ) external payable returns (uint64 assignedSequenceNumber);

    // Request a random number. The method expects the provider address and a secret random number
    // in the arguments. It returns a sequence number.
    //
    // The address calling this function should be a contract that inherits from the IEntropyConsumer interface.
    // The `entropyCallback` method on that interface will receive a callback with the generated random number.
    //
    // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value.
    // Note that excess value is *not* refunded to the caller.
    function requestWithCallback(
        address provider,
        bytes32 userRandomNumber
    ) external payable returns (uint64 assignedSequenceNumber);

    // Fulfill a request for a random number. This method validates the provided userRandomness and provider's proof
    // against the corresponding commitments in the in-flight request. If both values are validated, this function returns
    // the corresponding random number.
    //
    // Note that this function can only be called once per in-flight request. Calling this function deletes the stored
    // request information (so that the contract doesn't use a linear amount of storage in the number of requests).
    // If you need to use the returned random number more than once, you are responsible for storing it.
    function reveal(
        address provider,
        uint64 sequenceNumber,
        bytes32 userRevelation,
        bytes32 providerRevelation
    ) external returns (bytes32 randomNumber);

    // Fulfill a request for a random number. This method validates the provided userRandomness
    // and provider's revelation against the corresponding commitment in the in-flight request. If both values are validated
    // and the requestor address is a contract address, this function calls the requester's entropyCallback method with the
    // sequence number, provider address and the random number as arguments. Else if the requestor is an EOA, it won't call it.
    //
    // Note that this function can only be called once per in-flight request. Calling this function deletes the stored
    // request information (so that the contract doesn't use a linear amount of storage in the number of requests).
    // If you need to use the returned random number more than once, you are responsible for storing it.
    //
    // Anyone can call this method to fulfill a request, but the callback will only be made to the original requester.
    function revealWithCallback(
        address provider,
        uint64 sequenceNumber,
        bytes32 userRandomNumber,
        bytes32 providerRevelation
    ) external;

    function getProviderInfo(
        address provider
    ) external view returns (EntropyStructs.ProviderInfo memory info);

    function getDefaultProvider() external view returns (address provider);

    function getRequest(
        address provider,
        uint64 sequenceNumber
    ) external view returns (EntropyStructs.Request memory req);

    function getFee(address provider) external view returns (uint128 feeAmount);

    function getAccruedPythFees()
        external
        view
        returns (uint128 accruedPythFeesInWei);

    function setProviderFee(uint128 newFeeInWei) external;

    function setProviderFeeAsFeeManager(
        address provider,
        uint128 newFeeInWei
    ) external;

    function setProviderUri(bytes calldata newUri) external;

    // Set manager as the fee manager for the provider msg.sender.
    // After calling this function, manager will be able to set the provider's fees and withdraw them.
    // Only one address can be the fee manager for a provider at a time -- calling this function again with a new value
    // will override the previous value. Call this function with the all-zero address to disable the fee manager role.
    function setFeeManager(address manager) external;

    function constructUserCommitment(
        bytes32 userRandomness
    ) external pure returns (bytes32 userCommitment);

    function combineRandomValues(
        bytes32 userRandomness,
        bytes32 providerRandomness,
        bytes32 blockHash
    ) external pure returns (bytes32 combinedRandomness);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

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

interface IFeeVault {
    event DepositAmount(IERC20 indexed token, address indexed account, uint256 amount);
    event Claim(IERC20 indexed token, address indexed account, uint256 amount);

    /**
     * @notice View the balance of a given address for a given token.
     */
    function tokenUserToBalance(IERC20 token, address user) external view returns (uint256 balance);

    /**
     * @notice Transfers any fee set aside for sender to the sender.
     */
    function claim(IERC20 token) external returns (uint256 amount);

    /**
     * @notice Deposit token amounts to addresses.  This function will
     * transfer the sum amounts to the FeeVault.  The amounts can later be
     * `claim`ed at any time by the respective deposited address.
     */
    function depositAmount(IERC20 token, address addr1, uint256 amount1) external;

    /**
     * @notice Deposit token amounts to addresses.  This function will
     * transfer the sum amounts to the FeeVault.  The amounts can later be
     * `claim`ed at any time by the respective deposited address.
     */
    function depositAmounts(
        IERC20 token,
        address addr1,
        uint256 amount1,
        address addr2,
        uint256 amount2,
        address addr3,
        uint256 amount3,
        address addr4,
        uint256 amount4
    ) external;

    /**
     * @notice Deposit token amounts to addresses.  This function will
     * transfer the sum amounts to the FeeVault.  The amounts can later be
     * `claim`ed at any time by the respective deposited address.
     */
    function depositAmounts(IERC20 token, address addr1, uint256 amount1, address addr2, uint256 amount2) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

interface IHistoricalBalance {
    /**
     * @notice This function retrieves the historical balance of an account at
     * a specific point in time.
     * @param account The address of the account for which to retrieve the
     * historical balance.
     * @param timepoint The timepoint (block number or timestamp depending on
     * implementation) at which to query the balance (uint256).
     * @return balance The balance of the account at the specified timepoint.
     */
    function getPastBalanceOf(address account, uint256 timepoint) external view returns (uint256 balance);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

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

/**
 * @notice Adds support for tracking historical balance on ERC20  and adds
 * support for contributing and retrieving incentives pro-rata of historical
 * balanceOf.
 *
 * @notice Uses a timestamp-based clock for checkpoints as opposed to the
 * default OZ implementation that is blocknumber based.
 */
interface IHistoricalBalanceNonTransferableERC20 is IERC20 {
    error ERC5805FutureLookup(uint256 timepoint, uint48 clock);
    error TransferNotAllowed();
    error OnlyMinter(address sender, address minter);

    event NewTopHolder(address topHolder, uint256 topHolderBalance);
    event NewTopDayHolder(uint256 dayNumber, address topHolder, uint256 topHolderBalance);

    struct AddressBalance {
        address holder;
        uint256 balance;
    }

    /**
     * @notice This function retrieves the historical balance of an account at
     * a specific point in time.
     * @param account The address of the account for which to retrieve the
     * historical balance.
     * @param timepoint The timepoint (block number or timestamp depending on
     * implementation) at which to query the balance (uint256).
     * @return balance The balance of the account at the specified timepoint.
     */
    function getPastBalanceOf(address account, uint256 timepoint) external view returns (uint256 balance);

    /**
     * @notice Returns the total supply of votes available at a specific moment in the past. If the `clock()` is
     * configured to use block numbers, this will return the value at the end of the corresponding block.
     *
     * NOTE: This value is the sum of all available balance.
     */
    function getPastTotalSupply(uint256 timepoint) external view returns (uint256);

    /**
     * @notice Token units this trackers tracks
     */
    function trackerToken() external view returns (IERC20);
    /**
     * @notice Account that can mint tokens
     */
    function minter() external view returns (address);
    /**
     * @notice Mint token
     */
    function mint(address recipient, uint256 amount) external;
    /**
     * @notice Account/Balance that has the highest balance
     */
    function topAccount() external view returns (address, uint256);
    /**
     * @notice Account/Balance of the top holder for given day
     */
    function topAccountByDay(uint256 dayNumber) external view returns (address, uint256);
    /**
     * @notice Account/Balance of the top holder for given day
     */
    function topAccountCurrentDay() external view returns (address, uint256);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ITokenManager} from "./ITokenManager.sol";
import {ITokenManagerLens} from "./ITokenManagerLens.sol";
import {ISwapper} from "./ISwapper.sol";
import {IMaverickV2Pool} from "../v2-common/interfaces/IMaverickV2Pool.sol";
import {IMaverickV2Factory} from "../v2-common/interfaces/IMaverickV2Factory.sol";

interface ILaunchFactory {
    error InvalidLaunchFee(uint256 valueSent, uint256 valueRequired);
    error InvalidPoolFee(uint256 fee, uint256 feeMinAllowed, uint256 feeMaxAllowed);
    error InvalidBorrowFeeRate();
    error AllLiquidityDeployed();
    error MainLiquidityDeployed();
    error MainLiquidityNotDeployed();
    error NameSymbolAlreadyDeployed();

    struct TokenData {
        string name;
        string symbol;
        string imageHash;
        string metadataHash;
    }

    struct BorrowFeeRates {
        uint64 proportionToVotingDistributorD18;
        uint64 proportionToCreatorD18;
        uint64 proportionToVoterD18;
    }

    struct PoolData {
        uint64 buyFee;
        uint64 sellFee;
        uint8 curveIndex;
    }

    struct TempLaunchData {
        TokenData tokenData;
        IERC20 token;
        IMaverickV2Pool pool;
        bool borrowingEnabled;
        address feeRecipient;
        PoolData poolData;
    }

    event CreateTokenManager(
        IERC20 indexed token,
        IMaverickV2Pool indexed pool,
        ITokenManager indexed tokenManager,
        address feeRecipient,
        bool borrowingEnabled,
        TokenData tokenData,
        PoolData poolData,
        IERC20 quoteToken,
        bool tokenIsA,
        uint256 ethLaunchFeePaid
    );

    event SetProtocolFeeCollector(address protocolFeeCollector, bool notifyFeeCollector);
    event SetLaunchFeeCollector(address launchFeeCollector);
    event SetSwapper(ISwapper swapper);
    event SetBorrowFeeRateD18(uint256 borrowFeeRate);
    event SetEthLaunchFee(uint128 ethLaunchFee);
    event SetProtocolFee(uint128 protocolFeeProportionD18);
    event SetBorrowFeeRates(BorrowFeeRates rates);
    event DeployTailLiqudiity(IERC20 indexed token, IMaverickV2Pool indexed pool, ITokenManager indexed tokenManager);
    event DeployMainLiqudiity(IERC20 indexed token, IMaverickV2Pool indexed pool, ITokenManager indexed tokenManager);
    event AddFreeMinter(address user);
    event RemoveFreeMinter(address user);

    function tempLaunchData() external view returns (TempLaunchData memory);

    /**
     * @notice Indicator of whether an address can mint a token without paying
     * the eth fee
     */
    function freeMinter(address) external view returns (bool);

    /**
     * @notice Gets the ratio of fees going to voter/creator/protocol
     */
    function borrowFeeRates()
        external
        view
        returns (uint64 proportionToVotingDistributorD18, uint64 proportionToCreatorD18, uint64 proportionToVoterD18);

    /**
     * @notice Gets the ETH launch fee for creating a new token manager
     */
    function ethLaunchFee() external view returns (uint128);

    /**
     * @notice Gets Borrowing fee rate
     */
    function borrowFeeRateD18() external view returns (uint256);

    /**
     * @notice Gets the quote contract address
     */
    function quoteToken() external view returns (IERC20);

    /**
     * @notice Gets the Token Manager Lens contract
     */
    function lens() external view returns (ITokenManagerLens);

    /**
     * @notice Gets the Maverick V2 Factory contract
     */
    function factory() external view returns (IMaverickV2Factory);

    /**
     * @notice Gets the launch fee collector address
     */
    function launchFeeCollector() external view returns (address);

    /**
     * @notice Checks if a given Token Manager is managed by this factory
     */
    function isFactoryManager(ITokenManager tokenManager) external view returns (bool);

    /**
     * @notice Checks if a given token has been created by this factory
     */
    function isFactoryToken(IERC20 token) external view returns (bool);

    /**
     * @notice Checks if a given pool has been created by this factory
     */
    function isFactoryPool(IMaverickV2Pool pool) external view returns (bool);

    /**
     * @notice Indicates if symbol hash has already been deployed
     */
    function symbolHashDeployed(bytes32 spaceStrippedLowerCaseSymbolHash) external view returns (bool);

    /**
     * @notice Gets the Token Manager associated with a given ERC20 token
     */
    function managerFromToken(IERC20 token) external view returns (ITokenManager tokenManager);

    /**
     * @notice True if tail liquidity has been deployed
     */
    function tailLiquidityDeployed(IERC20 token) external view returns (bool);

    /**
     * @notice True if main liquidity has been deployed
     */
    function mainLiquidityDeployed(IERC20 token) external view returns (bool);

    /**
     * @notice Gets the Token Manager associated with a given pool
     */
    function managerFromPool(IMaverickV2Pool pool) external view returns (ITokenManager tokenManager);

    /**
     * @notice Gets the total number of Token Managers created by this factory
     */
    function managerCount() external view returns (uint256 _managerCount);

    /**
     * @notice Gets the factory swapper which is also the permissioned pool accessor
     */
    function swapper() external view returns (ISwapper swapper);

    /**
     * @notice Gets a list of Token Managers within a specified range
     * @param startIndex The starting index of the range (inclusive)
     * @param endIndex The ending index of the range (exclusive)
 of Token Manager contracts
     */
    function managers(uint256 startIndex, uint256 endIndex) external view returns (ITokenManager[] memory);

    /**
     * @notice Creates a new Token Manager contract
     * @param tokenData The name/symbol and ipfs data of the new token
     * @param poolData The pool fee/distribution parameters
     * @param feeRecipient The address that will receive the fees
     * @param borrowingEnabled Whether borrowing is enabled for the new token
     * @param tokenSalt Salt for token create2
     * @return tokenManager The newly created Token Manager contract
     */
    function createTokenManager(
        TokenData memory tokenData,
        PoolData memory poolData,
        address feeRecipient,
        bool borrowingEnabled,
        string memory tokenSalt
    ) external payable returns (ITokenManager tokenManager);

    /**
     * @notice Creates a new Token Manager contract but does not add liquidity to pool.
     * @param tokenData The name/symbol and ipfs data of the new token
     * @param poolData The pool fee/distribution parameters
     * @param feeRecipient The address that will receive the fees
     * @param borrowingEnabled Whether borrowing is enabled for the new token
     * @param tokenSalt Salt for token create2
     * @return tokenManager The newly created Token Manager contract
     */
    function createTokenManagerWithoutLiquidity(
        TokenData memory tokenData,
        PoolData memory poolData,
        address feeRecipient,
        bool borrowingEnabled,
        string memory tokenSalt
    ) external payable returns (ITokenManager tokenManager);

    /**
     * @notice Creates a new Token Manager contract
     * @param tokenData The name/symbol and ipfs data of the new token
     * @param poolData The pool fee/distribution parameters
     * @param feeRecipient The address that will receive the fees
     * @param borrowingEnabled Whether borrowing is enabled for the new token
     * @param tokenSalt Salt for token create2
     * @param tokenRecipient The address to receive the purchased tokens
     * @param ethToQuotePool The Maverick pool that can swap eth for quote token
     * @param amountOutMinimum The minimum amount of tokens to receive
     * @param deployTail True to deploy all supply; false to only deploy main supply
     * @return tokenManager The newly created Token Manager contract
     * @return amountOut Amount sent with buy
     */
    function createTokenManagerAndBuy(
        TokenData memory tokenData,
        PoolData memory poolData,
        address feeRecipient,
        bool borrowingEnabled,
        string memory tokenSalt,
        address tokenRecipient,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountOutMinimum,
        bool deployTail
    ) external payable returns (ITokenManager tokenManager, uint256 amountOut);

    /**
     * @notice Deploys a thin layer of liquidity 100 ticks past the end of the
     * initial distribution.  This is effectively prices the supply out to
     * price = inifinity meaning that the launch pool will always have supply to
     * sell.
     */
    function deployTailLiquidity(IERC20 token) external;

    /**
     * @notice Deploys main liquidity to a token's pool.
     */
    function deployMainLiquidity(IERC20 token) external;

    /**
     * @notice Init code hash of launch token.  Useful for computing create2
     * addresses of tokens. Address can be computed in solidity with:
     *
     * ```
     * Create2.computeAddress(
     *     keccak256(abi.encode(symbol, salt)),
     *     factory.tokenCreationCodeHash(),
     *     address(_factory)
     * )
     *```
     */
    function tokenCreationCodeHash() external pure returns (bytes32);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

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

import {IHistoricalBalance} from "./external/IHistoricalBalance.sol";

interface ILaunchToken is IHistoricalBalance {
    error SupplyAlreadyMinted();

    /**
     * @notice Returns the hash of the token image.
     */
    function getImageHash() external view returns (string memory);

    /**
     * @notice Returns the hash of the token metadata.
     */
    function getMetadataHash() external view returns (string memory);

    /**
     * @notice Returns the hash of the token metadata.
     */
    function getLaunchFactory() external view returns (ILaunchFactory);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

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

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

interface IMaverickV2Factory {
    error FactoryInvalidProtocolFeeRatio(uint8 protocolFeeRatioD3);
    error FactoryInvalidLendingFeeRate(uint256 protocolLendingFeeRateD18);
    error FactoryProtocolFeeOnRenounce(uint8 protocolFeeRatioD3);
    error FactorAlreadyInitialized();
    error FactorNotInitialized();
    error FactoryInvalidTokenOrder(IERC20 _tokenA, IERC20 _tokenB);
    error FactoryInvalidFee();
    error FactoryInvalidKinds(uint8 kinds);
    error FactoryInvalidTickSpacing(uint256 tickSpacing);
    error FactoryInvalidLookback(uint256 lookback);
    error FactoryInvalidTokenDecimals(uint8 decimalsA, uint8 decimalsB);
    error FactoryPoolAlreadyExists(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds,
        address accessor
    );
    error FactoryAccessorMustBeNonZero();

    event PoolCreated(
        IMaverickV2Pool poolAddress,
        uint8 protocolFeeRatio,
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        int32 activeTick,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds,
        address accessor
    );
    event SetFactoryProtocolFeeRatio(uint8 protocolFeeRatioD3);
    event SetFactoryProtocolLendingFeeRate(uint256 lendingFeeRateD18);
    event SetFactoryProtocolFeeReceiver(address receiver);

    struct DeployParameters {
        uint64 feeAIn;
        uint64 feeBIn;
        uint32 lookback;
        int32 activeTick;
        uint64 tokenAScale;
        uint64 tokenBScale;
        // slot
        IERC20 tokenA;
        // slot
        IERC20 tokenB;
        // slot
        uint16 tickSpacing;
        uint8 options;
        address accessor;
    }

    /**
     * @notice Called by deployer library to initialize a pool.
     */
    function deployParameters()
        external
        view
        returns (
            uint64 feeAIn,
            uint64 feeBIn,
            uint32 lookback,
            int32 activeTick,
            uint64 tokenAScale,
            uint64 tokenBScale,
            // slot
            IERC20 tokenA,
            // slot
            IERC20 tokenB,
            // slot
            uint16 tickSpacing,
            uint8 options,
            address accessor
        );

    /**
     * @notice Create a new MaverickV2Pool with symmetric swap fees.
     * @param fee Fraction of the pool swap amount that is retained as an LP in
     * D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function create(
        uint64 fee,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2Pool.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * e.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function create(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with symmetric swap fees
     * with all functions permissioned.  Set fee to zero to make the pool fee settable by the accessor.
     * @param fee Fraction of the pool swap amount that is retained as an LP in
     * D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor Only address that can access the pool's public write functions.
     */
    function createPermissioned(
        uint64 fee,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with all functions
     * permissioned. Set fees to zero to make the pool fee settable by the
     * accessor.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor only address that can access the pool's public write functions.
     */
    function createPermissioned(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor
    ) external returns (IMaverickV2Pool);

    /**
     * @notice Create a new MaverickV2PoolPermissioned with the option to make
     * a subset of function permissionless. Set fee to zero to make the pool
     * fee settable by the accessor.
     * @param feeAIn Fraction of the pool swap amount for tokenA-input swaps
     * that is retained as an LP in D18 scale.
     * @param feeBIn Fraction of the pool swap amount for tokenB-input swaps
     * that is retained as an LP in D18 scale.
     * @param tickSpacing Tick spacing of pool where 1.0001^tickSpacing is the
     * bin width.
     * @param lookback Pool lookback in seconds.
     * @param tokenA Address of tokenA.
     * @param tokenB Address of tokenB.
     * @param activeTick Tick position that contains the active bins.
     * @param kinds 1-15 number to represent the active kinds
     * 0b0001 = static;
     * 0b0010 = right;
     * 0b0100 = left;
     * 0b1000 = both.
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     * @param accessor only address that can access the pool's public permissioned write functions.
     * @param  permissionedLiquidity If true, then only accessor can call
     * pool's liquidity management functions: `flashLoan`,
     * `migrateBinsUpstack`, `addLiquidity`, `removeLiquidity`.
     * @param  permissionedSwap If true, then only accessor can call
     * pool's swap function.
     */
    function createPermissioned(
        uint64 feeAIn,
        uint64 feeBIn,
        uint16 tickSpacing,
        uint32 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        int32 activeTick,
        uint8 kinds,
        address accessor,
        bool permissionedLiquidity,
        bool permissionedSwap
    ) external returns (IMaverickV2Pool pool);

    /**
     * @notice Update the protocol fee ratio for a pool. Can be called
     * permissionlessly allowing any user to sync the pool protocol fee value
     * with the factory protocol fee value.
     * @param pool The pool for which to update.
     */
    function updateProtocolFeeRatioForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Update the protocol lending fee rate for a pool. Can be called
     * permissionlessly allowing any user to sync the pool protocol lending fee
     * rate value with the factory value.
     * @param pool The pool for which to update.
     */
    function updateProtocolLendingFeeRateForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Claim protocol fee for a pool and transfer it to the protocolFeeReceiver.
     * @param pool The pool from which to claim the protocol fee.
     * @param isTokenA A boolean indicating whether tokenA (true) or tokenB
     * (false) is being collected.
     */
    function claimProtocolFeeForPool(IMaverickV2Pool pool, bool isTokenA) external;

    /**
     * @notice Claim protocol fee for a pool and transfer it to the protocolFeeReceiver.
     * @param pool The pool from which to claim the protocol fee.
     */
    function claimProtocolFeeForPool(IMaverickV2Pool pool) external;

    /**
     * @notice Bool indicating whether the pool was deployed from this factory.
     */
    function isFactoryPool(IMaverickV2Pool pool) external view returns (bool);

    /**
     * @notice Address that receives the protocol fee when users call
     * `claimProtocolFeeForPool`.
     */
    function protocolFeeReceiver() external view returns (address);

    /**
     * @notice Lookup a pool for given parameters.
     *
     * @dev  options bit map of kinds and function permissions
     * 0b000001 = static;
     * 0b000010 = right;
     * 0b000100 = left;
     * 0b001000 = both;
     * 0b010000 = liquidity functions are permissioned
     * 0b100000 = swap function is permissioned
     */
    function lookupPermissioned(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 options,
        address accessor
    ) external view returns (IMaverickV2Pool);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookupPermissioned(
        IERC20 _tokenA,
        IERC20 _tokenB,
        address accessor,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookupPermissioned(
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(
        uint256 feeAIn,
        uint256 feeBIn,
        uint256 tickSpacing,
        uint256 lookback,
        IERC20 tokenA,
        IERC20 tokenB,
        uint8 kinds
    ) external view returns (IMaverickV2Pool);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(
        IERC20 _tokenA,
        IERC20 _tokenB,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Lookup a pool for given parameters.
     */
    function lookup(uint256 startIndex, uint256 endIndex) external view returns (IMaverickV2Pool[] memory pools);

    /**
     * @notice Count of permissionless pools.
     */
    function poolCount() external view returns (uint256 _poolCount);

    /**
     * @notice Count of permissioned pools.
     */
    function poolPermissionedCount() external view returns (uint256 _poolCount);

    /**
     * @notice Count of pools for a given accessor and token pair.  For
     * permissionless pools, pass `accessor = address(0)`.
     */
    function poolByTokenCount(
        IERC20 _tokenA,
        IERC20 _tokenB,
        address accessor
    ) external view returns (uint256 _poolCount);

    /**
     * @notice Get the current factory owner.
     */
    function owner() external view returns (address);

    /**
     * @notice Proportion of protocol fee to collect on each swap.  Value is in
     * 3-decimal format with a maximum value of 0.25e3.
     */
    function protocolFeeRatioD3() external view returns (uint8);

    /**
     * @notice Fee rate charged by the protocol for flashloans.  Value is in
     * 18-decimal format with a maximum value of 0.02e18.
     */
    function protocolLendingFeeRateD18() external view returns (uint256);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2Factory} from "./IMaverickV2Factory.sol";

interface IMaverickV2Pool {
    error PoolZeroLiquidityAdded();
    error PoolMinimumLiquidityNotMet();
    error PoolLocked();
    error PoolInvalidFee();
    error PoolTicksNotSorted(uint256 index, int256 previousTick, int256 tick);
    error PoolTicksAmountsLengthMismatch(uint256 ticksLength, uint256 amountsLength);
    error PoolBinIdsAmountsLengthMismatch(uint256 binIdsLength, uint256 amountsLength);
    error PoolKindNotSupported(uint256 kinds, uint256 kind);
    error PoolInsufficientBalance(uint256 deltaLpAmount, uint256 accountBalance);
    error PoolReservesExceedMaximum(uint256 amount);
    error PoolValueExceedsBits(uint256 amount, uint256 bits);
    error PoolTickMaxExceeded(uint256 tick);
    error PoolMigrateBinFirst();
    error PoolCurrentTickBeyondSwapLimit(int32 startingTick);
    error PoolSenderNotAccessor(address sender_, address accessor);
    error PoolSenderNotFactory(address sender_, address accessor);
    error PoolFunctionNotImplemented();
    error PoolTokenNotSolvent(uint256 internalReserve, uint256 tokenBalance, IERC20 token);

    event PoolSwap(address sender, address recipient, SwapParams params, uint256 amountIn, uint256 amountOut);

    event PoolAddLiquidity(
        address sender,
        address recipient,
        uint256 subaccount,
        AddLiquidityParams params,
        uint256 tokenAAmount,
        uint256 tokenBAmount,
        uint32[] binIds
    );

    event PoolMigrateBinsUpStack(address sender, uint32 binId, uint32 maxRecursion);

    event PoolRemoveLiquidity(
        address sender,
        address recipient,
        uint256 subaccount,
        RemoveLiquidityParams params,
        uint256 tokenAOut,
        uint256 tokenBOut
    );

    event PoolSetVariableFee(uint256 newFeeAIn, uint256 newFeeBIn);

    /**
     * @notice Tick state parameters.
     */
    struct TickState {
        uint128 reserveA;
        uint128 reserveB;
        uint128 totalSupply;
        uint32[4] binIdsByTick;
    }

    /**
     * @notice Tick data parameters.
     * @param currentReserveA Current reserve of token A.
     * @param currentReserveB Current reserve of token B.
     * @param currentLiquidity Current liquidity amount.
     */
    struct TickData {
        uint256 currentReserveA;
        uint256 currentReserveB;
        uint256 currentLiquidity;
    }

    /**
     * @notice Bin state parameters.
     * @param mergeBinBalance LP token balance that this bin possesses of the merge bin.
     * @param mergeId Bin ID of the bin that this bin has merged into.
     * @param totalSupply Total amount of LP tokens in this bin.
     * @param kind One of the 4 kinds (0=static, 1=right, 2=left, 3=both).
     * @param tick The lower price tick of the bin in its current state.
     * @param tickBalance Balance of the tick.
     */
    struct BinState {
        uint128 mergeBinBalance;
        uint128 tickBalance;
        uint128 totalSupply;
        uint8 kind;
        int32 tick;
        uint32 mergeId;
    }

    /**
     * @notice Parameters for swap.
     * @param amount Amount of the token that is either the input if exactOutput is false
     * or the output if exactOutput is true.
     * @param tokenAIn Boolean indicating whether tokenA is the input.
     * @param exactOutput Boolean indicating whether the amount specified is
     * the exact output amount (true).
     * @param tickLimit The furthest tick a swap will execute in. If no limit
     * is desired, value should be set to type(int32).max for a tokenAIn swap
     * and type(int32).min for a swap where tokenB is the input.
     */
    struct SwapParams {
        uint256 amount;
        bool tokenAIn;
        bool exactOutput;
        int32 tickLimit;
    }

    /**
     * @notice Parameters associated with adding liquidity.
     * @param kind One of the 4 kinds (0=static, 1=right, 2=left, 3=both).
     * @param ticks Array of ticks to add liquidity to.
     * @param amounts Array of bin LP amounts to add.
     */
    struct AddLiquidityParams {
        uint8 kind;
        int32[] ticks;
        uint128[] amounts;
    }

    /**
     * @notice Parameters for each bin that will have liquidity removed.
     * @param binIds Index array of the bins losing liquidity.
     * @param amounts Array of bin LP amounts to remove.
     */
    struct RemoveLiquidityParams {
        uint32[] binIds;
        uint128[] amounts;
    }

    /**
     * @notice State of the pool.
     * @param reserveA Pool tokenA balanceOf at end of last operation
     * @param reserveB Pool tokenB balanceOf at end of last operation
     * @param lastTwaD8 Value of log time weighted average price at last block.
     * Value is 8-decimal scale and is in the fractional tick domain.  E.g. a
     * value of 12.3e8 indicates the TWAP was 3/10ths of the way into the 12th
     * tick.
     * @param lastLogPriceD8 Value of log price at last block. Value is
     * 8-decimal scale and is in the fractional tick domain.  E.g. a value of
     * 12.3e8 indicates the price was 3/10ths of the way into the 12th tick.
     * @param lastTimestamp Last block.timestamp value in seconds for latest
     * swap transaction.
     * @param activeTick Current tick position that contains the active bins.
     * @param isLocked Pool isLocked, E.g., locked or unlocked; isLocked values
     * defined in Pool.sol.
     * @param binCounter Index of the last bin created.
     * @param protocolFeeRatioD3 Ratio of the swap fee that is kept for the
     * protocol.
     */
    struct State {
        uint128 reserveA;
        uint128 reserveB;
        int64 lastTwaD8;
        int64 lastLogPriceD8;
        uint40 lastTimestamp;
        int32 activeTick;
        bool isLocked;
        uint32 binCounter;
        uint8 protocolFeeRatioD3;
    }

    /**
     * @notice Internal data used for data passing between Pool and Bin code.
     */
    struct BinDelta {
        uint128 deltaA;
        uint128 deltaB;
    }

    /**
     * @notice 1-15 number to represent the active kinds.
     * @notice 0b0001 = static;
     * @notice 0b0010 = right;
     * @notice 0b0100 = left;
     * @notice 0b1000 = both;
     *
     * E.g. a pool with all 4 modes will have kinds = b1111 = 15
     */
    function kinds() external view returns (uint8 _kinds);

    /**
     * @notice Returns whether a pool has permissioned functions. If true, the
     * `accessor()` of the pool can set the pool fees.  Other functions in the
     * pool may also be permissioned; whether or not they are can be determined
     * through calls to `permissionedLiquidity()` and `permissionedSwap()`.
     */
    function permissionedPool() external view returns (bool _permissionedPool);

    /**
     * @notice Returns whether a pool has permissioned liquidity management
     * functions. If true, the pool is incompatible with permissioned pool
     * liquidity management infrastructure.
     */
    function permissionedLiquidity() external view returns (bool _permissionedLiquidity);

    /**
     * @notice Returns whether a pool has a permissioned swap functions. If
     * true, the pool is incompatible with permissioned pool swap router
     * infrastructure.
     */
    function permissionedSwap() external view returns (bool _permissionedSwap);

    /**
     * @notice Pool swap fee for the given direction (A-in or B-in swap) in
     * 18-decimal format. E.g. 0.01e18 is a 1% swap fee.
     */
    function fee(bool tokenAIn) external view returns (uint256);

    /**
     * @notice TickSpacing of pool where 1.0001^tickSpacing is the bin width.
     */
    function tickSpacing() external view returns (uint256);

    /**
     * @notice Lookback period of pool in seconds.
     */
    function lookback() external view returns (uint256);

    /**
     * @notice Address of Pool accessor.  This is Zero address for
     * permissionless pools.
     */
    function accessor() external view returns (address);

    /**
     * @notice Pool tokenA.  Address of tokenA is such that tokenA < tokenB.
     */
    function tokenA() external view returns (IERC20);

    /**
     * @notice Pool tokenB.
     */
    function tokenB() external view returns (IERC20);

    /**
     * @notice Deploying factory of the pool and also contract that has ability
     * to set and collect protocol fees for the pool.
     */
    function factory() external view returns (IMaverickV2Factory);

    /**
     * @notice Most significant bit of scale value is a flag to indicate whether
     * tokenA has more or less than 18 decimals.  Scale is used in conjuction
     * with Math.toScale/Math.fromScale functions to convert from token amounts
     * to D18 scale internal pool accounting.
     */
    function tokenAScale() external view returns (uint256);

    /**
     * @notice Most significant bit of scale value is a flag to indicate whether
     * tokenA has more or less than 18 decimals.  Scale is used in conjuction
     * with Math.toScale/Math.fromScale functions to convert from token amounts
     * to D18 scale internal pool accounting.
     */
    function tokenBScale() external view returns (uint256);

    /**
     * @notice ID of bin at input tick position and kind.
     */
    function binIdByTickKind(int32 tick, uint256 kind) external view returns (uint32);

    /**
     * @notice Accumulated tokenA protocol fee.
     */
    function protocolFeeA() external view returns (uint128);

    /**
     * @notice Accumulated tokenB protocol fee.
     */
    function protocolFeeB() external view returns (uint128);

    /**
     * @notice Lending fee rate on flash loans.
     */
    function lendingFeeRateD18() external view returns (uint256);

    /**
     * @notice External function to get the current time-weighted average price.
     */
    function getCurrentTwa() external view returns (int256);

    /**
     * @notice External function to get the state of the pool.
     */
    function getState() external view returns (State memory);

    /**
     * @notice Return state of Bin at input binId.
     */
    function getBin(uint32 binId) external view returns (BinState memory bin);

    /**
     * @notice Return state of Tick at input tick position.
     */
    function getTick(int32 tick) external view returns (TickState memory tickState);

    /**
     * @notice Retrieves the balance of a user within a bin.
     * @param user The user's address.
     * @param subaccount The subaccount for the user.
     * @param binId The ID of the bin.
     */
    function balanceOf(address user, uint256 subaccount, uint32 binId) external view returns (uint128 lpToken);

    /**
     * @notice Add liquidity to a pool. This function allows users to deposit
     * tokens into a liquidity pool.
     * @dev This function will call `maverickV2AddLiquidityCallback` on the
     * calling contract to collect the tokenA/tokenB payment.
     * @param recipient The account that will receive credit for the added liquidity.
     * @param subaccount The account that will receive credit for the added liquidity.
     * @param params Parameters containing the details for adding liquidity,
     * such as token types and amounts.
     * @param data Bytes information that gets passed to the callback.
     * @return tokenAAmount The amount of token A added to the pool.
     * @return tokenBAmount The amount of token B added to the pool.
     * @return binIds An array of bin IDs where the liquidity is stored.
     */
    function addLiquidity(
        address recipient,
        uint256 subaccount,
        AddLiquidityParams calldata params,
        bytes calldata data
    ) external returns (uint256 tokenAAmount, uint256 tokenBAmount, uint32[] memory binIds);

    /**
     * @notice Removes liquidity from the pool.
     * @dev Liquidy can only be removed from a bin that is either unmerged or
     * has a mergeId of an unmerged bin.  If a bin is merged more than one
     * level deep, it must be migrated up the merge stack to the root bin
     * before liquidity removal.
     * @param recipient The address to receive the tokens.
     * @param subaccount The subaccount for the recipient.
     * @param params The parameters for removing liquidity.
     * @return tokenAOut The amount of token A received.
     * @return tokenBOut The amount of token B received.
     */
    function removeLiquidity(
        address recipient,
        uint256 subaccount,
        RemoveLiquidityParams calldata params
    ) external returns (uint256 tokenAOut, uint256 tokenBOut);

    /**
     * @notice Migrate bins up the linked list of merged bins so that its
     * mergeId is the currrent active bin.
     * @dev Liquidy can only be removed from a bin that is either unmerged or
     * has a mergeId of an unmerged bin.  If a bin is merged more than one
     * level deep, it must be migrated up the merge stack to the root bin
     * before liquidity removal.
     * @param binId The ID of the bin to migrate.
     * @param maxRecursion The maximum recursion depth for the migration.
     */
    function migrateBinUpStack(uint32 binId, uint32 maxRecursion) external;

    /**
     * @notice Swap tokenA/tokenB assets in the pool.  The swap user has two
     * options for funding their swap.
     * - The user can push the input token amount to the pool before calling
     * the swap function. In order to avoid having the pool call the callback,
     * the user should pass a zero-length `data` bytes object with the swap
     * call.
     * - The user can send the input token amount to the pool when the pool
     * calls the `maverickV2SwapCallback` function on the calling contract.
     * That callback has input parameters that specify the token address of the
     * input token, the input and output amounts, and the bytes data sent to
     * the swap function.
     * @dev  If the users elects to do a callback-based swap, the output
     * assets will be sent before the callback is called, allowing the user to
     * execute flash swaps.  However, the pool does have reentrancy protection,
     * so a swapper will not be able to interact with the same pool again
     * while they are in the callback function.
     * @param recipient The address to receive the output tokens.
     * @param params Parameters containing the details of the swap
     * @param data Bytes information that gets passed to the callback.
     */
    function swap(
        address recipient,
        SwapParams memory params,
        bytes calldata data
    ) external returns (uint256 amountIn, uint256 amountOut);

    /**
     * @notice Loan tokenA/tokenB assets from the pool to recipient. The fee
     * rate of a loan is determined by `lendingFeeRateD18`, which is set at the
     * protocol level by the factory.  This function calls
     * `maverickV2FlashLoanCallback` on the calling contract.  At the end of
     * the callback, the caller must pay back the loan with fee (if there is a
     * fee).
     * @param recipient The address to receive the loaned tokens.
     * @param amountB Loan amount of tokenA sent to recipient.
     * @param amountB Loan amount of tokenB sent to recipient.
     * @param data Bytes information that gets passed to the callback.
     */
    function flashLoan(
        address recipient,
        uint256 amountA,
        uint256 amountB,
        bytes calldata data
    ) external returns (uint128 lendingFeeA, uint128 lendingFeeB);

    /**
     * @notice Sets fee for permissioned pools.  May only be called by the
     * accessor.
     */
    function setFee(uint256 newFeeAIn, uint256 newFeeBIn) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IMaverickV2Pool} from "../../v2-common/interfaces/IMaverickV2Pool.sol";

interface IMaverickV2Quoter {
    error QuoterInvalidSwap();
    error QuoterInvalidAddLiquidity();

    /**
     * @notice Calculates a swap on a MaverickV2Pool and returns the resulting
     * amount and estimated gas.  The gas estimate is only a rough estimate and
     * may not match a swap's gas.
     * @param pool The MaverickV2Pool to swap on.
     * @param amount The input amount.
     * @param tokenAIn Indicates if token A is the input token.
     * @param exactOutput Indicates if the amount is the output amount (true)
     * or input amount (false). If the tickLimit is reached, the full value of
     * the exactOutput may not be returned because the pool will stop swapping
     * before the whole order is filled.
     * @param tickLimit The tick limit for the swap. Once the swap lands in
     * this tick, it will stop and return the output amount swapped up to that
     * tick.
     */
    function calculateSwap(
        IMaverickV2Pool pool,
        uint128 amount,
        bool tokenAIn,
        bool exactOutput,
        int32 tickLimit
    ) external returns (uint256 amountIn, uint256 amountOut, uint256 gasEstimate);

    /**
     * @notice Calculates a multihop swap and returns the resulting amount and
     * estimated gas. The gas estimate is only a rough estimate and
     * may not match a swap's gas.
     * @param path The path of pools to swap through. Path is given by an
     * packed array of (pool, tokenAIn) tuples. So each step in the path is 160
     * + 8 = 168 bits of data. e.g. path = abi.encodePacked(pool1, true, pool2, false);
     * @param amount The input amount.
     * @param exactOutput A boolean indicating if exact output is required.
     */
    function calculateMultiHopSwap(
        bytes memory path,
        uint256 amount,
        bool exactOutput
    ) external returns (uint256 returnAmount, uint256 gasEstimate);

    /**
     * @notice Computes the token amounts required for a given set of
     * addLiquidity parameters. The gas estimate is only a rough estimate and
     * may not match a add's gas.
     */
    function calculateAddLiquidity(
        IMaverickV2Pool pool,
        IMaverickV2Pool.AddLiquidityParams calldata params
    ) external returns (uint256 amountA, uint256 amountB, uint256 gasEstimate);

    /**
     * @notice Pool's sqrt price.
     */
    function poolSqrtPrice(IMaverickV2Pool pool) external view returns (uint256 sqrtPrice);
}

// SPDX-License-Identifier: GPL-2.0-or-later
// As the copyright holder of this work, Ubiquity Labs retains
// the right to distribute, use, and modify this code under any license of
// their choosing, in addition to the terms of the GPL-v2 or later.
pragma solidity ^0.8.25;

interface IMulticall {
    function multicall(bytes[] calldata data) external returns (bytes[] memory results);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IHistoricalBalanceNonTransferableERC20} from "./IHistoricalBalanceNonTransferableERC20.sol";
import {ISwapper} from "./ISwapper.sol";

interface IRaffleVault {
    error NoLootBoxesToOpen();
    error RaffleBuyTooLittleReceived(uint256 amountOutMinimum, uint256 amountOut);
    error EpochHasNotEnded(uint256 currentTimestamp, uint256 endEpochTimestamp);
    error InvalidEndEpochTimestamp(uint256 inputTimstamp);
    error OutputTokenDoesNotMatch(IERC20 outputToken, IERC20 expectedOutputToken);
    error InsufficientEthForFee(uint256 amountAvailable, uint256 amountRequired);

    struct LootBoxData {
        address user;
        uint8 count;
        uint64 sequenceNumber;
        uint256 endEpochTimestamp;
    }

    struct LootBoxUserData {
        uint32 countOfLootBoxesOpened;
        uint32 countOfEpochsWithLootBoxOpened;
        uint32 minRandomNumber;
        uint160 totalQuoteTokenPrizes;
    }

    event OpenLootBoxes(IERC20 indexed quoteToken, LootBoxData lootBoxData);
    event SpendPrizeEscrow(address user, uint256 amountIn, uint256 amountOut, IERC20 inputToken, IERC20 outputToken);
    event RevealLoot(
        IERC20 indexed quoteToken,
        uint256 nextMultiplier,
        uint256 prizeAmount,
        uint256 randomNumber,
        uint256 boxNumber,
        LootBoxData lootBoxData
    );

    /**
     * @notice Returns buy fee tracker token
     */
    function buyTracker() external view returns (IHistoricalBalanceNonTransferableERC20);
    /**
     * @notice Returns Swapper contract that created this vault
     */
    function swapper() external view returns (ISwapper);
    /**
     * @notice Returns quote token that this vault holds
     */
    function quoteToken() external view returns (IERC20);
    /**
     * @notice Returns total amount of quote token escrowed by users who have
     * claimed their loot boxes.  This escrow is spent when the users call
     * `spendPrizeEscrow`
     */
    function totalEscrow() external view returns (uint256);

    /**
     * @notice Returns epoch-end timestamp of the epoch that that `timestamp` is in
     * offset by `epochOffset`.  For instance, to find yesterepoch's
     * `epochEndTimestamp`, set timestamp to any timestamp toepoch ,like
     * `block.timestamp`, and set `epochOffset` to `-1`.
     */
    function endEpochTimestampAtOffset(
        uint256 timestamp,
        int256 epochOffset
    ) external view returns (uint256 endEpochTimestamp);

    /**
     * @notice Returns epoch-end timestamp of toepoch.  This `endEpochTimestamp` will
     * not yet be claimable.
     */
    function currentEndEpochTimestamp() external view returns (uint256 endEpochTimestamp);

    /**
     * @notice Returns lootbox user data
     */
    function lootBoxUserData(
        address user
    )
        external
        returns (
            uint32 countOfLootBoxesOpened,
            uint32 countOfEpochsWithLootBoxOpened,
            uint32 minRandomNumber,
            uint160 totalQuoteTokenPrizes
        );

    /**
     * @notice Returns multiplier that will applied to the next loot box open
     * for this user (0 is equivilent to a "multiplier" of 1)
     */
    function multiplierByUser(address user) external view returns (uint256);
    /**
     * @notice Returns an indicator of whether this user has already collected
     * for a given epoch
     */
    function hasCollectedByUserEpoch(address user, uint256 datTs) external view returns (bool);
    /**
     * @notice Returns escrowed prize for a user; users can spend this escrow
     * to collect their prize with `spendPrizeEscrow`
     */
    function escrowByUser(address user) external view returns (uint256);

    /**
     * @notice Returns number of loot boxes the user can claim for that epoch
     */
    function newLootBoxCount(
        address user,
        uint256 endEpochTimestamp
    ) external view returns (uint256 numberOfNewLootBoxes);

    /**
     * @notice Returns fractional number of loot boxes for a given epoch.
     */
    function lootBoxRawData(
        address user,
        uint256 endEpochTimestamp
    ) external view returns (uint256 numberOfNewLootBoxes, uint256 epochBalanceChange, uint256 balancePerLootBox);

    /**
     * @notice Claims and "Opens" loot boxes for user to realize the random prize result;
     * the result with either by a probability multiplier for the next loot box
     * the user opens or it will be a portion of the vault's quote token assets
     * which will be escrowed until the user calls `spendPrizeEscrow`.
     *
     * @notice Caller needs to get the eth call fee from `getOpenLootBoxFee`
     * and send that much value.
     */
    function openLootBoxes(uint256 endEpochTimestamp) external payable returns (uint256 numberOfNewLootBoxes);

    /**
     * @notice Amount of gas token value that must be sent when calling
     * `openLootBoxes`.
     */
    function getOpenLootBoxFee() external view returns (uint256 fee);

    /**
     * @notice Buys the Swapper-specified token with the user's prize escrow.
     * Caller passes in the expected token they will receive which is
     * `swapper.getTopToken(quoteToken)`, but the top token may change as the
     * call is being submitted.  In the case that the expected token does not
     * match the output token, this call will revert.
     */
    function spendPrizeEscrow(
        IERC20 expectedOutputToken,
        uint256 amountOutMinimum
    ) external returns (IERC20 outputToken, uint256 amountOut);

    /**
     * @notice Estimates the amount of token a user will get if they spend
     * their escrow
     */
    function estimatePrize(address user) external returns (IERC20 outputToken, uint256 amountOut);

    /**
     * @notice Interval in seconds between raffles (1 epoch)
     */
    // solhint-disable-next-line func-name-mixedcase
    function RAFFLE_INTERVAL() external view returns (uint256);

    /**
     * @notice Move tokens from fee vault to raffle contract.
     */
    function pullTokensFromFeeVault() external returns (uint256 amount);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

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

interface IReferralRegistry {
    event Refer(address referee, address referer, uint256 timestamp);
    error SenderAlreadyRefered();
    error OnlySwapperOwner();

    /**
     * @notice Registers caller to the given referer
     */
    function refer(address referer) external;

    /**
     * @notice Registers specific refer pair. Only callable by swapper owner.
     */
    function setReferer(address user, address referer) external;

    /**
     * @notice User lookup
     */
    function userToRefererData(address user) external view returns (address referer, uint96 timestamp);

    /**
     * @notice Paginated lookup of referees
     */
    function referees(uint256 startIndex, uint256 endIndex, address referer) external view returns (address[] memory);

    /**
     * @notice Swapper
     */
    function swapper() external view returns (ISwapper);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

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

import {IEntropy} from "@pythnetwork/entropy-sdk-solidity/IEntropy.sol";

import {IMaverickV2Pool} from "../v2-common/interfaces/IMaverickV2Pool.sol";
import {IMaverickV2Factory} from "../v2-common/interfaces/IMaverickV2Factory.sol";

import {IWETH9} from "./external/IWETH9.sol";
import {IMaverickV2Quoter} from "./external/IMaverickV2Quoter.sol";
import {IHistoricalBalanceNonTransferableERC20} from "./IHistoricalBalanceNonTransferableERC20.sol";
import {IRaffleVault} from "./IRaffleVault.sol";
import {ILaunchFactory} from "./ILaunchFactory.sol";
import {IFeeVault} from "./IFeeVault.sol";
import {IVotingDistributor} from "./IVotingDistributor.sol";
import {IReferralRegistry} from "./IReferralRegistry.sol";

interface ISwapper {
    error SenderNotWETH();
    error InvalidFeeParameter();
    error TooLittleReceived(uint256 amountOutMinimumExcludingFee, uint256 amountOut);
    error TokenNotFromLaunchFactory();
    error IncorrectEthValueSent(uint256 amountQuoteIn, uint256 valueSent);
    error QuoteTokenIsNotEth(IERC20 quoteToken);
    error NoTracker();
    error QuoteTokenAlreadyRegistered(IERC20 quoteToken);
    error ValueSentForNonEthQuoteToken(IERC20 quoteToken, uint256 valueSent);
    error NotFactoryPool(IMaverickV2Pool ethToQuotePool);

    struct Trackers {
        IHistoricalBalanceNonTransferableERC20 sell;
        IHistoricalBalanceNonTransferableERC20 buy;
        IHistoricalBalanceNonTransferableERC20 token;
        IHistoricalBalanceNonTransferableERC20 creator;
        IHistoricalBalanceNonTransferableERC20 referer;
    }

    struct FeeRates {
        uint64 proportionToRaffleVaultD18;
        uint64 proportionToRefererD18;
        uint64 proportionToVotingDistributorD18;
        uint64 proportionToCreatorD18;
        uint64 proportionToVoterD18;
    }

    struct Amounts {
        uint256 amountToProtocol;
        uint256 amountToCreator;
        uint256 amountToReferer;
        uint256 amountToRaffleVault;
        uint256 amountToSwapper;
        uint256 amountToVoteDistribution;
        uint256 amountToVoters;
    }
    struct Recipients {
        address protocol;
        address creator;
        address referer;
        address raffleVault;
        address votingDistributor;
        address swapper;
    }

    event SetFeeVault(IFeeVault feeVault);
    event NewTrackers(
        IERC20 quoteToken,
        ILaunchFactory factory,
        IHistoricalBalanceNonTransferableERC20 sellTracker,
        IHistoricalBalanceNonTransferableERC20 buyTracker,
        IHistoricalBalanceNonTransferableERC20 tokenTracker,
        IHistoricalBalanceNonTransferableERC20 creatorTracker,
        IHistoricalBalanceNonTransferableERC20 refererTracker
    );
    event SetFeeRates(FeeRates feeRates);
    event SetFeeRate(uint64 feeRateD18);
    event SetProtocolRecipient(address protocolRecipient);
    event SetReferralRegistry(IReferralRegistry registry);
    event SetEntropy(IEntropy entropy);
    event FeeEmission(IERC20 indexed token, Recipients recipients, Amounts amounts, uint256 rawAmount, bool isBuy);
    event NewRaffleVault(IERC20 quoteToken, IRaffleVault raffleVault);
    event SetBalancePerLootBox(IERC20 quoteToken, uint256 balanceRequirement);
    event SetPrizesAndThresholds(uint24[8] thresholds, uint64[8] prizes, uint8 boxBonus);
    event SetVotingDistributor(IERC20 quoteToken, IVotingDistributor votingDistributor);
    event BuyToken(
        address recipient,
        IERC20 token,
        uint256 amountQuoteIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient,
        uint256 amountOut,
        IMaverickV2Pool pool,
        uint256 poolSqrtPrice
    );
    event SellToken(
        address recipient,
        IERC20 token,
        uint256 amountTokenIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient,
        uint256 amountOut,
        IMaverickV2Pool pool,
        uint256 poolSqrtPrice
    );

    /**
     * @notice Buys tokens using quote token.
     * @param recipient The address to receive the purchased tokens
     * @param token The ERC20 token to buy
     * @param amountQuoteIn The amount of quote to spend
     * @param amountOutMinimum The minimum amount of tokens to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @param raffleRecipient The address that gets credit for the buy volume in the tracker token
     * @return amountOut The actual amount of tokens received
     * @return pool The Maverick V2 pool used for the swap
     */
    function buyTokenSpecifyRaffleRecipient(
        address recipient,
        IERC20 token,
        uint256 amountQuoteIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient
    ) external payable returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Buys tokens using eth where the quote token is not ETH.  The
     * token is bought through a two-pool swap: ethToQuote -> quoteToToken.
     * @param recipient The address to receive the purchased tokens
     * @param token The ERC20 token to buy
     * @param ethToQuotePool The Maverick pool that can swap eth for quote token
     * @param amountEthIn The amount of ETH to spend
     * @param amountOutMinimum The minimum amount of tokens to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @param raffleRecipient The address that gets credit for the buy volume in the tracker token
     * @return amountOut The actual amount of tokens received
     * @return pool The Maverick V2 pool used for the swap
     */
    function buyTokenTwoHopSpecifyRaffleRecipient(
        address recipient,
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountEthIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient
    ) external payable returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Sells tokens for quote token.
     * @param recipient The address to receive the quote
     * @param token The ERC20 token to sell
     * @param amountTokenIn The amount of tokens to sell
     * @param amountOutMinimum The minimum amount of ETH to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @param raffleRecipient The address that gets credit for the buy volume in the tracker token
     * @return amountOut The actual amount of quote token received
     * @return pool The Maverick V2 pool used for the swap
     */
    function sellTokenSpecifyRaffleRecipient(
        address recipient,
        IERC20 token,
        uint256 amountTokenIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient
    ) external returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Sells tokens for quote token and then swaps the quote token for eth.
     * @param recipient The address to receive the quote
     * @param token The ERC20 token to sell
     * @param ethToQuotePool The Maverick pool that can swap quote token for eth
     * @param amountTokenIn The amount of tokens to sell
     * @param amountOutMinimum The minimum amount of ETH to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @param raffleRecipient The address that gets credit for the buy volume in the tracker token
     * @return amountOut The actual amount of ETH received
     * @return pool The Maverick V2 pool used for the swap
     */
    function sellTokenTwoHopSpecifyRaffleRecipient(
        address recipient,
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountTokenIn,
        uint256 amountOutMinimum,
        address referer,
        address raffleRecipient
    ) external returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Buys tokens using quote token.  Credits msg.sender with the buy volume on the tracker token.
     * @param recipient The address to receive the purchased tokens
     * @param token The ERC20 token to buy
     * @param amountQuoteIn The amount of quote to spend
     * @param amountOutMinimum The minimum amount of tokens to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @return amountOut The actual amount of tokens received
     * @return pool The Maverick V2 pool used for the swap
     */
    function buyToken(
        address recipient,
        IERC20 token,
        uint256 amountQuoteIn,
        uint256 amountOutMinimum,
        address referer
    ) external payable returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Buys tokens using eth where the quote token is not eth.  The
     * token is bought through a two-pool swap: ethToQuote -> quoteToToken.
     * Credits msg.sender with the buy volume on the tracker token.
     * @param recipient The address to receive the purchased tokens
     * @param token The ERC20 token to buy
     * @param ethToQuotePool The Maverick pool that can swap eth for quote token
     * @param amountEthIn The amount of ETH to spend
     * @param amountOutMinimum The minimum amount of tokens to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @return amountOut The actual amount of tokens received
     * @return pool The Maverick V2 pool used for the swap
     */
    function buyTokenTwoHop(
        address recipient,
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountEthIn,
        uint256 amountOutMinimum,
        address referer
    ) external payable returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Sells tokens for quote token.  Credits msg.sender with the sell volume on the tracker token.
     * @param recipient The address to receive the ETH
     * @param token The ERC20 token to sell
     * @param amountTokenIn The amount of tokens to sell
     * @param amountOutMinimum The minimum amount of ETH to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @return amountOut The actual amount of ETH received
     * @return pool The Maverick V2 pool used for the swap
     */
    function sellToken(
        address recipient,
        IERC20 token,
        uint256 amountTokenIn,
        uint256 amountOutMinimum,
        address referer
    ) external returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Sells tokens for quote token and then swaps the quote token for eth.
     * @param recipient The address to receive the quote
     * @param token The ERC20 token to sell
     * @param ethToQuotePool The Maverick pool that can swap quote token for eth
     * @param amountTokenIn The amount of tokens to sell
     * @param amountOutMinimum The minimum amount of ETH to receive
     * @param referer The address of the referrer (adddress(0) should be used if there is no referer)
     * @return amountOut The actual amount of ETH received
     * @return pool The Maverick V2 pool used for the swap
     */
    function sellTokenTwoHop(
        address recipient,
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountTokenIn,
        uint256 amountOutMinimum,
        address referer
    ) external returns (uint256 amountOut, IMaverickV2Pool pool);

    /**
     * @notice Gets an output estimate for buying tokens with quote token
     * @param token The ERC20 token to buy
     * @param amountQuoteIn The amount of quote to spend
     * @return amountOut The estimated amount of tokens that would be received inclusive of all fees
     */
    function buyTokenQuote(IERC20 token, uint256 amountQuoteIn) external returns (uint256 amountOut);

    /**
     * @notice Gets an output estimate for buying tokens with ETH via an intermediate eth-to-quote pool
     * @param token The ERC20 token to buy
     * @param ethToQuotePool The Maverick pool that can swap eth for quote token
     * @param amountEthIn The amount of ETH to spend
     * @return amountOut The estimated amount of tokens that would be received inclusive of all fees
     */
    function buyTokenTwoHopQuote(
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountEthIn
    ) external returns (uint256 amountOut);

    /**
     * @notice Gets a quote for selling tokens for ETH
     * @param token The ERC20 token to sell
     * @param amountTokenIn The amount of tokens to sell
     * @return amountOut The estimated amount of ETH that would be received inclusive of all fees
     */
    function sellTokenQuote(IERC20 token, uint256 amountTokenIn) external returns (uint256 amountOut);

    /**
     * @notice Gets a quote for selling tokens for ETH
     * @param token The ERC20 token to sell
     * @param ethToQuotePool The Maverick pool that can swap quote for eth
     * @param amountTokenIn The amount of tokens to sell
     * @return amountOut The estimated amount of ETH that would be received inclusive of all fees
     */
    function sellTokenTwoHopQuote(
        IERC20 token,
        IMaverickV2Pool ethToQuotePool,
        uint256 amountTokenIn
    ) external returns (uint256 amountOut);

    /**
     * @notice Gets the entropy contract address
     */
    function entropy() external view returns (IEntropy);

    /**
     * @notice Gets prize, threshold values and box bonus
     */
    function getPrizesAndThresholdsAndBonus()
        external
        view
        returns (uint24[8] memory thresholds, uint64[8] memory prizes, uint8 boxBonus);

    /**
     * @notice Gets top meme token for given quote token
     */
    function getTopToken(IERC20 quoteToken) external view returns (IERC20 topToken);

    /**
     * @notice Gets the WETH contract address
     */
    function weth() external view returns (IWETH9);

    /**
     * @notice Gets the feeRecipient address
     */
    function protocolRecipient() external view returns (address);

    /**
     * @notice Gets the fee rate in D18 format
     */
    function feeRateD18() external view returns (uint64);

    /**
     * @notice Gets the fee rate in D18 format
     */
    function feeRates()
        external
        view
        returns (
            uint64 proportionToRaffleVaultD18,
            uint64 proportionToRefererD18,
            uint64 proportionToVotingDistributorD18,
            uint64 proportionToCreatorD18,
            uint64 proportionToVoterD18
        );

    /**
     * @notice Gets the Maverick V2 price quoter
     */
    function quoter() external view returns (IMaverickV2Quoter);

    function feeVault() external view returns (IFeeVault);
    function referralRegistry() external view returns (IReferralRegistry);
    function poolFactory() external view returns (IMaverickV2Factory);
    function quoteToRaffleVault(IERC20) external view returns (IRaffleVault);
    function quoteToVotingDistributor(IERC20) external view returns (IVotingDistributor);
    function quoteToFactory(IERC20) external view returns (ILaunchFactory);
    function quoteToTrackers(
        IERC20
    )
        external
        view
        returns (
            IHistoricalBalanceNonTransferableERC20 sell,
            IHistoricalBalanceNonTransferableERC20 buy,
            IHistoricalBalanceNonTransferableERC20 token,
            IHistoricalBalanceNonTransferableERC20 creator,
            IHistoricalBalanceNonTransferableERC20 referer
        );

    /**
     * @notice Gets fee balance requirement needed to claim a lootbox
     */
    function balancePerLootBox(IERC20 quoteToken) external view returns (uint256);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IMaverickV2Pool} from "../v2-common/interfaces/IMaverickV2Pool.sol";

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

interface ITokenManager {
    error NotFactoryPool();
    error OnlyCurrentRecipientAllowed(address existingRecipient, address newRecipient);
    error BorrowingNotEnabled();
    error NoLiquidityToBorrow();
    error NothingToRedeem();
    error TooMuchQuoteInRedeem(uint256 amountRequested, uint256 maxAmount);
    error NotInClosePeriod(uint256 lastPoolSwap, uint256 closePeriodThreshold);
    error AddressZeroNotValidFeeRecipient();
    error MinTimeNotElaspedSinceLastFeeChange(uint256 timeDifference, uint256 minTimeDifference);
    error FeeChangeNotEnabled();
    error SenderNotWETH();
    error MinRedeemNotMet(uint256 totalTokenRedeemed, uint256 minRedeemTokenAmount);
    error MinBorrowNotMet(uint256 amountToBorrow, uint256 minAmountToBorrower);
    error InsufficientEthSentByUser(uint256 amountToPay, uint256 amountRecived);

    event ExtractFee(
        int32[] ticks,
        IMaverickV2Pool.RemoveLiquidityParams params,
        uint256 amountToProtocol,
        uint256 amountToRecipient,
        address recipient
    );
    event ChangeFeeRecipient(address existingRecipient, address newRecipient);
    event ClosePool(IMaverickV2Pool.RemoveLiquidityParams params, uint256 quoteAmount, uint256 tokenAmount);
    event BorrowQuote(
        address borrower,
        uint128 inputTokenBorrowAmount,
        uint128 inputMinSent,
        int32[] ticks,
        uint128[] tokenAmounts,
        uint128[] quoteToRepayAmounts,
        uint128 tokenCollateralAmount,
        uint128 quoteToRepayAmount,
        uint128 quoteToBorrowerAmount,
        uint128 ethToBorrowerAmount
    );
    event RedeemTokenCollateral(
        address borrower,
        uint128 inputRedeemTokenAmount,
        int32[] ticks,
        uint128[] tokenAmounts,
        uint128[] quoteToRepayAmounts,
        uint128 totalQuoteSpent,
        uint128 totalEthSpent,
        uint128 totalTokenRedeemed
    );
    event ChangeFees(uint256 newBuyFee, uint256 newSellFee, uint256 timestamp);
    event BorrowFeeEmission(IERC20 quoteToken, IERC20 token, Recipients recipients, Amounts amounts);

    struct DebtData {
        uint128 quoteAmount;
        uint128 tokenAmount;
    }

    struct Recipients {
        address protocol;
        address creator;
        address votingDistributor;
    }

    struct Amounts {
        uint256 amountToCreator;
        uint256 amountToProtocol;
        uint256 amountToVoters;
        uint256 amountToVoteDistribution;
    }

    /**
     * @notice Gets the Maverick V2 fairlaunch pool
     */
    function pool() external view returns (IMaverickV2Pool);

    /**
     * @notice Gets the index of the curve which corresponds to the liquidity
     * distribution exponent. Valid values are 0 to 5.
     */
    function curveIndex() external view returns (uint8);

    /**
     * @notice Gets the launch factory
     */
    function launchFactory() external view returns (ILaunchFactory);

    /**
     * @notice Gets the ERC20 token that was launched
     */
    function token() external view returns (IERC20);

    /**
     * @notice Checks if the token is tokenA in the pool
     */
    function tokenIsA() external view returns (bool);

    /**
     * @notice Gets the address that receives fees
     */
    function feeRecipient() external view returns (address);

    /**
     * @notice Checks if borrowing is enabled
     */
    function borrowingEnabled() external view returns (bool);

    /**
     * @notice Returns pool swap fees.
     */
    function fees() external view returns (uint64 _buyFee, uint64 _sellFee);

    /**
     * @notice Returns pool swap sell fee.
     */
    function sellFee() external view returns (uint64);

    /**
     * @notice Returns pool swap sell fee.
     */
    function buyFee() external view returns (uint64);

    /**
     * @notice Returns timestamp of last fee change.
     */
    function lastFeeChangeTimestamp() external view returns (uint64);

    /**
     * @notice Borrows QUOTE from the pool.  This function may create a loan for
     * less token collateral than the user specifies if there is not enough quote
     * in the pool to be borrowed.  Users can specify the minimum amount of
     * QUOTE they will accept in the loan.
     * @param tokenBorrowAmount The desired amount of tokens to send as collateral
     * @param minQuoteSent The minimum amount of QUOTE that can be sent to the user
     * @return ticks The ticks involved in the borrowing operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return tokenCollateralAmount The amount of tokens used as collateral
     * @return quoteToRepayAmount The total amount of QUOTE to repay
     * @return quoteToBorrowerAmount The amount of QUOTE sent to the borrower
     */
    function borrowQuote(
        uint128 tokenBorrowAmount,
        uint128 minQuoteSent
    )
        external
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 tokenCollateralAmount,
            uint128 quoteToRepayAmount,
            uint128 quoteToBorrowerAmount
        );

    /**
     * @notice Borrows QUOTE from the pool and swap to ETH.  This function may
     * create a loan for less token collateral than the user specifies if there
     * is not enough quote in the pool to be borrowed.  Users can specify the
     * minimum amount of ETH they will accept in the loan.
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param tokenBorrowAmount The desired amount of tokens to send as collateral
     * @param minEthSent The minimum amount of ETH that can be sent to the user
     * @return ticks The ticks involved in the borrowing operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return tokenCollateralAmount The amount of tokens used as collateral
     * @return quoteToRepayAmount The total amount of QUOTE to repay
     * @return quoteToBorrowerAmount The amount of QUOTE sent to the borrower
     * @return ethToBorrowerAmount The amount of ETH sent to the borrower
     */
    function borrowQuoteToEth(
        IMaverickV2Pool ethToQuotePool,
        uint128 tokenBorrowAmount,
        uint128 minEthSent
    )
        external
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 tokenCollateralAmount,
            uint128 quoteToRepayAmount,
            uint128 quoteToBorrowerAmount,
            uint128 ethToBorrowerAmount
        );

    /**
     * @notice Redeems token collateral; The caller needs to approve this
     * TokenManager to `transferFrom` amount.
     * @param maxRedeemTokenAmount The max amount of tokens to redeem
     * @param minRedeemTokenAmount The min amount of tokens to redeem
     * @param maxQuoteAmount The max amount of quote tokens to spend in redemption
     * @return ticks The ticks involved in the redemption operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function redeemTokenCollateral(
        uint128 maxRedeemTokenAmount,
        uint128 minRedeemTokenAmount,
        uint128 maxQuoteAmount
    )
        external
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint128 totalTokenRedeemed
        );

    /**
     * @notice Redeems token collateral at specified ticks which have to be
     * passed in sorted order. The caller needs to approve this TokenManager to
     * `transferFrom` amount.
     * @param ticks The ticks involved in the redemption operation
     * @param tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function redeemTokenCollateralByTick(
        int32[] memory ticks,
        uint128[] memory tokenAmounts
    ) external returns (uint128[] memory quoteToRepayAmounts, uint128 totalQuoteSpent, uint128 totalTokenRedeemed);

    /**
     * @notice Redeems token collateral at specified ticks which have to be
     * passed in sorted order. caller needs to send ETH with the call equal to
     * the repay amount.  Any excess ETH will be sent back to the caller.  The
     * ETH will be swapped in the input pool for quote token.
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param ticks The ticks involved in the redemption operation
     * @param tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalEthSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function redeemTokenCollateralWithEthByTick(
        IMaverickV2Pool ethToQuotePool,
        int32[] memory ticks,
        uint128[] memory tokenAmounts
    )
        external
        payable
        returns (
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint128 totalEthSpent,
            uint128 totalTokenRedeemed
        );

    /**
     * @notice Redeems token collateral; The caller needs to send ETH with the
     * call equal to the repay amount.  Any excess ETH will be sent back to the
     * caller.  The ETH will be swapped in the input pool for quote token.
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param maxRedeemTokenAmount The max amount of tokens to redeem
     * @param minRedeemTokenAmount The min amount of tokens to redeem
     * @return ticks The ticks involved in the redemption operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalEthSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function redeemTokenCollateralWithEth(
        IMaverickV2Pool ethToQuotePool,
        uint128 maxRedeemTokenAmount,
        uint128 minRedeemTokenAmount
    )
        external
        payable
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint128 totalEthSpent,
            uint128 totalTokenRedeemed
        );

    /**
     * @notice Gets the borrowed amounts for a user at a specific tick
     * @param user The user address
     * @param tick The tick
     * @return amounts The debt data (token collateral amount and QUOTE amount)
     */
    function userBorrowedAmounts(address user, int32 tick) external view returns (DebtData memory amounts);

    /**
     * @notice Gets the total borrowed amounts across all users at a specific tick
     * @param tick The tick
     * @return amounts The debt data (token collateral amount and QUOTE amount)
     */
    function borrowedAmounts(int32 tick) external view returns (DebtData memory amounts);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IMaverickV2Pool} from "../v2-common/interfaces/IMaverickV2Pool.sol";
import {ITokenManager} from "./ITokenManager.sol";
import {IDistribution} from "./IDistribution.sol";

interface ITokenManagerLens {
    error BorrowingNotSupported(int32 startTick, int32 endTick);
    error RedeemNotSupported(int32 startTick, int32 endTick);
    error NonQuoteBin(IMaverickV2Pool pool, uint32 binId);
    error TickIsNotAllQuote(int32 tick, int32 activeTick);
    error TryingToRedeemMoreThanDebt(uint256 index, int32 tick, uint256 debtDataTokenAmount, uint256 inputTokenAmount);

    /**
     * @notice Gets information about redeeming tokens for a specific user
     * @param manager The token manager contract
     * @param user The user address
     * @param tokenRedeemAmount The amount of tokens to redeem
     * @return tokenAmounts The amount of tokens to redeems at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     * @return params The parameters for adding liquidity to the pool
     */
    function redeemInformation(
        ITokenManager manager,
        address user,
        uint128 tokenRedeemAmount
    )
        external
        view
        returns (
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint128 totalTokenRedeemed,
            IMaverickV2Pool.AddLiquidityParams memory params
        );

    /**
     * @notice Gets information about redeeming tokens for a specific user
     * where the user inputs the ticks and token amounts they want to redeem.
     * @param manager The token manager contract
     * @param user The user address
     * @param ticks The ticks to redeem from
     * @param tokenAmounts The amount of token to redeem from each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     * @return params The parameters for adding liquidity to the pool
     */
    function redeemInformationByTick(
        ITokenManager manager,
        address user,
        int32[] memory ticks,
        uint128[] memory tokenAmounts
    )
        external
        view
        returns (
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint128 totalTokenRedeemed,
            IMaverickV2Pool.AddLiquidityParams memory params
        );

    /**
     * @notice Estimates output from borrowing QUOTE from the pool and swap to ETH
     * @param manager Token manager to estimate
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param tokenBorrowAmount The desired amount of tokens to send as collateral
     * @return ticks The ticks involved in the borrowing operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return tokenCollateralAmount The amount of tokens used as collateral
     * @return quoteToRepayAmount The total amount of QUOTE to repay
     * @return quoteToBorrowerAmount The amount of QUOTE sent to the borrower
     * @return ethToBorrowerAmount The amount of ETH sent to the borrower
     */
    function estimateBorrowQuoteToEth(
        ITokenManager manager,
        IMaverickV2Pool ethToQuotePool,
        uint128 tokenBorrowAmount
    )
        external
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 tokenCollateralAmount,
            uint128 quoteToRepayAmount,
            uint128 quoteToBorrowerAmount,
            uint256 ethToBorrowerAmount
        );

    /**
     * @notice Estimates the output of the redeem token collateral
     * @param manager Token manager to estimate
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param maxRedeemTokenAmount The max amount of tokens to redeem
     * @return ticks The ticks involved in the redemption operation
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalEthSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function estimateRedeemTokenCollateralWithEth(
        ITokenManager manager,
        IMaverickV2Pool ethToQuotePool,
        uint128 maxRedeemTokenAmount
    )
        external
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint256 totalEthSpent,
            uint128 totalTokenRedeemed
        );

    /**
     * @notice Estimates the output of the redeem token collateral
     * @param manager Token manager to estimate
     * @param ethToQuotePool The maverick pool that has eth and quote.
     * @param ticks The ticks involved in the redemption operation
     * @param tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalQuoteSpent The total amount of QUOTE spent
     * @return totalEthSpent The total amount of QUOTE spent
     * @return totalTokenRedeemed The total amount of tokens redeemed
     */
    function estimateRedeemTokenCollateralWithEthByTick(
        ITokenManager manager,
        IMaverickV2Pool ethToQuotePool,
        int32[] memory ticks,
        uint128[] memory tokenAmounts
    )
        external
        returns (
            uint128[] memory quoteToRepayAmounts,
            uint128 totalQuoteSpent,
            uint256 totalEthSpent,
            uint128 totalTokenRedeemed
        );

    /**
     * @notice Gets information about borrowing tokens
     * @param manager The token manager contract
     * @param tokenBorrowAmount The amount of tokens to borrow
     * @return ticks The ticks borrowed from
     * @return tokenAmounts The token amounts at each tick
     * @return quoteToRepayAmounts The QUOTE amounts to repay at each tick
     * @return totalTokenCollateralAmount The total amount of tokens used as collateral
     * @return params The parameters for removing liquidity from the pool
     */
    function borrowInformation(
        ITokenManager manager,
        uint128 tokenBorrowAmount
    )
        external
        view
        returns (
            int32[] memory ticks,
            uint128[] memory tokenAmounts,
            uint128[] memory quoteToRepayAmounts,
            uint128 totalTokenCollateralAmount,
            IMaverickV2Pool.RemoveLiquidityParams memory params
        );

    /**
     * @notice Gets the tick and total number of ticks for a token manager's pool
     * @param manager The token manager contract
     * @return tick The current tick of the pool
     */
    function ticksIntoPool(ITokenManager manager) external view returns (uint256 tick);

    /**
     * @notice Gets the borrowed amounts for a specific user in a token manager
     * @param manager The token manager contract
     * @param user The user address
     * @return ticks The ticks where the user has borrowed amounts
     * @return quoteAmounts The QUOTE amounts borrowed at each tick
     * @return tokenAmounts The token amounts borrowed at each tick
     * @return totalQuoteAmount The total QUOTE amount borrowed by the user
     * @return totalTokenAmount The total token amount borrowed by the user
     */
    function userBorrowedAmounts(
        ITokenManager manager,
        address user
    )
        external
        view
        returns (
            int32[] memory ticks,
            uint128[] memory quoteAmounts,
            uint128[] memory tokenAmounts,
            uint128 totalQuoteAmount,
            uint128 totalTokenAmount
        );

    /**
     * @notice Gets the total borrowed amounts in a token manager
     * @param manager The token manager contract
     * @return ticks The ticks where there are borrowed amounts
     * @return quoteAmounts The total QUOTE amounts borrowed at each tick
     * @return tokenAmounts The total token amounts borrowed at each tick
     * @return totalQuoteAmount The total QUOTE amount borrowed
     * @return totalTokenAmount The total token amount borrowed
     */
    function totalBorrowedAmounts(
        ITokenManager manager
    )
        external
        view
        returns (
            int32[] memory ticks,
            uint128[] memory quoteAmounts,
            uint128[] memory tokenAmounts,
            uint128 totalQuoteAmount,
            uint128 totalTokenAmount
        );

    function lastTick() external view returns (int32);
    function distribution() external view returns (IDistribution);
    function borrowAllowed(bool tokenIsA, int32 tick, uint256 tickIntoPool) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol)
pragma solidity ^0.8.20;

/**
 * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.
 */
interface IVotes {
    /**
     * @dev The signature used has expired.
     */
    error VotesExpiredSignature(uint256 expiry);

    /**
     * @dev Emitted when an account changes their delegate.
     */
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /**
     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units.
     */
    event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes);

    /**
     * @dev Returns the current amount of votes that `account` has.
     */
    function getVotes(address account) external view returns (uint256);

    /**
     * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is
     * configured to use block numbers, this will return the value at the end of the corresponding block.
     */
    function getPastVotes(address account, uint256 timepoint) external view returns (uint256);

    /**
     * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is
     * configured to use block numbers, this will return the value at the end of the corresponding block.
     *
     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.
     * Votes that have not been delegated are still part of total supply, even though they would not participate in a
     * vote.
     */
    function getPastTotalSupply(uint256 timepoint) external view returns (uint256);

    /**
     * @dev Returns the delegate that `account` has chosen.
     */
    function delegates(address account) external view returns (address);

    /**
     * @dev Delegates votes from the sender to `delegatee`.
     */
    function delegate(address delegatee) external;

    /**
     * @dev Delegates votes from signer to `delegatee`.
     */
    function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.25;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC5805} from "@openzeppelin/contracts/interfaces/IERC5805.sol";

import {ILaunchFactory} from "./ILaunchFactory.sol";
import {ISwapper} from "./ISwapper.sol";
import {IMulticall} from "../v2-common/base/IMulticall.sol";

interface IVotingDistributor is IMulticall {
    error InvalidEpoch(uint256 epoch);
    error InvalidVeToken();

    error InvalidVote(IERC20 token, uint256 weight, uint256 totalWeight, uint256 vote);
    error NotFactoryToken(IERC20 token);
    error SenderHasNoVotingPower(address sender, uint256 epoch);
    error InvalidTargetOrder(IERC20 lastToken, IERC20 currentToken);
    error SenderHasAlreadyVoted();

    error TokenAlreadyDistributed(IERC20 token, uint256 epoch);
    error VoterAlreadyCollected(address user, IERC20 token, uint256 epoch);
    error NothingToDistribute();
    error ZeroAmount();
    error RolloverNotAllowed(uint256 voteForThisToken);

    error PoolTwapGapTooBig(int256 tickDiffD8, int256 maxTickDiffD8);
    error VotePeriodNotActive(uint256 timestamp, uint256 epochStart, uint256 epochEnd);
    error VotePeriodNotEnded(uint256 timestamp, uint256 epochStart, uint256 epochEnd);
    error EpochEnded(uint256 timestamp, uint256 epochStart, uint256 epochEnd);
    error UseCollectVoteFee();
    error MustCallFromEOA(address txOrigin, address msgSender);

    event Vote(IERC20 indexed quoteToken, uint256 indexed epoch, address indexed voter, IERC20 token, uint256 vote);
    event AddDistributionBudget(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        address indexed sender,
        uint256 amount
    );
    event AddVoteIncentive(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        address indexed sender,
        IERC20 token,
        uint256 amount,
        IERC20 incentiveToken
    );
    event RollUnvotedIncentive(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        IERC20 tokenToIncentivize,
        IERC20 incentiveToken,
        uint256 amount,
        uint256 newEpoch
    );
    event Distribute(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        address indexed sender,
        IERC20 token,
        uint256 quoteTokenAmountDistributed,
        uint256 tokenAmountBurned
    );
    event CollectVoteIncentive(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        address indexed voter,
        IERC20 token,
        uint256 amount,
        IERC20 incentiveToken
    );
    event CollectVoteFee(
        IERC20 indexed quoteToken,
        uint256 indexed epoch,
        address indexed voter,
        IERC20 token,
        uint256 quoteTokenAmount,
        uint256 tokenAmount
    );

    /**
     * @param startIndex The start index of the tokens to get.
     * @param endIndex The end index of the tokens to get.
     * @param incentiveStartIndex The start index of the incentive tokens to get.
     * @param incentiveEndIndex The end index of the incentive tokens to get.
     */
    struct IndexBounds {
        uint256 startIndex;
        uint256 endIndex;
        uint256 incentiveStartIndex;
        uint256 incentiveEndIndex;
    }

    struct ClaimData {
        IERC20 token;
        uint256 incentiveTokenCount;
        IERC20[] incentiveTokens;
        uint256[] incentiveAmounts;
        uint256[] tokenBoughtAmounts;
        bool[] hasCollected;
    }

    struct VoterData {
        bool hasVoted;
        uint128[] votes;
        IERC20[] tokens;
    }

    struct TokenView {
        IERC20 token;
        uint256 votes;
        bool hasDistributed;
        IERC20[] incentiveTokens;
        uint256[] voteIncentives;
        uint256 incentiveTokenCount;
    }

    /**
     * @notice Get the quote token used for distributions.
     * @return The quote token.
     */
    function quoteToken() external view returns (IERC20);

    /**
     * @notice Get the launch factory associated with this distributor.
     * @return The launch factory.
     */
    function factory() external view returns (ILaunchFactory);

    /**
     * @notice Get the voting escrow token used for voting power.
     * @return The voting escrow token.
     */
    function veToken() external view returns (IERC5805);

    /**
     * @notice Get the swapper contract used for token operations.
     * @return The swapper contract.
     */
    function swapper() external view returns (ISwapper);

    /////////////////////////////////////
    /// Voting
    /////////////////////////////////////

    /**
     * @notice Vote for the given tokens with the given weights.
     * @param voteTargets The tokens to vote for.
     * @param weights The relative weight of each token.
     */
    function vote(IERC20[] memory voteTargets, uint256[] memory weights) external;

    /////////////////////////////////////
    /// Epoch Budgets
    /////////////////////////////////////

    /**
     * @notice Add a distribution budget for the given epoch.  Function
     * performs a transferFrom from msg.sender, so the send must first approve
     * this contract for the amount.
     * @param amount The amount of the budget.
     * @param epoch The epoch to add the budget to.
     */
    function addDistributionBudget(uint256 amount, uint256 epoch) external;

    /**
     * @notice Add a distribution budget for the current epoch.  Function
     * performs a transferFrom from msg.sender, so the send must first approve
     * this contract for the amount.
     * @param amount The amount of the budget.
     */
    function addDistributionBudgetCurrentEpoch(uint256 amount) external;

    /**
     * @notice Add a vote incentive for the given token and epoch.
     * @param tokenToIncentivize The token to incentivize.
     * @param incentiveToken The incentive token.
     * @param amount The amount of the incentive.
     * @param epoch The epoch to add the incentive to.
     */
    function addVoteIncentive(IERC20 tokenToIncentivize, IERC20 incentiveToken, uint256 amount, uint256 epoch) external;

    /**
     * @notice Add a vote incentive for the given token and current epoch.
     * @param tokenToIncentivize The token to incentivize.
     * @param incentiveToken The incentive token.
     * @param amount The amount of the incentive.
     */
    function addVoteIncentiveToCurrentEpoch(IERC20 tokenToIncentivize, IERC20 incentiveToken, uint256 amount) external;

    /**
     * @notice Rollover a vote incentive for the given token and epoch to the next epoch.
     * @param tokenToIncentivize The token to incentivize.
     * @param incentiveToken The incentive token.
     * @param epoch The epoch the incentives were added to.
     * @return amount The amount of the incentive.
     * @return newEpoch The new epoch where the incentives will be distributed.
     */
    function rollUnvotedIncentive(
        IERC20 tokenToIncentivize,
        IERC20 incentiveToken,
        uint256 epoch
    ) external returns (uint256 amount, uint256 newEpoch);

    /////////////////////////////////////
    /// Post-Epoch Collections
    /////////////////////////////////////

    /**
     * @notice Distribute the incentives for the given token and epoch.
     * @param token The token to distribute incentives for.
     * @param epoch The epoch to distribute incentives for.
     * @return amountDistributed The amount of incentives distributed.
     * @return amountBurned The amount of incentives burned.
     */
    function distribute(IERC20 token, uint256 epoch) external returns (uint256 amountDistributed, uint256 amountBurned);

    /**
     * @notice Distribute the incentives for the given token and epoch.
     * @param token The token to distribute incentives for.
     * @param epoch The epoch to distribute incentives for.
     * @return amountDistributed The amount of incentives distributed.
     * @return amountBurned The amount of incentives burned.
     * @return twaGapPasses Indicator of whether the pool twa is such that a
     * swap will be executed.
     */
    function distributeAmount(
        IERC20 token,
        uint256 epoch
    ) external returns (uint256 amountDistributed, uint256 amountBurned, bool twaGapPasses);

    /**
     * @notice Collect the vote incentive for the given token, incentive
     * token, and epoch.
     * @param token The token to collect the incentive for.
     * @param incentiveToken The incentive token to collect.
     * @param epoch The epoch to collect the incentive for.
     * @return amount The amount of the incentive collected.
     */
    function collectVoteIncentive(IERC20 token, IERC20 incentiveToken, uint256 epoch) external returns (uint256 amount);

    /**
     * @notice Collect the vote incentive for the given token, incentive
     * token, and epoch when the incentive token is the quoteToken.
     * @param token The token to collect the incentive for.
     * @param epoch The epoch to collect the incentive for.
     * @return amount The amount of the incentive.
     * @return amountToken The amount of the token bought and send to sender.
     */
    function collectVoteFee(
        IERC20 token,
        uint256 amountOutMinimum,
        uint256 epoch
    ) external returns (uint256 amount, uint256 amountToken);

    /**
     * @notice View the vote incentive for the given token, incentive
     * token, and epoch.
     * @param user Address of user to check amounts for.
     * @param token The token to collect the incentive for.
     * @param incentiveToken The incentive token to collect.
     * @param epoch The epoch to collect the incentive for.
     * @return amount The amount of the incentive collected.
     */
    function collectVoteIncentiveAmount(
        address user,
        IERC20 token,
        IERC20 incentiveToken,
        uint256 epoch
    ) external view returns (uint256 amount);

    /**
     * @notice View the vote incentive for the given token, incentive
     * token, and epoch when the incentive token is the quoteToken.
     * @param user Address of user to check amounts for.
     * @param token The token to collect the incentive for.
     * @param epoch The epoch to collect the incentive for.
     * @return amount The amount of the incentive collected.
     * @return amountToken The amount of the token bought and send to sender.
     */
    function collectVoteFeeAmount(
        address user,
        IERC20 token,
        uint256 epoch
    ) external returns (uint256 amount, uint256 amountToken);

    /////////////////////////////////////
    /// Epoch State Viewers
    /////////////////////////////////////

    /**
     * @notice Get the checkpoint data for the given epoch.
     * @param epoch The epoch to get the checkpoint data for.
     * @param bounds Index bounds to search.
     * @return budget The budget for the epoch.
     * @return totalVote The total vote for the epoch.
     * @return tokens The tokens for the epoch.
     */
    function getCheckpointData(
        uint256 epoch,
        IndexBounds memory bounds
    ) external view returns (uint128 budget, uint128 totalVote, TokenView[] memory tokens, uint256 totalCount);

    /**
     * @notice Get the incentive data for the given epoch and token.
     * @param epoch The epoch to get the incentive data for.
     * @param token The token to get the incentive data for.
     * @param startIndex The start index of the incentive tokens to get.
     * @param endIndex The end index of the incentive tokens to get.
     * @return incentiveTokens The incentive tokens for the epoch and token.
     * @return voteIncentives The vote incentives for the epoch and token.
     * @return totalCount The total count of incentive tokens for the epoch and token.
     */
    function getIncentiveData(
        IERC20 token,
        uint256 epoch,
        uint256 startIndex,
        uint256 endIndex
    ) external view returns (IERC20[] memory incentiveTokens, uint256[] memory voteIncentives, uint256 totalCount);

    /**
     * @notice Get the claim data for the given user/epoch. Performs a pool
     * quote so is not a view function, but does not alter state.
     * @param user account to check
     * @param epoch The epoch to get the checkpoint data for.
     * @param bounds Index bounds to search.
     */
    function getVoterClaimData(
        address user,
        uint256 epoch,
        IndexBounds memory bounds
    ) external returns (ClaimData[] memory claimData, uint256 totalCount);

    /**
     * @notice Check if the given user has voted in the given epoch.
     * @param user The user to check.
     * @param epoch The epoch to check.
     * @return hasVoted True if the user has voted, false otherwise.
     */
    function hasVoted(address user, uint256 epoch) external view returns (bool);

    /**
     * @notice Get the voter data for the given user and epoch.
     * @param user The user to get the voter data for.
     * @param epoch The epoch to get the voter data for.
     * @return voterData The voter data for the user and epoch.
     */
    function getVoterData(address user, uint256 epoch) external view returns (VoterData memory voterData);

    /////////////////////////////////////
    /// Epoch Checkers and Helpers
    /////////////////////////////////////

    /**
     * @notice Check if the given epoch is a valid epoch.
     * @param epoch The epoch to check.
     * @return _isEpoch True if the epoch is a valid epoch, false otherwise.
     */
    function isEpoch(uint256 epoch) external pure returns (bool _isEpoch);

    /**
     * @notice Check if the given epoch is over.
     * @param epoch The epoch to check.
     * @return isOver True if the epoch is over, false otherwise.
     */
    function epochIsOver(uint256 epoch) external view returns (bool isOver);

    /**
     * @notice Check if voting is active in the given epoch.
     * @param epoch The epoch to check.
     * @return isActive True if voting is active, false otherwise.
     */
    function votingIsActive(uint256 epoch) external view returns (bool isActive);

    /**
     * @notice Get the end timestamp of the given epoch.
     * @param epoch The epoch to get the end timestamp for.
     * @return end The end timestamp of the epoch.
     */
    function epochEnd(uint256 epoch) external pure returns (uint256 end);

    /**
     * @notice Get the current epoch.
     */
    function currentEpoch() external view returns (uint256 epoch);

    /**
     * @notice Get the last epoch.
     */
    function lastEpoch() external view returns (uint256 epoch);

    /**
     * @notice Get the next epoch.
     */
    function nextEpoch() external view returns (uint256 epoch);

    /**
     * @notice Get the epoch period.
     */
    // solhint-disable-next-line func-name-mixedcase
    function EPOCH_PERIOD() external view returns (uint256);

    /**
     * @notice Get the pool TWA gap for the given token.
     * @param token The token to get the pool TWA gap for.
     * @return tickDiffD8 Tick difference in 8-decimal scale.
     * @return isReady Bool indicator of whether the blocktimestamp is valid.
     */
    function poolTwaGap(IERC20 token) external view returns (int256 tickDiffD8, bool isReady);
}