Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;

// libraries
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../core/libraries/TransferHelper.sol";
import "./libraries/PoolAddress.sol";
import "./libraries/Path.sol";

// interfaces
import "../core/interfaces/ISmardexFactory.sol";
import "../core/interfaces/ISmardexPair.sol";
import "./interfaces/ISmardexRouter.sol";
import "./interfaces/IWETH.sol";

/**
 * @title SmardexRouter
 * @notice Router for execution of swaps and liquidity management on SmardexPair
 */
contract SmardexRouter is ISmardexRouter {
    using Path for bytes;
    using Path for address[];
    using SafeCast for uint256;
    using SafeCast for int256;

    /**
     * @notice : callback data for swap
     * @param path : path of the swap, array of token addresses tightly packed
     * @param payer : address of the payer for the swap
     */
    struct SwapCallbackData {
        bytes path;
        address payer;
    }

    address public immutable factory;
    address public immutable WETH;

    /// @dev Used as the placeholder value for amountInCached, because the computed amount in for an exact output swap
    /// can never actually be this value
    uint256 private constant DEFAULT_AMOUNT_IN_CACHED = type(uint256).max;

    /// @dev Transient storage variable used for returning the computed amount in for an exact output swap.
    uint256 private amountInCached = DEFAULT_AMOUNT_IN_CACHED;

    modifier ensure(uint256 deadline) {
        require(deadline >= block.timestamp, "SmarDexRouter: EXPIRED");
        _;
    }

    constructor(address _factory, address _WETH) {
        factory = _factory;
        WETH = _WETH;
    }

    receive() external payable {
        assert(msg.sender == WETH); // only accept ETH via fallback from the WETH contract
    }

    /// @inheritdoc ISmardexSwapCallback
    function smardexSwapCallback(int256 _amount0Delta, int256 _amount1Delta, bytes calldata _data) external override {
        require(_amount0Delta > 0 || _amount1Delta > 0, "SmardexRouter: Callback Invalid amount");

        SwapCallbackData memory _decodedData = abi.decode(_data, (SwapCallbackData));
        (address _tokenIn, address _tokenOut) = _decodedData.path.decodeFirstPool();

        // ensure that msg.sender is a pair
        require(msg.sender == PoolAddress.pairFor(factory, _tokenIn, _tokenOut), "SmarDexRouter: INVALID_PAIR");

        (bool _isExactInput, uint256 _amountToPay) = _amount0Delta > 0
            ? (_tokenIn < _tokenOut, uint256(_amount0Delta))
            : (_tokenOut < _tokenIn, uint256(_amount1Delta));

        if (_isExactInput) {
            pay(_tokenIn, _decodedData.payer, msg.sender, _amountToPay);
        } else if (_decodedData.path.hasMultiplePools()) {
            _decodedData.path = _decodedData.path.skipToken();
            _swapExactOut(_amountToPay, msg.sender, _decodedData);
        } else {
            amountInCached = _amountToPay;
            _tokenIn = _tokenOut; // swap in/out because exact output swaps are reversed
            pay(_tokenIn, _decodedData.payer, msg.sender, _amountToPay);
        }
    }

    /**
     * @notice send tokens to a user. Handle transfer/transferFrom and WETH / ETH or any ERC20 token
     * @param _token The token to pay
     * @param _payer The entity that must pay
     * @param _to The entity that will receive payment
     * @param _value The amount to pay
     *
     * @custom:from UniV3 PeripheryPayments.sol
     * @custom:url https://github.com/Uniswap/v3-periphery/blob/v1.3.0/contracts/base/PeripheryPayments.sol
     */
    function pay(address _token, address _payer, address _to, uint256 _value) internal {
        if (_token == WETH && address(this).balance >= _value) {
            // pay with WETH
            IWETH(WETH).deposit{ value: _value }(); // wrap only what is needed to pay
            IWETH(WETH).transfer(_to, _value);
            //refund dust eth, if any ?
        } else if (_payer == address(this)) {
            // pay with tokens already in the contract (for the exact input multihop case)
            TransferHelper.safeTransfer(_token, _to, _value);
        } else {
            // pull payment
            TransferHelper.safeTransferFrom(_token, _payer, _to, _value);
        }
    }

    ///@inheritdoc ISmardexMintCallback
    function smardexMintCallback(MintCallbackData calldata _data) external override {
        // ensure that msg.sender is a pair
        require(msg.sender == PoolAddress.pairFor(factory, _data.token0, _data.token1), "SmarDexRouter: INVALID_PAIR");
        require(_data.amount0 > 0 || _data.amount1 > 0, "SmardexRouter: Callback Invalid amount");

        pay(_data.token0, _data.payer, msg.sender, _data.amount0);
        pay(_data.token1, _data.payer, msg.sender, _data.amount1);
    }

    /// @inheritdoc ISmardexRouter
    function addLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _amountADesired,
        uint256 _amountBDesired,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline
    ) external virtual override ensure(_deadline) returns (uint256 amountA_, uint256 amountB_, uint256 liquidity_) {
        (amountA_, amountB_) = _addLiquidity(
            _tokenA,
            _tokenB,
            _amountADesired,
            _amountBDesired,
            _amountAMin,
            _amountBMin
        );
        address _pair = PoolAddress.pairFor(factory, _tokenA, _tokenB);
        bool _orderedPair = _tokenA < _tokenB;
        liquidity_ = ISmardexPair(_pair).mint(
            _to,
            _orderedPair ? amountA_ : amountB_,
            _orderedPair ? amountB_ : amountA_,
            msg.sender
        );
    }

    /// @inheritdoc ISmardexRouter
    function addLiquidityETH(
        address _token,
        uint256 _amountTokenDesired,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    )
        external
        payable
        virtual
        override
        ensure(_deadline)
        returns (uint256 amountToken_, uint256 amountETH_, uint256 liquidity_)
    {
        (amountToken_, amountETH_) = _addLiquidity(
            _token,
            WETH,
            _amountTokenDesired,
            msg.value,
            _amountTokenMin,
            _amountETHMin
        );

        address _pair = PoolAddress.pairFor(factory, _token, WETH);
        bool _orderedPair = _token < WETH;

        liquidity_ = ISmardexPair(_pair).mint(
            _to,
            _orderedPair ? amountToken_ : amountETH_,
            _orderedPair ? amountETH_ : amountToken_,
            msg.sender
        );

        // refund dust eth, if any
        if (msg.value > amountETH_) {
            TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH_);
        }
    }

    /// @inheritdoc ISmardexRouter
    function removeLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _liquidity,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline
    ) public virtual override ensure(_deadline) returns (uint256 amountA_, uint256 amountB_) {
        address _pair = PoolAddress.pairFor(factory, _tokenA, _tokenB);
        ISmardexPair(_pair).transferFrom(msg.sender, _pair, _liquidity); // send liquidity to pair

        (uint256 _amount0, uint256 _amount1) = ISmardexPair(_pair).burn(_to);
        (address _token0, ) = PoolHelpers.sortTokens(_tokenA, _tokenB);
        (amountA_, amountB_) = _tokenA == _token0 ? (_amount0, _amount1) : (_amount1, _amount0);

        require(amountA_ >= _amountAMin, "SmarDexRouter: INSUFFICIENT_A_AMOUNT");
        require(amountB_ >= _amountBMin, "SmarDexRouter: INSUFFICIENT_B_AMOUNT");
    }

    /// @inheritdoc ISmardexRouter
    function removeLiquidityETH(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    ) public virtual override ensure(_deadline) returns (uint256 amountToken_, uint256 amountETH_) {
        (amountToken_, amountETH_) = removeLiquidity(
            _token,
            WETH,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            address(this),
            _deadline
        );
        TransferHelper.safeTransfer(_token, _to, amountToken_);
        IWETH(WETH).withdraw(amountETH_);
        TransferHelper.safeTransferETH(_to, amountETH_);
    }

    /// @inheritdoc ISmardexRouter
    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 virtual override returns (uint256 amountA_, uint256 amountB_) {
        address _pair = PoolAddress.pairFor(factory, _tokenA, _tokenB);
        uint256 _value = _approveMax ? type(uint256).max : _liquidity;
        ISmardexPair(_pair).permit(msg.sender, address(this), _value, _deadline, _v, _r, _s);
        (amountA_, amountB_) = removeLiquidity(_tokenA, _tokenB, _liquidity, _amountAMin, _amountBMin, _to, _deadline);
    }

    /// @inheritdoc ISmardexRouter
    function removeLiquidityETHWithPermit(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline,
        bool _approveMax,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    ) external virtual override returns (uint256 amountToken_, uint256 amountETH_) {
        address _pair = PoolAddress.pairFor(factory, _token, WETH);
        uint256 _value = _approveMax ? type(uint256).max : _liquidity;
        ISmardexPair(_pair).permit(msg.sender, address(this), _value, _deadline, _v, _r, _s);
        (amountToken_, amountETH_) = removeLiquidityETH(
            _token,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            _to,
            _deadline
        );
    }

    /// @inheritdoc ISmardexRouter
    function swapExactTokensForTokens(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] memory _path,
        address _to,
        uint256 _deadline
    ) public virtual override ensure(_deadline) returns (uint256 amountOut_) {
        address _payer = msg.sender; // msg.sender pays for the first hop

        bytes memory _bytesPath = _path.encodeTightlyPacked(); //could be done in the caller function
        while (true) {
            bool _hasMultiplePools = _bytesPath.hasMultiplePools();

            // the outputs of prior swaps become the inputs to subsequent ones
            _amountIn = _swapExactIn(
                _amountIn,
                // for intermediate swaps, this contract custodies
                _hasMultiplePools ? address(this) : _to,
                // only the first pool in the path is necessary
                SwapCallbackData({ path: _bytesPath.getFirstPool(), payer: _payer })
            );

            // decide whether to continue or terminate
            if (_hasMultiplePools) {
                _payer = address(this); // at this point, the caller has paid
                _bytesPath = _bytesPath.skipToken();
            } else {
                // amountOut of the final swap is the last amountIn captured in the loop
                amountOut_ = _amountIn;
                break;
            }
        }
        require(amountOut_ >= _amountOutMin, "SmarDexRouter: INSUFFICIENT_OUTPUT_AMOUNT");
    }

    /// @inheritdoc ISmardexRouter
    function swapTokensForExactTokens(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) public virtual override ensure(_deadline) returns (uint256 amountIn_) {
        // Path needs to be reversed as to get the amountIn that we will ask from next pair hop
        bytes memory _reversedPath = _path.encodeTightlyPackedReversed();
        amountIn_ = _swapExactOut(_amountOut, _to, SwapCallbackData({ path: _reversedPath, payer: msg.sender }));
        // amount In is only the right one for one Hop, otherwise we need cached amountIn from callback
        if (_path.length > 2) amountIn_ = amountInCached;
        require(amountIn_ <= _amountInMax, "SmarDexRouter: EXCESSIVE_INPUT_AMOUNT");
        amountInCached = DEFAULT_AMOUNT_IN_CACHED;

        _refundETH(_to);
    }

    /// @inheritdoc ISmardexRouter
    function swapTokensForExactETH(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external virtual override ensure(_deadline) returns (uint256 amountIn_) {
        require(_path[_path.length - 1] == WETH, "SmarDexRouter: INVALID_PATH");
        amountIn_ = swapTokensForExactTokens(_amountOut, _amountInMax, _path, address(this), _deadline);
        _unwrapWETH(_amountOut, _to);
    }

    /// @inheritdoc ISmardexRouter
    function swapETHForExactTokens(
        uint256 _amountOut,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external payable virtual override ensure(_deadline) returns (uint256 amountIn_) {
        require(_path[0] == WETH, "SmarDexRouter: INVALID_PATH");
        amountIn_ = swapTokensForExactTokens(_amountOut, msg.value, _path, _to, _deadline);
    }

    /// @inheritdoc ISmardexRouter
    function swapExactETHForTokens(
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external payable virtual override ensure(_deadline) returns (uint256 amountOut_) {
        require(_path[0] == WETH, "SmarDexRouter: INVALID_PATH");
        amountOut_ = swapExactTokensForTokens(msg.value, _amountOutMin, _path, _to, _deadline);
    }

    /// @inheritdoc ISmardexRouter
    function swapExactTokensForETH(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external virtual override ensure(_deadline) returns (uint256 amountOut_) {
        require(_path[_path.length - 1] == WETH, "SmarDexRouter: INVALID_PATH");
        amountOut_ = swapExactTokensForTokens(_amountIn, _amountOutMin, _path, address(this), _deadline);
        _unwrapWETH(amountOut_, _to);
    }

    /**
     * @notice internal function to unwrap WETH to ETH after swap
     * @param _amountMinimum minimum amount of WETH that the contract should have
     * @param _to address that will receive the ETH unwrapped
     *
     * @custom:from UniV3 PeripheryPayments.sol
     * @custom:url https://github.com/Uniswap/v3-periphery/blob/v1.3.0/contracts/base/PeripheryPayments.sol
     */
    function _unwrapWETH(uint256 _amountMinimum, address _to) internal {
        uint256 _balanceWETH = IERC20(WETH).balanceOf(address(this));
        require(_balanceWETH >= _amountMinimum, "Insufficient WETH");

        if (_balanceWETH > 0) {
            IWETH(WETH).withdraw(_balanceWETH);
            TransferHelper.safeTransferETH(_to, _balanceWETH);
        }
    }

    /**
     * @notice internal function to send all ETH of the contract. Do not fail if the contract does not have any ETH
     * @param _to address that will receive the ETH
     *
     * @custom:from UniV3 PeripheryPayments.sol
     * @custom:url https://github.com/Uniswap/v3-periphery/blob/v1.3.0/contracts/base/PeripheryPayments.sol
     */
    function _refundETH(address _to) private {
        if (address(this).balance > 0) {
            TransferHelper.safeTransferETH(_to, address(this).balance);
        }
    }

    /**
     * @notice internal function to swap quantity of token to receive a determined quantity
     * @param _amountOut quantity to receive
     * @param _to address that will receive the token
     * @param _data SwapCallbackData data of the swap to transmit
     * @return amountIn_ amount of token to pay
     */
    function _swapExactOut(
        uint256 _amountOut,
        address _to,
        SwapCallbackData memory _data
    ) private returns (uint256 amountIn_) {
        // allow swapping to the router address with address 0
        if (_to == address(0)) {
            _to = address(this);
        }

        (address _tokenOut, address _tokenIn) = _data.path.decodeFirstPool();
        bool _zeroForOne = _tokenIn < _tokenOut;

        // do the swap
        (int256 _amount0, int256 _amount1) = ISmardexPair(PoolAddress.pairFor(factory, _tokenIn, _tokenOut)).swap(
            _to,
            _zeroForOne,
            -_amountOut.toInt256(),
            abi.encode(_data)
        );

        amountIn_ = _zeroForOne ? uint256(_amount0) : uint256(_amount1);
    }

    /**
     * @notice Add liquidity to an ERC-20=ERC-20 pool. Receive liquidity token to materialize shares in the pool
     * @param _tokenA address of the first token in the pair
     * @param _tokenB address of the second token in the pair
     * @param _amountADesired The amount of tokenA to add as liquidity
     * if the B/A price is <= amountBDesired/amountADesired
     * @param _amountBDesired The amount of tokenB to add as liquidity
     * if the A/B price is <= amountADesired/amountBDesired
     * @param _amountAMin Bounds the extent to which the B/A price can go up before the transaction reverts.
     * Must be <= amountADesired.
     * @param _amountBMin Bounds the extent to which the A/B price can go up before the transaction reverts.
     * Must be <= amountBDesired.
     * @return amountA_ The amount of tokenA sent to the pool.
     * @return amountB_ The amount of tokenB sent to the pool.
     */
    function _addLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _amountADesired,
        uint256 _amountBDesired,
        uint256 _amountAMin,
        uint256 _amountBMin
    ) internal virtual returns (uint256 amountA_, uint256 amountB_) {
        // create the pair if it doesn't exist yet
        if (ISmardexFactory(factory).getPair(_tokenA, _tokenB) == address(0)) {
            ISmardexFactory(factory).createPair(_tokenA, _tokenB);
        }
        (uint256 _reserveA, uint256 _reserveB) = PoolHelpers.getReserves(factory, _tokenA, _tokenB);
        if (_reserveA == 0 && _reserveB == 0) {
            (amountA_, amountB_) = (_amountADesired, _amountBDesired);
        } else {
            uint256 _amountBOptimal = PoolHelpers.quote(_amountADesired, _reserveA, _reserveB);
            if (_amountBOptimal <= _amountBDesired) {
                require(_amountBOptimal >= _amountBMin, "SmarDexRouter: INSUFFICIENT_B_AMOUNT");
                (amountA_, amountB_) = (_amountADesired, _amountBOptimal);
            } else {
                uint256 _amountAOptimal = PoolHelpers.quote(_amountBDesired, _reserveB, _reserveA);
                assert(_amountAOptimal <= _amountADesired);
                require(_amountAOptimal >= _amountAMin, "SmarDexRouter: INSUFFICIENT_A_AMOUNT");
                (amountA_, amountB_) = (_amountAOptimal, _amountBDesired);
            }
        }
    }

    /**
     * @notice internal function to swap a determined quantity of token
     * @param _amountIn quantity to swap
     * @param _to address that will receive the token
     * @param _data SwapCallbackData data of the swap to transmit
     * @return amountOut_ amount of token that _to will receive
     */
    function _swapExactIn(
        uint256 _amountIn,
        address _to,
        SwapCallbackData memory _data
    ) internal returns (uint256 amountOut_) {
        // allow swapping to the router address with address 0
        if (_to == address(0)) {
            _to = address(this);
        }

        (address _tokenIn, address _tokenOut) = _data.path.decodeFirstPool();
        bool _zeroForOne = _tokenIn < _tokenOut;
        (int256 _amount0, int256 _amount1) = ISmardexPair(PoolAddress.pairFor(factory, _tokenIn, _tokenOut)).swap(
            _to,
            _zeroForOne,
            _amountIn.toInt256(),
            abi.encode(_data)
        );

        amountOut_ = (_zeroForOne ? -_amount1 : -_amount0).toUint256();
    }

    /// @inheritdoc ISmardexRouter
    function quote(
        uint256 _amountA,
        uint256 _reserveA,
        uint256 _reserveB
    ) public pure virtual override returns (uint256 amountB_) {
        return PoolHelpers.quote(_amountA, _reserveA, _reserveB);
    }

    /// @inheritdoc ISmardexRouter
    function getAmountOut(
        uint256 _amountIn,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        external
        pure
        returns (
            uint256 amountOut_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        (amountOut_, newReserveIn_, newReserveOut_, newFictiveReserveIn_, newFictiveReserveOut_) = SmardexLibrary
            .getAmountOut(
                _amountIn,
                _reserveIn,
                _reserveOut,
                _fictiveReserveIn,
                _fictiveReserveOut,
                _priceAverageIn,
                _priceAverageOut
            );
    }

    /// @inheritdoc ISmardexRouter
    function getAmountIn(
        uint256 _amountOut,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        external
        pure
        returns (
            uint256 amountIn_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        (amountIn_, newReserveIn_, newReserveOut_, newFictiveReserveIn_, newFictiveReserveOut_) = SmardexLibrary
            .getAmountIn(
                _amountOut,
                _reserveIn,
                _reserveOut,
                _fictiveReserveIn,
                _fictiveReserveOut,
                _priceAverageIn,
                _priceAverageOut
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.2._
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v2.5._
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.2._
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v2.5._
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v2.5._
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v2.5._
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v2.5._
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     *
     * _Available since v3.0._
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     *
     * _Available since v3.0._
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

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

interface ISmardexFactory {
    /**
     * @notice emitted at each SmardexPair created
     * @param token0 address of the token0
     * @param token1 address of the token1
     * @param pair address of the SmardexPair created
     * @param totalPair number of SmardexPair created so far
     */
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256 totalPair);

    /**
     * @notice return which address fees will be transferred
     */
    function feeTo() external view returns (address);

    /**
     * @notice return which address can update feeTo
     */
    function feeToSetter() external view returns (address);

    /**
     * @notice return the address of the pair of 2 tokens
     */
    function getPair(address _tokenA, address _tokenB) external view returns (address pair_);

    /**
     * @notice return the address of the pair at index
     * @param _index index of the pair
     * @return pair_ address of the pair
     */
    function allPairs(uint256 _index) external view returns (address pair_);

    /**
     * @notice return the quantity of pairs
     * @return quantity in uint256
     */
    function allPairsLength() external view returns (uint256);

    /**
     * @notice create pair with 2 address
     * @param _tokenA address of tokenA
     * @param _tokenB address of tokenB
     * @return pair_ address of the pair created
     */
    function createPair(address _tokenA, address _tokenB) external returns (address pair_);

    /**
     * @notice set the address who will receive fees, can only be call by feeToSetter
     * @param _feeTo address to replace
     */
    function setFeeTo(address _feeTo) external;

    /**
     * @notice set the address who can update feeTo, can only be call by feeToSetter
     * @param _feeToSetter address to replace
     */
    function setFeeToSetter(address _feeToSetter) external;
}

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

interface ISmardexMintCallback {
    /**
     * @notice callback data for mint
     * @param token0 address of the first token of the pair
     * @param token1 address of the second token of the pair
     * @param amount0 amount of token0 to provide
     * @param amount1 amount of token1 to provide
     * @param payer address of the payer to provide token for the mint
     */
    struct MintCallbackData {
        address token0;
        address token1;
        uint256 amount0;
        uint256 amount1;
        address payer;
    }

    /**
     * @notice callback to implement when calling SmardexPair.mint
     * @param _data callback data for mint
     */
    function smardexMintCallback(MintCallbackData calldata _data) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.8.17;

// interfaces
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";

interface ISmardexPair is IERC20, IERC20Permit {
    /**
     * @notice emitted at each mint
     * @param sender address calling the mint function (usualy the Router contract)
     * @param to address that receives the LP-tokens
     * @param amount0 amount of token0 to be added in liquidity
     * @param amount1 amount of token1 to be added in liquidity
     * @dev the amount of LP-token sent can be caught using the transfer event of the pair
     */
    event Mint(address indexed sender, address indexed to, uint256 amount0, uint256 amount1);

    /**
     * @notice emitted at each burn
     * @param sender address calling the burn function (usualy the Router contract)
     * @param to address that receives the tokens
     * @param amount0 amount of token0 to be withdrawn
     * @param amount1 amount of token1 to be withdrawn
     * @dev the amount of LP-token sent can be caught using the transfer event of the pair
     */
    event Burn(address indexed sender, address indexed to, uint256 amount0, uint256 amount1);

    /**
     * @notice emitted at each swap
     * @param sender address calling the swap function (usualy the Router contract)
     * @param to address that receives the out-tokens
     * @param amount0 amount of token0 to be swapped
     * @param amount1 amount of token1 to be swapped
     * @dev one of the 2 amount is always negative, the other one is always positive. The positive one is the one that
     * the user send to the contract, the negative one is the one that the contract send to the user.
     */
    event Swap(address indexed sender, address indexed to, int256 amount0, int256 amount1);

    /**
     * @notice emitted each time the fictive reserves are changed (mint, burn, swap)
     * @param reserve0 the new reserve of token0
     * @param reserve1 the new reserve of token1
     * @param fictiveReserve0 the new fictive reserve of token0
     * @param fictiveReserve1 the new fictive reserve of token1
     * @param priceAverage0 the new priceAverage of token0
     * @param priceAverage1 the new priceAverage of token1
     */
    event Sync(
        uint256 reserve0,
        uint256 reserve1,
        uint256 fictiveReserve0,
        uint256 fictiveReserve1,
        uint256 priceAverage0,
        uint256 priceAverage1
    );

    /**
     * @notice get the factory address
     * @return address of the factory
     */
    function factory() external view returns (address);

    /**
     * @notice get the token0 address
     * @return address of the token0
     */
    function token0() external view returns (address);

    /**
     * @notice get the token1 address
     * @return address of the token1
     */
    function token1() external view returns (address);

    /**
     * @notice called once by the factory at time of deployment
     * @param _token0 address of token0
     * @param _token1 address of token1
     */
    function initialize(address _token0, address _token1) external;

    /**
     * @notice return current Reserves of both token in the pair,
     *  corresponding to token balance - pending fees
     * @return reserve0_ current reserve of token0 - pending fee0
     * @return reserve1_ current reserve of token1 - pending fee1
     */
    function getReserves() external view returns (uint256 reserve0_, uint256 reserve1_);

    /**
     * @notice return current Fictives Reserves of both token in the pair
     * @return fictiveReserve0_ current fictive reserve of token0
     * @return fictiveReserve1_ current fictive reserve of token1
     */
    function getFictiveReserves() external view returns (uint256 fictiveReserve0_, uint256 fictiveReserve1_);

    /**
     * @notice return current pending fees of both token in the pair
     * @return fees0_ current pending fees of token0
     * @return fees1_ current pending fees of token1
     */
    function getFees() external view returns (uint256 fees0_, uint256 fees1_);

    /**
     * @notice return last updated price average at timestamp of both token in the pair,
     *  read price0Average/price1Average for current price of token0/token1
     * @return priceAverage0_ current price for token0
     * @return priceAverage1_ current price for token1
     * @return blockTimestampLast_ last block timestamp when price was updated
     */
    function getPriceAverage()
        external
        view
        returns (uint256 priceAverage0_, uint256 priceAverage1_, uint256 blockTimestampLast_);

    /**
     * @notice return current price average of both token in the pair for provided currentTimeStamp
     *  read price0Average/price1Average for current price of token0/token1
     * @param _fictiveReserveIn,
     * @param _fictiveReserveOut,
     * @param _priceAverageLastTimestamp,
     * @param _priceAverageIn current price for token0
     * @param _priceAverageOut current price for token1
     * @param _currentTimestamp block timestamp to get price
     * @return priceAverageIn_ current price for token0
     * @return priceAverageOut_ current price for token1
     */
    function getUpdatedPriceAverage(
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageLastTimestamp,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut,
        uint256 _currentTimestamp
    ) external pure returns (uint256 priceAverageIn_, uint256 priceAverageOut_);

    /**
     * @notice Mint lp tokens proportionally of added tokens in balance. Should be called from a contract
     * that makes safety checks like the SmardexRouter
     * @param _to address who will receive minted tokens
     * @param _amount0 amount of token0 to provide
     * @param _amount1 amount of token1 to provide
     * @return liquidity_ amount of lp tokens minted and sent to the address defined in parameter
     */
    function mint(
        address _to,
        uint256 _amount0,
        uint256 _amount1,
        address _payer
    ) external returns (uint256 liquidity_);

    /**
     * @notice Burn lp tokens in the balance of the contract. Sends to the defined address the amount of token0 and
     * token1 proportionally of the amount burned. Should be called from a contract that makes safety checks like the
     * SmardexRouter
     * @param _to address who will receive tokens
     * @return amount0_ amount of token0 sent to the address defined in parameter
     * @return amount1_ amount of token0 sent to the address defined in parameter
     */
    function burn(address _to) external returns (uint256 amount0_, uint256 amount1_);

    /**
     * @notice Swaps tokens. Sends to the defined address the amount of token0 and token1 defined in parameters.
     * Tokens to trade should be already sent in the contract.
     * Swap function will check if the resulted balance is correct with current reserves and reserves fictive.
     * Should be called from a contract that makes safety checks like the SmardexRouter
     * @param _to address who will receive tokens
     * @param _zeroForOne token0 to token1
     * @param _amountSpecified amount of token wanted
     * @param _data used for flash swap, data.length must be 0 for regular swap
     */
    function swap(
        address _to,
        bool _zeroForOne,
        int256 _amountSpecified,
        bytes calldata _data
    ) external returns (int256 amount0_, int256 amount1_);
}

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

interface ISmardexSwapCallback {
    /**
     * @notice callback data for swap
     * @param _amount0Delta amount of token0 for the swap (negative is incoming, positive is required to pay to pair)
     * @param _amount1Delta amount of token1 for the swap (negative is incoming, positive is required to pay to pair)
     * @param _data for Router path and payer for the swap (see router for details)
     */
    function smardexSwapCallback(int256 _amount0Delta, int256 _amount1Delta, bytes calldata _data) external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.17;

// libraries
import "@openzeppelin/contracts/utils/math/Math.sol";

// interfaces
import "../interfaces/ISmardexPair.sol";

library SmardexLibrary {
    /// @notice amount of fees sent to LP, not in percent but in FEES_BASE
    uint256 public constant FEES_LP = 5;

    /// @notice amount of fees sent to the pool, not in percent but in FEES_BASE. if feeTo is null, sent to the LP
    uint256 public constant FEES_POOL = 2;

    /// @notice total amount of fees, not in percent but in FEES_BASE
    uint256 public constant FEES_TOTAL = FEES_LP + FEES_POOL;

    /// @notice base of the FEES
    uint256 public constant FEES_BASE = 10000;

    /// @notice ratio of quantity that is send to the user, after removing the fees, not in percent but in FEES_BASE
    uint256 public constant REVERSE_FEES_TOTAL = FEES_BASE - FEES_TOTAL;

    /// @notice precision for approxEq, not in percent but in APPROX_PRECISION_BASE
    uint256 public constant APPROX_PRECISION = 1;

    /// @notice base of the APPROX_PRECISION
    uint256 public constant APPROX_PRECISION_BASE = 1_000_000;

    /// @notice number of seconds to reset priceAverage
    uint256 private constant MAX_BLOCK_DIFF_SECONDS = 300;

    /**
     * @notice check if 2 numbers are approximatively equal, using APPROX_PRECISION
     * @param _x number to compare
     * @param _y number to compare
     * @return true if numbers are approximatively equal, false otherwise
     */
    function approxEq(uint256 _x, uint256 _y) internal pure returns (bool) {
        if (_x > _y) {
            return _x < (_y + (_y * APPROX_PRECISION) / APPROX_PRECISION_BASE);
        } else {
            return _y < (_x + (_x * APPROX_PRECISION) / APPROX_PRECISION_BASE);
        }
    }

    /**
     * @notice check if 2 ratio are approximatively equal: _xNum _/ xDen ~= _yNum / _yDen
     * @param _xNum numerator of the first ratio to compare
     * @param _xDen denominator of the first ratio to compare
     * @param _yNum numerator of the second ratio to compare
     * @param _yDen denominator of the second ratio to compare
     * @return true if ratio are approximatively equal, false otherwise
     */
    function ratioApproxEq(uint256 _xNum, uint256 _xDen, uint256 _yNum, uint256 _yDen) internal pure returns (bool) {
        return approxEq(_xNum * _yDen, _xDen * _yNum);
    }

    /**
     * @notice update priceAverage given old timestamp, new timestamp and prices
     * @param _fictiveReserveIn ratio component of the new price of the in-token
     * @param _fictiveReserveOut ratio component of the new price of the out-token
     * @param _priceAverageLastTimestamp timestamp of the last priceAvregae update (0, if never updated)
     * @param _priceAverageIn ratio component of the last priceAverage of the in-token
     * @param _priceAverageOut ratio component of the last priceAverage of the out-token
     * @param _currentTimestamp timestamp of the priceAverage to update
     * @return newPriceAverageIn_ ratio component of the updated priceAverage of the in-token
     * @return newPriceAverageOut_ ratio component of the updated priceAverage of the out-token
     */
    function getUpdatedPriceAverage(
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageLastTimestamp,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut,
        uint256 _currentTimestamp
    ) internal pure returns (uint256 newPriceAverageIn_, uint256 newPriceAverageOut_) {
        require(_currentTimestamp >= _priceAverageLastTimestamp, "SmardexPair: INVALID_TIMESTAMP");

        // very first time
        if (_priceAverageLastTimestamp == 0) {
            newPriceAverageIn_ = _fictiveReserveIn;
            newPriceAverageOut_ = _fictiveReserveOut;
        }
        // another tx has been done in the same block
        else if (_priceAverageLastTimestamp == _currentTimestamp) {
            newPriceAverageIn_ = _priceAverageIn;
            newPriceAverageOut_ = _priceAverageOut;
        }
        // need to compute new linear-average price
        else {
            // compute new price:
            uint256 _timeDiff = Math.min(_currentTimestamp - _priceAverageLastTimestamp, MAX_BLOCK_DIFF_SECONDS);

            newPriceAverageIn_ = _fictiveReserveIn;
            newPriceAverageOut_ =
                (((MAX_BLOCK_DIFF_SECONDS - _timeDiff) * _priceAverageOut * newPriceAverageIn_) /
                    _priceAverageIn +
                    _timeDiff *
                    _fictiveReserveOut) /
                MAX_BLOCK_DIFF_SECONDS;
        }
    }

    /**
     * @notice compute the firstTradeAmountIn so that the price reach the price Average
     * @param _amountIn the amountIn requested, it's the maximum possible value for firstAmountIn_
     * @param _fictiveReserveIn fictive reserve of the in-token
     * @param _fictiveReserveOut fictive reserve of the out-token
     * @param _priceAverageIn ratio component of the priceAverage of the in-token
     * @param _priceAverageOut ratio component of the priceAverage of the out-token
     * @return firstAmountIn_ the first amount of in-token
     *
     * @dev if the trade is going in the direction that the price will never reach the priceAverage, or if _amountIn
     * is not big enough to reach the priceAverage or if the price is already equal to the priceAverage, then
     * firstAmountIn_ will be set to _amountIn
     */
    function computeFirstTradeQtyIn(
        uint256 _amountIn,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    ) internal pure returns (uint256 firstAmountIn_) {
        // default value
        firstAmountIn_ = _amountIn;

        // if trade is in the good direction
        if (_fictiveReserveOut * _priceAverageIn > _fictiveReserveIn * _priceAverageOut) {
            // pre-compute all operands
            uint256 _toSub = _fictiveReserveIn * (FEES_BASE + REVERSE_FEES_TOTAL - FEES_POOL);
            uint256 _toDiv = (REVERSE_FEES_TOTAL + FEES_LP) << 1;
            uint256 _inSqrt = (((_fictiveReserveIn * _fictiveReserveOut) << 2) / _priceAverageOut) *
                _priceAverageIn *
                (REVERSE_FEES_TOTAL * (FEES_BASE - FEES_POOL)) +
                (_fictiveReserveIn * _fictiveReserveIn * (FEES_LP * FEES_LP));

            // reverse sqrt check to only compute sqrt if really needed
            if (_inSqrt < (_toSub + _amountIn * _toDiv) ** 2) {
                firstAmountIn_ = (Math.sqrt(_inSqrt) - _toSub) / _toDiv;
            }
        }
    }

    /**
     * @notice compute the firstTradeAmountOut so that the price reach the price Average
     * @param _amountOut the amountOut requested, it's the maximum possible value for firstAmountOut_
     * @param _fictiveReserveIn fictive reserve of the in-token
     * @param _fictiveReserveOut fictive reserve of the out-token
     * @param _priceAverageIn ratio component of the priceAverage of the in-token
     * @param _priceAverageOut ratio component of the priceAverage of the out-token
     * @return firstAmountOut_ the first amount of out-token
     *
     * @dev if the trade is going in the direction that the price will never reach the priceAverage, or if _amountOut
     * is not big enough to reach the priceAverage or if the price is already equal to the priceAverage, then
     * firstAmountOut_ will be set to _amountOut
     */
    function computeFirstTradeQtyOut(
        uint256 _amountOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    ) internal pure returns (uint256 firstAmountOut_) {
        // default value
        firstAmountOut_ = _amountOut;

        // if trade is in the good direction
        if (_fictiveReserveOut * _priceAverageIn > _fictiveReserveIn * _priceAverageOut) {
            // pre-compute all operands
            uint256 _fictiveReserveOutPredFees = (_fictiveReserveIn * FEES_LP * _priceAverageOut) / _priceAverageIn;
            uint256 _toAdd = ((_fictiveReserveOut * REVERSE_FEES_TOTAL) << 1) + _fictiveReserveOutPredFees;
            uint256 _toDiv = REVERSE_FEES_TOTAL << 1;
            uint256 _inSqrt = (((_fictiveReserveOut * _fictiveReserveOutPredFees) << 2) *
                (REVERSE_FEES_TOTAL * (FEES_BASE - FEES_POOL))) /
                FEES_LP +
                _fictiveReserveOutPredFees *
                _fictiveReserveOutPredFees;

            // reverse sqrt check to only compute sqrt if really needed
            if (_inSqrt > (_toAdd - _amountOut * _toDiv) ** 2) {
                firstAmountOut_ = (_toAdd - Math.sqrt(_inSqrt)) / _toDiv;
            }
        }
    }

    /**
     * @notice compute fictive reserves
     * @param _reserveIn reserve of the in-token
     * @param _reserveOut reserve of the out-token
     * @param _fictiveReserveIn fictive reserve of the in-token
     * @param _fictiveReserveOut fictive reserve of the out-token
     * @return newFictiveReserveIn_ new fictive reserve of the in-token
     * @return newFictiveReserveOut_ new fictive reserve of the out-token
     */
    function computeFictiveReserves(
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut
    ) internal pure returns (uint256 newFictiveReserveIn_, uint256 newFictiveReserveOut_) {
        if (_reserveOut * _fictiveReserveIn < _reserveIn * _fictiveReserveOut) {
            uint256 _temp = (((_reserveOut * _reserveOut) / _fictiveReserveOut) * _fictiveReserveIn) / _reserveIn;
            newFictiveReserveIn_ =
                (_temp * _fictiveReserveIn) /
                _fictiveReserveOut +
                (_reserveOut * _fictiveReserveIn) /
                _fictiveReserveOut;
            newFictiveReserveOut_ = _reserveOut + _temp;
        } else {
            newFictiveReserveIn_ = (_fictiveReserveIn * _reserveOut) / _fictiveReserveOut + _reserveIn;
            newFictiveReserveOut_ = (_reserveIn * _fictiveReserveOut) / _fictiveReserveIn + _reserveOut;
        }

        // div all values by 4
        newFictiveReserveIn_ >>= 2;
        newFictiveReserveOut_ >>= 2;
    }

    /**
     * @notice apply k const rule using fictive reserve, when the amountIn is specified
     * @param _amountIn qty of token that arrives in the contract
     * @param _reserveIn reserve of the in-token
     * @param _reserveOut reserve of the out-token
     * @param _fictiveReserveIn fictive reserve of the in-token
     * @param _fictiveReserveOut fictive reserve of the out-token
     * @return amountOut_ qty of token that leaves in the contract
     * @return newReserveIn_ new reserve of the in-token after the transaction
     * @return newReserveOut_ new reserve of the out-token after the transaction
     * @return newFictiveReserveIn_ new fictive reserve of the in-token after the transaction
     * @return newFictiveReserveOut_ new fictive reserve of the out-token after the transaction
     */
    function applyKConstRuleOut(
        uint256 _amountIn,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut
    )
        internal
        pure
        returns (
            uint256 amountOut_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        // k const rule
        uint256 _amountInWithFee = _amountIn * REVERSE_FEES_TOTAL;
        uint256 _numerator = _amountInWithFee * _fictiveReserveOut;
        uint256 _denominator = _fictiveReserveIn * FEES_BASE + _amountInWithFee;
        amountOut_ = _numerator / _denominator;

        // update new reserves and add lp-fees to pools
        uint256 _amountInWithFeeLp = (_amountInWithFee + (_amountIn * FEES_LP)) / FEES_BASE;
        newReserveIn_ = _reserveIn + _amountInWithFeeLp;
        newFictiveReserveIn_ = _fictiveReserveIn + _amountInWithFeeLp;
        newReserveOut_ = _reserveOut - amountOut_;
        newFictiveReserveOut_ = _fictiveReserveOut - amountOut_;
    }

    /**
     * @notice apply k const rule using fictive reserve, when the amountOut is specified
     * @param _amountOut qty of token that leaves in the contract
     * @param _reserveIn reserve of the in-token
     * @param _reserveOut reserve of the out-token
     * @param _fictiveReserveIn fictive reserve of the in-token
     * @param _fictiveReserveOut fictive reserve of the out-token
     * @return amountIn_ qty of token that arrives in the contract
     * @return newReserveIn_ new reserve of the in-token after the transaction
     * @return newReserveOut_ new reserve of the out-token after the transaction
     * @return newFictiveReserveIn_ new fictive reserve of the in-token after the transaction
     * @return newFictiveReserveOut_ new fictive reserve of the out-token after the transaction
     */
    function applyKConstRuleIn(
        uint256 _amountOut,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut
    )
        internal
        pure
        returns (
            uint256 amountIn_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        // k const rule
        uint256 _numerator = _fictiveReserveIn * _amountOut * FEES_BASE;
        uint256 _denominator = (_fictiveReserveOut - _amountOut) * REVERSE_FEES_TOTAL;
        amountIn_ = _numerator / _denominator + 1;

        // update new reserves
        uint256 _amountInWithFeeLp = (amountIn_ * (REVERSE_FEES_TOTAL + FEES_LP)) / FEES_BASE;
        newReserveIn_ = _reserveIn + _amountInWithFeeLp;
        newFictiveReserveIn_ = _fictiveReserveIn + _amountInWithFeeLp;
        newReserveOut_ = _reserveOut - _amountOut;
        newFictiveReserveOut_ = _fictiveReserveOut - _amountOut;
    }

    /**
     * @notice return the amount of tokens the user would get by doing a swap
     * @param _amountIn quantity of token the user want to swap (to sell)
     * @param _reserveIn reserves of the selling token (getReserve())
     * @param _reserveOut reserves of the buying token (getReserve())
     * @param _fictiveReserveIn fictive reserve of the selling token (getFictiveReserves())
     * @param _fictiveReserveOut fictive reserve of the buying token (getFictiveReserves())
     * @param _priceAverageIn price average of the selling token
     * @param _priceAverageOut price average of the buying token
     * @return amountOut_ The amount of token the user would receive
     * @return newReserveIn_ reserves of the selling token after the swap
     * @return newReserveOut_ reserves of the buying token after the swap
     * @return newFictiveReserveIn_ fictive reserve of the selling token after the swap
     * @return newFictiveReserveOut_ fictive reserve of the buying token after the swap
     */
    function getAmountOut(
        uint256 _amountIn,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        internal
        pure
        returns (
            uint256 amountOut_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        require(_amountIn > 0, "SmarDexLibrary: INSUFFICIENT_INPUT_AMOUNT");
        require(
            _reserveIn > 0 && _reserveOut > 0 && _fictiveReserveIn > 0 && _fictiveReserveOut > 0,
            "SmarDexLibrary: INSUFFICIENT_LIQUIDITY"
        );

        uint256 _amountInWithFees = (_amountIn * REVERSE_FEES_TOTAL) / FEES_BASE;
        uint256 _firstAmountIn = computeFirstTradeQtyIn(
            _amountInWithFees,
            _fictiveReserveIn,
            _fictiveReserveOut,
            _priceAverageIn,
            _priceAverageOut
        );

        // if there is 2 trade: 1st trade mustn't re-compute fictive reserves, 2nd should
        if (
            _firstAmountIn == _amountInWithFees &&
            ratioApproxEq(_fictiveReserveIn, _fictiveReserveOut, _priceAverageIn, _priceAverageOut)
        ) {
            (_fictiveReserveIn, _fictiveReserveOut) = computeFictiveReserves(
                _reserveIn,
                _reserveOut,
                _fictiveReserveIn,
                _fictiveReserveOut
            );
        }

        // avoid stack too deep
        {
            uint256 _firstAmountInNoFees = (_firstAmountIn * FEES_BASE) / REVERSE_FEES_TOTAL;
            (
                amountOut_,
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            ) = applyKConstRuleOut(
                _firstAmountInNoFees,
                _reserveIn,
                _reserveOut,
                _fictiveReserveIn,
                _fictiveReserveOut
            );

            // update amountIn in case there is a second trade
            _amountIn -= _firstAmountInNoFees;
        }

        // if we need a second trade
        if (_firstAmountIn < _amountInWithFees) {
            // in the second trade ALWAYS recompute fictive reserves
            (newFictiveReserveIn_, newFictiveReserveOut_) = computeFictiveReserves(
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            );

            uint256 _secondAmountOutNoFees;
            (
                _secondAmountOutNoFees,
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            ) = applyKConstRuleOut(
                _amountIn,
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            );
            amountOut_ += _secondAmountOutNoFees;
        }
    }

    /**
     * @notice return the amount of tokens the user should spend by doing a swap
     * @param _amountOut quantity of token the user want to swap (to buy)
     * @param _reserveIn reserves of the selling token (getReserve())
     * @param _reserveOut reserves of the buying token (getReserve())
     * @param _fictiveReserveIn fictive reserve of the selling token (getFictiveReserves())
     * @param _fictiveReserveOut fictive reserve of the buying token (getFictiveReserves())
     * @param _priceAverageIn price average of the selling token
     * @param _priceAverageOut price average of the buying token
     * @return amountIn_ The amount of token the user would spend to receive _amountOut
     * @return newReserveIn_ reserves of the selling token after the swap
     * @return newReserveOut_ reserves of the buying token after the swap
     * @return newFictiveReserveIn_ fictive reserve of the selling token after the swap
     * @return newFictiveReserveOut_ fictive reserve of the buying token after the swap
     */
    function getAmountIn(
        uint256 _amountOut,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        internal
        pure
        returns (
            uint256 amountIn_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        )
    {
        require(_amountOut > 0, "SmarDexLibrary: INSUFFICIENT_OUTPUT_AMOUNT");
        require(
            _amountOut < _fictiveReserveOut &&
                _reserveIn > 0 &&
                _reserveOut > 0 &&
                _fictiveReserveIn > 0 &&
                _fictiveReserveOut > 0,
            "SmarDexLibrary: INSUFFICIENT_LIQUIDITY"
        );

        uint256 _firstAmountOut = computeFirstTradeQtyOut(
            _amountOut,
            _fictiveReserveIn,
            _fictiveReserveOut,
            _priceAverageIn,
            _priceAverageOut
        );

        // if there is 2 trade: 1st trade mustn't re-compute fictive reserves, 2nd should
        if (
            _firstAmountOut == _amountOut &&
            ratioApproxEq(_fictiveReserveIn, _fictiveReserveOut, _priceAverageIn, _priceAverageOut)
        ) {
            (_fictiveReserveIn, _fictiveReserveOut) = computeFictiveReserves(
                _reserveIn,
                _reserveOut,
                _fictiveReserveIn,
                _fictiveReserveOut
            );
        }

        (amountIn_, newReserveIn_, newReserveOut_, newFictiveReserveIn_, newFictiveReserveOut_) = applyKConstRuleIn(
            _firstAmountOut,
            _reserveIn,
            _reserveOut,
            _fictiveReserveIn,
            _fictiveReserveOut
        );

        // if we need a second trade
        if (_firstAmountOut < _amountOut) {
            // in the second trade ALWAYS recompute fictive reserves
            (newFictiveReserveIn_, newFictiveReserveOut_) = computeFictiveReserves(
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            );

            uint256 _secondAmountIn;
            (
                _secondAmountIn,
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            ) = applyKConstRuleIn(
                _amountOut - _firstAmountOut,
                newReserveIn_,
                newReserveOut_,
                newFictiveReserveIn_,
                newFictiveReserveOut_
            );
            amountIn_ += _secondAmountIn;
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;

/**
 * @title TransferHelper
 * @notice helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
 * @custom:from Uniswap lib, adapted to version 0.8.17
 * @custom:url https://github.com/Uniswap/solidity-lib/blob/master/contracts/libraries/TransferHelper.sol
 */
library TransferHelper {
    function safeApprove(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper::safeApprove: approve failed"
        );
    }

    function safeTransfer(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper::safeTransfer: transfer failed"
        );
    }

    function safeTransferFrom(address token, address from, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper::transferFrom: transferFrom failed"
        );
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{ value: value }(new bytes(0));
        require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
    }
}

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

// interfaces
import "../../core/interfaces/ISmardexSwapCallback.sol";
import "../../core/interfaces/ISmardexMintCallback.sol";

interface ISmardexRouter is ISmardexSwapCallback, ISmardexMintCallback {
    /**
     * @notice get the factory address
     * @return address of the factory
     */
    function factory() external view returns (address);

    /**
     * @notice get WETH address
     * @return address of the WETH token (Wrapped Ether)
     */
    function WETH() external view returns (address);

    /**
     * @notice Add liquidity to an ERC-20=ERC-20 pool. Receive liquidity token to materialize shares in the pool
     * @param _tokenA address of the first token in the pair
     * @param _tokenB address of the second token in the pair
     * @param _amountADesired The amount of tokenA to add as liquidity
     * if the B/A price is <= amountBDesired/amountADesired
     * @param _amountBDesired The amount of tokenB to add as liquidity
     * if the A/B price is <= amountADesired/amountBDesired
     * @param _amountAMin Bounds the extent to which the B/A price can go up before the transaction reverts.
     * Must be <= amountADesired.
     * @param _amountBMin Bounds the extent to which the A/B price can go up before the transaction reverts.
     * Must be <= amountBDesired.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountA_ The amount of tokenA sent to the pool.
     * @return amountB_ The amount of tokenB sent to the pool.
     * @return liquidity_ The amount of liquidity tokens minted.
     */
    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_);

    /**
     * @notice Adds liquidity to an ERC-20=WETH pool with ETH. msg.value is the amount of ETH to add as liquidity.
     * if the token/WETH price is <= amountTokenDesired/msg.value (WETH depreciates).
     * @param _token A pool token.
     * @param _amountTokenDesired The amount of token to add as liquidity if the WETH/token price
     * is <= msg.value/amountTokenDesired (token depreciates).
     * @param _amountTokenMin Bounds the extent to which the WETH/token price can go up before the transaction reverts.
     * Must be <= amountTokenDesired.
     * @param _amountETHMin Bounds the extent to which the token/WETH price can go up before the transaction reverts.
     * Must be <= msg.value.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountToken_ The amount of token sent to the pool.
     * @return amountETH_ The amount of ETH converted to WETH and sent to the pool.
     * @return liquidity_ The amount of liquidity tokens minted.
     */
    function addLiquidityETH(
        address _token,
        uint256 _amountTokenDesired,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    ) external payable returns (uint256 amountToken_, uint256 amountETH_, uint256 liquidity_);

    /**
     * @notice Removes liquidity from an ERC-20=ERC-20 pool.
     * @param _tokenA A pool token.
     * @param _tokenB A pool token.
     * @param _liquidity The amount of liquidity tokens to remove.
     * @param _amountAMin The minimum amount of tokenA that must be received for the transaction not to revert.
     * @param _amountBMin The minimum amount of tokenB that must be received for the transaction not to revert.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountA_ The amount of tokenA received.
     * @return amountB_ The amount of tokenB received.
     */
    function removeLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _liquidity,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountA_, uint256 amountB_);

    /**
     * @notice Removes liquidity from an ERC-20=WETH pool and receive ETH.
     * @param _token A pool token.
     * @param _liquidity The amount of liquidity tokens to remove.
     * @param _amountTokenMin The minimum amount of token that must be received for the transaction not to revert.
     * @param _amountETHMin The minimum amount of ETH that must be received for the transaction not to revert.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountToken_ The amount of token received.
     * @return amountETH_ The amount of ETH received.
     */
    function removeLiquidityETH(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountToken_, uint256 amountETH_);

    /**
     * @notice Removes liquidity from an ERC-20=WETH pool and receive ETH.
     * @param _tokenA A pool token.
     * @param _tokenB A pool token.
     * @param _liquidity The amount of liquidity tokens to remove.
     * @param _amountAMin The minimum amount of tokenA that must be received for the transaction not to revert.
     * @param _amountBMin The minimum amount of tokenB that must be received for the transaction not to revert.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @param _approveMax Whether or not the approval amount in the signature is for liquidity or uint(-1).
     * @param _v The v component of the permit signature.
     * @param _r The r component of the permit signature.
     * @param _s The s component of the permit signature.
     * @return amountA_ The amount of tokenA received.
     * @return amountB_ The amount of tokenB received.
     */
    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_);

    /**
     * @notice Removes liquidity from an ERC-20=WETTH pool and receive ETH without pre-approval
     * @param _token A pool token.
     * @param _liquidity The amount of liquidity tokens to remove.
     * @param _amountTokenMin The minimum amount of token that must be received for the transaction not to revert.
     * @param _amountETHMin The minimum amount of ETH that must be received for the transaction not to revert.
     * @param _to Recipient of the liquidity tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @param _approveMax Whether or not the approval amount in the signature is for liquidity or uint(-1).
     * @param _v The v component of the permit signature.
     * @param _r The r component of the permit signature.
     * @param _s The s component of the permit signature.
     * @return amountToken_ The amount of token received.
     * @return amountETH_ The amount of ETH received.
     */
    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_);

    /**
     * @notice Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined
     * by the path. The first element of path is the input token, the last is the output token, and any intermediate
     * elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).
     * @param _amountIn The amount of input tokens to send.
     * @param _amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of the output tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountOut_ The output token amount.
     */
    function swapExactTokensForTokens(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountOut_);

    /**
     * @notice Receive an exact amount of output tokens for as few input tokens as possible, along the route determined
     * by the path. The first element of path is the input token, the last is the output token, and any intermediate
     * elements represent intermediate tokens to trade through (if, for example, a direct pair does not exist).
     * @param _amountOut The amount of output tokens to receive.
     * @param _amountInMax The maximum amount of input tokens that can be required before the transaction reverts.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of the output tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountIn_ The input token amount.
     */
    function swapTokensForExactTokens(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountIn_);

    /**
     * @notice Swaps an exact amount of ETH for as many output tokens as possible, along the route determined by the
     * path. The first element of path must be WETH, the last is the output token, and any intermediate elements
     * represent intermediate pairs to trade through (if, for example, a direct pair does not exist).
     * @param _amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of the output tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountOut_ The input token amount.
     */
    function swapExactETHForTokens(
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external payable returns (uint256 amountOut_);

    /**
     * @notice Receive an exact amount of ETH for as few input tokens as possible, along the route determined by the
     * path. The first element of path is the input token, the last must be WETH, and any intermediate elements
     * represent intermediate pairs to trade through (if, for example, a direct pair does not exist).
     * @param _amountOut The amount of ETH to receive.
     * @param _amountInMax The maximum amount of input tokens that can be required before the transaction reverts.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of ETH.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountIn_ The input token amount.
     */
    function swapTokensForExactETH(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountIn_);

    /**
     * @notice Swaps an exact amount of tokens for as much ETH as possible, along the route determined by the path.
     * The first element of path is the input token, the last must be WETH, and any intermediate elements represent
     * intermediate pairs to trade through (if, for example, a direct pair does not exist).
     * @param _amountIn The amount of input tokens to send.
     * @param _amountOutMin The minimum amount of output tokens that must be received for the transaction not to revert.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of ETH.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountOut_ The input token amount.
     */
    function swapExactTokensForETH(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external returns (uint256 amountOut_);

    /**
     * @notice Receive an exact amount of tokens for as little ETH as possible, along the route determined by the path.
     * The first element of path must be WETH, the last is the output token and any intermediate elements represent
     * intermediate pairs to trade through (if, for example, a direct pair does not exist).
     * msg.value The maximum amount of ETH that can be required before the transaction reverts.
     * @param _amountOut The amount of tokens to receive.
     * @param _path An array of token addresses. path.length must be >= 2. Pools for each consecutive pair of addresses
     * must exist and have liquidity.
     * @param _to Recipient of output tokens.
     * @param _deadline Unix timestamp after which the transaction will revert.
     * @return amountIn_ The input token amount.
     */
    function swapETHForExactTokens(
        uint256 _amountOut,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    ) external payable returns (uint256 amountIn_);

    /**
     * @notice Given some asset amount and reserves, returns an amount of the other asset representing equivalent value.
     */
    function quote(
        uint256 _amountA,
        uint256 _fictiveReserveA,
        uint256 _fictiveReserveB
    ) external pure returns (uint256 amountB_);

    /**
     * @notice return the amount of tokens the user would get by doing a swap
     * @param _amountIn quantity of token the user want to swap (to sell)
     * @param _reserveIn reserves of the selling token (getReserve())
     * @param _reserveOut reserves of the buying token (getReserve())
     * @param _fictiveReserveIn fictive reserve of the selling token (getFictiveReserves())
     * @param _fictiveReserveOut fictive reserve of the buying token (getFictiveReserves())
     * @param _priceAverageIn price average of the selling token
     * @param _priceAverageOut price average of the buying token
     * @return amountOut_ The amount of token the user would receive
     * @return newReserveIn_ reserves of the selling token after the swap
     * @return newReserveOut_ reserves of the buying token after the swap
     * @return newFictiveReserveIn_ fictive reserve of the selling token after the swap
     * @return newFictiveReserveOut_ fictive reserve of the buying token after the swap
     */
    function getAmountOut(
        uint256 _amountIn,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        external
        pure
        returns (
            uint256 amountOut_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        );

    /**
     * @notice return the amount of tokens the user should spend by doing a swap
     * @param _amountOut quantity of token the user want to swap (to buy)
     * @param _reserveIn reserves of the selling token (getReserve())
     * @param _reserveOut reserves of the buying token (getReserve())
     * @param _fictiveReserveIn fictive reserve of the selling token (getFictiveReserves())
     * @param _fictiveReserveOut fictive reserve of the buying token (getFictiveReserves())
     * @param _priceAverageIn price average of the selling token
     * @param _priceAverageOut price average of the buying token
     * @return amountIn_ The amount of token the user would spend to receive _amountOut
     * @return newReserveIn_ reserves of the selling token after the swap
     * @return newReserveOut_ reserves of the buying token after the swap
     * @return newFictiveReserveIn_ fictive reserve of the selling token after the swap
     * @return newFictiveReserveOut_ fictive reserve of the buying token after the swap
     */
    function getAmountIn(
        uint256 _amountOut,
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _fictiveReserveIn,
        uint256 _fictiveReserveOut,
        uint256 _priceAverageIn,
        uint256 _priceAverageOut
    )
        external
        pure
        returns (
            uint256 amountIn_,
            uint256 newReserveIn_,
            uint256 newReserveOut_,
            uint256 newFictiveReserveIn_,
            uint256 newFictiveReserveOut_
        );
}

// SPDX-License-Identifier: GPL-3.0

// Copyright (C) 2015, 2016, 2017 Dapphub

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.17;

interface IWETH {
    function deposit() external payable;

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

    function withdraw(uint256) external;
}

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

/**
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 * @custom:url https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
library BytesLib {
    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
        require(_length + 31 >= _length, "slice_overflow");
        require(_start + _length >= _start, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_start + 20 >= _start, "toAddress_overflow");
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint24(bytes memory _bytes, uint256 _start) internal pure returns (uint24) {
        require(_start + 3 >= _start, "toUint24_overflow");
        require(_bytes.length >= _start + 3, "toUint24_outOfBounds");
        uint24 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x3), _start))
        }

        return tempUint;
    }
}

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

// libraries
import "./BytesLib.sol";

/**
 * @title Functions for manipulating path data for multihop swaps
 * @custom:from UniswapV3
 * @custom:url https://github.com/Uniswap/v3-periphery/blob/main/contracts/libraries/Path.sol
 */
library Path {
    using BytesLib for bytes;

    /// @dev The length of the bytes encoded address
    uint256 private constant ADDR_SIZE = 20;

    /// @dev The offset of a single token address
    uint256 private constant NEXT_OFFSET = ADDR_SIZE;
    /// @dev The offset of an encoded pool key
    uint256 private constant POP_OFFSET = NEXT_OFFSET + ADDR_SIZE;
    /// @dev The minimum length of an encoding that contains 2 or more pools
    uint256 private constant MULTIPLE_POOLS_MIN_LENGTH = POP_OFFSET + NEXT_OFFSET;

    /// @notice Returns true if the path contains two or more pools
    /// @param path The encoded swap path
    /// @return True if path contains two or more pools, otherwise false
    function hasMultiplePools(bytes memory path) internal pure returns (bool) {
        return path.length >= MULTIPLE_POOLS_MIN_LENGTH;
    }

    /// @notice Returns the number of pools in the path
    /// @param path The encoded swap path
    /// @return The number of pools in the path
    function numPools(bytes memory path) internal pure returns (uint256) {
        // Ignore the first token address. From then on every fee and token offset indicates a pool.
        return ((path.length - ADDR_SIZE) / NEXT_OFFSET);
    }

    /// @notice Decodes the first pool in path
    /// @param path The bytes encoded swap path
    /// @return tokenA The first token of the given pool
    /// @return tokenB The second token of the given pool
    function decodeFirstPool(bytes memory path) internal pure returns (address tokenA, address tokenB) {
        tokenA = path.toAddress(0);
        tokenB = path.toAddress(NEXT_OFFSET);
    }

    /// @notice Gets the segment corresponding to the first pool in the path
    /// @param path The bytes encoded swap path
    /// @return The segment containing all data necessary to target the first pool in the path
    function getFirstPool(bytes memory path) internal pure returns (bytes memory) {
        return path.slice(0, POP_OFFSET);
    }

    /// @notice Skips a token from the buffer and returns the remainder
    /// @param path The swap path
    /// @return The remaining token elements in the path
    function skipToken(bytes memory path) internal pure returns (bytes memory) {
        return path.slice(NEXT_OFFSET, path.length - NEXT_OFFSET);
    }

    function encodeTightlyPacked(address[] memory path) internal pure returns (bytes memory encoded) {
        uint256 len = path.length;
        for (uint256 i = 0; i < len; i++) {
            encoded = bytes.concat(encoded, abi.encodePacked(path[i]));
        }
    }

    function encodeTightlyPackedReversed(address[] memory path) internal pure returns (bytes memory encoded) {
        uint256 len = path.length;
        for (uint256 i = len; i > 0; i--) {
            encoded = bytes.concat(encoded, abi.encodePacked(path[i - 1]));
        }
    }
}

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

// libraries
import "./PoolHelpers.sol";

// interfaces
import "../../core/interfaces/ISmardexFactory.sol";

library PoolAddress {
    /**
     * @notice Deterministically computes the pool address given the factory and PoolKey
     * @param _factory The SmarDex factory contract address
     * @param _tokenA The first token of the pool
     * @param _tokenB The second token of the pool
     * @return pair_ The contract address of the SmardexPair
     */
    function pairFor(address _factory, address _tokenA, address _tokenB) internal pure returns (address pair_) {
        (address token0, address token1) = PoolHelpers.sortTokens(_tokenA, _tokenB);
        pair_ = address(
            uint160(
                uint256(
                    keccak256(
                        abi.encodePacked(
                            hex"ff",
                            _factory,
                            keccak256(abi.encodePacked(token0, token1)),
                            hex"b477a06204165d50e6d795c7c216306290eff5d6015f8b65bb46002a8775b548" // init code hash
                        )
                    )
                )
            )
        );
    }

    /**
     * @notice make a call to the factory to determine the pair address. usefull for coverage test
     * @param _factory The SmarDex factory contract address
     * @param _tokenA The first token of the pool
     * @param _tokenB The second token of the pool
     * @return pair_ The contract address of the SmardexPair
     */
    function pairForByStorage(
        address _factory,
        address _tokenA,
        address _tokenB
    ) internal view returns (address pair_) {
        return ISmardexFactory(_factory).getPair(_tokenA, _tokenB);
    }
}

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

// libraries
import "./PoolAddress.sol";
import "../../core/libraries/SmardexLibrary.sol";

// interfaces
import "../../core/interfaces/ISmardexPair.sol";

library PoolHelpers {
    /**
     * @notice sort token addresses, used to handle return values from pairs sorted in this order
     * @param _tokenA token to sort
     * @param _tokenB token to sort
     * @return token0_ token0 sorted
     * @return token1_ token1 sorted
     */
    function sortTokens(address _tokenA, address _tokenB) internal pure returns (address token0_, address token1_) {
        require(_tokenA != _tokenB, "SmardexHelper: IDENTICAL_ADDRESSES");
        (token0_, token1_) = _tokenA < _tokenB ? (_tokenA, _tokenB) : (_tokenB, _tokenA);
        require(token0_ != address(0), "SmardexHelper: ZERO_ADDRESS");
    }

    /**
     * @notice fetches the reserves for a pair
     * @param _factory the factory address
     * @param _tokenA token to fetch reserves
     * @param _tokenB token to fetch reserves
     * @return reserveA_ reserves of tokenA in the pair tokenA/TokenB
     * @return reserveB_ reserves of tokenB in the pair tokenA/TokenB
     */
    function getReserves(
        address _factory,
        address _tokenA,
        address _tokenB
    ) internal view returns (uint256 reserveA_, uint256 reserveB_) {
        (address _token0, ) = sortTokens(_tokenA, _tokenB);
        (uint256 _reserve0, uint256 _reserve1) = ISmardexPair(PoolAddress.pairFor(_factory, _tokenA, _tokenB))
            .getReserves();
        (reserveA_, reserveB_) = _tokenA == _token0 ? (_reserve0, _reserve1) : (_reserve1, _reserve0);
    }

    /**
     * @notice fetches the fictive reserves for a pair
     * @param _factory the factory address
     * @param _tokenA token to fetch fictive reserves
     * @param _tokenB token to fetch fictive reserves
     * @return fictiveReserveA_ fictive reserves of tokenA in the pair tokenA/TokenB
     * @return fictiveReserveB_ fictive reserves of tokenB in the pair tokenA/TokenB
     */
    function getFictiveReserves(
        address _factory,
        address _tokenA,
        address _tokenB
    ) internal view returns (uint256 fictiveReserveA_, uint256 fictiveReserveB_) {
        (address _token0, ) = sortTokens(_tokenA, _tokenB);
        (uint256 _fictiveReserve0, uint256 _fictiveReserve1) = ISmardexPair(
            PoolAddress.pairFor(_factory, _tokenA, _tokenB)
        ).getFictiveReserves();
        (fictiveReserveA_, fictiveReserveB_) = _tokenA == _token0
            ? (_fictiveReserve0, _fictiveReserve1)
            : (_fictiveReserve1, _fictiveReserve0);
    }

    /**
     * @notice fetches the priceAverage for a pair
     * @param _factory the factory address
     * @param _tokenA token to fetch priceAverage
     * @param _tokenB token to fetch priceAverage
     * @return priceAverageA_ priceAverage of tokenA in the pair tokenA/TokenB
     * @return priceAverageB_ priceAverage of tokenB in the pair tokenA/TokenB
     */
    function getPriceAverage(
        address _factory,
        address _tokenA,
        address _tokenB
    ) internal view returns (uint256 priceAverageA_, uint256 priceAverageB_) {
        (address _token0, ) = sortTokens(_tokenA, _tokenB);
        (uint256 _priceAverage0, uint256 _priceAverage1, ) = ISmardexPair(
            PoolAddress.pairFor(_factory, _tokenA, _tokenB)
        ).getPriceAverage();
        (priceAverageA_, priceAverageB_) = _tokenA == _token0
            ? (_priceAverage0, _priceAverage1)
            : (_priceAverage1, _priceAverage0);
    }

    /**
     * @notice given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
     * @param _amountA amount of asset A
     * @param _reserveA reserve of asset A
     * @param _reserveB reserve of asset B
     * @return amountB_ equivalent amount of asset B
     */
    function quote(uint256 _amountA, uint256 _reserveA, uint256 _reserveB) internal pure returns (uint256 amountB_) {
        require(_amountA > 0, "SmardexHelper: INSUFFICIENT_AMOUNT");
        require(_reserveA > 0 && _reserveB > 0, "SmardexHelper: INSUFFICIENT_LIQUIDITY");
        amountB_ = (_amountA * _reserveB) / _reserveA;
    }
}

{
  "metadata": {
    "bytecodeHash": "none",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_WETH","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"},{"internalType":"uint256","name":"_amountADesired","type":"uint256"},{"internalType":"uint256","name":"_amountBDesired","type":"uint256"},{"internalType":"uint256","name":"_amountAMin","type":"uint256"},{"internalType":"uint256","name":"_amountBMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"addLiquidity","outputs":[{"internalType":"uint256","name":"amountA_","type":"uint256"},{"internalType":"uint256","name":"amountB_","type":"uint256"},{"internalType":"uint256","name":"liquidity_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amountTokenDesired","type":"uint256"},{"internalType":"uint256","name":"_amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"_amountETHMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"addLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken_","type":"uint256"},{"internalType":"uint256","name":"amountETH_","type":"uint256"},{"internalType":"uint256","name":"liquidity_","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"},{"internalType":"uint256","name":"_reserveIn","type":"uint256"},{"internalType":"uint256","name":"_reserveOut","type":"uint256"},{"internalType":"uint256","name":"_fictiveReserveIn","type":"uint256"},{"internalType":"uint256","name":"_fictiveReserveOut","type":"uint256"},{"internalType":"uint256","name":"_priceAverageIn","type":"uint256"},{"internalType":"uint256","name":"_priceAverageOut","type":"uint256"}],"name":"getAmountIn","outputs":[{"internalType":"uint256","name":"amountIn_","type":"uint256"},{"internalType":"uint256","name":"newReserveIn_","type":"uint256"},{"internalType":"uint256","name":"newReserveOut_","type":"uint256"},{"internalType":"uint256","name":"newFictiveReserveIn_","type":"uint256"},{"internalType":"uint256","name":"newFictiveReserveOut_","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_reserveIn","type":"uint256"},{"internalType":"uint256","name":"_reserveOut","type":"uint256"},{"internalType":"uint256","name":"_fictiveReserveIn","type":"uint256"},{"internalType":"uint256","name":"_fictiveReserveOut","type":"uint256"},{"internalType":"uint256","name":"_priceAverageIn","type":"uint256"},{"internalType":"uint256","name":"_priceAverageOut","type":"uint256"}],"name":"getAmountOut","outputs":[{"internalType":"uint256","name":"amountOut_","type":"uint256"},{"internalType":"uint256","name":"newReserveIn_","type":"uint256"},{"internalType":"uint256","name":"newReserveOut_","type":"uint256"},{"internalType":"uint256","name":"newFictiveReserveIn_","type":"uint256"},{"internalType":"uint256","name":"newFictiveReserveOut_","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountA","type":"uint256"},{"internalType":"uint256","name":"_reserveA","type":"uint256"},{"internalType":"uint256","name":"_reserveB","type":"uint256"}],"name":"quote","outputs":[{"internalType":"uint256","name":"amountB_","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"},{"internalType":"uint256","name":"_liquidity","type":"uint256"},{"internalType":"uint256","name":"_amountAMin","type":"uint256"},{"internalType":"uint256","name":"_amountBMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"removeLiquidity","outputs":[{"internalType":"uint256","name":"amountA_","type":"uint256"},{"internalType":"uint256","name":"amountB_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_liquidity","type":"uint256"},{"internalType":"uint256","name":"_amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"_amountETHMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"removeLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken_","type":"uint256"},{"internalType":"uint256","name":"amountETH_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_liquidity","type":"uint256"},{"internalType":"uint256","name":"_amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"_amountETHMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"bool","name":"_approveMax","type":"bool"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"removeLiquidityETHWithPermit","outputs":[{"internalType":"uint256","name":"amountToken_","type":"uint256"},{"internalType":"uint256","name":"amountETH_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"},{"internalType":"uint256","name":"_liquidity","type":"uint256"},{"internalType":"uint256","name":"_amountAMin","type":"uint256"},{"internalType":"uint256","name":"_amountBMin","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"},{"internalType":"bool","name":"_approveMax","type":"bool"},{"internalType":"uint8","name":"_v","type":"uint8"},{"internalType":"bytes32","name":"_r","type":"bytes32"},{"internalType":"bytes32","name":"_s","type":"bytes32"}],"name":"removeLiquidityWithPermit","outputs":[{"internalType":"uint256","name":"amountA_","type":"uint256"},{"internalType":"uint256","name":"amountB_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"address","name":"payer","type":"address"}],"internalType":"struct ISmardexMintCallback.MintCallbackData","name":"_data","type":"tuple"}],"name":"smardexMintCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"_amount0Delta","type":"int256"},{"internalType":"int256","name":"_amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"smardexSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapETHForExactTokens","outputs":[{"internalType":"uint256","name":"amountIn_","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountOutMin","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapExactETHForTokens","outputs":[{"internalType":"uint256","name":"amountOut_","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_amountOutMin","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapExactTokensForETH","outputs":[{"internalType":"uint256","name":"amountOut_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_amountOutMin","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapExactTokensForTokens","outputs":[{"internalType":"uint256","name":"amountOut_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"},{"internalType":"uint256","name":"_amountInMax","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapTokensForExactETH","outputs":[{"internalType":"uint256","name":"amountIn_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"},{"internalType":"uint256","name":"_amountInMax","type":"uint256"},{"internalType":"address[]","name":"_path","type":"address[]"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"name":"swapTokensForExactTokens","outputs":[{"internalType":"uint256","name":"amountIn_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000007753f36e711b66a0350a753aba9f5651bae76a1d000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _factory (address): 0x7753F36E711B66a0350a753aba9F5651BAE76A1D
Arg [1] : _WETH (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007753f36e711b66a0350a753aba9f5651bae76a1d
Arg [1] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2