Cryo Explorer Ethereum Mainnet

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: 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.1.0) (utils/Create2.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev There's no code to deploy.
     */
    error Create2EmptyBytecode();

    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }
        if (bytecode.length == 0) {
            revert Create2EmptyBytecode();
        }
        assembly ("memory-safe") {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
            // if no address was created, and returndata is not empty, bubble revert
            if and(iszero(addr), not(iszero(returndatasize()))) {
                let p := mload(0x40)
                returndatacopy(p, 0, returndatasize())
                revert(p, returndatasize())
            }
        }
        if (addr == address(0)) {
            revert Errors.FailedDeployment();
        }
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        assembly ("memory-safe") {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }
}

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

pragma solidity ^0.8.20;

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
import {IGradientRegistry} from "./interfaces/IGradientRegistry.sol";
import {GradientMarketMakerPoolV3} from "./GradientMarketMakerPoolV3.sol";
import {IEventAggregator} from "./interfaces/IEventAggregator.sol";
import {IGradientMarketMakerPoolV3} from "./interfaces/IGradientMarketMakerPoolV3.sol";

// Custom errors to save gas and reduce contract size
error InvalidRegistry();
error InvalidEventAggregator();
error InvalidTokenAddress();
error PoolAlreadyExists();
error TokenBlocked();
error EthAmountMismatch();
error TokenAmountZero();

/**
 * @title GradientMarketMakerFactory
 * @notice Factory contract for deploying individual token market maker pools
 * @dev Similar to Uniswap V2 Factory pattern - one pool per token
 */
contract GradientMarketMakerFactory is Ownable {
    using SafeERC20 for IERC20;
    IGradientRegistry public immutable gradientRegistry;
    IEventAggregator public eventAggregator;

    // Mapping from token address to pool address
    mapping(address => address) public getPool;

    // Reverse mapping from pool address to token address
    mapping(address => address) public getToken;

    // Array of all pools
    address[] public allPools;

    // Events
    event PoolCreated(
        address indexed token,
        address indexed pool,
        uint256 poolIndex
    );
    event EventAggregatorUpdated(
        address indexed oldEventAggregator,
        address indexed newEventAggregator
    );

    constructor(
        IGradientRegistry _gradientRegistry,
        IEventAggregator _eventAggregator
    ) Ownable(msg.sender) {
        if (address(_gradientRegistry) == address(0)) revert InvalidRegistry();
        gradientRegistry = _gradientRegistry;

        if (address(_eventAggregator) != address(0)) {
            if (address(_eventAggregator).code.length == 0)
                revert InvalidEventAggregator();
        }

        eventAggregator = _eventAggregator;
    }

    /**
     * @notice Set the EventAggregator address
     * @param _eventAggregator New EventAggregator address
     */
    function setEventAggregator(
        IEventAggregator _eventAggregator
    ) external onlyOwner {
        if (
            address(_eventAggregator) == address(0) ||
            address(_eventAggregator).code.length == 0
        ) revert InvalidEventAggregator();
        address oldEventAggregator = address(eventAggregator);
        eventAggregator = _eventAggregator;
        emit EventAggregatorUpdated(
            oldEventAggregator,
            address(_eventAggregator)
        );
    }

    /**
     * @notice Calculate the salt for CREATE2 deployment
     * @param token Address of the token
     * @return salt The calculated salt
     */
    function _calculateSalt(
        address token
    ) internal pure returns (bytes32 salt) {
        return keccak256(abi.encodePacked(token));
    }

    /**
     * @notice Get the bytecode for GradientMarketMakerPool with constructor arguments
     * @param token Address of the token
     * @return bytecode The complete bytecode for deployment
     */
    function _getPoolBytecode(
        address token
    ) internal view returns (bytes memory bytecode) {
        bytecode = abi.encodePacked(
            type(GradientMarketMakerPoolV3).creationCode,
            abi.encode(IERC20(token), address(this))
        );
    }

    /**
     * @notice Predict the address where a pool will be deployed for a given token
     * @param token Address of the token
     * @return predictedAddress The predicted pool address
     */
    function predictPoolAddress(
        address token
    ) external view returns (address predictedAddress) {
        bytes32 salt = _calculateSalt(token);
        bytes memory bytecode = _getPoolBytecode(token);
        predictedAddress = Create2.computeAddress(salt, keccak256(bytecode));
    }

    /**
     * @notice Get the number of pools created
     * @return Number of pools
     */
    function allPoolsLength() external view returns (uint256) {
        return allPools.length;
    }

    /**
     * @notice Create a new market maker pool for a token using CREATE2
     * @param token Address of the token
     * @return pool Address of the created pool
     */
    function createPool(address token) external returns (address pool) {
        if (token == address(0)) revert InvalidTokenAddress();
        if (token.code.length == 0) revert InvalidTokenAddress();
        if (getPool[token] != address(0)) revert PoolAlreadyExists();
        if (gradientRegistry.blockedTokens(token)) revert TokenBlocked();

        // Calculate salt and bytecode for CREATE2
        bytes32 salt = _calculateSalt(token);
        bytes memory bytecode = _getPoolBytecode(token);

        // Deploy pool using CREATE2
        pool = Create2.deploy(0, salt, bytecode);

        // Store pool address
        getPool[token] = pool;
        getToken[pool] = token;
        allPools.push(pool);

        try eventAggregator.emitPoolCreated(token, pool) {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }
    }

    /**
     * @notice Create a new market maker pool for a token with initial liquidity
     * @param token Address of the token
     * @param initialEthAmount Amount of ETH to add as initial liquidity
     * @param initialTokenAmount Amount of tokens to add as initial liquidity
     * @param minPrice Minimum price for liquidity range
     * @param maxPrice Maximum price for liquidity range
     * @return pool Address of the created pool
     */
    function createPoolWithLiquidity(
        address token,
        uint256 initialEthAmount,
        uint256 initialTokenAmount,
        uint256 minPrice,
        uint256 maxPrice
    ) external payable returns (address pool) {
        if (token == address(0)) revert InvalidTokenAddress();
        if (token.code.length == 0) revert InvalidTokenAddress();
        if (getPool[token] != address(0)) revert PoolAlreadyExists();
        if (gradientRegistry.blockedTokens(token)) revert TokenBlocked();
        if (msg.value != initialEthAmount) revert EthAmountMismatch();

        // Create the pool using CREATE2
        bytes32 salt = _calculateSalt(token);
        bytes memory bytecode = _getPoolBytecode(token);
        pool = Create2.deploy(0, salt, bytecode);

        // Store pool address
        getPool[token] = pool;
        getToken[pool] = token;
        allPools.push(pool);

        // Add initial liquidity for the specified user
        if (initialEthAmount > 0) {
            IGradientMarketMakerPoolV3(pool).addETHLiquidityForUser{
                value: initialEthAmount
            }(msg.sender, minPrice, maxPrice);
        }

        if (initialTokenAmount > 0) {
            // Transfer tokens from caller to factory first
            IERC20(token).safeTransferFrom(
                msg.sender,
                address(this),
                initialTokenAmount
            );
            // Approve pool to spend tokens
            IERC20(token).forceApprove(pool, initialTokenAmount);
            // Add token liquidity for the specified user
            IGradientMarketMakerPoolV3(pool).addTokenLiquidityForUser(
                msg.sender,
                initialTokenAmount,
                minPrice,
                maxPrice
            );
            // Reset allowance to zero to prevent future unexpected pulls
            IERC20(token).forceApprove(pool, 0);
        }

        try eventAggregator.emitPoolCreated(token, pool) {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }
    }

    /**
     * @notice Check if a pool exists for a token
     * @param token Address of the token
     * @return exists True if pool exists
     */
    function poolExists(address token) external view returns (bool exists) {
        return getPool[token] != address(0);
    }

    /**
     * @notice Get all deployed pools
     * @return allPoolAddresses Array of all pool addresses
     */
    function getAllPools()
        external
        view
        returns (address[] memory allPoolAddresses)
    {
        return allPools;
    }

    /**
     * @notice Check if a given address is a valid pool
     * @param poolAddress Address to check
     * @return isValid True if the address is a valid pool
     */
    function isValidPool(
        address poolAddress
    ) external view returns (bool isValid) {
        return getToken[poolAddress] != address(0);
    }

    /**
     * @notice Get the registry address
     * @return registryAddress Address of the GradientRegistry
     */
    function getRegistry() external view returns (address) {
        return address(gradientRegistry);
    }

    /**
     * @notice Get the event aggregator address
     * @return eventAggregatorAddress Address of the EventAggregator
     */
    function getEventAggregator() external view returns (address) {
        return address(eventAggregator);
    }

    // =============================== EMERGENCY FUNCTIONS ===============================

    /**
     * @notice Emergency function to withdraw ETH from the contract
     * @param recipient Address to receive the ETH
     * @param amount Amount of ETH to withdraw (0 = withdraw all)
     * @dev Only callable by contract owner in emergency situations
     */
    function emergencyWithdrawETH(
        address payable recipient,
        uint256 amount
    ) external onlyOwner {
        require(recipient != address(0), "Invalid recipient");
        require(address(this).balance > 0, "No ETH to withdraw");

        uint256 withdrawAmount = amount == 0 ? address(this).balance : amount;
        require(
            withdrawAmount <= address(this).balance,
            "Insufficient ETH balance"
        );

        (bool success, ) = recipient.call{value: withdrawAmount}("");
        require(success, "ETH withdrawal failed");

        emit EmergencyWithdrawETH(recipient, withdrawAmount);
    }

    /**
     * @notice Emergency function to withdraw ERC20 tokens from the contract
     * @param token Address of the token to withdraw
     * @param recipient Address to receive the tokens
     * @param amount Amount of tokens to withdraw (0 = withdraw all)
     * @dev Only callable by contract owner in emergency situations
     */
    function emergencyWithdrawToken(
        address token,
        address recipient,
        uint256 amount
    ) external onlyOwner {
        require(token != address(0), "Invalid token address");
        require(recipient != address(0), "Invalid recipient");

        uint256 balance = IERC20(token).balanceOf(address(this));
        require(balance > 0, "No tokens to withdraw");

        uint256 withdrawAmount = amount == 0 ? balance : amount;
        require(withdrawAmount <= balance, "Insufficient token balance");

        IERC20(token).safeTransfer(recipient, withdrawAmount);

        emit EmergencyWithdrawToken(token, recipient, withdrawAmount);
    }

    /**
     * @notice Emergency function to withdraw multiple tokens at once
     * @param tokens Array of token addresses to withdraw
     * @param recipient Address to receive all tokens
     * @dev Only callable by contract owner in emergency situations
     * @dev More gas efficient than calling emergencyWithdrawToken multiple times
     */
    function emergencyWithdrawMultipleTokens(
        address[] calldata tokens,
        address recipient
    ) external onlyOwner {
        require(recipient != address(0), "Invalid recipient");
        require(tokens.length > 0, "No tokens specified");
        require(tokens.length <= 20, "Too many tokens to withdraw at once");

        for (uint256 i = 0; i < tokens.length; i++) {
            address token = tokens[i];
            require(token != address(0), "Invalid token address");

            uint256 balance = IERC20(token).balanceOf(address(this));
            if (balance > 0) {
                IERC20(token).safeTransfer(recipient, balance);
                emit EmergencyWithdrawToken(token, recipient, balance);
            }
        }
    }

    // Events for emergency withdrawals
    event EmergencyWithdrawETH(address indexed recipient, uint256 amount);
    event EmergencyWithdrawToken(
        address indexed token,
        address indexed recipient,
        uint256 amount
    );
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IGradientRegistry} from "./interfaces/IGradientRegistry.sol";
import {IGradientMarketMakerFactory} from "./interfaces/IGradientMarketMakerFactory.sol";
import {IUniswapV2Pair} from "./interfaces/IUniswapV2Pair.sol";
import {IUniswapV2Router02} from "./interfaces/IUniswapV2Router.sol";
import {IUniswapV2Factory} from "./interfaces/IUniswapV2Factory.sol";
import {IUniswapV3PriceHelper} from "./interfaces/IUniswapV3PriceHelper.sol";
import {IEventAggregator} from "./interfaces/IEventAggregator.sol";
import {IGradientMarketMakerPoolV3} from "./interfaces/IGradientMarketMakerPoolV3.sol";

// Custom errors
error InvalidTokenAddress();
error TokenBlocked();
error OnlyRewardDistributor();
error OnlyOrderbook();
error OnlyFactory();
error OnlyOwner();
error UnsupportedTokenDecimals();
error AmountZero();
error InsufficientShares();
error InsufficientPoolBalance();
error InsufficientWithdrawal();
error ETHTransferFailed();
error ETHTransferToOrderbookFailed();
error VersionAlreadyProcessed();
error VersionNotAvailable();
error InvalidMerkleProof();
error NoMerkleRootForUpdates();
error InvalidSharesPercentage();
error NoLiquidity();
error NoLiquidityToWithdraw();
error NoSharesToBurn();
error InsufficientSharesToBurn();
error NoRewards();
error NoETHLiquidityOrRewards();
error NoTokenLiquidityOrRewards();
error NoTokenProviderRewards();
error InvalidRecipient();
error InsufficientETHBalance();
error InsufficientTokenBalance();
error ETHWithdrawalFailed();
error TokenWithdrawalFailed();
error RouterNotSet();
error PairDoesNotExist();
error OverflowInETHRewardCalculation();
error OverflowInTokenProviderRewardCalculation();
error OverflowInTokenRewardCalculation();
error ETHAmountMismatch();
error InsufficientTokenLiquidity();
error InsufficientETHLiquidity();
error ETHAmountBelowMinimum();
error TokenAmountBelowMinimum();
error NoETHSent();
error NoLiquidityOrRewards();
error InvalidMinLiquidity();
error InvalidMinTokenLiquidity();
error InvalidPriceRange();
error PriceOutOfRange();
error InvalidPriceOrder();
error OverlappingPriceRange();

/**
 * @title GradientMarketMakerPoolV3
 * @notice Individual pool contract for a single token with price range functionality
 * @dev Each token gets its own pool contract with concentrated liquidity price ranges
 * @dev Users can specify min/max price ranges when adding liquidity
 * @dev Enhanced version with better gas optimization and security
 */
contract GradientMarketMakerPoolV3 is ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Price range struct for concentrated liquidity
    struct PriceRange {
        uint256 minPrice; // Minimum price (in wei per token)
        uint256 maxPrice; // Maximum price (in wei per token)
        bool isActive; // Whether this range is active
    }

    // Provider position with price range support
    struct ProviderPosition {
        uint256 position;
        uint256 rewardDebt;
        uint256 pendingRewards;
        uint256 lastUpdateVersion;
    }

    // Pool metrics with price range support
    struct PoolMetrics {
        uint256 position; // Total ETH or tokens
        uint256 totalLPShares; // Total LP shares
        uint256 accRewardPerShare; // Accumulated rewards per share
        uint256 rewardBalance; // Available reward balance
        uint256 accountedPosition; // Accounted position for calculations
    }

    // Events
    event LiquidityDeposited(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 positionMinted,
        bool isETH,
        uint256 minPrice,
        uint256 maxPrice
    );

    event LiquidityWithdrawn(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 positionBurned,
        bool isETH,
        uint256 minPrice,
        uint256 maxPrice
    );

    event PoolFeeDistributed(
        address indexed from,
        uint256 amount,
        address indexed token,
        bool isETH
    );

    event FeeClaimed(
        address indexed user,
        uint256 amount,
        address indexed token,
        bool isETH
    );

    event FeeRefunded(address indexed recipient, uint256 amount, bool isETH);

    event PoolBalanceUpdated(
        address indexed token,
        uint256 newTotalETH,
        uint256 newTotalTokens,
        uint256 newETHLPShares,
        uint256 newTokenLPShares
    );

    event PriceRangeUpdated(
        address indexed user,
        uint256 oldMinPrice,
        uint256 oldMaxPrice,
        uint256 newMinPrice,
        uint256 newMaxPrice,
        bool isETH
    );

    event MerkleRootUpdated(uint256 indexed version, bytes32 merkleRoot);

    event UserPositionUpdated(
        address indexed user,
        uint256 indexed version,
        uint256 newETHPositions,
        uint256 newTokenPositions
    );

    event MinLiquidityUpdated(uint256 newMinLiquidity, bool isETH);

    event EmergencyWithdraw(
        address indexed token,
        address indexed recipient,
        uint256 amount,
        bool isETH
    );

    // Position events
    event PositionCreated(
        uint256 indexed positionId,
        address indexed owner,
        uint256 amount,
        uint256 minPrice,
        uint256 maxPrice,
        bool isETH
    );

    event PositionUpdated(
        uint256 indexed positionId,
        address indexed owner,
        uint256 newAmount,
        uint256 newMinPrice,
        uint256 newMaxPrice
    );

    event PositionClosed(
        uint256 indexed positionId,
        address indexed owner,
        uint256 amount,
        uint256 rewards
    );

    // Immutable token address - this pool is dedicated to one token
    IERC20 public immutable tokenContract;
    IGradientMarketMakerFactory public immutable factoryContract;

    // Pool state with price range support
    uint256 public totalETH;
    uint256 public totalTokens;

    // Single position per user (like V2 but with price range)
    mapping(address => ProviderPosition) public ethProviders;
    mapping(address => ProviderPosition) public tokenProviders;

    // User price ranges (shared between ETH and token positions)
    mapping(address => PriceRange) public userPriceRanges;

    // Reward tracking - separate ETH pools for each provider type (same as V2)
    uint256 public accRewardPerShare; // For ETH providers (ETH rewards)
    uint256 public accTokenRewardPerShare; // For token providers (token rewards)
    uint256 public rewardBalance; // ETH rewards for ETH providers
    uint256 public tokenProviderRewardBalance; // ETH rewards for token providers

    uint256 public constant SCALE = 1e18;

    // Maximum supported token decimals to prevent overflow
    uint8 public constant MAX_TOKEN_DECIMALS = 24;

    uint8 public tokenDecimals;

    // Configurable minimum liquidity requirements
    uint256 public minLiquidity;
    uint256 public minTokenLiquidity;

    // Track totals for this specific token pool
    uint256 public totalEthAdded;
    uint256 public totalEthRemoved;
    uint256 public totalTokensAdded;
    uint256 public totalTokensRemoved; // Total tokens removed from this pool
    uint256 public totalTokenRewardsDistributed; // Total token rewards distributed

    // Uniswap pair address
    address public uniswapPair;

    // Uniswap V3 Price Helper for accessing V3 pools
    IUniswapV3PriceHelper public priceHelper;

    // Merkle root for LP share updates
    bytes32 public merkleRoot;
    uint256 public currentVersion;
    mapping(uint256 => bytes32) public versionMerkleRoots;

    // Position limits

    // Events are inherited from interface

    modifier isNotBlocked() {
        if (getRegistry().blockedTokens(address(tokenContract)))
            revert TokenBlocked();
        _;
    }

    modifier onlyRewardDistributor() {
        if (!getRegistry().isRewardDistributor(msg.sender))
            revert OnlyRewardDistributor();
        _;
    }

    modifier onlyOrderbook() {
        if (msg.sender != getRegistry().orderbook()) revert OnlyOrderbook();
        _;
    }

    modifier onlyFactory() {
        if (msg.sender != address(factoryContract)) revert OnlyFactory();
        _;
    }

    modifier onlyOwner() {
        if (msg.sender != factoryContract.owner()) revert OnlyOwner();
        _;
    }

    constructor(IERC20 _token, address _factory) {
        if (address(_token) == address(0)) revert InvalidTokenAddress();
        if (_factory == address(0)) revert InvalidRecipient();

        tokenContract = _token;
        factoryContract = IGradientMarketMakerFactory(_factory);

        tokenDecimals = IERC20Metadata(address(_token)).decimals();

        // Validate token decimals to prevent overflow
        if (tokenDecimals > MAX_TOKEN_DECIMALS) {
            revert UnsupportedTokenDecimals();
        }

        minLiquidity = 1000000000000; // 0.000001 ETH minimum (default)
        minTokenLiquidity = 2 * (10 ** tokenDecimals); // Set minimum token liquidity to 2 tokens
    }

    /**
     * @notice Receive ETH for reward distribution
     */
    receive() external payable {}

    /**
     * @notice Get the current owner (factory owner)
     * @return The current owner of the factory
     */
    function owner() public view returns (address) {
        return factoryContract.owner();
    }

    // =============================== INTERNAL FUNCTIONS ===============================

    /**
     * @notice Get the registry address from the factory
     * @return registryAddress Address of the GradientRegistry
     */
    function getRegistry() public view returns (IGradientRegistry) {
        return IGradientRegistry(factoryContract.getRegistry());
    }

    /**
     * @notice Get the event aggregator address from the factory
     * @return eventAggregatorAddress Address of the EventAggregator
     */
    function getEventAggregator() public view returns (IEventAggregator) {
        return IEventAggregator(factoryContract.getEventAggregator());
    }

    /**
     * @notice Validate price range parameters
     * @param minPrice Minimum price
     * @param maxPrice Maximum price
     */
    function _validatePriceRange(
        uint256 minPrice,
        uint256 maxPrice
    ) internal pure {
        if (minPrice == 0 || maxPrice == 0) revert InvalidPriceRange();
        if (minPrice >= maxPrice) revert InvalidPriceOrder();
    }

    /**
     * @notice Check if current price is within a given range
     * @param price Current price to check
     * @param minPrice Minimum price
     * @param maxPrice Maximum price
     * @return isWithinRange True if price is within range
     */
    function _isPriceWithinRange(
        uint256 price,
        uint256 minPrice,
        uint256 maxPrice
    ) internal pure returns (bool isWithinRange) {
        return price >= minPrice && price <= maxPrice;
    }

    /**
     * @notice Normalize token amount to 18 decimals for consistent calculations
     * @param amount Amount in token decimals
     * @return uint256 Amount normalized to 18 decimals
     */
    function _normalizeTo18Decimals(
        uint256 amount
    ) internal view returns (uint256) {
        if (tokenDecimals == 18) {
            return amount;
        } else if (tokenDecimals < 18) {
            return amount * (10 ** (18 - tokenDecimals));
        } else {
            return amount / (10 ** (tokenDecimals - 18));
        }
    }

    /**
     * @notice Denormalize from 18 decimals to token decimals
     * @param amount Amount in 18 decimals
     * @return uint256 Amount in token decimals
     */
    function _denormalizeFrom18Decimals(
        uint256 amount
    ) internal view returns (uint256) {
        if (tokenDecimals == 18) {
            return amount;
        } else if (tokenDecimals < 18) {
            return amount / (10 ** (18 - tokenDecimals));
        } else {
            return amount * (10 ** (tokenDecimals - 18));
        }
    }

    /**
     * @notice Update merkle root after trade execution
     * @param newMerkleRoot New merkle root to set
     */
    function _updateMerkleRootAfterTrade(bytes32 newMerkleRoot) internal {
        if (newMerkleRoot != bytes32(0)) {
            currentVersion++;
            merkleRoot = newMerkleRoot;
            versionMerkleRoots[currentVersion] = newMerkleRoot;

            try
                getEventAggregator().emitMerkleRootUpdated(
                    currentVersion,
                    newMerkleRoot
                )
            {
                // Success - EventAggregator call completed
            } catch {
                // EventAggregator call failed - continue execution
            }

            emit MerkleRootUpdated(currentVersion, newMerkleRoot);
        }
    }

    /**
     * @notice Verify merkle proof for user position update
     * @param user User address
     * @param proof Merkle proof
     * @param newETHPosition New ETH position value
     * @param newTokenPosition New token position value
     * @param ethRewardsToAdd ETH rewards to add
     * @param tokenRewardsToAdd Token rewards to add
     * @return isValid Whether the proof is valid
     */
    function _verifyMerkleProof(
        address user,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) internal view returns (bool isValid) {
        bytes32 leaf = keccak256(
            abi.encodePacked(
                user,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            )
        );

        // Special handling for single provider case
        if (proof.length == 0) {
            // For single provider, verify that the leaf equals the merkle root
            return leaf == merkleRoot;
        }

        // Use standard merkle proof verification
        return MerkleProof.verify(proof, merkleRoot, leaf);
    }

    /**
     * @notice Check if user needs position update for either asset type
     * @param user User address to check
     * @return needsUpdate True if user needs position update
     */
    function _needsPositionUpdate(address user) internal view returns (bool) {
        // Check ETH position
        if (
            ethProviders[user].position > 0 &&
            ethProviders[user].lastUpdateVersion < currentVersion
        ) {
            return true;
        }
        if (
            ethProviders[user].pendingRewards > 0 &&
            ethProviders[user].lastUpdateVersion < currentVersion
        ) {
            return true;
        }

        // Check token position
        if (
            tokenProviders[user].position > 0 &&
            tokenProviders[user].lastUpdateVersion < currentVersion
        ) {
            return true;
        }
        if (
            tokenProviders[user].pendingRewards > 0 &&
            tokenProviders[user].lastUpdateVersion < currentVersion
        ) {
            return true;
        }

        return false;
    }

    // =============================== PUBLIC FUNCTIONS ===============================

    /**
     * @notice Add ETH liquidity with price range and optional position update
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position value (required if proof provided)
     * @param newTokenPosition New token position value (required if proof provided)
     * @param ethRewardsToAdd ETH rewards to add
     * @param tokenRewardsToAdd Token rewards to add
     */
    function addETHLiquidity(
        uint256 minPrice,
        uint256 maxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external payable isNotBlocked nonReentrant {
        if (msg.value < minLiquidity) revert ETHAmountBelowMinimum();
        _validatePriceRange(minPrice, maxPrice);

        // Check if user needs position update - only if they have existing liquidity
        if (_needsPositionUpdate(msg.sender)) {
            // Proof is required - validate parameters
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();

            // Verify merkle proof
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) revert InvalidMerkleProof();

            // Update user position first
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        // Then add ETH liquidity with price range
        _addETHLiquidity(msg.sender, msg.value, minPrice, maxPrice);
    }

    /**
     * @notice Add token liquidity with price range and optional position update
     * @param tokenAmount Amount of tokens to deposit
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position value (required if proof provided)
     * @param newTokenPosition New token position value (required if proof provided)
     * @param ethRewardsToAdd ETH rewards to add
     * @param tokenRewardsToAdd Token rewards to add
     */
    function addTokenLiquidity(
        uint256 tokenAmount,
        uint256 minPrice,
        uint256 maxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external isNotBlocked nonReentrant {
        if (tokenAmount < minTokenLiquidity) revert TokenAmountBelowMinimum();
        _validatePriceRange(minPrice, maxPrice);

        // Check if user needs position update - only if they have existing liquidity
        if (_needsPositionUpdate(msg.sender)) {
            // Proof is required - validate parameters
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();

            // Verify merkle proof
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) revert InvalidMerkleProof();

            // Update user position first
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        // Then add token liquidity with price range
        _addTokenLiquidity(msg.sender, tokenAmount, minPrice, maxPrice);
    }

    /**
     * @notice Add both ETH and token liquidity with price range and optional position update
     * @param tokenAmount Amount of tokens to deposit
     * @param minPrice Minimum price for liquidity position (applies to both ETH and token positions)
     * @param maxPrice Maximum price for liquidity position (applies to both ETH and token positions)
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position value (required if proof provided)
     * @param newTokenPosition New token position value (required if proof provided)
     * @param ethRewardsToAdd ETH rewards to add
     * @param tokenRewardsToAdd Token rewards to add
     */
    function addLiquidity(
        uint256 tokenAmount,
        uint256 minPrice,
        uint256 maxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external payable isNotBlocked nonReentrant {
        if (msg.value < minLiquidity) revert ETHAmountBelowMinimum();
        if (tokenAmount < minTokenLiquidity) revert TokenAmountBelowMinimum();
        _validatePriceRange(minPrice, maxPrice);

        // Check if user needs position update for either asset type - only if they have existing liquidity
        bool needsUpdate = _needsPositionUpdate(msg.sender);

        if (needsUpdate) {
            // Proof is required - validate parameters
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();

            // Verify merkle proof
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) revert InvalidMerkleProof();

            // Update user position first
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        // Then add liquidity with price ranges
        _addETHLiquidity(msg.sender, msg.value, minPrice, maxPrice);
        _addTokenLiquidity(msg.sender, tokenAmount, minPrice, maxPrice);
    }

    /**
     * @notice Add ETH liquidity to the pool with price range (internal function)
     * @param user User address to add liquidity for
     * @param ethAmount Amount of ETH to deposit
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     */
    function _addETHLiquidity(
        address user,
        uint256 ethAmount,
        uint256 minPrice,
        uint256 maxPrice
    ) internal {
        // Initialize Uniswap pair if not set
        if (uniswapPair == address(0)) {
            uniswapPair = getPairAddress();
        }
        if (uniswapPair == address(0)) revert PairDoesNotExist();

        // Calculate pending rewards for existing position
        if (ethProviders[user].position > 0) {
            uint256 pendingReward = (ethProviders[user].position *
                accRewardPerShare) /
                SCALE -
                ethProviders[user].rewardDebt;
            ethProviders[user].pendingRewards += pendingReward;
        }

        // Add to existing position or create new one
        if (ethProviders[user].position > 0) {
            // User already has ETH position, add to it
            ethProviders[user].position += ethAmount;
        } else {
            // Create new ETH position
            ethProviders[user] = ProviderPosition({
                position: ethAmount,
                rewardDebt: 0,
                pendingRewards: 0,
                lastUpdateVersion: currentVersion
            });
        }

        // Set or update user price range (allow updates when inactive)
        if (!userPriceRanges[user].isActive) {
            userPriceRanges[user] = PriceRange({
                minPrice: minPrice,
                maxPrice: maxPrice,
                isActive: true
            });
        }

        // Update reward debt for the position
        ethProviders[user].rewardDebt =
            (ethProviders[user].position * accRewardPerShare) /
            SCALE;

        totalETH += ethAmount;
        totalEthAdded += ethAmount;

        uint256 eventMinPrice = userPriceRanges[user].isActive
            ? userPriceRanges[user].minPrice
            : minPrice;
        uint256 eventMaxPrice = userPriceRanges[user].isActive
            ? userPriceRanges[user].maxPrice
            : maxPrice;

        try
            getEventAggregator().emitLiquidityEvent(
                user,
                address(tokenContract),
                0, // ETH_ADD
                ethAmount,
                eventMinPrice,
                eventMaxPrice
            )
        {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }

        // Emit local event
        emit LiquidityDeposited(
            user,
            address(tokenContract),
            ethAmount,
            ethAmount,
            true,
            eventMinPrice,
            eventMaxPrice
        );
    }

    /**
     * @notice Add token liquidity to the pool with price range (internal function)
     * @param user User address to add liquidity for
     * @param tokenAmount Amount of tokens to deposit
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     */
    function _addTokenLiquidity(
        address user,
        uint256 tokenAmount,
        uint256 minPrice,
        uint256 maxPrice
    ) internal {
        // Initialize Uniswap pair if not set
        if (uniswapPair == address(0)) {
            uniswapPair = getPairAddress();
        }
        if (uniswapPair == address(0)) revert PairDoesNotExist();

        // Record balance before transfer to handle fee-on-transfer tokens
        uint256 balanceBefore = tokenContract.balanceOf(address(this));

        // Transfer tokens from user
        tokenContract.safeTransferFrom(msg.sender, address(this), tokenAmount);

        // Calculate actual received amount (handles fee-on-transfer and rebasing tokens)
        uint256 actualReceived = tokenContract.balanceOf(address(this)) -
            balanceBefore;

        // Calculate pending rewards for existing position
        if (tokenProviders[user].position > 0) {
            uint256 pendingReward = (tokenProviders[user].position *
                accTokenRewardPerShare) /
                SCALE -
                tokenProviders[user].rewardDebt;
            tokenProviders[user].pendingRewards += pendingReward;
        }

        // Add to existing position or create new one
        if (tokenProviders[user].position > 0) {
            // User already has token position, add to it
            tokenProviders[user].position += actualReceived;
        } else {
            // Create new token position
            tokenProviders[user] = ProviderPosition({
                position: actualReceived,
                rewardDebt: 0,
                pendingRewards: 0,
                lastUpdateVersion: currentVersion
            });
        }

        // Set or update user price range
        if (!userPriceRanges[user].isActive) {
            userPriceRanges[user] = PriceRange({
                minPrice: minPrice,
                maxPrice: maxPrice,
                isActive: true
            });
        }

        // Update reward debt for the position
        tokenProviders[user].rewardDebt =
            (tokenProviders[user].position * accTokenRewardPerShare) /
            SCALE;

        totalTokens += actualReceived;
        totalTokensAdded += actualReceived;

        uint256 eventMinPrice = userPriceRanges[user].isActive
            ? userPriceRanges[user].minPrice
            : minPrice;
        uint256 eventMaxPrice = userPriceRanges[user].isActive
            ? userPriceRanges[user].maxPrice
            : maxPrice;

        try
            getEventAggregator().emitLiquidityEvent(
                user,
                address(tokenContract),
                2, // TOKEN_ADD
                actualReceived,
                eventMinPrice,
                eventMaxPrice
            )
        {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }

        // Emit local event
        emit LiquidityDeposited(
            user,
            address(tokenContract),
            actualReceived,
            actualReceived,
            false,
            eventMinPrice,
            eventMaxPrice
        );
    }

    /**
     * @notice Get the Uniswap pool/pair address for this token (checks V3 first, then V2)
     * @return poolAddress Address of the Uniswap V3 pool or V2 pair (returns address(0) if neither exists)
     * @dev Returns V3 pool address if available, otherwise V2 pair address
     */
    function getPairAddress() public view returns (address poolAddress) {
        address routerAddress = getRegistry().router();
        if (routerAddress == address(0)) revert RouterNotSet();

        IUniswapV2Router02 router = IUniswapV2Router02(routerAddress);
        address weth = router.WETH();

        // Try V3 first
        if (address(priceHelper) != address(0)) {
            address v3Pool = priceHelper.getV3PoolAddress(
                address(tokenContract),
                weth
            );
            if (v3Pool != address(0)) {
                return v3Pool;
            }
        }

        // Fall back to V2
        address factoryAddress = router.factory();
        IUniswapV2Factory uniswapFactory = IUniswapV2Factory(factoryAddress);
        return uniswapFactory.getPair(address(tokenContract), weth);
    }

    /**
     * @notice Get the reserves for this token pair
     * @return reserveETH ETH reserve amount
     * @return reserveToken Token reserve amount
     */
    function getReserves()
        public
        view
        returns (uint256 reserveETH, uint256 reserveToken)
    {
        address pairAddress = getPairAddress();
        // For V3-only tokens, there's no V2 pair - reserves not available via V2
        if (pairAddress == address(0)) {
            // V3 tokens don't have V2 reserves - return zeros or revert based on your needs
            // For now, returning zeros for V3 tokens
            return (0, 0);
        }

        (uint112 reserve0, uint112 reserve1, ) = IUniswapV2Pair(pairAddress)
            .getReserves();
        address token0 = IUniswapV2Pair(pairAddress).token0();

        (reserveETH, reserveToken) = token0 == address(tokenContract)
            ? (reserve1, reserve0)
            : (reserve0, reserve1);
    }

    /**
     * @notice Update both ETH and token provider positions using merkle proof
     * @param user User address
     * @param newETHPosition New ETH position value
     * @param newTokenPosition New token position value
     * @param ethRewardsToAdd Total ETH rewards (accumulated)
     * @param tokenRewardsToAdd Total token rewards (accumulated)
     */
    function _updateUserPosition(
        address user,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) internal {
        // Update ETH position
        ethProviders[user].position = newETHPosition;
        ethProviders[user].pendingRewards = ethRewardsToAdd;
        ethProviders[user].lastUpdateVersion = currentVersion;
        ethProviders[user].rewardDebt =
            (newETHPosition * accRewardPerShare) /
            SCALE;

        // Update token position
        tokenProviders[user].position = newTokenPosition;
        tokenProviders[user].pendingRewards = tokenRewardsToAdd;
        tokenProviders[user].lastUpdateVersion = currentVersion;
        uint256 normalizedPosition = _normalizeTo18Decimals(newTokenPosition);
        tokenProviders[user].rewardDebt =
            (normalizedPosition * accTokenRewardPerShare) /
            SCALE;

        // Emit event for position update
        emit UserPositionUpdated(
            user,
            currentVersion,
            newETHPosition,
            newTokenPosition
        );
    }

    function removeETHLiquidityWithProof(
        uint256 shares,
        uint256 minEthAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external {
        if (shares <= 0 || shares > 10000) revert InvalidSharesPercentage();
        if (totalETH == 0) revert NoLiquidity();
        if (ethProviders[msg.sender].position == 0)
            revert NoLiquidityToWithdraw();

        bool needsUpdate = _needsPositionUpdate(msg.sender);
        if (needsUpdate) {
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) {
                revert InvalidMerkleProof();
            }
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        uint256 amountToWithdraw = _removeETHLiquidityInternal(
            msg.sender,
            shares,
            minEthAmount
        );

        // Deactivate price range only if both positions are empty
        if (
            ethProviders[msg.sender].position == 0 &&
            tokenProviders[msg.sender].position == 0
        ) {
            userPriceRanges[msg.sender].isActive = false;
        }

        emit LiquidityWithdrawn(
            msg.sender,
            address(tokenContract),
            amountToWithdraw,
            amountToWithdraw,
            true,
            userPriceRanges[msg.sender].minPrice,
            userPriceRanges[msg.sender].maxPrice
        );

        try
            getEventAggregator().emitLiquidityEvent(
                msg.sender,
                address(tokenContract),
                1, // ETH_REMOVE
                amountToWithdraw,
                userPriceRanges[msg.sender].minPrice,
                userPriceRanges[msg.sender].maxPrice
            )
        {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }
    }

    function removeTokenLiquidityWithProof(
        uint256 shares,
        uint256 minTokenAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external {
        if (shares <= 0 || shares > 10000) revert InvalidSharesPercentage();
        if (totalTokens == 0) revert NoLiquidity();
        if (tokenProviders[msg.sender].position == 0)
            revert NoLiquidityToWithdraw();

        bool needsUpdate = _needsPositionUpdate(msg.sender);
        if (needsUpdate) {
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) {
                revert InvalidMerkleProof();
            }
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        uint256 amountToWithdraw = _removeTokenLiquidityInternal(
            msg.sender,
            shares,
            minTokenAmount
        );

        // Deactivate price range only if both positions are empty
        if (
            ethProviders[msg.sender].position == 0 &&
            tokenProviders[msg.sender].position == 0
        ) {
            userPriceRanges[msg.sender].isActive = false;
        }

        emit LiquidityWithdrawn(
            msg.sender,
            address(tokenContract),
            amountToWithdraw,
            amountToWithdraw,
            false,
            userPriceRanges[msg.sender].minPrice,
            userPriceRanges[msg.sender].maxPrice
        );

        try
            getEventAggregator().emitLiquidityEvent(
                msg.sender,
                address(tokenContract),
                3, // TOKEN_REMOVE
                amountToWithdraw,
                userPriceRanges[msg.sender].minPrice,
                userPriceRanges[msg.sender].maxPrice
            )
        {
            // Success - EventAggregator call completed
        } catch {
            // EventAggregator call failed - continue execution
        }
    }

    function removeLiquidityWithProof(
        uint256 ethShares,
        uint256 tokenShares,
        uint256 minEthAmount,
        uint256 minTokenAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external {
        if (ethShares <= 0 || ethShares > 10000)
            revert InvalidSharesPercentage();
        if (tokenShares <= 0 || tokenShares > 10000)
            revert InvalidSharesPercentage();
        if (totalETH == 0 && totalTokens == 0) revert NoLiquidity();
        if (
            ethProviders[msg.sender].position == 0 &&
            tokenProviders[msg.sender].position == 0
        ) {
            revert NoLiquidityToWithdraw();
        }

        bool needsUpdate = _needsPositionUpdate(msg.sender);
        if (needsUpdate) {
            if (merkleRoot == bytes32(0)) revert NoMerkleRootForUpdates();
            if (
                !_verifyMerkleProof(
                    msg.sender,
                    proof,
                    newETHPosition,
                    newTokenPosition,
                    ethRewardsToAdd,
                    tokenRewardsToAdd
                )
            ) {
                revert InvalidMerkleProof();
            }
            _updateUserPosition(
                msg.sender,
                newETHPosition,
                newTokenPosition,
                ethRewardsToAdd,
                tokenRewardsToAdd
            );
        }

        uint256 ethAmountToWithdraw = 0;
        uint256 tokenAmountToWithdraw = 0;

        if (ethProviders[msg.sender].position > 0) {
            ethAmountToWithdraw = _removeETHLiquidityInternal(
                msg.sender,
                ethShares,
                minEthAmount
            );
        }

        if (tokenProviders[msg.sender].position > 0) {
            tokenAmountToWithdraw = _removeTokenLiquidityInternal(
                msg.sender,
                tokenShares,
                minTokenAmount
            );
        }

        if (
            ethAmountToWithdraw < minEthAmount &&
            tokenAmountToWithdraw < minTokenAmount
        ) revert InsufficientWithdrawal();

        // Deactivate price range only if both positions are empty
        if (
            ethProviders[msg.sender].position == 0 &&
            tokenProviders[msg.sender].position == 0
        ) {
            userPriceRanges[msg.sender].isActive = false;
        }

        // Emit separate events for each position
        if (ethAmountToWithdraw > 0) {
            emit LiquidityWithdrawn(
                msg.sender,
                address(tokenContract),
                ethAmountToWithdraw,
                ethAmountToWithdraw,
                true,
                userPriceRanges[msg.sender].minPrice,
                userPriceRanges[msg.sender].maxPrice
            );

            try
                getEventAggregator().emitLiquidityEvent(
                    msg.sender,
                    address(tokenContract),
                    1, // ETH_REMOVE
                    ethAmountToWithdraw,
                    userPriceRanges[msg.sender].minPrice,
                    userPriceRanges[msg.sender].maxPrice
                )
            {
                // Success - EventAggregator call completed
            } catch {
                // EventAggregator call failed - continue execution
            }
        }

        if (tokenAmountToWithdraw > 0) {
            emit LiquidityWithdrawn(
                msg.sender,
                address(tokenContract),
                tokenAmountToWithdraw,
                tokenAmountToWithdraw,
                false,
                userPriceRanges[msg.sender].minPrice,
                userPriceRanges[msg.sender].maxPrice
            );

            try
                getEventAggregator().emitLiquidityEvent(
                    msg.sender,
                    address(tokenContract),
                    3, // TOKEN_REMOVE
                    tokenAmountToWithdraw,
                    userPriceRanges[msg.sender].minPrice,
                    userPriceRanges[msg.sender].maxPrice
                )
            {
                // Success - EventAggregator call completed
            } catch {
                // EventAggregator call failed - continue execution
            }
        }
    }

    function executeBuyOrder(
        uint256 ethAmount,
        uint256 tokenAmount,
        bytes32 newMerkleRoot
    ) external payable isNotBlocked onlyOrderbook {
        if (ethAmount == 0) revert AmountZero();
        if (tokenAmount == 0) revert AmountZero();
        if (msg.value != ethAmount) revert ETHAmountMismatch();
        if (totalTokens <= tokenAmount) revert InsufficientTokenLiquidity();

        totalTokens -= tokenAmount;
        totalTokensRemoved += tokenAmount;
        totalETH += msg.value;
        totalEthAdded += msg.value;

        if (tokenAmount > 0) {
            tokenContract.safeTransfer(msg.sender, tokenAmount);
        }

        _updateMerkleRootAfterTrade(newMerkleRoot);
        emit PoolBalanceUpdated(
            address(tokenContract),
            totalETH,
            totalTokens,
            totalETH,
            totalTokens
        );
    }

    function executeSellOrder(
        uint256 ethAmount,
        uint256 tokenAmount,
        bytes32 newMerkleRoot
    ) external isNotBlocked onlyOrderbook {
        if (ethAmount == 0) revert AmountZero();
        if (tokenAmount == 0) revert AmountZero();
        if (totalETH <= ethAmount) revert InsufficientETHLiquidity();

        tokenContract.safeTransferFrom(msg.sender, address(this), tokenAmount);

        totalETH -= ethAmount;
        totalEthRemoved += ethAmount;
        totalTokens += tokenAmount;
        totalTokensAdded += tokenAmount;

        (bool success, ) = payable(msg.sender).call{value: ethAmount}("");
        if (!success) revert ETHTransferToOrderbookFailed();

        _updateMerkleRootAfterTrade(newMerkleRoot);
        emit PoolBalanceUpdated(
            address(tokenContract),
            totalETH,
            totalTokens,
            totalETH,
            totalTokens
        );
    }

    /**
     * @notice Distribute pool fee as ETH rewards to liquidity providers
     * @dev Only callable by reward distributor
     */
    function distributePoolFee()
        external
        payable
        onlyRewardDistributor
        nonReentrant
    {
        if (msg.value == 0) revert NoETHSent();
        totalEthAdded += msg.value;
        _updatePoolRewards(msg.value);
        emit PoolFeeDistributed(
            msg.sender,
            msg.value,
            address(tokenContract),
            true
        );
    }

    /**
     * @notice Update pool rewards distribution
     * @param ethAmount Amount of ETH to distribute as rewards
     */
    function _updatePoolRewards(uint256 ethAmount) internal {
        if (ethAmount == 0) revert AmountZero();

        // Distribute ETH rewards to ETH providers only
        if (totalETH > 0) {
            uint256 newAccRewardPerShare = accRewardPerShare +
                ((ethAmount * SCALE) / totalETH);
            if (newAccRewardPerShare < accRewardPerShare)
                revert OverflowInETHRewardCalculation();
            accRewardPerShare = newAccRewardPerShare;
        } else {
            // No liquidity exists - immediately refund the ETH
            (bool success, ) = payable(msg.sender).call{value: ethAmount}("");
            if (!success) revert ETHTransferFailed();
            emit FeeRefunded(msg.sender, ethAmount, true);
        }

        // Track ETH rewards
        rewardBalance += ethAmount;
    }

    /**
     * @notice Update token pool rewards distribution
     * @param tokenAmount Amount of tokens to distribute as rewards
     */
    function _updateTokenRewards(uint256 tokenAmount) internal {
        if (tokenAmount == 0) revert AmountZero();

        // Distribute token rewards to token providers only
        if (totalTokens > 0) {
            // Normalize token amount to 18 decimals for consistent calculations
            uint256 normalizedTokenAmount = _normalizeTo18Decimals(tokenAmount);
            uint256 normalizedTotalTokens = _normalizeTo18Decimals(totalTokens);

            uint256 newAccTokenRewardPerShare = accTokenRewardPerShare +
                ((normalizedTokenAmount * SCALE) / normalizedTotalTokens);
            if (newAccTokenRewardPerShare < accTokenRewardPerShare)
                revert OverflowInTokenRewardCalculation();
            accTokenRewardPerShare = newAccTokenRewardPerShare;

            // Track token rewards distributed
            totalTokenRewardsDistributed += tokenAmount;
        } else {
            // No liquidity exists - immediately refund the tokens
            tokenContract.safeTransfer(msg.sender, tokenAmount);
            emit FeeRefunded(msg.sender, tokenAmount, false);
        }
    }

    /**
     * @notice Distribute token fee as rewards to liquidity providers
     * @param tokenAmount Amount of tokens to distribute as rewards
     * @dev Only callable by reward distributor
     */
    function distributeTokenFee(
        uint256 tokenAmount
    ) external onlyRewardDistributor nonReentrant {
        if (tokenAmount == 0) revert AmountZero();

        // Record balance before transfer to handle fee-on-transfer tokens
        uint256 balanceBefore = tokenContract.balanceOf(address(this));

        // Transfer tokens from orderbook to this contract
        tokenContract.safeTransferFrom(msg.sender, address(this), tokenAmount);

        // Calculate actual received amount (handles fee-on-transfer and rebasing tokens)
        uint256 actualReceived = tokenContract.balanceOf(address(this)) -
            balanceBefore;

        totalTokensAdded += actualReceived;
        _updateTokenRewards(actualReceived);
        emit PoolFeeDistributed(
            msg.sender,
            actualReceived,
            address(tokenContract),
            false
        );
    }

    /**
     * @notice Internal function to remove ETH liquidity
     * @param user User address
     * @param shares Percentage of shares to remove (0-10000)
     * @param minAmount Minimum amount to withdraw
     * @return amountToWithdraw Amount actually withdrawn
     */
    function _removeETHLiquidityInternal(
        address user,
        uint256 shares,
        uint256 minAmount
    ) internal returns (uint256 amountToWithdraw) {
        uint256 pendingReward = (ethProviders[user].position *
            accRewardPerShare) /
            SCALE -
            ethProviders[user].rewardDebt;
        ethProviders[user].pendingRewards += pendingReward;

        amountToWithdraw = (ethProviders[user].position * shares) / 10000;
        if (amountToWithdraw == 0) revert NoSharesToBurn();
        if (amountToWithdraw > ethProviders[user].position) {
            amountToWithdraw = ethProviders[user].position;
        }
        if (amountToWithdraw > totalETH) revert InsufficientPoolBalance();

        ethProviders[user].position -= amountToWithdraw;
        ethProviders[user].rewardDebt =
            (ethProviders[user].position * accRewardPerShare) /
            SCALE;

        totalETH -= amountToWithdraw;
        totalEthRemoved += amountToWithdraw;

        if (amountToWithdraw < minAmount) revert InsufficientWithdrawal();
        (bool success, ) = payable(user).call{value: amountToWithdraw}("");
        if (!success) revert ETHTransferFailed();

        return amountToWithdraw;
    }

    /**
     * @notice Internal function to remove token liquidity
     * @param user User address
     * @param shares Percentage of shares to remove (0-10000)
     * @param minAmount Minimum amount to withdraw
     * @return amountToWithdraw Amount actually withdrawn
     */
    function _removeTokenLiquidityInternal(
        address user,
        uint256 shares,
        uint256 minAmount
    ) internal returns (uint256 amountToWithdraw) {
        uint256 normalizedLpShares = _normalizeTo18Decimals(
            tokenProviders[user].position
        );
        uint256 pendingReward = (normalizedLpShares * accTokenRewardPerShare) /
            SCALE -
            tokenProviders[user].rewardDebt;
        tokenProviders[user].pendingRewards += pendingReward;

        amountToWithdraw = (tokenProviders[user].position * shares) / 10000;
        if (amountToWithdraw == 0) revert NoSharesToBurn();
        if (amountToWithdraw > tokenProviders[user].position) {
            amountToWithdraw = tokenProviders[user].position;
        }
        if (amountToWithdraw > totalTokens) revert InsufficientPoolBalance();

        tokenProviders[user].position -= amountToWithdraw;
        tokenProviders[user].rewardDebt =
            (tokenProviders[user].position * accTokenRewardPerShare) /
          ...

// [truncated — 67629 bytes total]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IGradientRegistry} from "./interfaces/IGradientRegistry.sol";
import {IGradientMarketMakerPoolV3} from "./interfaces/IGradientMarketMakerPoolV3.sol";
import {IGradientFeeManager} from "./interfaces/IGradientFeeManager.sol";
import {IUniswapV2Router02} from "./interfaces/IUniswapV2Router.sol";
import {IFallbackExecutor} from "./interfaces/IFallbackExecutor.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {IUniswapV2Factory} from "./interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Pair} from "./interfaces/IUniswapV2Pair.sol";
import {IUniswapV3Factory} from "./interfaces/IUniswapV3Factory.sol";
import {IUniswapV3Pool} from "./interfaces/IUniswapV3Pool.sol";
import {IUniswapV3PriceHelper} from "./interfaces/IUniswapV3PriceHelper.sol";
import {GradientMarketMakerFactory} from "./GradientMarketMakerFactory.sol";

/**
 * @title GradientOrderbook
 * @author Gradient Protocol
 * @notice A decentralized orderbook for trading ERC20 tokens against ETH
 * @dev This contract implements a traditional orderbook with limit and market orders.
 */
contract GradientOrderbook is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    /// @notice Registry contract for accessing other protocol contracts
    IGradientRegistry public gradientRegistry;

    /// @notice Fee manager contract for handling fee distribution
    IGradientFeeManager public feeManager;

    /// @notice Types of orders that can be placed
    enum OrderType {
        Buy,
        Sell
    }

    /// @notice Types of order execution
    enum OrderExecutionType {
        Limit,
        Market
    }

    /// @notice Possible states of an order
    enum OrderStatus {
        Active,
        Filled,
        Cancelled,
        Expired
    }

    /// @notice Structure containing all information about an order
    /// @dev All amounts use the decimal precision of their respective tokens
    struct Order {
        uint256 orderId; // Unique identifier for the order
        address owner; // Address that created the order
        OrderType orderType; // Whether this is a buy or sell order
        OrderExecutionType executionType; // Whether this is a limit or market order
        address token; // Token being traded
        uint256 amount; // Total amount of tokens to trade
        uint256 price; // For limit orders: exact price, For market orders: max price (buy) or min price (sell)
        uint256 ethAmount; // Amount of ETH committed for buy orders
        uint256 ethSpent; // Actual ETH spent so far (for buy market orders)
        uint256 filledAmount; // Amount of tokens that have been filled
        uint256 expirationTime; // Timestamp when the order expires
        OrderStatus status; // Current status of the order
    }

    /// @notice Parameters for matching orders
    struct OrderMatch {
        uint256 buyOrderId; // ID of the buy order
        uint256 sellOrderId; // ID of the sell order
        uint256 fillAmount; // Amount of tokens to exchange
    }

    /// @notice Counter for generating unique order IDs
    uint256 private _orderIdCounter;

    /// @notice Default fee percentage charged on all trades (in basis points, 1 = 0.01%)
    uint256 public defaultFeePercentage;

    /// @notice Token-specific fee percentages (in basis points, 1 = 0.01%)
    /// @dev Default is 100 basis points (1%) for all tokens
    mapping(address => uint256) public tokenSpecificFeePercentage;

    /// @notice Maximum fee percentage that can be set (in basis points)
    uint256 public constant MAX_FEE_PERCENTAGE = 500; // 5%

    /// @notice Minimum fee percentage that can be set (in basis points)
    uint256 public constant MIN_FEE_PERCENTAGE = 50; // 0.5%

    /// @notice Maximum token-specific fee percentage (in basis points)
    uint256 public constant MAX_TOKEN_SPECIFIC_FEE_PERCENTAGE = 300; // 3%

    /// @notice Mapping from order ID to Order struct
    mapping(uint256 => Order) public orders;

    /// @notice Mapping from token pair + order type + execution type hash to array of order IDs
    /// @dev Key is keccak256(abi.encodePacked(token, orderType, executionType))
    mapping(bytes32 => uint256) public totalOrderCount;
    mapping(bytes32 => uint256) public headOrder;
    mapping(bytes32 => uint256) public tailOrder;
    struct LinkedOrder {
        uint256 prev;
        uint256 next;
        bool exists;
    }
    mapping(bytes32 => mapping(uint256 => LinkedOrder)) public linkedOrders;

    /// @notice Mapping from order ID to its position in the queue
    /// @dev Used for efficient removal of orders from queues
    mapping(uint256 => uint256) private orderQueuePositions;

    /// @notice Divisor used for fee calculations (10000 = 100%)
    uint256 public constant DIVISOR = 10000;

    uint256 public minOrderSize;
    uint256 public maxOrderSize;
    uint256 public maxOrderTtl;

    /// @notice Maximum allowed price deviation from market price (in basis points, 1 = 0.01%)
    uint256 public maxPriceDeviation = 500; // 5% default

    /// @notice Dust tolerance for automatic order fulfillment (in basis points, 1 = 0.01%)
    uint256 public dustTolerance = 100; // 1% default

    /// @notice Uniswap V3 Factory address for accessing V3 pools
    address public uniswapV3Factory;

    /// @notice Uniswap V3 Price Helper contract for price calculations
    IUniswapV3PriceHelper public uniswapV3PriceHelper;

    /// @notice Common fee tiers for Uniswap V3 (500 = 0.05%, 3000 = 0.3%, 10000 = 1%)
    uint24[] public v3FeeTiers = [500, 3000, 10000];

    /// @notice Emitted when a new order is created
    event OrderCreated(
        uint256 indexed orderId,
        address indexed owner,
        OrderType orderType,
        OrderExecutionType executionType,
        address token,
        uint256 amount,
        uint256 price,
        uint256 expirationTime,
        uint256 totalCost,
        string objectId
    );

    /// @notice Emitted when an order is cancelled by its owner
    event OrderCancelled(uint256 indexed orderId);

    /// @notice Emitted when an order expires
    event OrderExpired(uint256 indexed orderId);

    /// @notice Emitted when an order is completely filled
    event OrderFulfilled(
        uint256 indexed orderId,
        uint256 amount,
        uint256 totalFilledAmount,
        uint256 executionPrice
    );

    /// @notice Emitted when an order is partially filled
    event OrderPartiallyFulfilled(
        uint256 indexed orderId,
        uint256 amount,
        uint256 remaining,
        uint256 totalFilledAmount,
        uint256 executionPrice
    );

    /// @notice Emitted when default fee percentage is updated
    event DefaultFeePercentageUpdated(
        uint256 oldFeePercentage,
        uint256 newFeePercentage
    );

    /// @notice Emitted when token-specific fee percentage is updated
    event TokenSpecificFeePercentageUpdated(
        address indexed token,
        uint256 oldFeePercentage,
        uint256 newFeePercentage
    );

    event OrderSizeLimitsUpdated(uint256 minSize, uint256 maxSize);
    event MaxTTLUpdated(uint256 newMaxTTL);
    event RateLimitUpdated(uint256 newInterval);

    /// @notice Emitted when an order is fulfilled through matching
    event OrderFulfilledByMatching(
        uint256 indexed orderId,
        uint256 indexed matchedOrderId,
        uint256 amount,
        uint256 price
    );

    /// @notice Emitted when an order is fulfilled through market maker
    event OrderFulfilledByMarketMaker(
        uint256 indexed orderId,
        address indexed marketMakerPool,
        uint256 amount,
        uint256 price
    );

    /// @notice Emitted when fees are distributed to market maker pool
    event FeeDistributedToPool(
        address indexed marketMakerPool,
        address indexed token,
        uint256 amount,
        uint256 totalFee
    );

    /// @notice Emitted when max price deviation is updated
    event MaxPriceDeviationUpdated(uint256 oldDeviation, uint256 newDeviation);

    /// @notice Emitted when dust tolerance is updated
    event DustToleranceUpdated(uint256 oldTolerance, uint256 newTolerance);

    /// @notice Emitted when Uniswap V3 Factory is updated
    event UniswapV3FactoryUpdated(
        address indexed oldFactory,
        address indexed newFactory
    );

    /// @notice Emitted when Uniswap V3 Price Helper is updated
    event UniswapV3PriceHelperUpdated(address indexed priceHelper);

    /// @notice Emitted when V3 fee tiers are updated
    event V3FeeTiersUpdated(uint24[] feeTiers);

    // Modifiers
    modifier onlyAuthorizedFulfiller() {
        require(
            gradientRegistry.isAuthorizedFulfiller(msg.sender),
            "Caller is not authorized"
        );
        _;
    }

    modifier orderExists(uint256 orderId) {
        require(orders[orderId].owner != address(0), "Order does not exist");
        _;
    }

    modifier onlyOrderOwner(uint256 orderId) {
        require(orders[orderId].owner == msg.sender, "Not order owner");
        _;
    }

    modifier validToken(address token) {
        require(token != address(0), "Invalid token");
        require(token.code.length > 0, "Not a contract");
        // Check if token is blocked
        require(!gradientRegistry.blockedTokens(token), "Token is blocked");
        _;
    }

    modifier validateMarketOrderPrice(uint256 orderId, uint256 executionPrice) {
        Order memory order = orders[orderId];

        if (order.executionType == OrderExecutionType.Market) {
            if (order.orderType == OrderType.Buy) {
                require(
                    executionPrice <= order.price,
                    "Execution price exceeds buyer's max price"
                );
            } else {
                require(
                    executionPrice >= order.price,
                    "Execution price below seller's min price"
                );
            }
        }

        if (order.executionType == OrderExecutionType.Limit) {
            require(
                executionPrice == order.price,
                "Execution price not matched with order price."
            );
        }
        _;
    }

    constructor(IGradientRegistry _gradientRegistry) Ownable(msg.sender) {
        gradientRegistry = _gradientRegistry;
        // feeManager will be set via setGradientRegistry after deployment
        defaultFeePercentage = 100; // 1% default fee for all trades

        minOrderSize = 1000000000000; // 0.000001 ETH
        maxOrderSize = 1000 ether;
        maxOrderTtl = 30 days;
    }

    receive() external payable {}

    fallback() external payable {}

    /// @notice Internal function to calculate and collect ETH fees
    /// @param amount Amount in ETH to calculate fee from
    /// @param token Token address for potential token-specific fee
    /// @return uint256 Fee amount collected
    function _collectEthFee(
        uint256 amount,
        address token
    ) internal returns (uint256) {
        // Use token-specific fee if set, otherwise use default fee
        uint256 feePercentage = getCurrentFeePercentage(token);

        uint256 feeAmount = (amount * feePercentage) / DIVISOR;
        if (feeAmount > 0) {
            // Transfer ETH to feeManager and track
            feeManager.collectEthFee{value: feeAmount}(feeAmount, token);
        }
        return feeAmount;
    }

    /// @notice Internal function to calculate and collect token fees
    /// @param amount Amount in tokens to calculate fee from
    /// @param token Token address
    /// @return uint256 Fee amount collected
    function _collectTokenFee(
        uint256 amount,
        address token
    ) internal returns (uint256) {
        // Use token-specific fee if set, otherwise use default fee
        uint256 feePercentage = getCurrentFeePercentage(token);

        uint256 feeAmount = (amount * feePercentage) / DIVISOR;
        if (feeAmount > 0) {
            // Transfer tokens to feeManager
            IERC20(token).safeTransfer(address(feeManager), feeAmount);
            // Track the fee in feeManager
            feeManager.collectTokenFee(feeAmount, token);
        }
        return feeAmount;
    }

    /// @notice Internal function to distribute market maker fees according to new split logic
    /// @param totalFee Total fee amount to distribute
    /// @param token Token address for partner token check
    /// @param marketMakerPool Market maker pool address for distribution
    function _distributeMarketMakerTokenFees(
        uint256 totalFee,
        address token,
        address marketMakerPool
    ) internal {
        feeManager.distributeMarketMakerTokenFees(
            totalFee,
            token,
            marketMakerPool
        );
    }

    /// @notice Internal function to distribute market maker ETH fees according to new split logic
    /// @param totalFee Total ETH fee amount to distribute
    /// @param token Token address for partner token check
    /// @param marketMakerPool Market maker pool address for distribution
    function _distributeMarketMakerEthFees(
        uint256 totalFee,
        address token,
        address marketMakerPool
    ) internal {
        feeManager.distributeMarketMakerEthFees{value: totalFee}(
            totalFee,
            token,
            marketMakerPool
        );
    }

    /// @notice Adds an order to its appropriate queue
    /// @param orderId The ID of the order to add
    /// @param token The token address
    /// @param orderType The type of order (Buy/Sell)
    /// @param executionType The type of execution (Limit/Market)
    function _addOrderToQueue(
        uint256 orderId,
        address token,
        OrderType orderType,
        OrderExecutionType executionType
    ) internal {
        bytes32 queueKey = _getQueueKey(token, orderType, executionType);

        linkedOrders[queueKey][orderId] = LinkedOrder({
            prev: tailOrder[queueKey],
            next: 0,
            exists: true
        });

        if (tailOrder[queueKey] != 0) {
            linkedOrders[queueKey][tailOrder[queueKey]].next = orderId;
        } else {
            headOrder[queueKey] = orderId;
        }

        tailOrder[queueKey] = orderId;

        // Store the position of the order in the queue
        orderQueuePositions[orderId] = totalOrderCount[queueKey];
        totalOrderCount[queueKey] += 1;
    }

    function _removeOrderFromLinkedQueue(
        bytes32 queueKey,
        uint256 orderId
    ) internal {
        LinkedOrder storage node = linkedOrders[queueKey][orderId];
        require(node.exists, "Order not in queue");

        if (node.prev != 0) {
            linkedOrders[queueKey][node.prev].next = node.next;
        } else {
            headOrder[queueKey] = node.next;
        }

        if (node.next != 0) {
            linkedOrders[queueKey][node.next].prev = node.prev;
        } else {
            tailOrder[queueKey] = node.prev;
        }

        delete linkedOrders[queueKey][orderId];
    }

    /// @notice Creates a new order in the orderbook
    /// @param orderType Type of order (Buy/Sell)
    /// @param executionType Type of execution (Limit/Market)
    /// @param token Address of the token to trade
    /// @param amount Amount of tokens to trade
    /// @param price For limit orders: exact price, For market orders: max price (buy) or min price (sell)
    /// @param ttl Time-to-live in seconds for the order
    /// @dev For buy orders, requires ETH to be sent with the transaction
    /// @dev For sell orders, requires token approval
    /// @return uint256 ID of the created order
    function createOrder(
        OrderType orderType,
        OrderExecutionType executionType,
        address token,
        uint256 amount,
        uint256 price,
        uint256 ttl,
        string memory objectId
    ) external payable validToken(token) nonReentrant returns (uint256) {
        require(amount > 0, "Amount must be greater than 0");
        require(price > 0, "Invalid price range");
        require(ttl > 0, "TTL must be greater than 0");
        require(ttl <= maxOrderTtl, "TTL too long");

        // Normalize token amount to 18 decimals for consistent price calculations
        uint256 normalizedAmount = normalizeTo18Decimals(amount, token);

        require(
            normalizedAmount <= type(uint256).max / price,
            "Price calculation would overflow"
        );
        uint256 totalCost = (normalizedAmount * price) / 1e18;
        require(totalCost >= minOrderSize, "Order too small");
        require(totalCost <= maxOrderSize, "Order too large");

        if (orderType == OrderType.Buy) {
            require(msg.value >= totalCost, "Insufficient ETH sent");
        } else {
            IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
        }

        uint256 orderId = _orderIdCounter++;
        uint256 expirationTime = block.timestamp + ttl;

        orders[orderId] = Order({
            orderId: orderId,
            owner: msg.sender,
            orderType: orderType,
            executionType: executionType,
            token: token,
            amount: normalizedAmount, // Store normalized amount for calculations
            price: price,
            ethAmount: (orderType == OrderType.Buy) ? totalCost : 0,
            ethSpent: 0,
            filledAmount: 0,
            expirationTime: expirationTime,
            status: OrderStatus.Active
        });

        _addOrderToQueue(orderId, token, orderType, executionType);

        emit OrderCreated(
            orderId,
            msg.sender,
            orderType,
            executionType,
            token,
            amount, // Emit original amount for transparency
            price,
            expirationTime,
            totalCost,
            objectId
        );

        if (orderType == OrderType.Buy && msg.value > totalCost) {
            (bool success, ) = msg.sender.call{value: msg.value - totalCost}(
                ""
            );
            require(success, "ETH return failed");
        }

        return orderId;
    }

    /// @notice Cancels an active order
    /// @param orderId ID of the order to cancel
    /// @dev Only the order owner can cancel their order
    /// @dev Refunds ETH for buy orders and tokens for sell orders
    function cancelOrder(
        uint256 orderId
    ) external nonReentrant orderExists(orderId) onlyOrderOwner(orderId) {
        Order storage order = orders[orderId];
        require(order.status == OrderStatus.Active, "Order not active");
        require(!isOrderExpired(orderId), "Order expired");

        order.status = OrderStatus.Cancelled;
        if (order.orderType == OrderType.Buy) {
            uint256 refundAmount;
            if (order.executionType == OrderExecutionType.Market) {
                refundAmount = order.ethAmount > order.ethSpent
                    ? (order.ethAmount - order.ethSpent)
                    : 0;
            } else {
                uint256 remainingAmount = order.amount > order.filledAmount
                    ? (order.amount - order.filledAmount)
                    : 0;
                refundAmount = (remainingAmount * order.price) / 1e18;
            }
            if (refundAmount > 0) {
                require(
                    address(this).balance >= refundAmount,
                    "Insufficient ETH in contract"
                );
                (bool success, ) = order.owner.call{value: refundAmount}("");
                require(success, "ETH refund failed");
            }
        } else {
            uint256 remainingAmount = order.amount > order.filledAmount
                ? (order.amount - order.filledAmount)
                : 0;
            if (remainingAmount > 0) {
                uint256 actualRemainingAmount = denormalizeFrom18Decimals(
                    remainingAmount,
                    order.token
                );
                IERC20(order.token).safeTransfer(
                    order.owner,
                    actualRemainingAmount
                );
            }
        }

        bytes32 queueKey = _getQueueKey(
            order.token,
            order.orderType,
            order.executionType
        );
        _removeOrderFromLinkedQueue(queueKey, orderId);

        emit OrderCancelled(orderId);
    }

    /// @notice Marks multiple expired orders as expired and handles refunds
    /// @param orderIds Array of IDs of expired orders to clean up
    /// @dev Anyone can call this function for expired orders
    /// @dev Refunds tokens for unfilled sell orders and ETH for unfilled buy orders
    /// @dev More gas efficient than calling cleanupExpiredOrder multiple times
    function cleanupExpiredOrders(
        uint256[] memory orderIds
    ) external nonReentrant {
        require(orderIds.length > 0, "No orders to clean up");
        require(orderIds.length <= 100, "Too many orders to clean up at once");

        for (uint256 i = 0; i < orderIds.length; i++) {
            uint256 orderId = orderIds[i];

            // Check if order exists
            require(
                orders[orderId].owner != address(0),
                "Order does not exist"
            );

            Order storage order = orders[orderId];
            require(order.status == OrderStatus.Active, "Order not active");
            require(isOrderExpired(orderId), "Order not expired");

            order.status = OrderStatus.Expired;

            if (order.orderType == OrderType.Sell) {
                uint256 remainingAmount = order.amount > order.filledAmount
                    ? (order.amount - order.filledAmount)
                    : 0;
                if (remainingAmount > 0) {
                    // Denormalize the remaining amount back to token decimals
                    uint256 actualRemainingAmount = denormalizeFrom18Decimals(
                        remainingAmount,
                        order.token
                    );
                    IERC20(order.token).safeTransfer(
                        order.owner,
                        actualRemainingAmount
                    );
                }
            }

            if (order.orderType == OrderType.Buy) {
                uint256 refundAmount;
                if (order.executionType == OrderExecutionType.Market) {
                    refundAmount = order.ethAmount > order.ethSpent
                        ? (order.ethAmount - order.ethSpent)
                        : 0;
                } else {
                    uint256 remainingAmount = order.amount > order.filledAmount
                        ? (order.amount - order.filledAmount)
                        : 0;
                    refundAmount = (remainingAmount * order.price) / 1e18;
                }
                if (refundAmount > 0) {
                    require(
                        address(this).balance >= refundAmount,
                        "Insufficient ETH in contract"
                    );
                    (bool success, ) = payable(order.owner).call{
                        value: refundAmount
                    }("");
                    require(success, "ETH refund failed");
                }
            }

            bytes32 queueKey = _getQueueKey(
                order.token,
                order.orderType,
                order.executionType
            );
            _removeOrderFromLinkedQueue(queueKey, orderId);

            emit OrderExpired(orderId);
        }
    }

    /// @notice Fulfills multiple matched limit orders
    /// @param matches Array of OrderMatch structs containing match details
    /// @dev Only whitelisted fulfillers can call this function
    /// @dev All orders in matches must be limit orders
    /// @dev This function matches buy and sell orders against each other
    function fulfillLimitOrders(
        OrderMatch[] calldata matches
    ) external nonReentrant onlyAuthorizedFulfiller {
        require(matches.length > 0, "No order matches to fulfill");

        for (uint256 i = 0; i < matches.length; i++) {
            _fulfillLimitOrders(matches[i]);
        }
    }

    /// @notice Fulfills multiple matched market orders through order matching
    /// @param matches Array of OrderMatch structs containing match details
    /// @param executionPrices Array of execution prices for each match
    /// @dev Only whitelisted fulfillers can call this function
    /// @dev All orders in matches must be market orders
    /// @dev This function matches buy and sell orders against each other
    function fulfillMarketOrders(
        OrderMatch[] calldata matches,
        uint256[] calldata executionPrices
    ) external nonReentrant onlyAuthorizedFulfiller {
        require(matches.length > 0, "No order matches to fulfill");
        require(
            matches.length == executionPrices.length,
            "Mismatched arrays length"
        );

        for (uint256 i = 0; i < matches.length; i++) {
            _fulfillMarketOrders(matches[i], executionPrices[i]);
        }
    }

    /// @notice Internal function to fulfill a matched pair of limit orders
    /// @param _match OrderMatch struct containing the match details
    /// @dev Handles the transfer of ETH and tokens between parties
    /// @dev Allows partial fills of either order
    function _fulfillLimitOrders(OrderMatch memory _match) internal {
        Order storage buyOrder = orders[_match.buyOrderId];
        Order storage sellOrder = orders[_match.sellOrderId];

        // Validate orders
        require(
            buyOrder.status == OrderStatus.Active &&
                sellOrder.status == OrderStatus.Active,
            "Orders must be active"
        );
        require(
            !isOrderExpired(_match.buyOrderId) &&
                !isOrderExpired(_match.sellOrderId),
            "1 of the orders expired"
        );
        require(
            buyOrder.orderType == OrderType.Buy &&
                sellOrder.orderType == OrderType.Sell,
            "Invalid order types"
        );
        require(buyOrder.token == sellOrder.token, "Token mismatch");
        require(
            buyOrder.owner != sellOrder.owner,
            "Seller and buyer cannot be the same"
        );
        require(
            buyOrder.executionType == OrderExecutionType.Limit &&
                sellOrder.executionType == OrderExecutionType.Limit,
            "Not limit orders"
        );

        // Handle different fulfillment types
        _fulfillLimitOrdersMatching(_match);
    }

    /// @notice Internal function to fulfill limit orders through matching
    /// @param _match OrderMatch struct containing the match details
    function _fulfillLimitOrdersMatching(OrderMatch memory _match) internal {
        Order storage buyOrder = orders[_match.buyOrderId];
        Order storage sellOrder = orders[_match.sellOrderId];

        require(
            buyOrder.price >= sellOrder.price,
            "Price mismatch for limit orders"
        );

        uint256 buyRemaining = buyOrder.amount > buyOrder.filledAmount
            ? (buyOrder.amount - buyOrder.filledAmount)
            : 0;
        uint256 sellRemaining = sellOrder.amount > sellOrder.filledAmount
            ? (sellOrder.amount - sellOrder.filledAmount)
            : 0;
        uint256 actualFillAmount = _match.fillAmount;

        if (actualFillAmount > buyRemaining) {
            actualFillAmount = buyRemaining;
        }
        if (actualFillAmount > sellRemaining) {
            actualFillAmount = sellRemaining;
        }

        require(actualFillAmount > 0, "No amount to fill");

        uint256 tokenAmount = actualFillAmount;
        uint256 paymentAmount = (actualFillAmount * sellOrder.price) / 1e18; // Use sell price for limit orders

        // Calculate fees from receiving amounts
        uint256 buyerFee = _collectEthFee(paymentAmount, sellOrder.token); // ETH fee from buyer's payment
        uint256 sellerFee = _collectTokenFee(tokenAmount, sellOrder.token); // Token fee from seller's tokens

        // Transfer ETH to seller (buyer pays ETH fee)
        uint256 sellerPayment = paymentAmount - buyerFee;
        (bool success, ) = sellOrder.owner.call{value: sellerPayment}("");
        require(success, "ETH transfer to seller failed");

        // Transfer tokens to buyer (seller pays token fee)
        {
            uint256 actualTokenAmount = denormalizeFrom18Decimals(
                tokenAmount,
                sellOrder.token
            );
            uint256 actualTokenFee = denormalizeFrom18Decimals(
                sellerFee,
                sellOrder.token
            );
            IERC20(sellOrder.token).safeTransfer(
                buyOrder.owner,
                actualTokenAmount - actualTokenFee
            );
        }

        buyOrder.filledAmount += actualFillAmount;
        sellOrder.filledAmount += actualFillAmount;

        if (buyOrder.price > sellOrder.price) {
            uint256 savedAmount = (actualFillAmount *
                (buyOrder.price - sellOrder.price)) / 1e18;
            (success, ) = buyOrder.owner.call{value: savedAmount}("");
            require(success, "ETH savings return failed");
        }

        _updateOrderStatus(
            _match.buyOrderId,
            actualFillAmount,
            sellOrder.price
        );
        _updateOrderStatus(
            _match.sellOrderId,
            actualFillAmount,
            buyOrder.price
        );
    }

    /// @notice Internal function to fulfill a matched pair of market orders
    /// @param _match OrderMatch struct containing the match details
    /// @param executionPrice The price at which the orders will be executed
    /// @dev Handles the transfer of ETH and tokens between parties
    /// @dev Allows partial fills of either order
    function _fulfillMarketOrders(
        OrderMatch memory _match,
        uint256 executionPrice
    ) internal {
        Order storage buyOrder = orders[_match.buyOrderId];
        Order storage sellOrder = orders[_match.sellOrderId];

        // Validate orders
        require(
            buyOrder.status == OrderStatus.Active &&
                sellOrder.status == OrderStatus.Active,
            "Orders must be active"
        );
        require(
            !isOrderExpired(_match.buyOrderId) &&
                !isOrderExpired(_match.sellOrderId),
            "Orders expired"
        );
        require(
            buyOrder.orderType == OrderType.Buy &&
                sellOrder.orderType == OrderType.Sell,
            "Invalid order types"
        );
        require(buyOrder.token == sellOrder.token, "Token mismatch");
        require(
            (buyOrder.executionType == OrderExecutionType.Market ||
                sellOrder.executionType == OrderExecutionType.Market),
            "Not market orders"
        );

        _fulfillMarketOrdersMatching(_match, executionPrice);
    }

    /// @notice Internal function to fulfill market orders through matching
    /// @param _match OrderMatch struct containing the match details
    /// @param executionPrice The price at which the orders will be executed
    function _fulfillMarketOrdersMatching(
        OrderMatch memory _match,
        uint256 executionPrice
    ) internal {
        Order storage buyOrder = orders[_match.buyOrderId];
        Order storage sellOrder = orders[_match.sellOrderId];

        // Validate execution price against market price
        require(
            validateExecutionPrice(buyOrder.token, executionPrice),
            "Execution price deviates too much from market price"
        );

        if (buyOrder.executionType == OrderExecutionType.Market) {
            require(
                executionPrice <= buyOrder.price,
                "Execution price exceeds buyer's max price"
            );
        }
        if (sellOrder.executionType == OrderExecutionType.Market) {
            require(
                executionPrice >= sellOrder.price,
                "Execution price below seller's min price"
            );
        }

        uint256 buyRemaining = getBuyOrderRemainingAmount(
            buyOrder,
            executionPrice
        );
        uint256 sellRemaining = sellOrder.amount > sellOrder.filledAmount
            ? (sellOrder.amount - sellOrder.filledAmount)
            : 0;

        uint256 actualFillAmount = _match.fillAmount;
        if (actualFillAmount > buyRemaining) {
            actualFillAmount = buyRemaining;
        }
        if (actualFillAmount > sellRemaining) {
            actualFillAmount = sellRemaining;
        }

        require(actualFillAmount > 0, "No amount to fill");

        uint256 tokenAmount = actualFillAmount;
        uint256 paymentAmount = (actualFillAmount * executionPrice) / 1e18;

        // Calculate fees from receiving amounts
        uint256 buyerFee = _collectEthFee(paymentAmount, sellOrder.token); // ETH fee from buyer's payment
        uint256 sellerFee = _collectTokenFee(tokenAmount, sellOrder.token); // Token fee from seller's tokens

        // Transfer ETH to seller (buyer pays ETH fee)
        uint256 sellerPayment = paymentAmount - buyerFee;

        (bool success, ) = sellOrder.owner.call{value: sellerPayment}("");
        require(success, "ETH transfer to seller failed");

        {
            uint256 actualTokenAmount = denormalizeFrom18Decimals(
                tokenAmount,
                sellOrder.token
            );
            uint256 actualTokenFee = denormalizeFrom18Decimals(
                sellerFee,
                sellOrder.token
            );
            IERC20(sellOrder.token).safeTransfer(
                buyOrder.owner,
                actualTokenAmount - actualTokenFee
            );
        }

        buyOrder.filledAmount += actualFillAmount;
        // Track actual ETH spent for buy market orders
        if (
            buyOrder.orderType == OrderType.Buy &&
            buyOrder.executionType == OrderExecutionType.Market
        ) {
            buyOrder.ethSpent += paymentAmount;
        }
        sellOrder.filledAmount += actualFillAmount;

        _updateOrderStatus(_match.buyOrderId, actualFillAmount, executionPrice);
        _updateOrderStatus(
            _match.sellOrderId,
            actualFillAmount,
            executionPrice
        );
    }

    /// @notice Fulfills multiple orders through the market maker pool
    /// @param orderIds Array of order IDs to fulfill
    /// @param fillAmounts Array of fill amounts for each order
    /// @param executionPrices Array of execution prices for each order
    /// @param merkleRoot The merkle root to use for position updates
    /// @dev Only whitelisted fulfillers can call this function
    function fulfillOrdersWithMarketMaker(
        uint256[] calldata orderIds,
        uint256[] calldata fillAmounts,
        uint256[] calldata executionPrices,
        bytes32 merkleRoot
    ) external nonReentrant onlyAuthorizedFulfiller {
        require(orderIds.length > 0, "No orders to fulfill");
        require(
            orderIds.length == fillAmounts.length &&
                orderIds.length == executionPrices.length,
            "Mismatched arrays length"
        );

        for (uint256 i = 0; i < orderIds.length; i++) {
            require(fillAmounts[i] > 0, "Fill amount must be greater than 0");
            require(
                executionPrices[i] > 0,
                "Execution price must be greater than 0"
            );
            _fulfillOrderWithMarketMaker(
                orderIds[i],
                fillAmounts[i],
                executionPrices[i],
                merkleRoot
            );
        }
    }

    /// @notice Internal function to fulfill a single order through the market maker pool
    /// @param orderId ID of the order to fulfill
    /// @param fillAmount Amount of tokens to fill
    /// @param executionPrice The price at which the order will be executed
    /// @param merkleRoot The merkle root to use for position updates
    function _fulfillOrderWithMarketMaker(
        uint256 orderId,
        uint256 fillAmount,
        uint256 executionPrice,
        bytes32 merkleRoot
    ) internal validateMarketOrderPrice(orderId, executionPrice) {
        Order storage order = orders[orderId];

        // Validate order
        require(order.status == OrderStatus.Active, "Order not active");
        require(!isOrderExpired(orderId), "Order expired");

        // Validate execution price against market price
        require(
            validateExecutionPrice(order.token, executionPrice),
            "Execution price deviates too much from market price"
        );

        address marketMakerFactory = gradientRegistry.marketMakerFactory();
        require(
            marketMakerFactory != address(0),
            "Market maker factory not set"
        );

        address marketMakerPool = GradientMarketMakerFactory(marketMakerFactory)
            .getPool(order.token);
        require(
            marketMakerPool != address(0),
            "Market maker pool not found for token"
        );

        // Calculate actual fill amount based on remaining amount
        uint256 remainingAmount;
        if (
            order.orderType == OrderType.Buy &&
            order.executionType == OrderExecutionType.Market
        ) {
            remainingAmount = getBuyOrderRemainingAmount(order, executionPrice);
        } else {
            remainingAmount = order.amount > order.filledAmount
                ? (order.amount - order.filledAmount)
                : 0;
        }
        uint256 actualFillAmount = fillAmount > remainingAmount
            ? remainingAmount
            : fillAmount;

        require(actualFillAmount > 0, "No amount to fill");

        // Calculate payment amount and fees
        uint256 paymentAmount = (actualFillAmount * executionPrice) / 1e18;

        if (order.orderType == OrderType.Buy) {
            // Buy order from order to get tokens from market maker pool
            uint256 actualTokenAmount = denormalizeFrom18Decimals(
                actualFillAmount,
                order.token
            );

            // For buy orders: orderbook sends ETH to market maker, receives tokens
            IGradientMarketMakerPoolV3(marketMakerPool).executeBuyOrder{
                value: paymentAmount
            }(paymentAmount, actualTokenAmount, merkleRoot);

            // Calculate fee from received tokens and deduct from user
            uint256 tokenFee = (actualTokenAmount *
                (getCurrentFeePercentage(order.token))) / DIVISOR;
            uint256 netTokenAmount = actualTokenAmount - tokenFee;

            // Distribute fees using new market maker split logic (50% to market makers, 50% to teams)
            if (tokenFee > 0) {
                // Transfer fee tokens to feeManager
                IERC20(order.token).safeTransfer(address(feeManager), tokenFee);

                // Distribute according to the split
                _distributeMarketMakerTokenFees(
                    tokenFee,
                    order.token,
                    marketMakerPool
                );
            }

            IERC20(order.token).safeTransfer(order.owner, netTokenAmount);
        } else {
            // Denormalize the amount for token approval
            uint256 actualTokenAmount = denormalizeFrom18Decimals(
                actualFillAmount,
                order.token
            );

            // For sell orders: orderbook sends full tokens to market maker, receives ETH
            IERC20(order.token).approve(marketMakerPool, actualTokenAmount);

            // Execute sell order - Orderbook sends tokens, receives ETH
            IGradientMarketMakerPoolV3(marketMakerPool).executeSellOrder(
                paymentAmount,
                actualTokenAmount,
                merkleRoot
            );

            // Calculate fee from received ETH and deduct from user
            uint256 ethFee = (paymentAmount *
                (getCurrentFeePercentage(order.token))) / DIVISOR;
            uint256 netEthAmount = paymentAmount - ethFee;

            // Distribute fees using new market maker split logic (50% to market makers, 50% to teams)
            if (ethFee > 0) {
                // Distribute according to the split
                _distributeMarketMakerEthFees(
                    ethFee,
                    order.token,
                    marketMakerPool
                );
            }

            // Transfer ETH to seller (minus fee)
            (bool success, ) = order.owner.call{value: netEthAmount}("");
            require(success, "ETH transfer to seller failed");
        }

        // Update order state
        order.filledAmount += actualFillAmount;
        // Track actual ETH spent for buy market orders
        if (
            order.orderType == OrderType.Buy &&
            order.executionType == OrderExecutionType.Market
        ) {
            order.ethSpent += paymentAmount;
        }

        // Update order status
        _updateOrderStatus(orderId, actualFillAmount, executionPrice);

        emit OrderFulfilledByMarketMaker(
            orderId,
            marketMakerPool,
            actualFillAmount,
            executionPrice
        );
    }

    /// @notice Allows users to fulfill their own order via AMM
    /// @param orderId ID of the order to fulfill
    /// @param fillAmount Amount of tokens to fill
    /// @param minAmountOut Minimum amount to receive (slippage protection)
    /// @dev Only the order owner can call this function
    /// @dev Uses FallbackExecutor to find the best DEX and execute the trade
    function fulfillOwnOrderWithAMM(
        uint256 orderId,
        uint256 fillAmount,
        uint256 minAmountOut
    ) external nonReentrant orderExists(orderId) onlyOrderOwner(orderId) {
        require(fillAmount > 0, "Fill amount must be greater than 0");

        Order storage order = orders[orderId];
        require(order.status == OrderStatus.Active, "Order not active");

        // Calculate actual fill amount based on remaining amount
        uint256 remainingAmount;
        if (
            order.orderType == OrderType.Buy &&
            order.executionType == OrderExecutionType.Market
        ) {
            remainingAmount = getBuyOrderRemainingAmount(order, order.price);
        } else {
            remainingAmount = order.amount > order.filledAmount
                ? (order.amount - order.filledAmount)
                : 0;
        }
        uint256 actualFillAmount = fillAmount > remainingAmount
            ? remainingAmount
            : fillAmount;
        require(actualFillAmount > 0, "No amount to fill");

        // Get FallbackExecutor from registry
        address fallbackExecutor = gradientRegistry.fallbackExecutor();
        require(fallbackExecutor != address(0), "FallbackExecutor not set");

        // For buy orders, calculate how much ETH to send based on order type
        uint256 ethToSend;
        uint256 effectiveExecutionPrice;

        if (order.orderType == OrderType.Buy) {
            if (order.executionType == OrderExecutionType.Market) {
                // For market orders, send the remaining ETH (up to the fill amount)
                uint256 ethRemaining = order.ethAmount > order.ethSpent
                    ? (order.ethAmount - order.ethSpent)
                    : 0;
                ethToSend = ethRemaining;
            } else {
                // For limit orders, calculate based on order price
                ethToSend = (actualFillAmount * order.price) / 1e18;
            }

            // Execute the buy trade directly through FallbackExecutor with full ETH amount
            uint256 tokensReceived = IFallbackExecutor(fallbackExecutor)
                .executeTrade{value: ethToSend}(
                order.token,
                ethToSend,
                minAmountOut,
                true // isBuy = true
            );

            // Calculate fee from received tokens and deduct from user (buy order receives tokens)
            uint256 tokenFee = _collectTokenFee(tokensReceived, order.token);
            uint256 netTokenAmount = tokensReceived - tokenFee;

            // Transfer tokens to the buyer (minus fee)
            IERC20(order.token).safeTransfer(order.owner, netTokenAmount);

            // Calculate effective execution price for buy orders
            if (tokensReceived > 0) {
                effectiveExecutionPrice = (ethToSend * 1e18) / tokensReceived;
            } else {
                effectiveExecutionPrice = order.price; // Fallback to order price
            }
        } else {
            // Denormalize the amount for token approval and transfer
            uint256 actualTokenAmount = denormalizeFrom18Decimals(
                actualFillAmount,
                order.token
            );

            // Approve tokens to FallbackExecutor (approve the full amount)
            IERC20(order.token).approve(fallbackExecutor, actualTokenAmount);

            // Execute the sell trade with full amount
            uint256 ethReceived = IFallbackExecutor(fallbackExecutor)
                .executeTrade(
                    order.token,
                    actualTokenAmount,
                    minAmountOut,
                    false // isBuy = false
                );

            // Calculate fee from received ETH and deduct from user (sell order receives ETH)
            uint256 ethFee = _collectEthFee(ethReceived, order.token);
            uint256 netEthAmount = ethReceived - ethFee;
            (bool success, ) = order.owner.call{value: netEthAmount}("");
            require(success, "ETH transfer to seller failed");

            // Calculate effective execution price for sell orders
            if (actualFillAmount > 0) {
                effectiveExecutionPrice =
                    (ethReceived * 1e18) /
                    actualFillAmount;
            } else {
                effectiveExecutionPrice = order.price; // Fallback to order price
            }
        }
        order.filledAmount += actualFillAmount;
        // Track actual ETH spent for buy market orders
        if (
            order.orderType == OrderType.Buy &&
            order.executionType == OrderExecutionType.Market
        ) {
            order.ethSpent += ethToSend;
        }

        // Update order status
        _updateOrderStatus(orderId, actualFillAmount, effectiveExecutionPrice);
    }

    /// @notice Internal function to update order status
    /// @param orderId ID of the order to update
    /// @param actualFillAmount Amount of tokens/ETH that was filled
    /// @param executionPrice The price at which the order was executed
    function _updateOrderStatus(
        uint256 orderId,
        uint256 actualFillAmount,
        uint256 executionPrice
    ) internal {
        Order storage order = orders[orderId];
        // For buy market orders, check if all ETH is spent
        if (
            order.orderType == OrderType.Buy &&
            order.executionType == OrderExecutionType.Market
        ) {
            uint256 remainingEth = order.ethAmount > order.ethSpent
                ? (order.ethAmount - order.ethSpent)
                : 0;

            // Check if remaining ETH is below dust tolerance
            bool isDustRemaining = remainingEth > 0 &&
                (remainingEth * 10000) / order.ethAmount <= dustTolerance;

            if (order.ethSpent >= order.ethAmount || isDustRemaining) {
                order.status = OrderStatus.Filled;
                // If dust remaining, mark it as spent to prevent refund issues
                if (isDustRemaining) {
                    order.ethSpent = order.ethAmount;
                }
                bytes32 queueKey = _getQueueKey(
                    order.token,
                    order.orderType,
                    order.executionType
                );
                _removeOrderFromLinkedQueue(queueKey, orderId);
                emit OrderFulfilled(
                    orderId,
                    actualFillAmount,
                    order.ethSpent,
                    executionPrice
                );
            } else {
                emit OrderPartiallyFulfilled(
                    orderId,
                    actualFillAmount,
                    remainingEth,
                    order.ethSpent,
                    executionPrice
                );
            }
        } else {
            uint256 remainingAmount = order.amount > order.filledAmount
                ? (order.amount - order.filledAmount)
                : 0;

            // Check if remaining tokens are below dust tolerance
            bool isDustRemaining = remainingAmount > 0 &&
                (remainingAmount * 10000) / order.amount <= dustTolerance;

            if (order.filledAmount == order.amount || isDustRemaining) {
                order.status = OrderStatus.Filled;
                // If dust remaining, mark it as filled to prevent refund issues
                if (isDustRemaining) {
                    order.filledAmount = order.amount;
                }
                bytes32 queueKey = _getQueueKey(
                    order.token,
                    order.orderType,
                    order.executionType
                );
                _removeOrderFromLinkedQueue(queueKey, orderId);
                emit OrderFulfilled(
                    orderId,
                    actualFillAmount,
                    order.filledAmount,
                    executionPrice
                );
            } else {
                emit OrderPartially...

// [truncated — 72995 bytes total]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IEventAggregator {
    // Event types
    function ETH_ADD() external view returns (uint8);

    function ETH_REMOVE() external view returns (uint8);

    function TOKEN_ADD() external view returns (uint8);

    function TOKEN_REMOVE() external view returns (uint8);

    function REWARDS_CLAIMED() external view returns (uint8);

    function TRADE_EXECUTED() external view returns (uint8);

    // Main functions
    function emitLiquidityEvent(
        address user,
        address token,
        uint8 eventType,
        uint256 amount,
        uint256 minPrice,
        uint256 maxPrice
    ) external;

    function emitETHRewardsClaimed(
        address user,
        address token,
        uint256 amount
    ) external;

    function emitTokenRewardsClaimed(
        address user,
        address token,
        uint256 amount
    ) external;

    function emitTradeExecuted(
        address user,
        uint8 tradeType,
        uint256 ethAmount,
        uint256 tokenAmount
    ) external;

    function emitMerkleRootUpdated(
        uint256 version,
        bytes32 merkleRoot
    ) external;

    function emitPoolCreated(address token, address pool) external;

    // View functions
    function getEventTypeName(
        uint8 eventType
    ) external pure returns (string memory name);

    function getTradeTypeName(
        uint8 tradeType
    ) external pure returns (string memory name);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IFallbackExecutor {
    struct DEXConfig {
        address router;
        address factory;
        bool isActive;
        uint256 priority;
    }

    // Events
    event DEXAdded(address indexed dex, address router, address factory);
    event DEXRemoved(address indexed dex);
    event TradeExecuted(
        address indexed token,
        address indexed dex,
        uint256 amountIn,
        uint256 amountOut,
        bool isBuy
    );

    // View functions
    function dexes(
        address dex
    )
        external
        view
        returns (
            address router,
            address factory,
            bool isActive,
            uint256 priority
        );

    function gradientRegistry() external view returns (address);

    function getActiveDEXes() external view returns (address[] memory);

    function getDEXConfig(address dex) external view returns (DEXConfig memory);

    // State changing functions
    function addDEX(address dex, address router, uint256 priority) external;

    function removeDEX(address dex) external;

    function executeTrade(
        address token,
        uint256 amount,
        uint256 minAmountOut,
        bool isBuy
    ) external payable returns (uint256 amountOut);

    function emergencyWithdraw(address[] calldata tokens) external;

    function emergencyWithdrawETH() external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title IGradientFeeManager
 * @notice Interface for the GradientFeeManager contract
 * @dev Handles partner fee distribution and platform fee management
 */
interface IGradientFeeManager {
    // ========================== Events ==========================

    /// @notice Emitted when ETH fees are withdrawn
    event EthFeesWithdrawn(address indexed recipient, uint256 amount);

    /// @notice Emitted when token fees are withdrawn
    event TokenFeesWithdrawn(
        address indexed token,
        address indexed recipient,
        uint256 amount
    );

    /// @notice Emitted when partner ETH fees are claimed
    event PartnerEthFeesClaimed(
        address indexed token,
        address indexed partnerWallet,
        uint256 amount
    );

    /// @notice Emitted when partner token fees are claimed
    event PartnerTokenFeesClaimed(
        address indexed token,
        address indexed partnerWallet,
        uint256 amount
    );

    /// @notice Emitted when fees are distributed to teams (market maker only)
    event FeeDistributedToTeams(
        address indexed token,
        uint256 grayTeamFee,
        uint256 partnerTeamFee,
        uint256 totalTeamFee
    );

    /// @notice Emitted when fees are distributed to market maker pool
    event FeeDistributedToPool(
        address indexed marketMakerPool,
        address indexed token,
        uint256 amount,
        uint256 totalFee
    );

    // ========================== Fee Distribution Functions ==========================

    /// @notice Distributes market maker token fees according to partner split logic
    /// @param totalFee Total fee amount to distribute
    /// @param token Token address for partner token check
    /// @param marketMakerPool Market maker pool address for distribution
    function distributeMarketMakerTokenFees(
        uint256 totalFee,
        address token,
        address marketMakerPool
    ) external;

    /// @notice Distributes market maker ETH fees according to partner split logic
    /// @param totalFee Total ETH fee amount to distribute
    /// @param token Token address for partner token check
    /// @param marketMakerPool Market maker pool address for distribution
    function distributeMarketMakerEthFees(
        uint256 totalFee,
        address token,
        address marketMakerPool
    ) external payable;

    // ========================== Fee Collection Functions ==========================

    /// @notice Collects ETH fees and updates totals
    /// @param amount Amount in ETH to collect
    /// @param token Token address for potential token-specific fee tracking
    function collectEthFee(uint256 amount, address token) external payable;

    /// @notice Collects token fees and updates totals
    /// @param amount Amount in tokens to collect
    /// @param token Token address
    function collectTokenFee(uint256 amount, address token) external;

    // ========================== Fee Withdrawal Functions ==========================

    /// @notice Withdraws collected ETH fees to the specified address
    /// @param recipient Address to receive the ETH fees
    function withdrawEthFees(address payable recipient) external;

    /// @notice Withdraws collected token fees to the specified address
    /// @param token Address of the token to withdraw fees for
    /// @param recipient Address to receive the token fees
    function withdrawTokenFees(address token, address recipient) external;

    /// @notice Claim partner ETH fees for a specific token
    /// @param token Address of the partner token to claim fees for
    function claimPartnerEthFees(address token) external;

    /// @notice Claim partner token fees for a specific token
    /// @param token Address of the partner token to claim fees for
    function claimPartnerTokenFees(address token) external;

    // ========================== View Functions ==========================

    /// @notice Gets total ETH fees collected
    /// @return uint256 Total ETH fees collected
    function totalEthFeesCollected() external view returns (uint256);

    /// @notice Gets total token fees collected for a specific token
    /// @param token Token address
    /// @return uint256 Total token fees collected
    function totalTokenFeesCollected(
        address token
    ) external view returns (uint256);

    /// @notice Gets partner ETH fees collected for a specific token
    /// @param token Token address
    /// @return uint256 Partner ETH fees collected
    function partnerEthFeesCollected(
        address token
    ) external view returns (uint256);

    /// @notice Gets partner token fees collected for a specific token
    /// @param token Token address
    /// @return uint256 Partner token fees collected
    function partnerTokenFeesCollected(
        address token
    ) external view returns (uint256);

    /// @notice Gets platform ETH fees claimed
    /// @return uint256 Platform ETH fees claimed
    function platformEthFeesClaimed() external view returns (uint256);

    /// @notice Gets platform token fees claimed for a specific token
    /// @param token Token address
    /// @return uint256 Platform token fees claimed
    function platformTokenFeesClaimed(
        address token
    ) external view returns (uint256);

    /// @notice Gets partner ETH fees claimed for a specific token
    /// @param token Token address
    /// @return uint256 Partner ETH fees claimed
    function partnerEthFeesClaimed(
        address token
    ) external view returns (uint256);

    /// @notice Gets partner token fees claimed for a specific token
    /// @param token Token address
    /// @return uint256 Partner token fees claimed
    function partnerTokenFeesClaimed(
        address token
    ) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IGradientMarketMakerFactory {
    // Events
    event PoolCreated(
        address indexed token,
        address indexed pool,
        uint256 timestamp
    );

    // Pool management
    function createPool(address token) external returns (address pool);

    function createPoolWithLiquidity(
        address token,
        address initialLiquidityProvider,
        uint256 initialEthAmount,
        uint256 initialTokenAmount
    ) external payable returns (address pool);

    function getPool(address token) external view returns (address pool);

    function poolExists(address token) external view returns (bool);

    function getAllPools() external view returns (address[] memory);

    function getPoolCount() external view returns (uint256);

    // Pool info
    function pools(uint256 index) external view returns (address);

    function poolCount() external view returns (uint256);

    // Factory info
    function owner() external view returns (address);

    function getEventAggregator() external view returns (address);

    function setEventAggregator(address _eventAggregator) external;

    /**
     * @notice Get the registry address
     * @return registryAddress Address of the GradientRegistry
     */
    function getRegistry() external view returns (address);

    /**
     * @notice Check if a given address is a valid pool
     * @param poolAddress Address to check
     * @return isValid True if the address is a valid pool
     */
    function isValidPool(
        address poolAddress
    ) external view returns (bool isValid);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title IGradientMarketMakerPoolV3
 * @notice Interface for individual token market maker pool contracts with price range functionality
 * @dev Each pool is dedicated to one token with concentrated liquidity price ranges
 * @dev Users can specify min/max price ranges when adding liquidity
 */
interface IGradientMarketMakerPoolV3 {
    // Price range struct for concentrated liquidity
    struct PriceRange {
        uint256 minPrice; // Minimum price (in wei per token)
        uint256 maxPrice; // Maximum price (in wei per token)
        bool isActive; // Whether this range is active
    }

    // Enhanced provider position with price range
    struct ProviderPosition {
        uint256 position; // ETH or token position
        uint256 rewardDebt; // Reward debt for accurate calculations
        uint256 pendingRewards; // Pending rewards to claim
        uint256 lastUpdateVersion; // Last version when position was updated
        uint256 lpShares; // LP shares for this provider
        PriceRange priceRange; // Price range for this position
    }

    // Pool metrics with price range support
    struct PoolMetrics {
        uint256 totalPosition; // Total ETH or tokens
        uint256 totalLPShares; // Total LP shares
        uint256 accRewardPerShare; // Accumulated rewards per share
        uint256 rewardBalance; // Available reward balance
        uint256 accountedPosition; // Accounted position for calculations
        uint256 currentPrice; // Current market price
    }

    // Events
    event LiquidityDeposited(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 lpSharesMinted,
        bool isETH,
        uint256 minPrice,
        uint256 maxPrice
    );

    event LiquidityWithdrawn(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 lpSharesBurned,
        bool isETH,
        uint256 minPrice,
        uint256 maxPrice
    );

    event PoolFeeDistributed(
        address indexed from,
        uint256 amount,
        address indexed token,
        bool isETH
    );

    event FeeClaimed(
        address indexed user,
        uint256 amount,
        address indexed token,
        bool isETH
    );

    event PoolBalanceUpdated(
        address indexed token,
        uint256 newTotalETH,
        uint256 newTotalTokens,
        uint256 newETHLPShares,
        uint256 newTokenLPShares
    );

    event PriceRangeUpdated(
        address indexed user,
        uint256 oldMinPrice,
        uint256 oldMaxPrice,
        uint256 newMinPrice,
        uint256 newMaxPrice,
        bool isETH
    );

    event MerkleRootUpdated(uint256 indexed version, bytes32 merkleRoot);
    event UserPositionUpdated(
        address indexed user,
        uint256 indexed version,
        uint256 newETHPosition,
        uint256 newTokenPosition
    );

    event MinLiquidityUpdated(uint256 newMinLiquidity, bool isETH);
    event EmergencyWithdraw(
        address indexed token,
        address indexed recipient,
        uint256 amount,
        bool isETH
    );

    // Enhanced liquidity management functions with price ranges
    /**
     * @notice Add ETH liquidity with price range and optional position update
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function addETHLiquidityWithPriceRange(
        uint256 minPrice,
        uint256 maxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external payable;

    /**
     * @notice Add token liquidity with price range and optional position update
     * @param tokenAmount Amount of tokens to deposit
     * @param minPrice Minimum price for this liquidity position
     * @param maxPrice Maximum price for this liquidity position
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function addTokenLiquidityWithPriceRange(
        uint256 tokenAmount,
        uint256 minPrice,
        uint256 maxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Add both ETH and token liquidity with price ranges and optional position update
     * @param tokenAmount Amount of tokens to deposit
     * @param ethMinPrice Minimum price for ETH liquidity position
     * @param ethMaxPrice Maximum price for ETH liquidity position
     * @param tokenMinPrice Minimum price for token liquidity position
     * @param tokenMaxPrice Maximum price for token liquidity position
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function addLiquidityWithPriceRanges(
        uint256 tokenAmount,
        uint256 ethMinPrice,
        uint256 ethMaxPrice,
        uint256 tokenMinPrice,
        uint256 tokenMaxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external payable;

    /**
     * @notice Update price range for existing ETH liquidity position
     * @param newMinPrice New minimum price
     * @param newMaxPrice New maximum price
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function updateETHPositionPriceRange(
        uint256 newMinPrice,
        uint256 newMaxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Update price range for existing token liquidity position
     * @param newMinPrice New minimum price
     * @param newMaxPrice New maximum price
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function updateTokenPositionPriceRange(
        uint256 newMinPrice,
        uint256 newMaxPrice,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    // Standard liquidity functions (without price ranges for backward compatibility)
    /**
     * @notice Add ETH liquidity with optional position update (no price range)
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function addETHLiquidityWithProof(
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external payable;

    /**
     * @notice Add token liquidity with optional position update (no price range)
     * @param tokenAmount Amount of tokens to deposit
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function addTokenLiquidityWithProof(
        uint256 tokenAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    // Removal functions with price range support
    /**
     * @notice Remove ETH liquidity with optional position update
     * @param shares Percentage of pool to withdraw (in basis points, 10000 = 100%)
     * @param minEthAmount Minimum amount of ETH to receive
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function removeETHLiquidityWithProof(
        uint256 shares,
        uint256 minEthAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Remove token liquidity with optional position update
     * @param shares Percentage of pool to withdraw (in basis points, 10000 = 100%)
     * @param minTokenAmount Minimum amount of tokens to receive
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function removeTokenLiquidityWithProof(
        uint256 shares,
        uint256 minTokenAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Remove both ETH and token liquidity with merkle proof
     * @param ethShares Percentage of ETH liquidity to remove (0-10000)
     * @param tokenShares Percentage of token liquidity to remove (0-10000)
     * @param minEthAmount Minimum ETH amount to receive
     * @param minTokenAmount Minimum token amount to receive
     * @param proof Merkle proof for position update
     * @param newETHPosition New ETH position after update
     * @param newTokenPosition New token position after update
     * @param ethRewardsToAdd Total ETH rewards (accumulated)
     * @param tokenRewardsToAdd Total token rewards (accumulated)
     */
    function removeLiquidityWithProof(
        uint256 ethShares,
        uint256 tokenShares,
        uint256 minEthAmount,
        uint256 minTokenAmount,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    // Order execution functions (same as V2)
    /**
     * @notice Execute buy order - Orderbook sends ETH, receives tokens
     * @param ethAmount Amount of ETH sent by orderbook
     * @param tokenAmount Amount of tokens to send to orderbook
     * @param newMerkleRoot New merkle root to update after trade
     */
    function executeBuyOrder(
        uint256 ethAmount,
        uint256 tokenAmount,
        bytes32 newMerkleRoot
    ) external payable;

    /**
     * @notice Execute sell order - Orderbook sends tokens, receives ETH
     * @param ethAmount Amount of ETH to send to orderbook
     * @param tokenAmount Amount of tokens sent by orderbook
     * @param newMerkleRoot New merkle root to update after trade
     */
    function executeSellOrder(
        uint256 ethAmount,
        uint256 tokenAmount,
        bytes32 newMerkleRoot
    ) external;

    // Reward distribution functions (same as V2)
    /**
     * @notice Distributes ETH fees to ETH providers
     */
    function distributePoolFee() external payable;

    /**
     * @notice Distributes token fees to token providers
     * @param tokenAmount Amount of tokens to distribute as fees
     */
    function distributeTokenFee(uint256 tokenAmount) external;

    // Reward claiming functions (same as V2)
    /**
     * @notice Claim all rewards with optional position update
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function claimRewardsWithProof(
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Claim only ETH rewards with optional position update
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function claimETHRewardsWithProof(
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    /**
     * @notice Claim only token rewards with optional position update
     * @param proof Merkle proof for position update (required if user has pending updates)
     * @param newETHPosition New ETH position (required if proof provided)
     * @param newTokenPosition New token position (required if proof provided)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function claimTokenRewardsWithProof(
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    // Position update functions (same as V2)
    /**
     * @notice Update user position using merkle proof
     * @param version Version of the merkle root
     * @param proof Merkle proof for the user's new position
     * @param newETHPosition New ETH position (actual ETH amount)
     * @param newTokenPosition New token position (actual token amount)
     * @param ethRewardsToAdd Off-chain calculated ETH rewards to add
     * @param tokenRewardsToAdd Off-chain calculated token rewards to add
     */
    function updateUserPosition(
        uint256 version,
        bytes32[] calldata proof,
        uint256 newETHPosition,
        uint256 newTokenPosition,
        uint256 ethRewardsToAdd,
        uint256 tokenRewardsToAdd
    ) external;

    // Factory-only functions (same as V2)
    /**
     * @notice Add ETH liquidity for a specific user (factory only)
     * @param user User address to add liquidity for
     */
    function addETHLiquidityForUser(
        address user,
        uint256 minPrice,
        uint256 maxPrice
    ) external payable;

    /**
     * @notice Add token liquidity for a specific user (factory only)
     * @param user User address to add liquidity for
     * @param tokenAmount Amount of tokens to deposit
     */
    function addTokenLiquidityForUser(
        address user,
        uint256 tokenAmount,
        uint256 minPrice,
        uint256 maxPrice
    ) external;

    // View functions with price range support
    /**
     * @notice Get comprehensive user position information including price ranges
     * @param user Address of the user
     * @return ethPosition User's ETH position
     * @return tokenPosition User's token position
     * @return ethLPShares User's ETH LP shares
     * @return tokenLPShares User's token LP shares
     * @return ethPendingRewards User's pending ETH rewards
     * @return tokenPendingRewards User's pending token rewards
     * @return lastUpdateVersion User's last update version
     * @return ethPriceRange User's ETH price range
     * @return tokenPriceRange User's token price range
     */
    function getUserPositionWithPriceRanges(
        address user
    )
        external
        view
        returns (
            uint256 ethPosition,
            uint256 tokenPosition,
            uint256 ethLPShares,
            uint256 tokenLPShares,
            uint256 ethPendingRewards,
            uint256 tokenPendingRewards,
            uint256 lastUpdateVersion,
            PriceRange memory ethPriceRange,
            PriceRange memory tokenPriceRange
        );

    /**
     * @notice Get user position information (backward compatibility)
     * @param user Address of the user
     * @return ethPosition User's ETH position
     * @return tokenPosition User's token position
     * @return ethLPShares User's ETH LP shares
     * @return tokenLPShares User's token LP shares
     * @return ethPendingRewards User's pending ETH rewards
     * @return tokenPendingRewards User's pending token rewards
     * @return lastUpdateVersion User's last update version
     */
    function getUserPosition(
        address user
    )
        external
        view
        returns (
            uint256 ethPosition,
            uint256 tokenPosition,
            uint256 ethLPShares,
            uint256 tokenLPShares,
            uint256 ethPendingRewards,
            uint256 tokenPendingRewards,
            uint256 lastUpdateVersion
        );

    /**
     * @notice Get pool metrics for ETH pool
     * @return metrics ETH pool metrics
     */
    function getETHPoolMetrics()
        external
        view
        returns (PoolMetrics memory metrics);

    /**
     * @notice Get pool metrics for token pool
     * @return metrics Token pool metrics
     */
    function getTokenPoolMetrics()
        external
        view
        returns (PoolMetrics memory metrics);

    /**
     * @notice Get current market price (ETH per token)
     * @return price Current market price in wei per token
     */
    function getCurrentPrice() external view returns (uint256 price);

    /**
     * @notice Check if a price is within a given range
     * @param price Price to check
     * @param minPrice Minimum price
     * @param maxPrice Maximum price
     * @return isWithinRange True if price is within range
     */
    function isPriceWithinRange(
        uint256 price,
        uint256 minPrice,
        uint256 maxPrice
    ) external view returns (bool isWithinRange);

    /**
     * @notice Get the Uniswap V2 pair address for this token
     * @return pairAddress Address of the Uniswap V2 pair
     */
    function getPairAddress() external view returns (address pairAddress);

    /**
     * @notice Get the reserves for this token pair
     * @return reserveETH ETH reserve amount
     * @return reserveToken Token reserve amount
     */
    function getReserves()
        external
        view
        returns (uint256 reserveETH, uint256 reserveToken);

    // Owner functions (same as V2)
    /**
     * @notice Set minimum ETH liquidity requirement
     * @param _minLiquidity New minimum ETH liquidity amount
     */
    function setMinLiquidity(uint256 _minLiquidity) external;

    /**
     * @notice Set minimum token liquidity requirement
     * @param _minTokenLiquidity New minimum token liquidity amount
     */
    function setMinTokenLiquidity(uint256 _minTokenLiquidity) external;

    // Emergency functions (same as V2)
    /**
     * @notice Emergency function to withdraw ETH from the contract
     * @param recipient Address to receive the ETH
     * @param amount Amount of ETH to withdraw (0 = withdraw all)
     */
    function emergencyWithdrawETH(
        address payable recipient,
        uint256 amount
    ) external;

    /**
     * @notice Emergency function to withdraw any ERC20 token from the contract
     * @param tokenAddress Address of the token to withdraw
     * @param recipient Address to receive the tokens
     * @param amount Amount of tokens to withdraw (0 = withdraw all)
     */
    function emergencyWithdrawToken(
        address tokenAddress,
        address recipient,
        uint256 amount
    ) external;

    // Basic view functions (same as V2)
    function token() external view returns (address);

    function factory() external view returns (address);

    function totalETH() external view returns (uint256);

    function totalTokens() external view returns (uint256);

    function merkleRoot() external view returns (bytes32);

    function currentVersion() external view returns (uint256);

    function minLiquidity() external view returns (uint256);

    function minTokenLiquidity() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title IGradientRegistry
 * @notice Interface for the GradientRegistry contract
 */
interface IGradientRegistry {
    /**
     * @notice Set all main contract addresses at once
     * @param _marketMakerFactory Address of the MarketMakerFactory contract
     * @param _gradientToken Address of the Gradient token contract
     * @param _orderbook Address of the Orderbook contract
     * @param _fallbackExecutor Address of the FallbackExecutor contract
     * @param _router Address of the Uniswap V2 Router contract
     * @param _feeManager Address of the FeeManager contract
     */
    function setMainContracts(
        address _marketMakerFactory,
        address _gradientToken,
        address _orderbook,
        address _fallbackExecutor,
        address _router,
        address _feeManager
    ) external;

    /**
     * @notice Set an individual main contract address
     * @param contractName Name of the contract to update
     * @param newAddress New address for the contract
     */
    function setContractAddress(
        string calldata contractName,
        address newAddress
    ) external;

    /**
     * @notice Set an additional contract address using a key
     * @param key The key to identify the contract
     * @param contractAddress The address of the contract
     */
    function setAdditionalContract(
        bytes32 key,
        address contractAddress
    ) external;

    /**
     * @notice Set the block status of a token
     * @param token The address of the token to set the block status of
     * @param blocked Whether the token should be blocked
     */
    function setTokenBlockStatus(address token, bool blocked) external;

    /**
     * @notice Set a reward distributor address
     * @param rewardDistributor The address of the reward distributor to authorize
     */
    function setRewardDistributor(address rewardDistributor) external;

    /**
     * @notice Authorize or deauthorize a fulfiller
     * @param fulfiller The address of the fulfiller to authorize
     * @param status The status of the fulfiller
     */
    function authorizeFulfiller(address fulfiller, bool status) external;

    /**
     * @notice Check if an address is an authorized fulfiller
     * @param fulfiller The address to check
     * @return bool Whether the address is an authorized fulfiller
     */
    function isAuthorizedFulfiller(
        address fulfiller
    ) external view returns (bool);

    /**
     * @notice Get all main contract addresses
     * @return _marketMakerFactory Address of the MarketMakerFactory contract
     * @return _gradientToken Address of the Gradient token contract
     * @return _orderbook Address of the Orderbook contract
     * @return _fallbackExecutor Address of the FallbackExecutor contract
     * @return _router Address of the Uniswap V2 Router contract
     * @return _feeManager Address of the FeeManager contract
     */
    function getAllMainContracts()
        external
        view
        returns (
            address _marketMakerFactory,
            address _gradientToken,
            address _orderbook,
            address _fallbackExecutor,
            address _router,
            address _feeManager
        );

    // View functions for individual contract addresses
    function marketMakerFactory() external view returns (address);

    // Legacy function for backward compatibility (returns factory address)
    function marketMakerPool() external view returns (address);

    // New function to get pool for specific token
    function getMarketMakerPool(address token) external view returns (address);

    // New function to check if pool exists for token
    function poolExists(address token) external view returns (bool);

    function gradientToken() external view returns (address);

    function orderbook() external view returns (address);

    function fallbackExecutor() external view returns (address);

    function router() external view returns (address);

    function feeManager() external view returns (address);

    // View functions for mappings
    function blockedTokens(address token) external view returns (bool);

    function isRewardDistributor(
        address rewardDistributor
    ) external view returns (bool);

    function authorizedFulfillers(
        address fulfiller
    ) external view returns (bool);

    // Partner token management functions (for market maker fee splits)
    function setPartnerToken(address token, address partnerWallet) external;

    function removePartnerToken(address token) external;

    function checkIsPartnerToken(address token) external view returns (bool);

    function getPartnerWallet(address token) external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);

    function allPairs(uint) external view returns (address pair);

    function allPairsLength() external view returns (uint);

    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint);

    function balanceOf(address owner) external view returns (uint);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);

    function transfer(address to, uint value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint);

    function permit(
        address owner,
        address spender,
        uint value,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(
        address indexed sender,
        uint amount0,
        uint amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint);

    function price1CumulativeLast() external view returns (uint);

    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);

    function burn(address to) external returns (uint amount0, uint amount1);

    function swap(
        uint amount0Out,
        uint amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountToken, uint amountETH);

    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function swapTokensForExactETH(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactTokensForETH(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapETHForExactTokens(
        uint amountOut,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function quote(
        uint amountA,
        uint reserveA,
        uint reserveB
    ) external pure returns (uint amountB);

    function getAmountOut(
        uint amountIn,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountOut);

    function getAmountIn(
        uint amountOut,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountIn);

    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory amounts);

    function getAmountsIn(
        uint amountOut,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IUniswapV3Factory {
    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external view returns (address pool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IUniswapV3Pool {
    function token0() external view returns (address);

    function token1() external view returns (address);

    function fee() external view returns (uint24);

    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );

    function liquidity() external view returns (uint128);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title IUniswapV3PriceHelper
 * @notice Interface for Uniswap V3 price helper contract
 * @dev This helper reduces pool contract size by handling all V3-specific logic
 */
interface IUniswapV3PriceHelper {
    /**
     * @notice Get V3 pool address for a token by trying different fee tiers
     * @param token Address of the token
     * @param weth WETH address
     * @return poolAddress Address of the V3 pool, or address(0) if not found
     */
    function getV3PoolAddress(
        address token,
        address weth
    ) external view returns (address poolAddress);

    /**
     * @notice Get price from Uniswap V3 pool
     * @param token Address of the token
     * @param weth WETH address
     * @param tokenDecimals Number of decimals for the token
     * @return price Price in ETH per token (18 decimals), or 0 if pool doesn't exist
     */
    function getPriceFromV3(
        address token,
        address weth,
        uint8 tokenDecimals
    ) external view returns (uint256 price);

    /**
     * @notice Get current market price from Uniswap (checks V3 first, then V2)
     * @param token Address of the token
     * @param routerAddress Address of the Uniswap V2 Router (to get WETH and V2 factory)
     * @param tokenDecimals Number of decimals for the token
     * @return price Current market price in wei per token
     */
    function getCurrentPrice(
        address token,
        address routerAddress,
        uint8 tokenDecimals
    ) external view returns (uint256 price);

    /**
     * @notice Get amount out for a swap in Uniswap V3 (similar to V2's getAmountOut)
     * @param amountIn Amount of input token
     * @param tokenIn Address of the input token
     * @param tokenOut Address of the output token
     * @return amountOut Amount of output token that would be received
     * @dev Returns 0 if pool doesn't exist or calculation fails
     */
    function getAmountOut(
        uint256 amountIn,
        address tokenIn,
        address tokenOut
    ) external view returns (uint256 amountOut);
}