Uniswap V2 入門＆徹底解析

function createPair(address tokenA, address tokenB) external returns (address pair) {
    // tokenAとtokenBが同じでないことを確認
    require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
    // tokenAとtokenBを比較して大きい方をtoken0小さい方をtoken1へ入れ直す
    (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    // token0のアドレスが０でないことを確認
    require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
    // token0とtoken1のペアが存在していないか確認
    require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
    // UniswapV2Pairのバイトコード取得
    bytes memory bytecode = type(UniswapV2Pair).creationCode;
    // token0とtoken1のアドレスを文字列結合してhash化でsaltを作る
    bytes32 salt = keccak256(abi.encodePacked(token0, token1));
    assembly {
        // create2を使ってコントラクトアドレスをデプロイ前に計算
        pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
    }
    // UniswapV2Pairのイニシャライズをする
    IUniswapV2Pair(pair).initialize(token0, token1);
    // pairのmapにtoken0とtoknen1のpairのアドレスを入れておく
    getPair[token0][token1] = pair;
    // 逆のtoken1&token0にも同じようにする
    getPair[token1][token0] = pair; // populate mapping in the reverse direction
    // pairのアドレスが入った配列のallPairsに追加
    allPairs.push(pair);
    // emitでペア作成を通知
    emit PairCreated(token0, token1, pair, allPairs.length);
}

IUniswapV2Factory factory;
address pair;
function create(address _tokenA, address _tokenB) external {
    pair = factory.createPair(_tokenA, _tokenB);
}

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);
        // tokenAをペアcontractへ送る
        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
        // tokenBをペアcontractへ送る
        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
        // ここで流動性トークンをtoに発行
        liquidity = IUniswapV2Pair(pair).mint(to);
    }

// **** 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);
        // 保有量が両方とも0かをチェック
        if (reserveA == 0 && reserveB == 0) {
            // 保有量が両方ゼロなら希望するトークンの量をペアにそれぞれ入れます
            (amountA, amountB) = (amountADesired, amountBDesired);
        } else {
            // ペアがどちらもゼロでなければ、ペアの保有量からamountBの最適なトークン量を計算する
            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
            // 上記で求められたamountBOptimalのトークン量が希望するトークン量より小さいと
            if (amountBOptimal <= amountBDesired) {
                // 最適なトークン量が最低トークン量より少なければエラー
                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
                // ここでamountBのトークン量は最適なトークン量となる
                (amountA, amountB) = (amountADesired, amountBOptimal);
            } else {
                // amountBOptimalのトークン量が希望するトークン量より小さいと

                // ペアの保有量からamountAの最適なトークン量を計算する
                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
                // amountAOptimal が amountADesired　より大きいとエラーになる
                // ここではassertが使われているためここで引っかかるとガス代も消費する
                assert(amountAOptimal <= amountADesired);
                // 最適なトークン量が最低トークン量より少なければエラー
                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
                // ここでamountAのトークン量は最適なトークン量となる
                (amountA, amountB) = (amountAOptimal, amountBDesired);
            }
        }
    }

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);
        // ERC20トークンをペアcontractへ送る 
        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
        // ETHをWETHへ変換
        IWETH(WETH).deposit{value: amountETH}();
        // WETH をペアcontractへ送る
        assert(IWETH(WETH).transfer(pair, amountETH));
        // ここで流動性トークンをtoに発行
        liquidity = IUniswapV2Pair(pair).mint(to);
        // refund dust eth, if any
        // 実際に送った金額と使用した金額に差異がある場合をあまりを返却する
        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
    }

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
        // ペアの流動性トークンをburnする
        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
        // tokenA,tokenBをソートして大きい順に並べ替える
        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
        // amountの並び替え
        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
        // 引き出す最小限のtokenAの量より大きか確認
        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
        // 引き出す最小限のtokenBの量より大きか確認
        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) {
        // removeLiquidityをそのまま使うでもETHを使えないので、wethを代わりに使い本来の処理の流れにしている
        (amountToken, amountETH) = removeLiquidity(
            token,
            WETH,
            liquidity,
            amountTokenMin,
            amountETHMin,
            address(this),
            deadline
        );
        // 引き出すトークンを対象のアドレスへ送る
        TransferHelper.safeTransfer(token, to, amountToken);
        // WETH→ETHへ変換
        IWETH(WETH).withdraw(amountETH);
        // ETHを返却
        TransferHelper.safeTransferETH(to, amountETH);
    }

// **** SWAP ****
    // requires the initial amount to have already been sent to the first pair
    function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
        // swapするアドレスの配列をループで回す
        for (uint i; i < path.length - 1; i++) {
            // アドレスの１つ目と次の配列のアドレスをinputとoutputとして変数に入れる
            (address input, address output) = (path[i], path[i + 1]);
            // 入力と出力トークンをソートし、token0（より小さいアドレス）を取得します
            (address token0,) = UniswapV2Library.sortTokens(input, output);
            // 現在のペアでの出力金額を取得します
            uint amountOut = amounts[i + 1];
            // input == token0の条件に合えばinputにゼロのamount0OutでtokenにamountOutの値を入れたamount1Out
            (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
            // 取引の受信者アドレスを設定します。最後のペアではない場合、次のペアのアドレスを設定し、最後のペアの場合、_toアドレスを使用します
            address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
            // 現在のペアでのswap関数を呼び出し、トレードを実行します。
            IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
                amount0Out, amount1Out, to, new bytes(0)
            );
        }
    }

function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
        // swapするトークンの出力金額を予測し計算
        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
        // 予測の金額が最低出力額より大きいことを担保
        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
        // swap予定のトークンをペアcontractへ送金
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
        );
        // swap処理
        _swap(amounts, path, to);
    }

function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
        // 特定の出力トークン量を取得するために必要な入力トークン量を計算
        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
        // 入力されるトークン量が最大入力量でないことを確認
        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
        // swap予定のトークンをペアcontractへ送金
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
        );
        // swap処理
        _swap(amounts, path, to);
    }

function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    ensure(deadline)
    returns (uint[] memory amounts)
    {
        // pathの最後がWETHであることを確認
        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
        // 特定の出力トークン量を取得するために必要な入力トークン量を計算
        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
        // 入力されるトークン量が最大入力量でないことを確認
        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
        // swap予定のトークンをペアcontractへ送金
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
        );
        // swap処理
        _swap(amounts, path, address(this));
        // WETH -> ETHへ戻す
        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
        // ETHをtoへ送金する
        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
    }

function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    payable
    ensure(deadline)
    returns (uint[] memory amounts)
    {
        // pathの最初がWETHであることを確認
        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
        // swapするトークンの出力金額を予測し計算
        amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path);
        // amountsの最後の金額が最小出力量より大きいことを確認
        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
        // ETH -> WETHへ変換します
        IWETH(WETH).deposit{value: amounts[0]}();
        // WETHがペアcontractへ送れていることを確認＆送金
        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
        // swap処理
        _swap(amounts, path, to);
    }