Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

import "./ISwapsPair.sol";
import "./SwapsPair.sol";

contract SwapsFactory {

    address public feeTo;
    address public feeToSetter;
    address public immutable cloneTarget;
    address constant ZERO_ADDRESS = address(0);

    address[] public allPairs;

    mapping(address => mapping(address => address)) public getPair;

    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    constructor(
        address _feeToSetter
    ) {
        if (_feeToSetter == ZERO_ADDRESS) {
            revert("SwapsFactory: INVALID_INPUT");
        }

        feeToSetter = _feeToSetter;
        feeTo = _feeToSetter;

        bytes32 salt;
        address pair;

        bytes memory bytecode = type(SwapsPair).creationCode;

        assembly {
            pair := create2(
                0,
                add(bytecode, 32),
                mload(bytecode),
                salt
            )
        }

        cloneTarget = pair;
    }

    function allPairsLength()
        external
        view
        returns (uint256)
    {
        return allPairs.length;
    }

    function createPair(
        address _tokenA,
        address _tokenB
    )
        external
        returns (address pair)
    {
        require(
            _tokenA != _tokenB,
            "SwapsFactory: IDENTICAL"
        );

        (address token0, address token1) = _tokenA < _tokenB
            ? (_tokenA, _tokenB)
            : (_tokenB, _tokenA);

        require(
            token0 != ZERO_ADDRESS,
            "SwapsFactory: ZERO_ADDRESS"
        );

        require(
            getPair[token0][token1] == ZERO_ADDRESS,
            "SwapsFactory: PAIR_ALREADY_EXISTS"
        );

        bytes32 salt = keccak256(
            abi.encodePacked(
                token0,
                token1
            )
        );

        bytes20 targetBytes = bytes20(
            cloneTarget
        );

        assembly {

            let clone := mload(0x40)

            mstore(
                clone,
                0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
            )

            mstore(
                add(clone, 0x14),
                targetBytes
            )

            mstore(
                add(clone, 0x28),
                0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
            )

            pair := create2(0, clone, 0x37, salt)
        }

        ISwapsPair(pair).initialize(
            token0,
            token1
        );

        getPair[token0][token1] = pair;
        getPair[token1][token0] = pair;

        allPairs.push(pair);

        emit PairCreated(
            token0,
            token1,
            pair,
            allPairs.length
        );
    }

    function setFeeTo(
        address _feeTo
    )
        external
    {
        require(
            msg.sender == feeToSetter,
            "SwapsFactory: FORBIDDEN"
        );

        require(
            _feeTo != ZERO_ADDRESS,
            'SwapsFactory: ZERO_ADDRESS'
        );

        feeTo = _feeTo;
    }

    function setFeeToSetter(
        address _feeToSetter
    )
        external
    {
        require(
            msg.sender == feeToSetter,
            "SwapsFactory: FORBIDDEN"
        );

        require(
            _feeToSetter != ZERO_ADDRESS,
            'SwapsFactory: ZERO_ADDRESS'
        );

        feeToSetter = _feeToSetter;
    }
}

contract FactoryCodeCheck {

    function factoryCodeHash()
        external
        pure
        returns (bytes32)
    {
        return keccak256(
            type(SwapsFactory).creationCode
        );
    }

    function pairCodeHash()
        external
        pure
        returns (bytes32)
    {
        return keccak256(
            type(SwapsPair).creationCode
        );
    }
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

interface IERC20 {

    function balanceOf(
        address _owner
    )
        external
        view
        returns (uint256);
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

interface ISwapsCallee {

    function swapsCall(
        address _sender,
        uint256 _amount0,
        uint256 _amount1,
        bytes calldata _data
    )
        external;
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

interface ISwapsERC20 {

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

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

    function decimals()
        external
        pure
        returns (uint8);

    function totalSupply()
        external
        view
        returns (uint256);

    function balanceOf(
        address _owner
    )
        external
        view
        returns (uint256);

    function allowance(
        address _owner,
        address _spender
    )
        external
        view
        returns (uint256);

    function approve(
        address _spender,
        uint256 _value
    )
        external
        returns (bool);

    function transfer(
        address _to,
        uint256 _value
    )
        external
        returns (bool);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    )
        external
        returns (bool);

    function DOMAIN_SEPARATOR()
        external
        view
        returns (bytes32);

    function PERMIT_TYPEHASH()
        external
        pure
        returns (bytes32);

    function nonces(
        address _owner
    )
        external
        view
        returns (uint256);

    function permit(
        address _owner,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external;
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

interface ISwapsFactory {

    function feeTo()
        external
        view
        returns (address);

    function feeToSetter()
        external
        view
        returns (address);

    function getPair(
        address _tokenA,
        address _tokenB
    )
        external
        view
        returns (address pair);

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

    function allPairsLength()
        external
        view
        returns (uint256);

    function createPair(
        address _tokenA,
        address _tokenB
    )
        external
        returns (address pair);

    function setFeeTo(
        address
    )
        external;

    function setFeeToSetter(
        address
    )
        external;

    function cloneTarget()
        external
        view
        returns (address target);
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

import "./ISwapsERC20.sol";

interface ISwapsPair is ISwapsERC20 {

    function MINIMUM_LIQUIDITY()
        external
        pure
        returns (uint256);

    function factory()
        external
        view
        returns (address);

    function token0()
        external
        view
        returns (address);

    function token1()
        external
        view
        returns (address);

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

    function price0CumulativeLast()
        external
        view
        returns (uint256);

    function price1CumulativeLast()
        external
        view
        returns (uint256);

    function kLast()
        external
        view
        returns (uint256);

    function mint(
        address _to
    )
        external
        returns (uint256 liquidity);

    function burn(
        address _to
    )
        external
        returns (
            uint256 amount0,
            uint256 amount1
        );

    function swap(
        uint256 _amount0Out,
        uint256 _amount1Out,
        address _to,
        bytes calldata _data
    )
        external;

    function skim()
        external;

    function initialize(
        address,
        address
    )
        external;
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

interface IWETH {

    function deposit()
        external
        payable;

    function transfer(
        address _to,
        uint256 _value
    )
        external
        returns (bool);

    function withdraw(
        uint256
    )
        external;
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

contract SwapsERC20 {

    string public constant name = "Verse Exchange";
    string public constant symbol = "VERSE-X";
    uint8 public constant decimals = 18;

    address constant ZERO_ADDRESS = address(0);
    uint256 constant UINT256_MAX = type(uint256).max;

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => uint256) public nonces;

    bytes32 public immutable DOMAIN_SEPARATOR;
    bytes32 public constant PERMIT_TYPEHASH = keccak256(
        "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
    );

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    event Transfer(
        address indexed from,
        address indexed to,
        uint256 value
    );

    constructor() {
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(name)),
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );
    }

    function _mint(
        address _to,
        uint256 _value
    )
        internal
    {
        totalSupply =
        totalSupply + _value;

        unchecked {
            balanceOf[_to] =
            balanceOf[_to] + _value;
        }

        emit Transfer(
            ZERO_ADDRESS,
            _to,
            _value
        );
    }

    function _burn(
        address _from,
        uint256 _value
    )
        internal
    {
        unchecked {
            totalSupply =
            totalSupply - _value;
        }

        balanceOf[_from] =
        balanceOf[_from] - _value;

        emit Transfer(
            _from,
            ZERO_ADDRESS,
            _value
        );
    }

    function _approve(
        address _owner,
        address _spender,
        uint256 _value
    )
        private
    {
        allowance[_owner][_spender] = _value;

        emit Approval(
            _owner,
            _spender,
            _value
        );
    }

    function _transfer(
        address _from,
        address _to,
        uint256 _value
    )
        private
    {
        balanceOf[_from] =
        balanceOf[_from] - _value;

        unchecked {
            balanceOf[_to] =
            balanceOf[_to] + _value;
        }

        emit Transfer(
            _from,
            _to,
            _value
        );
    }

    function approve(
        address _spender,
        uint256 _value
    )
        external
        returns (bool)
    {
        _approve(
            msg.sender,
            _spender,
            _value
        );

        return true;
    }

    function transfer(
        address _to,
        uint256 _value
    )
        external
        returns (bool)
    {
        _transfer(
            msg.sender,
            _to,
            _value
        );

        return true;
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    )
        external
        returns (bool)
    {
        if (allowance[_from][msg.sender] != UINT256_MAX) {
            allowance[_from][msg.sender] -= _value;
        }

        _transfer(
            _from,
            _to,
            _value
        );

        return true;
    }

    function permit(
        address _owner,
        address _spender,
        uint256 _value,
        uint256 _deadline,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external
    {
        require(
            _deadline >= block.timestamp,
            "SwapsERC20: PERMIT_CALL_EXPIRED"
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                keccak256(
                    abi.encode(
                        PERMIT_TYPEHASH,
                        _owner,
                        _spender,
                        _value,
                        nonces[_owner]++,
                        _deadline
                    )
                )
            )
        );

        if (uint256(_s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            revert("SwapsERC20: INVALID_SIGNATURE");
        }

        address recoveredAddress = ecrecover(
            digest,
            _v,
            _r,
            _s
        );

        require(
            recoveredAddress != ZERO_ADDRESS &&
            recoveredAddress == _owner,
            "SwapsERC20: INVALID_SIGNATURE"
        );

        _approve(
            _owner,
            _spender,
            _value
        );
    }
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

contract SwapsHelper {

    uint256 constant UINT256_MAX = type(uint256).max;
    address constant ZERO_ADDRESS = address(0);

    function sortTokens(
        address _tokenA,
        address _tokenB
    )
        internal
        pure
        returns (
            address token0,
            address token1
        )
    {
        require(
            _tokenA != _tokenB,
            "SwapsHelper: IDENTICAL_ADDRESSES"
        );

        (token0, token1) = _tokenA < _tokenB
            ? (_tokenA, _tokenB)
            : (_tokenB, _tokenA);

        require(
            token0 != ZERO_ADDRESS,
            "SwapsHelper: ZERO_ADDRESS"
        );
    }

    function quote(
        uint256 _amountA,
        uint256 _reserveA,
        uint256 _reserveB
    )
        public
        pure
        returns (uint256 amountB)
    {
        require(
            _amountA > 0,
            "SwapsHelper: INSUFFICIENT_AMOUNT"
        );

        require(
            _reserveA > 0 && _reserveB > 0,
            "SwapsHelper: INSUFFICIENT_LIQUIDITY"
        );

        amountB = _amountA
            * _reserveB
            / _reserveA;
    }

    function getAmountOut(
        uint256 _amountIn,
        uint256 _reserveIn,
        uint256 _reserveOut
    )
        public
        pure
        returns (uint256 amountOut)
    {
        require(
            _amountIn > 0,
            "SwapsHelper: INSUFFICIENT_INPUT_AMOUNT"
        );

        require(
            _reserveIn > 0 && _reserveOut > 0,
            "SwapsHelper: INSUFFICIENT_LIQUIDITY"
        );

        uint256 amountInWithFee = _amountIn * 997;
        uint256 numerator = amountInWithFee * _reserveOut;
        uint256 denominator = _reserveIn * 1000 + amountInWithFee;

        amountOut = numerator / denominator;
    }

    function getAmountIn(
        uint256 _amountOut,
        uint256 _reserveIn,
        uint256 _reserveOut
    )
        public
        pure
        returns (uint256 amountIn)
    {
        require(
            _amountOut > 0,
            "SwapsHelper: INSUFFICIENT_OUTPUT_AMOUNT"
        );

        require(
            _reserveIn > 0 &&
            _reserveOut > 0,
            "SwapsHelper: INSUFFICIENT_LIQUIDITY"
        );

        uint256 numerator = _reserveIn * _amountOut * 1000;
        uint256 denominator = (_reserveOut - _amountOut) * 997;

        amountIn = numerator / denominator + 1;
    }


    bytes4 constant TRANSFER = bytes4(
        keccak256(
            bytes(
                "transfer(address,uint256)"
            )
        )
    );

    bytes4 constant TRANSFER_FROM = bytes4(
        keccak256(
            bytes(
                "transferFrom(address,address,uint256)"
            )
        )
    );

    function _safeTransfer(
        address _token,
        address _to,
        uint256 _value
    )
        internal
    {
        (bool success, bytes memory data) = _token.call(
            abi.encodeWithSelector(
                TRANSFER,
                _to,
                _value
            )
        );

        require(
            success && (
                data.length == 0 || abi.decode(
                    data, (bool)
                )
            ),
            "SwapsHelper: TRANSFER_FAILED"
        );
    }

    function _safeTransferFrom(
        address _token,
        address _from,
        address _to,
        uint256 _value
    )
        internal
    {
        (bool success, bytes memory data) = _token.call(
            abi.encodeWithSelector(
                TRANSFER_FROM,
                _from,
                _to,
                _value
            )
        );

        require(
            success && (
                data.length == 0 || abi.decode(
                    data, (bool)
                )
            ),
            "SwapsHelper: TRANSFER_FROM_FAILED"
        );
    }

    function _safeTransferETH(
        address to,
        uint256 value
    )
        internal
    {
        (bool success,) = to.call{
            value: value
        }(new bytes(0));

        require(
            success,
            "SwapsHelper: ETH_TRANSFER_FAILED"
        );
    }

    function _pairFor(
        address _factory,
        address _tokenA,
        address _tokenB,
        address _implementation
    )
        internal
        pure
        returns (address predicted)
    {
        (address token0, address token1) = _tokenA < _tokenB
            ? (_tokenA, _tokenB)
            : (_tokenB, _tokenA);

        bytes32 salt = keccak256(
            abi.encodePacked(
                token0,
                token1
            )
        );

        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, _implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, _factory))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

import "./IERC20.sol";
import "./ISwapsFactory.sol";
import "./ISwapsCallee.sol";
import "./SwapsERC20.sol";

contract SwapsPair is SwapsERC20 {

    uint224 constant Q112 = 2 ** 112;
    uint112 constant UINT112_MAX = type(uint112).max;
    uint256 public constant MINIMUM_LIQUIDITY = 10 ** 3;

    bytes4 private constant SELECTOR = bytes4(
        keccak256(bytes('transfer(address,uint256)'))
    );

    address public factory;
    address public token0;
    address public token1;

    uint112 private reserve0;
    uint112 private reserve1;
    uint32  private blockTimestampLast;

    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;

    uint256 public kLast;
    uint256 private unlocked;

    modifier lock() {
        require(
            unlocked == 1,
            "SwapsPair: LOCKED"
        );
        unlocked = 0;
        _;
        unlocked = 1;
    }

    event Mint(
        address indexed sender,
        uint256 amount0,
        uint256 amount1
    );

    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );

    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );

    event Sync(
        uint112 reserve0,
        uint112 reserve1
    );

    function initialize(
        address _token0,
        address _token1
    )
        external
    {
        require(
            factory == ZERO_ADDRESS,
            "SwapsPair: ALREADY_INITIALIZED"
        );

        token0 = _token0;
        token1 = _token1;
        factory = msg.sender;
        unlocked = 1;
    }

    function getReserves()
        public
        view
        returns (
            uint112,
            uint112,
            uint32
        )
    {
        return (
            reserve0,
            reserve1,
            blockTimestampLast
        );
    }

    function _update(
        uint256 _balance0,
        uint256 _balance1,
        uint112 _reserve0,
        uint112 _reserve1
    )
        private
    {
        require(
            _balance0 <= UINT112_MAX &&
            _balance1 <= UINT112_MAX,
            "SwapsPair: OVERFLOW"
        );

        uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);

        unchecked {
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;
            if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                price0CumulativeLast += uint256(uqdiv(encode(_reserve1), _reserve0)) * timeElapsed;
                price1CumulativeLast += uint256(uqdiv(encode(_reserve0), _reserve1)) * timeElapsed;
            }
        }

        reserve0 = uint112(_balance0);
        reserve1 = uint112(_balance1);

        blockTimestampLast = blockTimestamp;

        emit Sync(
            reserve0,
            reserve1
        );
    }

    function _mintFee(
        uint112 _reserve0,
        uint112 _reserve1,
        uint256 _kLast
    )
        private
    {
        if (_kLast == 0) return;

        uint256 rootK = sqrt(uint256(_reserve0) * _reserve1);
        uint256 rootKLast = sqrt(_kLast);

        if (rootK > rootKLast) {

            uint256 liquidity = totalSupply
                * (rootK - rootKLast)
                / (rootK * 5 + rootKLast);

            if (liquidity == 0) return;

            _mint(
                ISwapsFactory(factory).feeTo(),
                liquidity
            );
        }
    }

    function mint(
        address _to
    )
        external
        lock
        returns (uint256 liquidity)
    {
        (
            uint112 _reserve0,
            uint112 _reserve1,

        ) = getReserves();

        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 balance1 = IERC20(token1).balanceOf(address(this));

        uint256 amount0 = balance0 - _reserve0;
        uint256 amount1 = balance1 - _reserve1;

        _mintFee(
            _reserve0,
            _reserve1,
            kLast
        );

        uint256 _totalSupply = totalSupply;

        if (_totalSupply == 0) {

            liquidity = sqrt(
                amount0 * amount1
            ) - MINIMUM_LIQUIDITY;

            _mint(
               ZERO_ADDRESS,
               MINIMUM_LIQUIDITY
            );

        } else {

            liquidity = min(
                amount0 * _totalSupply / _reserve0,
                amount1 * _totalSupply / _reserve1
            );
        }

        require(
            liquidity > 0,
            "INSUFFICIENT_LIQUIDITY_MINTED"
        );

        _mint(
            _to,
            liquidity
        );

        _update(
            balance0,
            balance1,
            _reserve0,
            _reserve1
        );

        kLast = uint256(reserve0) * reserve1;

        emit Mint(
            msg.sender,
            amount0,
            amount1
        );
    }

    function burn(
        address _to
    )
        external
        lock
        returns (
            uint256 amount0,
            uint256 amount1
        )
    {
        (
            uint112 _reserve0,
            uint112 _reserve1,

        ) = getReserves();

        address _token0 = token0;
        address _token1 = token1;

        uint256 balance0 = IERC20(_token0).balanceOf(address(this));
        uint256 balance1 = IERC20(_token1).balanceOf(address(this));

        uint256 liquidity = balanceOf[address(this)];

        _mintFee(
            _reserve0,
            _reserve1,
            kLast
        );

        uint256 _totalSupply = totalSupply;

        amount0 = liquidity * balance0 / _totalSupply;
        amount1 = liquidity * balance1 / _totalSupply;

        require(
            amount0 > 0 &&
            amount1 > 0,
            "INSUFFICIENT_LIQUIDITY_BURNED"
        );

        _burn(
            address(this),
            liquidity
        );

        _safeTransfer(
            _token0,
            _to,
            amount0
        );

        _safeTransfer(
            _token1,
            _to,
            amount1
        );

        balance0 = IERC20(_token0).balanceOf(address(this));
        balance1 = IERC20(_token1).balanceOf(address(this));

        _update(
            balance0,
            balance1,
            _reserve0,
            _reserve1
        );

        kLast = uint256(reserve0) * reserve1;

        emit Burn(
            msg.sender,
            amount0,
            amount1,
            _to
        );
    }

    function swap(
        uint256 _amount0Out,
        uint256 _amount1Out,
        address _to,
        bytes calldata _data
    )
        external
        lock
    {
        require(
            _amount0Out > 0 ||
            _amount1Out > 0,
            "INSUFFICIENT_OUTPUT_AMOUNT"
        );

        (
            uint112 _reserve0,
            uint112 _reserve1,

        ) = getReserves();

        require(
            _amount0Out < _reserve0 &&
            _amount1Out < _reserve1,
            "INSUFFICIENT_LIQUIDITY"
        );

        uint256 balance0;
        uint256 balance1;

        {
            address _token0 = token0;
            address _token1 = token1;

            if (_amount0Out > 0) _safeTransfer(_token0, _to, _amount0Out);
            if (_amount1Out > 0) _safeTransfer(_token1, _to, _amount1Out);

            if (_data.length > 0) ISwapsCallee(_to).swapsCall(
                msg.sender,
                _amount0Out,
                _amount1Out,
                _data
            );

            balance0 = IERC20(_token0).balanceOf(address(this));
            balance1 = IERC20(_token1).balanceOf(address(this));
        }

        uint256 _amount0In =
            balance0 > _reserve0 - _amount0Out ?
            balance0 - (_reserve0 - _amount0Out) : 0;

        uint256 _amount1In =
            balance1 > _reserve1 - _amount1Out ?
            balance1 - (_reserve1 - _amount1Out) : 0;

        require(
            _amount0In > 0 ||
            _amount1In > 0,
            "INSUFFICIENT_INPUT_AMOUNT"
        );

        {
            uint256 balance0Adjusted = balance0 * 1000 - (_amount0In * 3);
            uint256 balance1Adjusted = balance1 * 1000 - (_amount1In * 3);

            require(
                balance0Adjusted * balance1Adjusted >=
                uint256(_reserve0)
                    * _reserve1
                    * (1000 ** 2)
            );
        }

        _update(
            balance0,
            balance1,
            _reserve0,
            _reserve1
        );

        emit Swap(
            msg.sender,
            _amount0In,
            _amount1In,
            _amount0Out,
            _amount1Out,
            _to
        );
    }

    function skim()
        external
        lock
    {
        address _token0 = token0;
        address _token1 = token1;
        address _feesTo = ISwapsFactory(factory).feeTo();

        _safeTransfer(
            _token0,
            _feesTo,
            IERC20(_token0).balanceOf(address(this)) - reserve0
        );

        _safeTransfer(
            _token1,
            _feesTo,
            IERC20(_token1).balanceOf(address(this)) - reserve1
        );
    }

    function sync()
        external
        lock
    {
        _update(
            IERC20(token0).balanceOf(address(this)),
            IERC20(token1).balanceOf(address(this)),
            reserve0,
            reserve1
        );
    }

    function encode(
        uint112 _y
    )
        pure
        internal
        returns (uint224 z)
    {
        unchecked {
            z = uint224(_y) * Q112;
        }
    }

    function uqdiv(
        uint224 _x,
        uint112 _y
    )
        pure
        internal
        returns (uint224 z)
    {
        unchecked {
            z = _x / uint224(_y);
        }
    }

    function min(
        uint256 _x,
        uint256 _y
    )
        internal
        pure
        returns (uint256 z)
    {
        z = _x < _y ? _x : _y;
    }

    function sqrt(
        uint256 _y
    )
        internal
        pure
        returns (uint256 z)
    {
        unchecked {
            if (_y > 3) {
                z = _y;
                uint256 x = _y / 2 + 1;
                while (x < z) {
                    z = x;
                    x = (_y / x + x) / 2;
                }
            } else if (_y != 0) {
                z = 1;
            }
        }
    }

    function _safeTransfer(
        address _token,
        address _to,
        uint256 _value
    )
        internal
    {
        (bool success, bytes memory data) = _token.call(
            abi.encodeWithSelector(
                SELECTOR,
                _to,
                _value
            )
        );

        require(
            success && (
                data.length == 0 || abi.decode(
                    data, (bool)
                )
            ),
            "SwapsPair: TRANSFER_FAILED"
        );
    }
}

// SPDX-License-Identifier: BCOM

pragma solidity =0.8.14;

import "./IWETH.sol";
import "./IERC20.sol";
import "./ISwapsFactory.sol";
import "./ISwapsPair.sol";
import "./SwapsHelper.sol";

contract SwapsRouter is SwapsHelper {

    address public immutable FACTORY;
    address public immutable WETH;
    address public immutable PAIR;

    modifier ensure(
        uint256 _deadline
    ) {
        require(
            _deadline >= block.timestamp,
            "SwapsRouter: DEADLINE_EXPIRED"
        );
        _;
    }

    constructor(
        address _factory,
        address _WETH
    ) {
        FACTORY = _factory;
        WETH = _WETH;
        PAIR = ISwapsFactory(_factory).cloneTarget();
    }

    receive()
        external
        payable
    {
        require(
            msg.sender == WETH,
            "SwapsRouter: INVALID_SENDER"
        );
    }

    function _addLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _amountADesired,
        uint256 _amountBDesired,
        uint256 _amountAMin,
        uint256 _amountBMin
    )
        internal
        returns (uint256, uint256)
    {
        if (ISwapsFactory(FACTORY).getPair(_tokenA, _tokenB) == ZERO_ADDRESS) {
            ISwapsFactory(FACTORY).createPair(
                _tokenA,
                _tokenB
            );
        }

        (
            uint256 reserveA,
            uint256 reserveB

        ) = getReserves(
            FACTORY,
            _tokenA,
            _tokenB
        );

        if (reserveA == 0 && reserveB == 0) {
            return (
                _amountADesired,
                _amountBDesired
            );
        }

        uint256 amountBOptimal = quote(
            _amountADesired,
            reserveA,
            reserveB
        );

        if (amountBOptimal <= _amountBDesired) {

            require(
                amountBOptimal >= _amountBMin,
                "SwapsRouter: INSUFFICIENT_B_AMOUNT"
            );

            return (
                _amountADesired,
                amountBOptimal
            );
        }

        uint256 amountAOptimal = quote(
            _amountBDesired,
            reserveB,
            reserveA
        );

        require(
            amountAOptimal <= _amountADesired,
            "SwapsRouter: INVALID_DESIRED_AMOUNT"
        );

        require(
            amountAOptimal >= _amountAMin,
            "SwapsRouter: INSUFFICIENT_A_AMOUNT"
        );

        return (
            amountAOptimal,
            _amountBDesired
        );
    }

    function addLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _amountADesired,
        uint256 _amountBDesired,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        )
    {
        (amountA, amountB) = _addLiquidity(
            _tokenA,
            _tokenB,
            _amountADesired,
            _amountBDesired,
            _amountAMin,
            _amountBMin
        );

        address pair = _pairFor(
            FACTORY,
            _tokenA,
            _tokenB,
            PAIR
        );

        _safeTransferFrom(
            _tokenA,
            msg.sender,
            pair,
            amountA
        );

        _safeTransferFrom(
            _tokenB,
            msg.sender,
            pair,
            amountB
        );

        liquidity = ISwapsPair(pair).mint(_to);
    }

    function addLiquidityETH(
        address _token,
        uint256 _amountTokenDesired,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    )
        external
        payable
        ensure(_deadline)
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        )
    {
        (amountToken, amountETH) = _addLiquidity(
            _token,
            WETH,
            _amountTokenDesired,
            msg.value,
            _amountTokenMin,
            _amountETHMin
        );

        address pair = _pairFor(
            FACTORY,
            _token,
            WETH,
            PAIR
        );

        _safeTransferFrom(
            _token,
            msg.sender,
            pair,
            amountToken
        );

        IWETH(WETH).deposit{
            value: amountETH
        }();

        require(
            IWETH(WETH).transfer(
                pair,
                amountETH
            ),
            "SwapsRouter: TRANSFER_FAIL"
        );

        liquidity = ISwapsPair(pair).mint(_to);

        if (msg.value > amountETH) {
            unchecked {
                _safeTransferETH(
                    msg.sender,
                    msg.value - amountETH
                );
            }
        }
    }

    function removeLiquidity(
        address _tokenA,
        address _tokenB,
        uint256 _liquidity,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline
    )
        public
        ensure(_deadline)
        returns (
            uint256 amountA,
            uint256 amountB
        )
    {
        address pair = _pairFor(
            FACTORY,
            _tokenA,
            _tokenB,
            PAIR
        );

        _safeTransferFrom(
            pair,
            msg.sender,
            pair,
            _liquidity
        );

        (
            uint256 amount0,
            uint256 amount1

        ) = ISwapsPair(pair).burn(_to);

        (address token0,) = sortTokens(
            _tokenA,
            _tokenB
        );

        (amountA, amountB) = _tokenA == token0
            ? (amount0, amount1)
            : (amount1, amount0);

        require(
            amountA >= _amountAMin,
            "SwapsRouter: INSUFFICIENT_A_AMOUNT"
        );

        require(
            amountB >= _amountBMin,
            "SwapsRouter: INSUFFICIENT_B_AMOUNT"
        );
    }

    function removeLiquidityETH(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    )
        public
        ensure(_deadline)
        returns (
            uint256 amountToken,
            uint256 amountETH
        )
    {
        (amountToken, amountETH) = removeLiquidity(
            _token,
            WETH,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            address(this),
            _deadline
        );

        _safeTransfer(
            _token,
            _to,
            amountToken
        );

        IWETH(WETH).withdraw(
            amountETH
        );

        _safeTransferETH(
            _to,
            amountETH
        );
    }

    function removeLiquidityWithPermit(
        address _tokenA,
        address _tokenB,
        uint256 _liquidity,
        uint256 _amountAMin,
        uint256 _amountBMin,
        address _to,
        uint256 _deadline,
        bool _approveMax,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external
        returns (uint256, uint256)
    {
        address pair = _pairFor(
            FACTORY,
            _tokenA,
            _tokenB,
            PAIR
        );

        uint256 value = _approveMax
            ? UINT256_MAX
            : _liquidity;

        ISwapsPair(pair).permit(
            msg.sender,
            address(this),
            value,
            _deadline,
            _v,
            _r,
            _s
        );

        return removeLiquidity(
            _tokenA,
            _tokenB,
            _liquidity,
            _amountAMin,
            _amountBMin,
            _to,
            _deadline
        );
    }

    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, uint256)
    {
        address pair = _pairFor(
            FACTORY,
            _token,
            WETH,
            PAIR
        );

        uint256 value = _approveMax
            ? UINT256_MAX
            : _liquidity;

        ISwapsPair(pair).permit(
            msg.sender,
            address(this),
            value,
            _deadline,
            _v,
            _r,
            _s
        );

        return removeLiquidityETH(
            _token,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            _to,
            _deadline
        );
    }

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline
    )
        public
        ensure(_deadline)
        returns (uint256 amountETH)
    {
        (, amountETH) = removeLiquidity(
            _token,
            WETH,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            address(this),
            _deadline
        );

        _safeTransfer(
            _token,
            _to,
            IERC20(_token).balanceOf(address(this))
        );

        IWETH(WETH).withdraw(
            amountETH
        );

        _safeTransferETH(
            _to,
            amountETH
        );
    }

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address _token,
        uint256 _liquidity,
        uint256 _amountTokenMin,
        uint256 _amountETHMin,
        address _to,
        uint256 _deadline,
        bool _approveMax,
        uint8 _v,
        bytes32 _r,
        bytes32 _s
    )
        external
        returns (uint256 amountETH)
    {
        address pair = _pairFor(
            FACTORY,
            _token,
            WETH,
            PAIR
        );

        uint256 value = _approveMax
            ? UINT256_MAX
            : _liquidity;

        ISwapsPair(pair).permit(
            msg.sender,
            address(this),
            value,
            _deadline,
            _v,
            _r,
            _s
        );

        amountETH = removeLiquidityETHSupportingFeeOnTransferTokens(
            _token,
            _liquidity,
            _amountTokenMin,
            _amountETHMin,
            _to,
            _deadline
        );
    }

    function _swap(
        uint256[] memory _amounts,
        address[] memory _path,
        address _to
    )
        internal
    {
        for (uint256 i; i < _path.length - 1; i++) {

            (address input, address output) = (
                _path[i],
                _path[i + 1]
            );

            (address token0,) = sortTokens(
                input,
                output
            );

            uint256 amountOut = _amounts[i + 1];

            (uint256 amount0Out, uint256 amount1Out) = input == token0
                ? (uint(0), amountOut)
                : (amountOut, uint(0));

            address to = i < _path.length - 2
                ? _pairFor(FACTORY, output, _path[i + 2], PAIR)
                : _to;

            ISwapsPair(
                _pairFor(
                    FACTORY,
                    input,
                    output,
                    PAIR
                )
            ).swap(
                amount0Out,
                amount1Out,
                to,
                new bytes(0)
            );
        }
    }

    function swapExactTokensForTokens(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        amounts = _getAmountsOut(
            FACTORY,
            _amountIn,
            _path
        );

        require(
            amounts[amounts.length - 1] >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );

        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            amounts[0]
        );

        _swap(
            amounts,
            _path,
            _to
        );
    }

    function swapTokensForExactTokens(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        amounts = _getAmountsIn(
            FACTORY,
            _amountOut,
            _path
        );

        require(
            amounts[0] <= _amountInMax,
            "SwapsRouter: EXCESSIVE_INPUT_AMOUNT"
        );

        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            amounts[0]
        );

        _swap(
            amounts,
            _path,
            _to
        );
    }

    function swapExactETHForTokens(
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        payable
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        require(
            _path[0] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = _getAmountsOut(
            FACTORY,
            msg.value,
            _path
        );

        require(
            amounts[amounts.length - 1] >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );

        IWETH(WETH).deposit{
            value: amounts[0]
        }();

        require(
            IWETH(WETH).transfer(
                _pairFor(
                    FACTORY,
                    _path[0],
                    _path[1],
                    PAIR
                ),
                amounts[0]
            ),
            "SwapsRouter: TRANSFER_FAIL"
        );

        _swap(
            amounts,
            _path,
            _to
        );
    }

    function swapTokensForExactETH(
        uint256 _amountOut,
        uint256 _amountInMax,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        require(
            _path[_path.length - 1] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = _getAmountsIn(
            FACTORY,
            _amountOut,
            _path
        );

        require(
            amounts[0] <= _amountInMax,
            "SwapsRouter: EXCESSIVE_INPUT_AMOUNT"
        );

        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            amounts[0]
        );

        _swap(
            amounts,
            _path,
            address(this)
        );

        IWETH(WETH).withdraw(
            amounts[amounts.length - 1]
        );

        _safeTransferETH(
            _to,
            amounts[amounts.length - 1]
        );
    }

    function swapExactTokensForETH(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        require(
            _path[_path.length - 1] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = _getAmountsOut(
            FACTORY,
            _amountIn,
            _path
        );

        require(
            amounts[amounts.length - 1] >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );

        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            amounts[0]
        );

        _swap(
            amounts,
            _path,
            address(this)
        );

        IWETH(WETH).withdraw(
            amounts[amounts.length - 1]
        );

        _safeTransferETH(
            _to,
            amounts[amounts.length - 1]
        );
    }

    function swapETHForExactTokens(
        uint256 _amountOut,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        payable
        ensure(_deadline)
        returns (uint256[] memory amounts)
    {
        require(
            _path[0] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = _getAmountsIn(
            FACTORY,
            _amountOut,
            _path
        );

        require(
            amounts[0] <= msg.value,
            "SwapsRouter: EXCESSIVE_INPUT_AMOUNT"
        );

        IWETH(WETH).deposit{
            value: amounts[0]
        }();

        require(
            IWETH(WETH).transfer(
                _pairFor(
                    FACTORY,
                    _path[0],
                    _path[1],
                    PAIR
                ),
                amounts[0]
            ),
            "SwapsRouter: TRANSFER_FAIL"
        );

        _swap(
            amounts,
            _path,
            _to
        );

        if (msg.value > amounts[0]) {
            unchecked {
                _safeTransferETH(
                    msg.sender,
                    msg.value - amounts[0]
                );
            }
        }
    }

    function _swapSupportingFeeOnTransferTokens(
        address[] memory _path,
        address _to
    )
        internal
    {
        for (uint256 i; i < _path.length - 1; i++) {

            (address input, address output) = (
                _path[i],
                _path[i + 1]
            );

            (address token0,) = sortTokens(
                input,
                output
            );

            ISwapsPair pair = ISwapsPair(
                _pairFor(
                    FACTORY,
                    input,
                    output,
                    PAIR
                )
            );

            uint256 amountInput;
            uint256 amountOutput;

            {

            (
                uint256 reserve0,
                uint256 reserve1,

            ) = pair.getReserves();

            (uint256 reserveInput, uint256 reserveOutput) = input == token0
                ? (reserve0, reserve1)
                : (reserve1, reserve0);

            amountInput = IERC20(input).balanceOf(address(pair)) - reserveInput;
            amountOutput = getAmountOut(
                amountInput,
                reserveInput,
                reserveOutput
            );

            }

            (uint256 amount0Out, uint256 amount1Out) = input == token0
                ? (uint(0), amountOutput)
                : (amountOutput, uint(0));

            address to = i < _path.length - 2
                ? _pairFor(FACTORY, output, _path[i + 2], PAIR)
                : _to;

            pair.swap(
                amount0Out,
                amount1Out,
                to,
                new bytes(0)
            );
        }
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
    {
        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            _amountIn
        );

        uint256 balanceBefore = IERC20(_path[_path.length - 1]).balanceOf(_to);

        _swapSupportingFeeOnTransferTokens(
            _path,
            _to
        );

        require(
            IERC20(_path[_path.length - 1]).balanceOf(_to) - balanceBefore >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );
    }

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        payable
        ensure(_deadline)
    {
        require(
            _path[0] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        uint256 amountIn = msg.value;

        IWETH(WETH).deposit{
            value: amountIn
        }();

        require(
            IWETH(WETH).transfer(
                _pairFor(
                    FACTORY,
                    _path[0],
                    _path[1],
                    PAIR
                ),
                amountIn
            ),
            "SwapsRouter: TRANSFER_FAIL"
        );

        uint256 balanceBefore = IERC20(_path[_path.length - 1]).balanceOf(_to);

        _swapSupportingFeeOnTransferTokens(
            _path,
            _to
        );

        require(
            IERC20(_path[_path.length - 1]).balanceOf(_to) - balanceBefore >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );
    }

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] calldata _path,
        address _to,
        uint256 _deadline
    )
        external
        ensure(_deadline)
    {
        require(
            _path[_path.length - 1] == WETH,
            "SwapsRouter: INVALID_PATH"
        );

        _safeTransferFrom(
            _path[0],
            msg.sender,
            _pairFor(
                FACTORY,
                _path[0],
                _path[1],
                PAIR
            ),
            _amountIn
        );

        _swapSupportingFeeOnTransferTokens(
            _path,
            address(this)
        );

        uint256 amountOut = IERC20(WETH).balanceOf(
            address(this)
        );

        require(
            amountOut >= _amountOutMin,
            "SwapsRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );

        IWETH(WETH).withdraw(
            amountOut
        );

        _safeTransferETH(
            _to,
            amountOut
        );
    }

    function pairFor(
        address _factory,
        address _tokenA,
        address _tokenB
    )
        external
        view
        returns (address predicted)
    {
        predicted = _pairFor(
            _factory,
            _tokenA,
            _tokenB,
            PAIR
        );
    }

    function getAmountsOut(
        uint256 _amountIn,
        address[] memory _path
    )
        external
        view
        returns (uint256[] memory amounts)
    {
        return _getAmountsOut(
            FACTORY,
            _amountIn,
            _path
        );
    }

    function getAmountsIn(
        uint256 _amountOut,
        address[] memory _path
    )
        external
        view
        returns (uint256[] memory amounts)
    {
        return _getAmountsIn(
            FACTORY,
            _amountOut,
            _path
        );
    }

    function getReserves(
        address _factory,
        address _tokenA,
        address _tokenB
    )
        internal
        view
        returns (
            uint256 reserveA,
            uint256 reserveB
        )
    {
        (address token0,) = sortTokens(
            _tokenA,
            _tokenB
        );

        (
            uint256 reserve0,
            uint256 reserve1,

        ) = ISwapsPair(
            _pairFor(
                _factory,
                _tokenA,
                _tokenB,
                PAIR
            )
        ).getReserves();

        (reserveA, reserveB) = _tokenA == token0
            ? (reserve0, reserve1)
            : (reserve1, reserve0);
    }

    function _getAmountsOut(
        address _factory,
        uint256 _amountIn,
        address[] memory _path
    )
        internal
        view
        returns (uint256[] memory amounts)
    {
        require(
            _path.length >= 2,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = new uint256[](
            _path.length
        );

        amounts[0] = _amountIn;

        for (uint256 i; i < _path.length - 1; i++) {

            (
                uint256 reserveIn,
                uint256 reserveOut

            ) = getReserves(
                _factory,
                _path[i],
                _path[i + 1]
            );

            amounts[i + 1] = getAmountOut(
                amounts[i],
                reserveIn,
                reserveOut
            );
        }
    }

    function _getAmountsIn(
        address _factory,
        uint256 _amountOut,
        address[] memory _path
    )
        internal
        view
        returns (uint256[] memory amounts)
    {
        require(
            _path.length >= 2,
            "SwapsRouter: INVALID_PATH"
        );

        amounts = new uint256[](
            _path.length
        );

        amounts[amounts.length - 1] = _amountOut;

        for (uint256 i = _path.length - 1; i > 0; i--) {

            (
                uint256 reserveIn,
                uint256 reserveOut

            ) = getReserves(
                _factory,
                _path[i - 1],
                _path[i]
            );

            amounts[i - 1] = getAmountIn(
                amounts[i],
                reserveIn,
                reserveOut
            );
        }
    }
}

contract RouterCodeCheck {

    function routerCodeHash()
        external
        pure
        returns (bytes32)
    {
        return keccak256(
            type(SwapsRouter).creationCode
        );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_feeToSetter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token0","type":"address"},{"indexed":true,"internalType":"address","name":"token1","type":"address"},{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"PairCreated","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allPairs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allPairsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cloneTarget","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"}],"name":"createPair","outputs":[{"internalType":"address","name":"pair","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeTo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeToSetter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_feeTo","type":"address"}],"name":"setFeeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeToSetter","type":"address"}],"name":"setFeeToSetter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000021ae363b6c9b16158a8e7e3b14ced19ce6f5b492

-----Decoded View---------------
Arg [0] : _feeToSetter (address): 0x21aE363B6C9b16158a8e7e3b14CED19cE6F5B492

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000021ae363b6c9b16158a8e7e3b14ced19ce6f5b492

114:3404:7:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;143:20;;;;;-1:-1:-1;;;;;143:20:7;;;;;;-1:-1:-1;;;;;178:32:11;;;160:51;;148:2;133:18;143:20:7;;;;;;;;169:26;;;;;-1:-1:-1;;;;;169:26:7;;;292:25;;;;;;:::i;:::-;;:::i;201:36::-;;;;;1077:125;1180:8;:15;1077:125;;553:25:11;;;541:2;526:18;1077:125:7;407:177:11;3174:342:7;;;;;;:::i;:::-;;:::i;:::-;;1208:1642;;;;;;:::i;:::-;;:::i;324:62::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;324:62:7;;;2856:312;;;;;;:::i;:::-;;:::i;292:25::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;292:25:7;;-1:-1:-1;292:25:7;:::o;3174:342::-;3300:11;;-1:-1:-1;;;;;3300:11:7;3286:10;:25;3265:95;;;;-1:-1:-1;;;3265:95:7;;1425:2:11;3265:95:7;;;1407:21:11;1464:2;1444:18;;;1437:30;-1:-1:-1;;;1483:18:11;;;1476:53;1546:18;;3265:95:7;;;;;;;;;-1:-1:-1;;;;;3392:28:7;;3371:101;;;;-1:-1:-1;;;3371:101:7;;;;;;;:::i;:::-;3483:11;:26;;-1:-1:-1;;;;;;3483:26:7;-1:-1:-1;;;;;3483:26:7;;;;;;;;;;3174:342::o;1208:1642::-;1318:12;1378:7;-1:-1:-1;;;;;1367:18:7;:7;-1:-1:-1;;;;;1367:18:7;;1346:88;;;;-1:-1:-1;;;1346:88:7;;2132:2:11;1346:88:7;;;2114:21:11;2171:2;2151:18;;;2144:30;2210:25;2190:18;;;2183:53;2253:18;;1346:88:7;1930:347:11;1346:88:7;1446:14;1462;1490:7;-1:-1:-1;;;;;1480:17:7;:7;-1:-1:-1;;;;;1480:17:7;;:83;;1546:7;1555;1480:83;;;1513:7;1522;1480:83;1445:118;;-1:-1:-1;1445:118:7;-1:-1:-1;;;;;;1595:22:7;;1574:95;;;;-1:-1:-1;;;1574:95:7;;;;;;;:::i;:::-;-1:-1:-1;;;;;1701:15:7;;;283:1;1701:15;;;:7;:15;;;;;;;;:23;;;;;;;;;;;;:39;1680:119;;;;-1:-1:-1;;;1680:119:7;;2484:2:11;1680:119:7;;;2466:21:11;2523:2;2503:18;;;2496:30;2562:34;2542:18;;;2535:62;-1:-1:-1;;;2613:18:11;;;2606:31;2654:19;;1680:119:7;2282:397:11;1680:119:7;1848:78;;-1:-1:-1;;2911:2:11;2907:15;;;2903:24;;1848:78:7;;;2891:37:11;2962:15;;;2958:24;2944:12;;;2937:46;1810:12:7;;2999::11;;1848:78:7;;;;;;;;;;;;1825:111;;;;;;1810:126;;1947:19;1990:11;1969:42;;1947:64;;2065:4;2059:11;-1:-1:-1;;;2108:5:7;2084:127;2283:11;2260:4;2253:5;2249:16;2225:83;-1:-1:-1;;;2357:4:7;2350:5;2346:16;2322:138;2506:4;2500;2493:5;2490:1;2482:29;2531:77;;-1:-1:-1;;;2531:77:7;;-1:-1:-1;;;;;3252:15:11;;;2531:77:7;;;3234:34:11;3304:15;;;3284:18;;;3277:43;2474:37:7;;-1:-1:-1;2531:27:7;;;;-1:-1:-1;2531:27:7;;3169:18:11;;2531:77:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;2619:15:7;;;;;;;:7;:15;;;;;;;;:23;;;;;;;;;;;;:30;;;;;-1:-1:-1;;;;;;2619:30:7;;;;;;;;2659:15;;;;;;:23;;;;;;;;:30;;;;;;;;2700:8;:19;;-1:-1:-1;2700:19:7;;;;;;;;;;;;;;;;;;;;;;2818:15;;2735:108;;3505:51:11;;;3572:18;;;3565:34;2735:108:7;;3478:18:11;2735:108:7;;;;;;;1336:1514;;;;1208:1642;;;;:::o;2856:312::-;2970:11;;-1:-1:-1;;;;;2970:11:7;2956:10;:25;2935:95;;;;-1:-1:-1;;;2935:95:7;;1425:2:11;2935:95:7;;;1407:21:11;1464:2;1444:18;;;1437:30;-1:-1:-1;;;1483:18:11;;;1476:53;1546:18;;2935:95:7;1223:347:11;2935:95:7;-1:-1:-1;;;;;3062:22:7;;3041:95;;;;-1:-1:-1;;;3041:95:7;;;;;;;:::i;:::-;3147:5;:14;;-1:-1:-1;;;;;;3147:14:7;-1:-1:-1;;;;;3147:14:7;;;;;;;;;;2856:312::o;222:180:11:-;281:6;334:2;322:9;313:7;309:23;305:32;302:52;;;350:1;347;340:12;302:52;-1:-1:-1;373:23:11;;222:180;-1:-1:-1;222:180:11:o;589:173::-;657:20;;-1:-1:-1;;;;;706:31:11;;696:42;;686:70;;752:1;749;742:12;686:70;589:173;;;:::o;767:186::-;826:6;879:2;867:9;858:7;854:23;850:32;847:52;;;895:1;892;885:12;847:52;918:29;937:9;918:29;:::i;:::-;908:39;767:186;-1:-1:-1;;;767:186:11:o;958:260::-;1026:6;1034;1087:2;1075:9;1066:7;1062:23;1058:32;1055:52;;;1103:1;1100;1093:12;1055:52;1126:29;1145:9;1126:29;:::i;:::-;1116:39;;1174:38;1208:2;1197:9;1193:18;1174:38;:::i;:::-;1164:48;;958:260;;;;;:::o;1575:350::-;1777:2;1759:21;;;1816:2;1796:18;;;1789:30;1855:28;1850:2;1835:18;;1828:56;1916:2;1901:18;;1575:350::o

ipfs://fa081df5e17b676f55079757c12e1bfb8cfff147f8ec82075a71c156c872c328