Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: BUSL-1.1

pragma solidity =0.8.20;
pragma abicoder v2;
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol"; // Interface for Uniswap v3's swap router, for executing token swaps.
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./lib/ArrayUtils.sol";
import {Errors} from "./lib/Errors.sol";

interface IWETH9 is IERC20 {
    function deposit() external payable;

    function withdraw(uint256) external payable;
}

contract PayerV3 {
    using SafeERC20 for IERC20;
    using ArrayUtils for address[]; // Enables ArrayUtils operations for address arrays.
    address public owner1; // Address of the first owner.
    address public owner2; // Address of the second owner.
    address public service; // Address of a service account, for automated tasks.
    struct Order {
        address user; // The address of the user who created the order.
        address tokenIn; // The address of the token being sold.
        uint256 amountIn; // The amount of tokenIn being sold.
        address tokenOut; // The address of the token being bought.
        uint256 amountOut; // The amount of tokenOut being bought.
        uint256 price; // The price at which the swap is executed.
        uint256 additionalAmount; // Additional amount to be paid to the user
        uint256 endTimestamp; // Timestamp when the order expires.
        bool completed; // Whether the order has been completed.
        bool claimed; // Whether the result of the order has been claimed.
    }
    struct ExecuteOrderParams {
        // Parameters for executing multiple orders.
        uint256[] orderIds; // Array of order IDs to execute.
        bool[] swap; // Array indicating which orders should perform a swap.
        uint256[] additionalAmount; // Array of additional amounts for each order.
    }

    constructor() {
        owner1 = msg.sender; // Sets the deployer as the first owner.
        payerAddress = owner1; // Initializes payerAddress to the first owner's address.
    }

    // Fallback and receive functions for handling direct ether transfers.
    receive() external payable {}

    modifier onlyOwners() {
        // Ensures only the owners can call the modified function.
        if (msg.sender != owner1 && msg.sender != owner2) {
            revert Errors.NotAllowedAddress();
        }
        _;
    }
    modifier onlyOwnerOrService() {
        // Ensures only the owners or the service account can call the modified function.
        if (
            msg.sender != owner1 &&
            msg.sender != owner2 &&
            msg.sender != service
        ) {
            revert Errors.NotAllowedAddress();
        }
        _;
    }
    ISwapRouter public constant swapRouter =
        ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564); // Uniswap swap router
    uint24 public poolFee = 3000; // Fee for liquidity pool usage, in basis points.
    uint24 public constant maxAdditionalAmountPercentage = 750; // Maximum allowed percentage for additionalAmount, in basis points.
    uint256 public acceptableTokensArrayLength; // Array length of acceptable token addresses.
    uint256 constant swapDeadline = 10 minutes; // Deadline for completing swaps.
    mapping(address => mapping(address => uint256)) public balances; // Tracks user balances of various tokens.
    mapping(address => mapping(address => uint256)) public swapsIn; // Tracks incoming swaps.
    mapping(address => mapping(address => uint256)) public swapsOut; // Tracks outgoing swaps.
    mapping(address => uint256) public lastUserActionTime; // Tracks the last action time of users.
    Order[] public orders; // Array of all orders.
    mapping(address => bool) public acceptableTokens; // Tracks tokens that are acceptable for trading.
    mapping(address => bool) public isUsdToken; // Tracks if a token is considered a USD token.
    mapping(address => uint256) public minimalTokenAmounts; // Tracks minimal token amounts.
    address[] public acceptableTokensArray; // Array of acceptable token addresses.
    address public constant wethAddress =
        0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // Address of Wrapped ETH (WETH) contract.
    address public payerAddress; // Address used for making payments.
    uint public constant maxDuration = 90 days; // Maximum duration for orders.
    uint public constant maxExecutionTime = 1 hours; // Maximum time for executing orders
    uint public constant fullAccessAfter = 365 days; // The time that must pass after the user is inactive to gain access to his balances
    // Events for logging contract actions
    event Deposit(address indexed user, address indexed token, uint256 amount);
    event NewOrder(
        uint256 indexed orderId,
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 duration
    );
    event ClaimOrder(uint256 indexed orderId);
    event FullWithdrawal(
        address indexed user,
        address indexed token,
        uint256 amount
    );

    /**
     * @dev This combines deposit and makeOrder placement in a single transaction for user convenience.
     * Emits a {Deposit}, {NewOrder} events.
     */
    function depositAndOrder(
        address _tokenAddressIn,
        address _tokenAddressOut,
        uint256 _amountDeposit,
        uint256 _amountOrder,
        uint256 _price,
        uint256 _duration
    ) public {
        deposit(_tokenAddressIn, _amountDeposit);
        makeOrder(
            _tokenAddressIn,
            _tokenAddressOut,
            _amountOrder,
            _price,
            _duration
        );
    }

    /**
     * @dev This combines depositEth and makeOrder placement in a single transaction for user convenience.
     * Allows a user to deposit ETH (as WETH) and immediately place an order.
     * Emits a {Deposit}, {NewOrder} events.
     */
    function depositEthAndOrder(
        address _tokenAddressOut,
        uint256 _amount,
        uint256 _price,
        uint256 _duration
    ) public payable {
        depositEth();
        makeOrder(wethAddress, _tokenAddressOut, _amount, _price, _duration);
    }

    /**
     * @dev Create an order with the deposited tokens.
     * Emits a {NewOrder} events.
     */
    function makeOrder(
        address _tokenAddressIn,
        address _tokenAddressOut,
        uint256 _amountIn,
        uint256 _price,
        uint256 _duration
    ) public {
        // Checks ensure that the user has enough balance, the tokens are different, and the duration is within limits.
        if (!(balances[_tokenAddressIn][msg.sender] >= _amountIn)) {
            revert Errors.NoTokenBalance();
        }
        if (!(_tokenAddressIn != _tokenAddressOut)) {
            revert Errors.SameTokens();
        }
        if (!(_duration < maxDuration)) {
            revert Errors.DurationMoreMaximum();
        }
        if (!(_amountIn >= minimalTokenAmounts[_tokenAddressIn])) {
            revert Errors.WrongAmount();
        }
        balances[_tokenAddressIn][msg.sender] =
            balances[_tokenAddressIn][msg.sender] -
            _amountIn; // Deduct the amount from the user's balance and create the order.
        orders.push(
            Order(
                msg.sender,
                _tokenAddressIn,
                _amountIn,
                _tokenAddressOut,
                0,
                _price,
                0,
                block.timestamp + _duration,
                false,
                false
            )
        );
        _updateUserActionTime(); // Updates the timestamp of the user's last action.
        emit NewOrder(
            orders.length - 1,
            msg.sender,
            address(_tokenAddressIn),
            _amountIn,
            _duration
        );
    }

    /**
     * @dev Allows a user to deposit a specific token into their account on the contract.
     * Emits a {Deposit} events.
     */
    function deposit(address _tokenAddress, uint256 _amount) public payable {
        // Checks for token acceptability and non-zero amounts are performed.
        if (!acceptableTokens[_tokenAddress]) {
            revert Errors.NotAllowedToken();
        }
        if (_amount == 0) {
            revert Errors.NotAllowedZero();
        }
        IERC20(_tokenAddress).safeTransferFrom(
            msg.sender,
            address(this),
            _amount
        );
        // Adds the amount to the user's balance and performs the token transfer.
        balances[_tokenAddress][msg.sender] =
            balances[_tokenAddress][msg.sender] +
            _amount;
        _updateUserActionTime(); // Updates the timestamp of the user's last action.
        emit Deposit(msg.sender, _tokenAddress, _amount);
    }

    /**
     * @dev Allows a user to deposit ETH, which is automatically wrapped into WETH.
     * Emits a {Deposit} events.
     */
    function depositEth() public payable {
        // Checks for non-zero ETH amount.
        if (!(msg.value > 0)) {
            revert Errors.NotAllowedZero();
        }
        // Wraps the deposited ETH into WETH and updates the user's balance.
        IWETH9(wethAddress).deposit{value: msg.value}();
        balances[wethAddress][msg.sender] =
            balances[wethAddress][msg.sender] +
            msg.value;
        _updateUserActionTime(); // Updates the timestamp of the user's last action.
        emit Deposit(msg.sender, wethAddress, msg.value);
    }

    /**
     * @dev Allows batch execution of orders based on the provided parameters.
     */
    function executeOrders(
        ExecuteOrderParams calldata _params,
        uint256[] calldata _amountOutMinimum,
        bool _claimOrders,
        address _usdClaimToken
    ) public onlyOwnerOrService {
        uint256 orderIdsLength = _params.orderIds.length;
        // Ensures the consistency of the arrays' lengths and performs initial validations.
        if (
            !(orderIdsLength == _params.swap.length &&
                _params.swap.length == _params.additionalAmount.length)
        ) {
            revert Errors.DifferentLength();
        }
        // Loop through each order to perform initial checks and accumulate swap amounts.
        for (uint256 i; i < orderIdsLength; ) {
            Order storage order = orders[_params.orderIds[i]];
            if (!(block.timestamp >= order.endTimestamp)) {
                revert Errors.WrongExpirationTime();
            }
            if (order.claimed) {
                revert Errors.OrderAlreadyClaimed();
            }
            if (order.completed) {
                revert Errors.OrderAlreadyCompleted();
            }
            if (_params.swap[i]) {
                swapsIn[order.tokenIn][order.tokenOut] += order.amountIn;
            }
            unchecked {
                ++i;
            }
        }
        // Perform the swaps and update balances accordingly.
        uint256 swapsCount;
        for (uint256 i; i < acceptableTokensArrayLength; ) {
            for (uint256 j; j < acceptableTokensArrayLength; ) {
                if (
                    swapsIn[acceptableTokensArray[i]][
                        acceptableTokensArray[j]
                    ] > 0
                ) {
                    IERC20(acceptableTokensArray[i]).forceApprove(
                        address(swapRouter),
                        swapsIn[acceptableTokensArray[i]][
                            acceptableTokensArray[j]
                        ]
                    );
                    ISwapRouter.ExactInputSingleParams
                        memory swapParams = ISwapRouter.ExactInputSingleParams({
                            tokenIn: acceptableTokensArray[i],
                            tokenOut: acceptableTokensArray[j],
                            fee: poolFee,
                            recipient: address(this),
                            deadline: block.timestamp + swapDeadline,
                            amountIn: swapsIn[acceptableTokensArray[i]][
                                acceptableTokensArray[j]
                            ],
                            amountOutMinimum: _amountOutMinimum[swapsCount],
                            sqrtPriceLimitX96: 0
                        });
                    uint256 amountOut = swapRouter.exactInputSingle(swapParams);
                    if (!(amountOut > _amountOutMinimum[swapsCount])) {
                        revert Errors.IncorrectAmountOut();
                    }
                    swapsOut[acceptableTokensArray[i]][
                        acceptableTokensArray[j]
                    ] = amountOut;
                    swapsCount++;
                }
                unchecked {
                    ++j;
                }
            }
            unchecked {
                ++i;
            }
        }
        for (uint256 i; i < orderIdsLength; ) {
            _executeOrder(
                _params.orderIds[i],
                _params.swap[i],
                _params.additionalAmount[i]
            );
            unchecked {
                ++i;
            }
        }
        // A service on cheap ether networks can brand orders for the user, thereby reducing the user's interaction with the contact
        if (_claimOrders) {
            for (uint256 i; i < orderIdsLength; ) {
                claimOrder(_params.orderIds[i], _usdClaimToken, false);
                unchecked {
                    ++i;
                }
            }
        }
        // Reset swapsIn map
        for (uint256 i; i < acceptableTokensArrayLength; ) {
            for (uint256 j; j < acceptableTokensArrayLength; ) {
                swapsIn[acceptableTokensArray[i]][acceptableTokensArray[j]] = 0;
                unchecked {
                    ++j;
                }
            }
            unchecked {
                ++i;
            }
        }
    }

    /**
     * @dev Execution of the order. If the order requires swap then the swap is carried out in accordance with the amounts and proportions received after the exchange of tokens.
     * There is also a record of additional funds allocated to the user
     */
    function _executeOrder(
        uint256 orderId,
        bool swap,
        uint256 additionalAmount
    ) private {
        Order storage order = orders[orderId];
        order.additionalAmount = additionalAmount;
        order.completed = true;
        if (swap) {
            uint256 accuracy = wethAddress == order.tokenOut
                ? 1e10
                : 10 ** IERC20Metadata(order.tokenOut).decimals();
            uint256 proportionIn = calculateProportion(
                swapsIn[order.tokenIn][order.tokenOut],
                order.amountIn,
                accuracy
            );
            uint256 swapAmountOut = (swapsOut[order.tokenIn][order.tokenOut] *
                accuracy) / proportionIn;
            uint256 remainder;
            if (isUsdToken[order.tokenIn]) {
                remainder =
                    swapAmountOut -
                    (order.amountIn *
                        10 ** IERC20Metadata(order.tokenOut).decimals()) /
                    order.price;
                if (
                    !(order.additionalAmount <
                        calculatePercentage(
                            order.amountIn,
                            maxAdditionalAmountPercentage
                        ))
                ) {
                    revert Errors.WrongAdditionalAmount();
                }
            } else {
                remainder =
                    swapAmountOut -
                    (order.amountIn * order.price) /
                    10 ** IERC20Metadata(order.tokenIn).decimals();
                if (
                    !(order.additionalAmount <
                        calculatePercentage(
                            swapAmountOut - remainder,
                            maxAdditionalAmountPercentage
                        ))
                ) {
                    revert Errors.WrongAdditionalAmount();
                }
            }
            order.amountOut = swapAmountOut - remainder;
            balances[order.tokenOut][payerAddress] =
                balances[order.tokenOut][payerAddress] +
                remainder;
        } else {
            order.tokenOut = order.tokenIn;
            order.amountOut = order.amountIn;
        }
    }

    /**
     * @dev Allows user to get funds deposited to balance inside the contract when creating an order with an additional reward.
     * The _force parameter allows user to withdraw funds without receiving an additional amount
     */
    function claimOrder(
        uint256 _orderId,
        address _usdToken,
        bool _force
    ) public {
        // Checks ensure the order hasn't already been claimed and is either completed or beyond its execution time.
        Order storage order = orders[_orderId];
        if (order.claimed) {
            revert Errors.OrderAlreadyClaimed();
        }
        if (
            !(order.completed ||
                block.timestamp > order.endTimestamp + maxExecutionTime)
        ) {
            revert Errors.OrderNotCompleted();
        }
        // Handle forced claims differently from regular claims.
        if (!_force) {
            // For regular claims, verify the USD token and manage additional amounts if applicable.
            if (!isUsdToken[_usdToken]) {
                revert Errors.IsNotUsdToken();
            }
            if (
                order.additionalAmount > 0 &&
                balances[_usdToken][payerAddress] >= order.additionalAmount
            ) {
                _balanceTransfer(
                    _usdToken,
                    payerAddress,
                    order.user,
                    order.additionalAmount
                );
            }
        } else {
            // Forced claims are only available to the order's creator.
            if (msg.sender != order.user) {
                revert Errors.AvailableOnlyOwner();
            }
        }
        if (
            !order.completed &&
            block.timestamp > order.endTimestamp + maxExecutionTime
        ) {
            // If the order wasn't completed in time, revert to the original token and amount.
            order.tokenOut = order.tokenIn;
            order.amountOut = order.amountIn;
        }
        balances[order.tokenOut][order.user] =
            balances[order.tokenOut][order.user] +
            order.amountOut;
        order.claimed = true;
        if (msg.sender == order.user) {
            _updateUserActionTime();
            emit ClaimOrder(_orderId);
        }
    }

    /**
     * @dev Allows the user to withdraw their ERC20 tokens from the contract balance
     */
    function fullWithdrawal(address _tokenAddress, uint256 _amount) public {
        if (balances[_tokenAddress][msg.sender] < _amount) {
            revert Errors.NoTokenBalance();
        }
        balances[_tokenAddress][msg.sender] =
            balances[_tokenAddress][msg.sender] -
            _amount;
        IERC20(_tokenAddress).safeTransfer(msg.sender, _amount);
        _updateUserActionTime();
        emit FullWithdrawal(msg.sender, _tokenAddress, _amount);
    }

    /**
     * @dev Allows the user to withdraw their ETH from the contract balance
     */
    function fullWithdrawalETH(uint256 _amount) public payable {
        if (balances[wethAddress][msg.sender] < _amount) {
            revert Errors.NoTokenBalance();
        }
        balances[wethAddress][msg.sender] =
            balances[wethAddress][msg.sender] -
            _amount;
        IWETH9(wethAddress).withdraw(_amount);
        (bool sent, ) = msg.sender.call{value: _amount}("");
        if (!sent) {
            revert Errors.FailedToSendEther();
        }
        _updateUserActionTime();
        emit FullWithdrawal(msg.sender, wethAddress, _amount);
    }

    /**
     * @dev Сalculating the amount from the percentage
     */
    function calculatePercentage(
        uint256 _quantity,
        uint256 _percentage
    ) public pure returns (uint256) {
        return (_quantity * _percentage) / 10000;
    }

    /**
     * @dev Сalculating Proportion
     */
    function calculateProportion(
        uint256 _quantity,
        uint256 _total,
        uint256 _accuracy
    ) public pure returns (uint256) {
        return (_quantity * _accuracy) / _total;
    }

    /**
     * @dev Provides the balance of a given token for a specified user.
     */
    function balanceOf(
        address _tokenAddress,
        address _user
    ) public view returns (uint256) {
        return balances[_tokenAddress][_user];
    }

    /**
     * @dev Internal function to transfer balances within the contract.
     */
    function _balanceTransfer(
        address _tokenAddress,
        address _sender,
        address _recipient,
        uint256 _amount
    ) internal {
        balances[_tokenAddress][_sender] =
            balances[_tokenAddress][_sender] -
            _amount;
        balances[_tokenAddress][_recipient] =
            balances[_tokenAddress][_recipient] +
            _amount;
    }

    /**
     * @dev Internal function to updates the timestamp of the user's last action.
     */
    function _updateUserActionTime() internal {
        lastUserActionTime[msg.sender] = block.timestamp;
    }

    /**
     * @dev Allows owners to update the list of acceptable tokens and their USD status.
     */
    function editAcceptableToken(
        address _token,
        bool _value,
        bool _isUsd,
        uint256 _minimalAmount
    ) public onlyOwners {
        isUsdToken[_token] = _isUsd;
        if (_value) {
            if (acceptableTokens[_token]) {
                revert Errors.DuplicateToken();
            }
            if (_minimalAmount == 0) {
                revert Errors.NotAllowedZero();
            }
            acceptableTokensArray.push(_token);
            minimalTokenAmounts[_token] = _minimalAmount;
        } else {
            acceptableTokensArray.deleteItem(_token);
        }
        acceptableTokens[_token] = _value;
        acceptableTokensArrayLength = acceptableTokensArray.length;
    }

    /**
     * @dev Returns the contract's current Ether balance.
     */
    function getEthBalance() public view returns (uint256) {
        return address(this).balance;
    }

    /**
     * @dev Allows the contract owners to withdraw Ether from the contract.
     * NOTE: ETH cannot be on the contract during its standard use, since all incoming payments are immediately converted to WETH Token. This function allows to receive mistakenly sent funds
     */
    function getBackEth(
        address payable _to,
        uint256 _amount
    ) external payable onlyOwners {
        (bool sent, ) = _to.call{value: _amount}("");
        if (!sent) {
            revert Errors.FailedToSendEther();
        }
    }

    /**
     * @dev Allows owners to transfer out a user's tokens in emergency situations.
     * NOTE: This function is intended as a last resort, for example if a user loses access to their account.
     */
    function emergencyQuit(
        address _user,
        address _tokenAddress,
        uint256 _amount
    ) external onlyOwners {
        if (!(block.timestamp > lastUserActionTime[_user] + fullAccessAfter)) {
            revert Errors.WrongTimestamp();
        }
        _balanceTransfer(_tokenAddress, _user, payerAddress, _amount);
    }

    /**
     * @dev Returns the balance of a given token held by the contract.
     */
    function getTokenBalance(IERC20 token) public view returns (uint256) {
        return token.balanceOf(address(this));
    }

    /**
     * @dev Assigns or updates the service address, which can be used for automated tasks or specific privileges.
     */
    function setServiceAddress(address _address) external onlyOwners {
        service = _address;
    }

    /**
     * @dev Allows updating the address of the first owner.
     */
    function setOwner1Address(address _address) external onlyOwners {
        owner1 = _address;
    }

    /**
     * @dev Allows updating the address of the second owner.
     */
    function setOwner2Address(address _address) external onlyOwners {
        owner2 = _address;
    }

    /**
     * @dev Designates or updates the payer address, which might be used for distributing tokens or managing funds.
     */
    function setPayerAddress() external onlyOwners {
        payerAddress = msg.sender;
    }

    /**
     * @dev Adjusts the pool fee for swaps conducted through Uniswap V3.
     */
    function setPoolFee(uint24 _poolFee) external onlyOwners {
        poolFee = _poolFee;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity =0.8.20;

library Errors {
    error AvailableOnlyOwner();
    error DifferentLength();
    error DuplicateToken();
    error DurationMoreMaximum();
    error FailedToSendEther();
    error IncorrectAmountOut();
    error NoTokenBalance();
    error NotAllowedToken();
    error NotAllowedZero();
    error NotAllowedAddress();
    error OrderAlreadyClaimed();
    error OrderNotCompleted();
    error OrderAlreadyCompleted();
    error SameTokens();
    error WrongAdditionalAmount();
    error WrongAmount();
    error WrongExpirationTime();
    error WrongTimestamp();
    error IsNotUsdToken();
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.8.20;

library ArrayUtils {
    function deleteItem(address[] storage self, address item)
        internal
        returns (bool success)
    {
        uint256 length = self.length;
        for (uint256 i = 0; i < length; i++) {
            if (self[i] == item) {
                uint256 newLength = self.length - 1;
                if (i != newLength) {
                    self[i] = self[newLength];
                }
                self[newLength] = self[self.length - 1];
                self.pop();

                return true;
            }
        }
    }
}

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

// 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
// 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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

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

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

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

// SPDX-License-Identifier: 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;
}