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

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {ERC165} from "../utils/introspection/ERC165.sol";

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

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

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

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

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

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

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

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

        _revokeRole(role, callerConfirmation);
    }

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

pragma solidity ^0.8.20;

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

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

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

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 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[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title Quoter Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoter {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountIn The desired input amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    function quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountIn,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountOut);

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountOut The desired output amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    function quoteExactOutputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountOut,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountIn);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

interface IRouter {
    receive() external payable;

    /// @notice Sets the address of the treasure contract.
    /// @param treasure The address of the treasure contract to be set.
    /// @dev Only callable by accounts with the ADMIN_ROLE.
    /// @dev Updates the `_treasure` variable with the provided treasure contract address.
    /// @dev Emits a SetTreasure event upon successful update of the treasure contract address.

    function setTreasure(address treasure) external;

    /// @notice Swaps exact input amount of native currency for token or token for native currency using a specified path.
    /// @param amountIn The exact input amount of the token to be swapped. If swap from native currency it should be equal to msg.value
    /// @param path The path of tokens to be swapped, represented as a byte array.
    /// @param to The address to which the swapped tokens or native curency will be transferred.
    /// @param amountOutMinimum The minimum amount of tokens or native currency expected to receive after the swap.
    /// @param feePercent The percentage fee applied to the swap. Precision 1e8. 100% = 100 000 000
    /// @return amountOut The amount of tokens or native currency received after the swap.
    /// @dev If the token from or to token is not WETH address(representing native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH(representing native currency), the function accepts Ether (native) as payment and processes the swap.
    /// @dev If the token from is not WETH, it transfers tokens from the caller to the contract, approves the router, and processes the swap.
    /// @dev Start and end of swaps always in native currency
    /// @dev Transfers tax in native currency to treasure contract
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function exactInput(
        uint256 amountIn,
        bytes calldata path,
        address to,
        uint256 amountOutMinimum,
        uint256 feePercent
    ) external payable returns (uint256 amountOut);

    /// @notice Estimates the amount of output tokens or native currency for a given exact input amount and path.
    /// @param amountIn The exact input amount of the token to be swapped.
    /// @param path The path of tokens to be swapped, represented as a byte array.
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amountOut The estimated amount of output tokens or native currency after the swap.
    /// @return tax The estimated tax amount to be collected from the swap.
    /// @dev If the token from or to token is not WETH address (representing native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH (representing native currency), the function accepts Ether (native) as payment and calculates the estimated swap output.
    /// @dev If the token from is not WETH, it calculates the estimated swap output based on the provided token input amount.
    /// @dev Staticcall only

    function quoteExactInput(
        uint256 amountIn,
        bytes calldata path,
        uint256 feePercent
    ) external payable returns (uint256 amountOut, uint256 tax);

    /// @notice Swaps exact amount of ETH(native) for tokens using a specified path.
    /// @param amountOutMin The minimum amount of tokens expected to receive after the swap.
    /// @param path The path of tokens to be swapped, starting with WETH and ending with the desired token.
    /// @param to The address to which the swapped tokens will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @dev If the token from address is not WETH(represents native currency), it reverts with a PathError.
    /// @dev Accepts ETH sent with the transaction and calculates the actual amount to be swapped after deducting the fee.
    /// @dev Executes the swap using swapExactETHForTokens function of the router.
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external payable;

    /// @notice Swaps exact amount of tokens for ETH using a specified path.
    /// @param amountIn The exact amount of tokens to be swapped.
    /// @param amountOutMin The minimum amount of ETH expected to receive after the swap.
    /// @param path The path of tokens to be swapped, should starting with the token and ending with WETH address.
    /// @param to The address to which the swapped ETH will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amountOut The amount of ETH received after the swap.
    /// @dev If the token to address is not WETH, it reverts with a PathError.
    /// @dev Transfers tokens from the caller to the contract, approves the router, and executes the swap.
    /// @dev Calculates the actual amount of received ETH after deducting the fee.
    /// @dev Transfers the swapped ETH to the recipient and transfers the collected tax to the treasure contract.
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external returns (uint256 amountOut);

    /// @notice Retrieves the address of the treasure contract.
    /// @return treasure The address of the treasure contract.
    /// @dev Returns the stored address of the treasure contract, which holds collected taxes.

    function getTreasure() external view returns (address treasure);

    /// @notice Retrieves the expected output amounts for a given input amount of tokens or native currency, considering a specified path.
    /// @param amountIn The input amount of tokens or native currency.
    /// @param path The path of tokens to be swapped
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amounts The array of expected output amounts after the swap.
    /// @return tax The estimated tax amount to be collected from the swap.
    /// @dev If the token from or to token is not WETH address (represents native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH (represents native currency), the function calculates the expected output amounts after deducting the fee.
    /// @dev If the token from is not WETH, it calculates the expected output amounts based on the provided token input amount and then deducts the fee.

    function getAmountsOut(
        uint256 amountIn,
        address[] calldata path,
        uint256 feePercent
    ) external view returns (uint256[] memory amounts, uint256 tax);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';

/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter is IUniswapV3SwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.24;

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

    function WETH() external pure returns (address);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

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

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

/// @title Interface for WETH9
interface IWETH9 is IERC20 {
    /// @notice Deposit ether to get wrapped ether
    function deposit() external payable;

    /// @notice Withdraw wrapped ether to get ether
    function withdraw(uint256) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {ISwapRouter} from 'uniswap-v3-periphery-0.8/contracts/interfaces/ISwapRouter.sol';
import {IQuoter} from 'uniswap-v3-periphery-0.8/contracts/interfaces/IQuoter.sol';
import {IUniswapV2Router02} from './IUniswapV2Router02.sol';

import {AccessControl} from '@openzeppelin/contracts/access/AccessControl.sol';
import {Address, SafeERC20, IERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';

import {IWETH9} from './IWETH9.sol';
import {IRouter} from './IRouter.sol';

/// @title Bydex Router
/// @notice This smart contract provides functionality for exchanging tokens and native cryptocurrency via Uniswap V2 and V3 protocols.
/// @notice Including calculation and charging fees.

contract Router is AccessControl, IRouter {
    using SafeERC20 for IERC20;

    bytes32 public constant ADMIN_ROLE = keccak256('ADMIN_ROLE');

    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    ISwapRouter internal _swapRouterV3;
    IUniswapV2Router02 internal _swapRouterV2;
    IQuoter internal _quoter;
    address internal _treasure;

    event Swap(address from, address to, uint256 amountIn, uint256 amountOut, uint256 tax);
    event SetTreasure(address treasure);
    event SetFee(uint256 fee);

    error PathError();

    constructor(
        ISwapRouter swapRouter,
        IQuoter quoter,
        IUniswapV2Router02 swapRouterV2,
        address admin,
        address treasure
    ) {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, admin);

        _swapRouterV3 = swapRouter;
        _swapRouterV2 = swapRouterV2;
        _quoter = quoter;
        _treasure = treasure;
    }

    receive() external payable override {}

    // region #Admin

    /// @notice Sets the address of the treasure contract.
    /// @param treasure The address of the treasure contract to be set.
    /// @dev Only callable by accounts with the ADMIN_ROLE.
    /// @dev Updates the `_treasure` variable with the provided treasure contract address.
    /// @dev Emits a SetTreasure event upon successful update of the treasure contract address.

    function setTreasure(address treasure) external override onlyRole(ADMIN_ROLE) {
        _treasure = treasure;
        emit SetTreasure(treasure);
    }

    // endregion #Admin

    // region #UniV3

    /// @notice Swaps exact input amount of native currency for token or token for native currency using a specified path.
    /// @param amountIn The exact input amount of the token to be swapped. If swap from native currency it should be equal to msg.value
    /// @param path The path of tokens to be swapped, represented as a byte array.
    /// @param to The address to which the swapped tokens or native curency will be transferred.
    /// @param amountOutMinimum The minimum amount of tokens or native currency expected to receive after the swap.
    /// @param feePercent The percentage fee applied to the swap. Precision 1e8. 100% = 100 000 000
    /// @return amountOut The amount of tokens or native currency received after the swap.
    /// @dev If the token from or to token is not WETH address(representing native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH(representing native currency), the function accepts Ether (native) as payment and processes the swap.
    /// @dev If the token from is not WETH, it transfers tokens from the caller to the contract, approves the router, and processes the swap.
    /// @dev Start and end of swaps always in native currency
    /// @dev Transfers tax in native currency to treasure contract
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function exactInput(
        uint256 amountIn,
        bytes calldata path,
        address to,
        uint256 amountOutMinimum,
        uint256 feePercent
    ) external payable override returns (uint256 amountOut) {
        address tokenFrom = address(bytes20(path[0:20]));
        address tokenTo = address(bytes20(path[path.length - 20:]));
        uint256 tax;

        if (tokenFrom != WETH && tokenTo != WETH) {
            revert PathError();
        }

        ISwapRouter.ExactInputParams memory param;
        param.path = path;
        param.deadline = block.timestamp;
        param.amountOutMinimum = amountOutMinimum;

        if (tokenFrom == WETH) {
            amountIn = msg.value;

            tax = _takeFee(msg.value, feePercent);
            amountIn -= tax;

            param.recipient = to;
            param.amountIn = amountIn;
            amountOut = _swapRouterV3.exactInput{value: amountIn}(param);

            emit Swap({
                from: msg.sender,
                to: to,
                amountIn: msg.value,
                amountOut: amountOut,
                tax: tax
            });
        } else {
            _approveRouterV3(tokenFrom, amountIn);
            IERC20(tokenFrom).safeTransferFrom(msg.sender, address(this), amountIn);

            param.recipient = address(this);
            param.amountIn = amountIn;
            amountOut = _swapRouterV3.exactInput(param);

            IWETH9(WETH).withdraw(amountOut);
            tax = _takeFee(amountOut, feePercent);
            amountOut -= tax;
            Address.sendValue(payable(to), amountOut);
            emit Swap({
                from: msg.sender,
                to: to,
                amountIn: amountIn,
                amountOut: amountOut,
                tax: tax
            });
        }
        _transferTax(tax);
    }

    /// @notice Estimates the amount of output tokens or native currency for a given exact input amount and path.
    /// @param amountIn The exact input amount of the token to be swapped.
    /// @param path The path of tokens to be swapped, represented as a byte array.
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amountOut The estimated amount of output tokens or native currency after the swap.
    /// @return tax The estimated tax amount to be collected from the swap.
    /// @dev If the token from or to token is not WETH address (representing native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH (representing native currency), the function accepts Ether (native) as payment and calculates the estimated swap output.
    /// @dev If the token from is not WETH, it calculates the estimated swap output based on the provided token input amount.
    /// @dev Staticcall only

    function quoteExactInput(
        uint256 amountIn,
        bytes calldata path,
        uint256 feePercent
    ) external payable override returns (uint256 amountOut, uint256 tax) {
        address tokenFrom = address(bytes20(path[0:20]));
        address tokenTo = address(bytes20(path[path.length - 20:]));

        if (tokenFrom != WETH && tokenTo != WETH) {
            revert PathError();
        }

        if (tokenFrom == WETH) {
            amountIn = msg.value;
            tax = _takeFee(msg.value, feePercent);
            amountIn -= tax;
            amountOut = _quoter.quoteExactInput(path, amountIn);
        } else {
            amountOut = _quoter.quoteExactInput(path, amountIn);
            tax = _takeFee(amountOut, feePercent);
            amountOut -= tax;
        }
    }

    // endregion #UniV3

    // region #UniV2

    /// @notice Swaps exact amount of ETH(native) for tokens using a specified path.
    /// @param amountOutMin The minimum amount of tokens expected to receive after the swap.
    /// @param path The path of tokens to be swapped, starting with WETH and ending with the desired token.
    /// @param to The address to which the swapped tokens will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @dev If the token from address is not WETH(represents native currency), it reverts with a PathError.
    /// @dev Accepts ETH sent with the transaction and calculates the actual amount to be swapped after deducting the fee.
    /// @dev Executes the swap using swapExactETHForTokens function of the router.
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external payable override {
        address tokenFrom = path[0];

        if (tokenFrom != WETH) {
            revert PathError();
        }
        uint256 amountIn = msg.value;
        uint256 tax = _takeFee(amountIn, feePercent);
        amountIn -= tax;
        _transferTax(tax);

        uint256[] memory amounts = _swapRouterV2.swapExactETHForTokens{value: amountIn}(
            amountOutMin,
            path,
            to,
            block.timestamp
        );

        emit Swap({
            from: msg.sender,
            to: to,
            amountIn: msg.value,
            amountOut: amounts[amounts.length - 1],
            tax: tax
        });
    }

    /// @notice Swaps exact amount of tokens for ETH using a specified path.
    /// @param amountIn The exact amount of tokens to be swapped.
    /// @param amountOutMin The minimum amount of ETH expected to receive after the swap.
    /// @param path The path of tokens to be swapped, should starting with the token and ending with WETH address.
    /// @param to The address to which the swapped ETH will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amountOut The amount of ETH received after the swap.
    /// @dev If the token to address is not WETH, it reverts with a PathError.
    /// @dev Transfers tokens from the caller to the contract, approves the router, and executes the swap.
    /// @dev Calculates the actual amount of received ETH after deducting the fee.
    /// @dev Transfers the swapped ETH to the recipient and transfers the collected tax to the treasure contract.
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external override returns (uint256 amountOut) {
        address tokenTo = path[path.length - 1];
        if (tokenTo != WETH) {
            revert PathError();
        }

        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        _approveRouterV2(path[0], amountIn);

        uint256[] memory amounts = _swapRouterV2.swapExactTokensForETH(
            amountIn,
            amountOutMin,
            path,
            address(this),
            block.timestamp
        );

        amountOut = amounts[amounts.length - 1];
        uint256 tax = _takeFee(amountOut, feePercent);
        amountOut -= tax;

        Address.sendValue(payable(to), amountOut);
        _transferTax(tax);

        emit Swap({from: msg.sender, to: to, amountIn: amountIn, amountOut: amountOut, tax: tax});
    }

    /// @notice Swaps exact amount of tokens for ETH, supporting tokens with transfer fees, using a specified path.
    /// @param amountIn The exact amount of tokens to be swapped.
    /// @param amountOutMin The minimum amount of ETH expected to receive after the swap.
    /// @param path The path of tokens to be swapped, starting with the token and ending with WETH address.
    /// @param to The address to which the swapped ETH will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amountOut The amount of ETH received after the swap.
    /// @dev If the token to address from path is not WETH, it reverts with a PathError.
    /// @dev Transfers tokens from the caller to the contract, approves the router, and executes the swap.
    /// @dev Executes the swap supporting tokens with transfer fees using swapExactTokensForETHSupportingFeeOnTransferTokens function of the router.
    /// @dev Calculates the actual amount of received ETH after deducting the fee.
    /// @dev Transfers the swapped ETH to the recipient and transfers the collected tax to the treasure contract.
    /// @dev Emits a Swap event after the swap with details including the amount of tokens swapped and any tax applied.

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external returns (uint256 amountOut) {
        address tokenTo = path[path.length - 1];
        if (tokenTo != WETH) {
            revert PathError();
        }

        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        _approveRouterV2(path[0], amountIn);

        uint256 balanceBefore = address(this).balance;

        _swapRouterV2.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountIn,
            amountOutMin,
            path,
            address(this),
            block.timestamp
        );
        uint256 balanceAfter = address(this).balance;

        amountOut = balanceAfter - balanceBefore;
        uint256 tax = _takeFee(amountOut, feePercent);
        amountOut -= tax;

        Address.sendValue(payable(to), amountOut);
        _transferTax(tax);

        emit Swap({from: msg.sender, to: to, amountIn: amountIn, amountOut: amountOut, tax: tax});
    }

    /// @notice Swaps exact amount of ETH for tokens, supporting tokens with transfer fees, using a specified path.
    /// @param amountOutMin The minimum amount of tokens expected to receive after the swap.
    /// @param path The path of tokens to be swapped, starting with WETH and ending with the desired token.
    /// @param to The address to which the swapped tokens will be transferred.
    /// @param feePercent The percentage fee applied to the swap.
    /// @dev If the token from address from path is not WETH, it reverts with a PathError.
    /// @dev Accepts ETH sent with the transaction and calculates the actual amount to be swapped after deducting the fee.
    /// @dev Executes the swap supporting tokens with transfer fees using swapExactETHForTokensSupportingFeeOnTransferTokens function of the router.
    /// @dev Calculates the amount of tokens received after the swap and emits a Swap event with details including the amount of tokens swapped and any tax applied.

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 feePercent
    ) external payable {
        address tokenFrom = path[0];

        if (tokenFrom != WETH) {
            revert PathError();
        }
        uint256 amountIn = msg.value;
        uint256 tax = _takeFee(amountIn, feePercent);
        amountIn -= tax;
        _transferTax(tax);
        uint256 balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);

        _swapRouterV2.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amountIn}(
            amountOutMin,
            path,
            to,
            block.timestamp
        );
        uint256 balanceAfter = IERC20(path[path.length - 1]).balanceOf(to);

        emit Swap({
            from: msg.sender,
            to: to,
            amountIn: msg.value,
            amountOut: balanceAfter - balanceBefore,
            tax: tax
        });
    }

    /// @notice Retrieves the address of the treasure contract.
    /// @return treasure The address of the treasure contract.
    /// @dev Returns the stored address of the treasure contract, which holds collected taxes.

    function getTreasure() external view override returns (address treasure) {
        return _treasure;
    }

    /// @notice Retrieves the expected output amounts for a given input amount of tokens or native currency, considering a specified path.
    /// @param amountIn The input amount of tokens or native currency.
    /// @param path The path of tokens to be swapped
    /// @param feePercent The percentage fee applied to the swap.
    /// @return amounts The array of expected output amounts after the swap.
    /// @return tax The estimated tax amount to be collected from the swap.
    /// @dev If the token from or to token is not WETH address (represents native currency), it reverts with a PathError.
    /// @dev If the token from address is WETH (represents native currency), the function calculates the expected output amounts after deducting the fee.
    /// @dev If the token from is not WETH, it calculates the expected output amounts based on the provided token input amount and then deducts the fee.

    function getAmountsOut(
        uint256 amountIn,
        address[] calldata path,
        uint256 feePercent
    ) external view override returns (uint256[] memory amounts, uint256 tax) {
        address tokenFrom = path[0];
        address tokenTo = path[path.length - 1];

        if (tokenFrom != WETH && tokenTo != WETH) {
            revert PathError();
        }
        if (tokenFrom == WETH) {
            tax = _takeFee(amountIn, feePercent);
            amountIn -= tax;
            amounts = _swapRouterV2.getAmountsOut(amountIn, path);
        } else {
            amounts = _swapRouterV2.getAmountsOut(amountIn, path);
            tax = _takeFee(amounts[amounts.length - 1], feePercent);
            amounts[amounts.length - 1] -= tax;
        }
    }

    // endregion #UniV2

    /// @notice Transfers the collected tax amount to the treasure contract.
    /// @param amount The amount of tax to be transferred.
    /// @dev If the amount is not zero, transfers the specified amount of native currency to the treasure contract.

    function _transferTax(uint256 amount) internal {
        if (amount != 0) {
            Address.sendValue(payable(_treasure), amount);
        }
    }

    /// @notice Approves the SwapRouterV2 contract to spend the specified amount of tokens on behalf of this contract, if needed.
    /// @param token The address of the token to be approved.
    /// @param amount The amount of tokens to be approved.
    /// @dev If the current allowance for the token is less than the specified amount, approves the SwapRouterV2 contract to spend an max amount of tokens on behalf of this contract.

    function _approveRouterV2(address token, uint256 amount) internal {
        if (IERC20(token).allowance(address(this), address(_swapRouterV2)) < amount) {
            IERC20(token).approve(address(_swapRouterV2), type(uint256).max);
        }
    }

    /// @notice Approves the RouterV3 contract to spend the specified amount of tokens on behalf of this contract, if needed.
    /// @param token The address of the token to be approved.
    /// @param amount The amount of tokens to be approved.
    /// @dev If the current allowance for the token is less than the specified amount, approves the RouterV3 contract to spend an max amount of tokens on behalf of this contract.

    function _approveRouterV3(address token, uint256 amount) internal {
        if (IERC20(token).allowance(address(this), address(_swapRouterV3)) < amount) {
            IERC20(token).approve(address(_swapRouterV3), type(uint256).max);
        }
    }

    /// @notice Calculates the tax amount based on the specified fee percentage and the given amount.
    /// @param amount The amount on which the fee is to be calculated.
    /// @param feePercent The fee percentage applied to the amount, represented in precision of 1e8 (100% = 1e8).
    /// @return tax The calculated tax amount.
    /// @dev Calculates the tax by multiplying the fee percentage with the amount and dividing it by 1e8.

    function _takeFee(uint256 amount, uint256 feePercent) internal pure returns (uint256 tax) {
        tax = (feePercent * amount) / 1e8;

        return tax;
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 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 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 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 Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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.
     */
    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.
     */
    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 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).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            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 silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

{
  "compilationTarget": {
    "contracts/router/Router.sol": "Router"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}