Uniswap v2-periphery : Router02 코드 분석

UniswapV2Router01 은 토큰 전송 시 수수료를 받는 일부 메서드가 작동하지 않아 현재 사용되지 않는다. Uniswap 백서에서는 UniswapV2Router02 사용을 권장하고 있다.
Router 는 상태를 저장하지 않고, 토큰을 보유하지 않기 때문에 필요한 경우 교체될 수 있다. 이것은 보다 효율적인 스마트컨트랙트 패턴이 발견되거나 추가 기능이 필요한 경우라고 한다.

pragma solidity =0.6.6;

import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';

import './interfaces/IUniswapV2Router02.sol';
import './libraries/UniswapV2Library.sol';
import './libraries/SafeMath.sol';
import './interfaces/IERC20.sol';
import './interfaces/IWETH.sol';

contract UniswapV2Router02 is IUniswapV2Router02 {
    using SafeMath for uint;

    address public immutable override factory;
    address public immutable override WETH;

    modifier ensure(uint deadline) {
        require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
        _;
    }

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

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

UniswapV2Router02 컨트랙트의 첫 부분이다. UniswapV2Library.sol 를 import 하고 있다는 것을 눈여겨 봐야 한다. Router02 코드 안에서 Library 의 함수를 많이 사용하고 있기 때문이다.
factory 와 WETH 컨트랙트의 주소를 immutable 로 선언하여 상수로써 사용하고 있으며, 처음 배포될 때 constructor 에 의해 초기화하고 있다.
modifier ensure() 는 블럭의 timestamp 를 이용해서 아직 deadline 이 지나지 않았는지 체크한다.
receive() 함수는 Router 컨트랙트가 WETH 컨트랙트의 fallback 을 통해서만 Eth 를 수신한다는 것을 명시한다.

// **** ADD LIQUIDITY ****
    function _addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin
    ) internal virtual returns (uint amountA, uint amountB) {
        // create the pair if it doesn't exist yet
        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
        if (reserveA == 0 && reserveB == 0) {
            (amountA, amountB) = (amountADesired, amountBDesired);
        } else {
            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
            if (amountBOptimal <= amountBDesired) {
                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
                (amountA, amountB) = (amountADesired, amountBOptimal);
            } else {
                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
                assert(amountAOptimal <= amountADesired);
                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
                (amountA, amountB) = (amountAOptimal, amountBDesired);
            }
        }
    }
    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
        liquidity = IUniswapV2Pair(pair).mint(to);
    }
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
        (amountToken, amountETH) = _addLiquidity(
            token,
            WETH,
            amountTokenDesired,
            msg.value,
            amountTokenMin,
            amountETHMin
        );
        address pair = UniswapV2Library.pairFor(factory, token, WETH);
        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
        IWETH(WETH).deposit{value: amountETH}();
        assert(IWETH(WETH).transfer(pair, amountETH));
        liquidity = IUniswapV2Pair(pair).mint(to);
        // refund dust eth, if any
        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
    }

addLiquidity() 와 addLiquidityETH() 함수는 이름 그대로 유동성을 추가하는 함수이다.
우선 두 함수가 처음부터 공통적으로 호출하는 _addLiquidity() 함수를 봐야 한다.
- tokenA, tokenB는 pair 를 이룰 토큰의 주소이다.
- amountADesired, amountBDesired 는 유동성으로 추가할 토큰의 양이다.
- amountAMin, amountBMin 은 각각 트랜잭션이 revert 되기 전에 B/A 또는 A/B 가격이 상승할 수 있는 범위를 제한하기 위해 최소 수량을 정한 것이다. (교환비는 한없이 낮아지거나 높아질 수 없다.)
- 만약 두 토큰의 pair 가 존재하지 않는다면, IUniswapV2Factory(factory).createPair(tokenA, tokenB) 구문으로 pair 컨트랙트를 생성한다. pair 생성만 되었기 때문에 reserve 는 0일 것이다.
- Library 컨트랙트에서 getReserves() 함수를 실행하여 두 토큰의 reserve 값을 읽어온다.
- 어느 한 토큰의 reserve 라도 보유량이 없다면 희망하는 A, B 토큰의 양 amountXDesired 를 amountX 에 대입한다.
- 만약 pair 컨트랙트가 이미 존재하고, 보유하고 있는 A, B 토큰의 양도 이미 있다면, A 토큰의 양을 기준으로 Library 의 quote() 함수를 실행하여, 비례식에 따라 필요한 B 토큰의 양을 정확히 계산하여 amountBOptimal 변수에 넣는다.
- 이후 amountBOptimal 이 amountBDesired 보다 작거나 같다면, 유동성 풀에 B 토큰을 너무 많이 넣는 것과 같다. 이때 amountBOptimal 은 당연히 amountBMin 보다는 크거나 같아야 한다. amountA 에는 희망하는 A 토큰의 양을 넣어주고, amountB 에는 비율에 맞게 amountBOptimal 값을 넣어주게 된다.
- 반면 amountBOptimal 이 amountBDesired 보다 크다면, 반대로 유동성 풀에 A 토큰을 너무 많이 넣는 것과 같다. Library 의 quote() 함수로 적정한 A 토큰의 양 amountAOptimal 을 구한다. amountAOptimal 은 amountAMin 보다는 크거나 같아야 하며, amountA 에는 amountAOptimal 값을 amountB 에는 amountBDesired 값을 넣어주게 된다.
- 모든 연산이 끝나면 실제 pool 에 들어갈 두 토큰의 양인 amountA 와 amountB 를 반환한다.
addLiquidity() 함수가 _addLiquidity() 함수 실행을 끝내면 pool 에 넣을 두 토큰의 양을 얻는다.
- Library 를 통해 두 토큰의 pair 컨트랙트 주소를 얻고, 토큰을 해당 컨트랙트로 전송한다.
- pair 컨트랙트에서는 pool 에 유입된 토큰의 양을 계산하여 LP 토큰을 발행한다.
addLiquidityETH() 함수도 마찬가지로 _addLiquidity() 함수 실행을 끝내면 pool 에 넣을 토큰과 Eth 의 양을 얻는다.
- Library 를 통해 토큰과 WETH 의 pair 컨트랙트 주소를 얻고, 토큰은 amount 만큼 해당 컨트랙트로 전송한다.
- Eth 를 처리하기 위해 WETH 컨트랙트에 들어온 Eth 의 양(msg.value)과 함께 deposit() 함수를 실행시켜 Eth 를 보관한다.
- 그 다음 Eth 의 양만큼 WETH 를 pair 컨트랙트로 전송하고, pair 컨트랙트의 mint() 함수를 실행시켜 LP 토큰을 발행한다.

// **** REMOVE LIQUIDITY ****
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair
        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
    }
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) public virtual override ensure(deadline) returns (uint amountToken, uint 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);
    }
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external virtual override returns (uint amountA, uint amountB) {
        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
        uint value = approveMax ? uint(-1) : liquidity;
        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
        (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
    }
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external virtual override returns (uint amountToken, uint amountETH) {
        address pair = UniswapV2Library.pairFor(factory, token, WETH);
        uint value = approveMax ? uint(-1) : liquidity;
        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
        (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline);
    }

removeLiquidity() 는 ERC20 <> ERC20 pool 에서 유동성을 제거한다.

removeLiquidityETH() 는 ERC20 <> WETH pool 에서 유동성을 제거하고 Eth 를 회수한다.

removeLiquidityWithPermit() 는 permit 으로 인해 사전승인(approval) 없이 ERC20 <> ERC20 pool 에서 유동성을 제거한다.

removeLiquidityETHWithPermit() 는 permit 으로 인해 사전승인(approval) 없이 ERC20 <> WETH pool 에서 유동성을 제거하고 Eth 를 회수한다.
removeLiquidity() 함수는 Library 에서 pair 컨트랙트의 주소를 가져와, pair 컨트랙트에 LP 토큰을 liquidity 만큼 반납한다.

이후 IUniswapV2Pair(pair).burn(to)을 실행하면 pair 컨트랙트는 변경된(반납된) liquidity 토큰에 해당하는 양만큼 pair 를 이루는 두 토큰의 양을 반환한다.

그리고 두 토큰의 주소를 비교하여 amount1 과 amount2 를 토큰에 맞게 순서를 재배치한뒤 최소 요구량보다 크거나 같은지 확인한다.