Uniswap-v2 Router合约分析（下)

已于 2022-03-02 13:28:48 修改
阅读量4.8k 收藏 2
点赞数 1
文章标签： 区块链 智能合约 以太坊
于 2022-02-21 20:05:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41943430/article/details/123054779
版权

原文发布在 https://github.com/33357/smartcontract-apps这是一个面向中文社区，分析市面上智能合约应用的架构与实现的仓库。欢迎关注开源知识项目！

交易

  • 内部函数（仅供合约内部调用）
    • _swap

      • 代码速浏览

        function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
    for (uint i; i < path.length - 1; i++) {
        (address input, address output) = (path[i], path[i + 1]);
        (address token0,) = UniswapV2Library.sortTokens(input, output);
        uint amountOut = amounts[i + 1];
        (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
        IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
            amount0Out, amount1Out, to, new bytes(0)
        );
    }
}

      • 参数分析

        函数 _swap 的入参有3个，出参有0个，对应的解释如下：

        function _swap(
    uint[] memory amounts, // 交易期望数量列表
    address[] memory path, // 交易路径列表
    address _to // 交易获得的 token 发送到的地址
) internal virtual {
    ...
}

        函数 _swap 实现了由多重交易组成的交易集合。path 数组里定义了执行代币交易的顺序，amounts 数组里定义了每次交换获得代币的期望数量，_to 则是最后获得代币发送到的地址。

      • 实现分析

        ...
{
    // 循环交易路径列表
    for (uint i; i < path.length - 1; i++) {
        // 从 path 中取出 input 和 output
        (address input, address output) = (path[i], path[i + 1]);
        // 从 input 和 output 中算出谁是 token0
        (address token0,) = UniswapV2Library.sortTokens(input, output);
        // 期望交易获得的代币数量
        uint amountOut = amounts[i + 1];
        // 如果 input == token0，那么 amount0Out 就是0，amount1Out 就是 amountOut；反之则相反
        (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        // 如果这是最后的一笔交易，那么 to 地址就是 _to，否则 to 地址是下一笔交易的流动池地址
        address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
        // 执行 input 和 output 的交易
        IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
            amount0Out, amount1Out, to, new bytes(0)
        );
    }
}

      • 总结

        由于执行 swap 时，需要排列 amount0Out、amount1Out 的顺序，因此需要计算 input、output 中谁是 token0。

  • 外部函数（仅供合约外部调用）
    • swapExactTokensForTokens

      • 代码速浏览

        function swapExactTokensForTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
) external virtual override ensure(deadline) returns (uint[] memory amounts) {
    amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    _swap(amounts, path, to);
}

      • 参数分析

        函数swapExactTokensForTokens的入参有5个，出参有1个，对应的解释如下：

        function swapExactTokensForTokens(
    uint amountIn,// 交易支付代币数量
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
) {
    ...
}

        函数 swapExactTokensForTokens 实现了用户使用数量精确的 tokenA 交易数量不精确的 tokenB 的流程。用户使用确定的 amountIn 数量的 tokenA ，交易获得 tokenB 的数量不会小于 amountOutMin，但具体 tokenB 的数量只有交易完成之后才能知道。这同样是由于区块链上交易不是实时的，实际交易和预期交易相比会有一定的偏移。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 获取 path 列表下，支付 amountIn 数量的 path[0] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
    // 如果最终获得的代币数量小于 amountOutMin，则交易失败
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    // 将 amounts[0] 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    // 按 path 列表执行交易集合
    _swap(amounts, path, to);
}

      • 总结

        可以看到，由于区块链上的实际交易和预期交易有偏差是常见的事情，因此在设计链上交易的时候逻辑会比较复杂，条件选择会有很多。

    • swapTokensForExactTokens

      • 代码速浏览

        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');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    _swap(amounts, path, to);
}

      • 参数分析

        函数swapTokensForExactTokens的入参有5个，出参有1个，对应的解释如下：

        function swapTokensForExactTokens(
    uint amountOut, // 交易获得的代币数量
    uint amountInMax, // 交易支付代币的最多数量
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
    ){
    ...
}

        函数 swapTokensForExactTokens 实现了用户使用数量不精确的 tokenA 交易数量精确的 tokenB 的流程。用户会使用数量不大于 amountInMax 数量的 tokenA，交易获得 amountOut 数量的 tokenB。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 获取 path 列表下，获得 amountIn 数量的 path[path.length-1] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
    // 如果 path[0] 代币数量大于 amountInMax，则交易失败
    require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
    // 将 amounts[0] 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    // 按 path 列表执行交易集合
    _swap(amounts, path, to);
}

      • 总结

        函数 swapTokensForExactTokens 完全是函数 swapExactTokensForTokens 的相反操作。一般来说，swapExactTokensForTokens 用于出售确定数量的代币，swapTokensForExactTokens 用于购买确定数量的代币。

    • swapExactETHForTokens

      • 代码速浏览

        function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    payable
    ensure(deadline)
    returns (uint[] memory amounts)
{
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path);
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    IWETH(WETH).deposit{value: amounts[0]}();
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
    _swap(amounts, path, to);
}

      • 参数分析

        函数swapExactETHForTokens的入参有4个，出参有1个，对应的解释如下：

        function swapExactETHForTokens(
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override payable ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
){
    ...
}

        函数 swapExactETHForTokens 和函数 swapExactTokensForTokens 的逻辑几乎一样，只是把支付精确数量的 token 换成了支付精确数量的 ETH。因此多了一些和 ETH 相关的额外操作。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 检查 path[0] 是否为 WETH 地址
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 获取 path 列表下，支付 amountIn 数量的 path[0] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path);
    // 如果最终获得的代币数量小于 amountOutMin，则交易失败
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    // 把用户支付的 ETH 换成 WETH
    IWETH(WETH).deposit{value: amounts[0]}();
    // 将 amounts[0] 数量的 WETH 代币从 Router 中转移到 path[0], path[1] 的流动池
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
    // 按 path 列表执行交易集合
    _swap(amounts, path, to);
}

      • 总结

        此函数一般用于出售确定数量的 ETH，获得不确定数量代币。

    • swapTokensForExactETH

      • 代码速浏览

        function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    ensure(deadline)
    returns (uint[] memory amounts)
{
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
    require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    _swap(amounts, path, address(this));
    IWETH(WETH).withdraw(amounts[amounts.length - 1]);
    TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
}

      • 参数分析

        函数 swapTokensForExactETH 的入参有5个，出参有1个，对应的解释如下：

        function swapTokensForExactETH(
    uint amountOut, // 交易获得的代币数量
    uint amountInMax, // 交易支付代币的最多数量
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
)external virtual override ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
){
    ...
}

        函数 swapTokensForExactETH 和 函数 swapExactETHForTokens 相比，仅交换了一下代币的交易顺序，执行逻辑还是差不多的。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 检查 path[path.length - 1] 是否为 WETH 地址
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 获取 path 列表下，获得 amountOut 数量的 path[path.length-1] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
    // 如果最终获得的代币数量小于 amountOutMin，则交易失败
    require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
    // 将 amounts[0] 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    // 按 path 列表执行交易集合
    _swap(amounts, path, address(this));
    // 将 WETH 换成 ETH
    IWETH(WETH).withdraw(amounts[amounts.length - 1]);  
    // 把 ETH 发送给 to 地址
    TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
}

      • 总结

        此函数一般用于购买确定数量的 ETH，用不定数量的代币交换。

    • swapExactTokensForETH

      • 代码速浏览

        function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    ensure(deadline)
    returns (uint[] memory amounts)
{
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    _swap(amounts, path, address(this));
    IWETH(WETH).withdraw(amounts[amounts.length - 1]);
    TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
}

      • 参数分析

        函数swapExactTokensForETH的入参有5个，出参有1个，对应的解释如下：

        function swapExactTokensForETH(
    uint amountIn,// 交易支付代币数量
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
){
    ...
}

        函数 swapExactTokensForETH 和 函数 swapTokensForExactETH 相比，是更换了输入精确数量代币的顺序。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 检查 path[path.length - 1] 是否为 WETH 地址
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 获取 path 列表下，支付 amountIn 数量的 path[0] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
    // 如果最终获得的代币数量小于 amountOutMin，则交易失败
    require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    // 将 amounts[0] 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
    );
    // 按 path 列表执行交易集合
    _swap(amounts, path, address(this));
    // 将 WETH 换成 ETH
    IWETH(WETH).withdraw(amounts[amounts.length - 1]);
    // 把 ETH 发送给 to 地址
    TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
}

      • 总结

        此函数一般用于出售确定数量代币，获得不确定数量的 ETH。

    • swapETHForExactTokens

      • 代码速浏览

        function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
    external
    virtual
    override
    payable
    ensure(deadline)
    returns (uint[] memory amounts)
{
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
    require(amounts[0] <= msg.value, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
    IWETH(WETH).deposit{value: amounts[0]}();
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
    _swap(amounts, path, to);
    if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]);
}

      • 参数分析

        函数swapETHForExactTokens的入参有4个，出参有1个，对应的解释如下：

        function swapETHForExactTokens(
    uint amountOut, // 交易获得的代币数量
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override payable ensure(deadline) returns (
    uint[] memory amounts // 交易期望数量列表
){
    ...
}

        函数 swapETHForExactTokens 和 函数 swapExactTokensForETH 相比，更换了代币交易的顺序。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline)
{
    // 检查 path[0] 是否为 WETH 地址
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 获取 path 列表下，获得 amountOut 数量的 path[path.length-1] 代币，各个代币交易的预期数量
    amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
    // 如果 ETH 数量小于 amounts[0]，交易失败
    require(amounts[0] <= msg.value, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
    // 将 WETH 换成 ETH
    IWETH(WETH).deposit{value: amounts[0]}();
    // 将 amounts[0] 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
    // 按 path 列表执行交易集合
    _swap(amounts, path, to);
    // 如果 ETH 数量大于 amounts[0]，返还多余的 ETH
    if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]);
}

      • 总结

        此函数一般用于购买确定数量代币，支付不确定数量的 ETH。

交易（支持代付GAS代币）

  • 内部函数（仅供合约内部调用）
    • _swapSupportingFeeOnTransferTokens

      • 代码速浏览

        function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual {
    for (uint i; i < path.length - 1; i++) {
        (address input, address output) = (path[i], path[i + 1]);
        (address token0,) = UniswapV2Library.sortTokens(input, output);
        IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output));
        uint amountInput;
        uint amountOutput;
        {
            (uint reserve0, uint reserve1,) = pair.getReserves();
            (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
            amountInput = IERC20(input).balanceOf(address(pair)).sub(reserveInput);
            amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput);
        }
        (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOutput) : (amountOutput, uint(0));
        address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
        pair.swap(amount0Out, amount1Out, to, new bytes(0));
    }
}

      • 参数分析

        函数 swapETHForExactTokens 的入参有2个，出参有0个，对应的解释如下：

        function _swapSupportingFeeOnTransferTokens(
    address[] memory path, // 交易路径列表
    address _to // 交易获得的 token 发送到的地址
) internal virtual {
    ...
}

        函数 _swapSupportingFeeOnTransferTokens 相比函数 _swap 为了支持 path 中有交易后可变数量的代币，不需要输入 amounts，但需要额外做一些操作。

      • 实现分析

        ... 
{
    // 循环交易路径列表
    for (uint i; i < path.length - 1; i++) {
        // 从 path 中取出 input 和 output
        (address input, address output) = (path[i], path[i + 1]);
        // 从 input 和 output 中算出谁是 token0
        (address token0,) = UniswapV2Library.sortTokens(input, output);
        // 获得 input, output 的流动池
        IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output));
        uint amountInput;
        uint amountOutput;
        {
            // 获取流动池库存 reserve0, reserve1
            (uint reserve0, uint reserve1,) = pair.getReserves();
            // 如果 input == token0，那么 (reserveInput,reserveOutput) 就是 (reserve0, reserve1)；反之则相反
            (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
            // amountInput 等于流动池余额减去 reserveInput
            amountInput = IERC20(input).balanceOf(address(pair)).sub(reserveInput);
            // 获取 amountOutput
            amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput);
        }
        // 如果 input == token0，那么 amount0Out 就是0，amount1Out 就是 amountOut；反之则相反
        (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOutput) : (amountOutput, uint(0));
        // 如果这是最后的一笔交易，那么 to 地址就是 _to，否则 to 地址是下一笔交易的流动池地址
        address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
        // 执行 input 和 output 的交易
        pair.swap(amount0Out, amount1Out, to, new bytes(0));
    }
}

      • 总结

        可以看到，因为没有 amounts，需要使用流动池余额减去库存来计算amountInput。

  • 外部函数（仅供合约外部调用）
    • swapExactTokensForTokensSupportingFeeOnTransferTokens

      • 代码速浏览

        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
) external virtual override ensure(deadline) {
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
    );
    uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
    _swapSupportingFeeOnTransferTokens(path, to);
    require(
        IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
        'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
    );
}

      • 参数分析

        函数swapExactTokensForTokensSupportingFeeOnTransferTokens的入参有5个，出参有0个，对应的解释如下：

        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint amountIn,// 交易支付代币数量
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override ensure(deadline) {
    ...
}

        函数 swapExactTokensForTokensSupportingFeeOnTransferTokens 相比函数 swapExactTokensForTokens，少了 amounts，因为交易后可变数量的代币不能做amounts的预测。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline) 
{
    // 将 amountIn 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
    );
    // 记录 to 地址 path[path.length - 1] 代币的余额
    uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
    // 按 path 列表执行交易集合
    _swapSupportingFeeOnTransferTokens(path, to);
    // 如果 to 地址获得的代币数量小于 amountOutMin，交易失败
    require(
        IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
        'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
    );
}

      • 总结

        该函数适用于支付确定数量的代币，获得不定数量的代币，且在 path 路径列表中有交易后数量可变的代币。

    • swapExactETHForTokensSupportingFeeOnTransferTokens

      • 代码速浏览

        function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
)
    external
    virtual
    override
    payable
    ensure(deadline)
{
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    uint amountIn = msg.value;
    IWETH(WETH).deposit{value: amountIn}();
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn));
    uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
    _swapSupportingFeeOnTransferTokens(path, to);
    require(
        IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
        'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
    );
}

      • 参数分析

        函数swapExactETHForTokensSupportingFeeOnTransferTokens的入参有5个，出参有0个，对应的解释如下：

        function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override payable ensure(deadline)
{
    ...
}

        函数 swapExactETHForTokensSupportingFeeOnTransferTokens 相比函数 swapExactETHForTokens，同样少了 amounts，因为交易后可变数量的代币不能做amounts的预测。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline) 
{
    // 检查 path[0] 是否为 WETH
    require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 获取 amountIn
    uint amountIn = msg.value;
    // 把 ETH 换成 WETH
    IWETH(WETH).deposit{value: amountIn}();
    // 将 amountIn 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn));
    // 记录 to 地址 path[path.length - 1] 代币的余额
    uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
    // 按 path 列表执行交易集合
    _swapSupportingFeeOnTransferTokens(path, to);
    // 如果 to 地址获得的代币数量小于 amountOutMin，交易失败
    require(
        IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
        'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
    );
}

      • 总结

        该函数适用于支付确定数量的 ETH，获得不定数量的代币，且在 path 路径列表中有交易后数量可变的代币。

    • swapExactTokensForETHSupportingFeeOnTransferTokens

      • 代码速浏览

        function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
)
    external
    virtual
    override
    ensure(deadline)
{
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
    );
    _swapSupportingFeeOnTransferTokens(path, address(this));
    uint amountOut = IERC20(WETH).balanceOf(address(this));
    require(amountOut >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    IWETH(WETH).withdraw(amountOut);
    TransferHelper.safeTransferETH(to, amountOut);
}

      • 参数分析

        函数swapExactTokensForETHSupportingFeeOnTransferTokens的入参有5个，出参有0个，对应的解释如下：

        function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint amountIn,// 交易支付代币数量
    uint amountOutMin, // 交易获得代币最小值
    address[] calldata path, // 交易路径列表
    address to, // 交易获得的 token 发送到的地址
    uint deadline // 过期时间
) external virtual override ensure(deadline) {
    ...
}

        函数 swapExactTokensForETHSupportingFeeOnTransferTokens 相比函数 swapExactTokensForETH，也少了 amounts，因为交易后可变数量的代币不能做amounts的预测。

      • 实现分析

        ... 
// 检查交易是否过期
ensure(deadline) 
{
    // 检查 path[path.length - 1] 是否为 WETH
    require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
    // 将 amountIn 数量的 path[0] 代币从用户账户中转移到 path[0], path[1] 的流动池
    TransferHelper.safeTransferFrom(
        path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
    );
    // 按 path 列表执行交易集合
    _swapSupportingFeeOnTransferTokens(path, address(this));
    // 获取 Router 中的 WETH 余额
    uint amountOut = IERC20(WETH).balanceOf(address(this));
    // amountOut 大于 amountOutMin，否则交易失败
    require(amountOut >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
    // 将 WETH 换成 ETH
    IWETH(WETH).withdraw(amountOut);
    // 将 ETH 发送给 to 地址
    TransferHelper.safeTransferETH(to, amountOut);
}

      • 总结

        该函数适用于支付确定数量的 token，获得不定数量的 WETH，且在 path 路径列表中有交易后数量可变的代币。

33357
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UniswapV2周边合约学习（三）-- UniswapV2Router02.sol（下）
天草降临的博客
10-18 6881
Uniswap是当前以太坊上最流行的去中心化交易所，它使用恒定乘积算法来自动做市，任何人都可以在上面创建自己的ERC20代币交易对。本文为个人学习UniswapV2智能合约源码的系列记录文章。
Solidity Uniswap V2 Router contract addLiquidity
最新发布
The future is already here it's just not evenly distributed。
03-14 872
在这个函数中，我们要找到满足我们所需和最低金额的流动性金额。由于从我们在用户界面选择流动性金额到我们的交易被处理之间存在延迟，实际reserve比率可能会发生变化，这将导致我们损失一些 LP-token（作为对存入不平衡流动性的惩罚）。报价是库合约中的另一个函数：通过输入金额和配对储备金，计算输出金额，即tokenA 的价格乘以token B 的输入金额。如果储备金是空的，那么这是一对新的货币对，这意味着我们的流动性将决定储备金比率，这意味着我们不会因为提供不平衡的流动性而受到惩罚。
Uniswap-v2 Router合约分析（上）
qq_41943430的博客
02-20 5416
Uniswap-v2 Router合约分析（上)
完整部署uniswap 合约、前端教程（可部署uniswap到bsc、heco）
zgf1991 IT新人
10-17 2万+
文章目录前提条件部署合约部署工厂和WETH合约部署路由合约（重要环节！！）步骤1 获取字节码步骤2 获得initCode步骤3 替换路由中的initCode当前部署结果部署前端其他补充（懂solidity的可以看看）添加流动性交换方法工具in/out计算公式推导 参考链接 崔棉大师的教程 手把手教你部署自己的uniswap交易所 之前部署是跟着崔棉大师的教程走的，但是部署完了，没法实际使用，添加流动性还是交易会报错 这里主要是做补充; 前提条件 自己有账号，且申请测试以太坊 (ropsten直接小狐狸 b
【区块链 | Uniswap】2.剖析DeFi交易产品之Uniswap：V2中篇
08-19 803
上篇我们主要讲了 UniswapV2 整体分为了哪些项目，并重点讲解了的核心代码实现。这篇我们来看看。本篇文章核心就是讲解路由合约的实现，因为接口比较多，就没有全部都展开进行阐述，但核心逻辑基本都已经讲解了。下篇再来聊聊质押挖矿合约，以及 TWAP。
uniswap-v3-periphery:与Uniswap v3交互的外围智能合约
04-02
Uniswap V3外围设备 该存储库包含Uniswap V3协议的外围智能合约。 有关较低级别的核心合同，请参见存储库。本地部署为了将此代码部署到本地测试网，您应该安装npm软件包@uniswap/v3-periphery并导入从位于@uniswap/...
koa-router-analysis:koa-router源码分析
05-09
《深入剖析Koa-router：基于JavaScript的Web应用路由解析》 Koa-router是基于Node.js的Koa框架的一个核心中间件，它为开发者提供了强大的路由处理能力，使得构建RESTful API变得更为简洁高效。在本篇文章中，我们将...
stencil-router-v2
05-02
模具路由器v2 模板路由器V2是针对模板的实验性新路由器，主要关注于： 轻量级（600字节） Treeshakable （未使用的功能未包含在最终...安装npm install stencil-router-v2 --save-dev例子import { createRouter , Route
uni-simple-router实现简单的路由守卫
04-21
在`uni-simple-router-my-demo-master`这个项目中，你可以找到一个具体的示例，展示如何配置和使用这些路由守卫。研究这个示例代码，将有助于你更好地理解如何在uni-app中实现实用的路由管理和控制。 总结一下，uni...
vue学习之Vue-Router用法实例分析
11-28
本文实例讲述了vue学习之Vue-Router用法。分享给大家供大家参考，具体如下： Vue-router就像一个路由器，将组件(components)映射到路由(routes)后，通过点击<router>它可以在<router>中将相应的组件渲染出来。 1、...
UniswapV2-SwapExactEthForTokens
02-11
UniswapV2-SwapExactEthForTokens
UniswapV2代码中文注释
m0_60938243的博客
05-25 485
Uniswap V2是一种基于以太坊的去中心化交易协议，旨在提供快速、安全、无信任的代币交换服务。它是Uniswap协议的第二个版本，是对第一个版本的改进和升级。
UniswapV2Library.sol
的博客
06-14 2741
pragma solidity >=0.5.0; //导入了Pair import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol'; //导入了SafeMath，包含add、sub、mul import "./SafeMath.sol"; library UniswapV2Library { using SafeMath for uint; //返回分离过的token地址，用于控制按顺序分类过的交易对的返回.
UniswapV2Router02.sol
的博客
06-15 9349
pragma solidity =0.6.6; //导入工厂接口 import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol'; //导入TransferHelper，里面提供一些safe转账方法，以后细看 import '@uniswap/lib/contracts/libraries/TransferHelper.sol'; //导入Router02接口 import './interfaces/IUniswapV2Rou.
pancakeswap 抢币
热门推荐
06-29 2万+
前断时间 pancakeswap抢币 比较流行，所以研究了下pancakeswap 合约 抢币核心函数就是swapExactTokensForTokens 用一种币换另外一种币 pancakeswap合约分为 factory router pair 3个核心部分，其他的还有些周边合约，暂时用不上(bakeryswap和uniswap都一样的架构) 第一步: 先向币1合约地址 approve 允许router合约花费当前账户多少数量的币 approve函数如下 function approve.
UniswapV2周边合约学习（一）-- 工具库学习
天草降临的博客
10-09 4913
Uniswap是当前以太坊上最流行的去中心化交易所，它使用恒定乘积算法来自动做市，任何人都可以在上面创建自己的ERC20代币交易对。本文为个人学习UniswapV2智能合约源码的系列记录文章。
学习二：调用流动性接口，进行添加流动性
fengjinghong的博客
03-01 1万+
1、部署合约后调用添加流动性的函数的各个参数： 2、调用函数成功后的交易截图如下： 代码参考： * 注意——（代码片段前面的有些接口，库函数并未使用，是用来做其他操作的） *（在提供流动性的时候注意合约是否有足够的相应的币，如果不够会报“金额不足”的错误，最后执行也不会成功，所以调试的时候数值尽量写的少一点就可以了，，，，记住一定得提前向合约中提供相应的币才可以进行添加流动性操作。，，，） // SPDX-License-Identifier: GPL-3.0 pragma solidity
Uniswap计算过程推演
biakia的专栏
04-10 2797
0、创建一个交易对 假设创建了一个DAI/USDT交易对，其中有一个用户lpUser负责存入和提取交易对，另一个用户swapUser负责交易。 1、初始状态
uni-simple-router router-view
09-26
在uni-simple-router中，router-view是一个必需的组件，用于渲染路由对应的组件。 uni-simple-router的使用步骤如下： 1. 在router目录下的index.js中引入需要的模块，并初始化路由对象。 2. 可以为h5平台进行一些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值