核心合约

v2-core

v2-core核心合约库主要有三个合约文件:

UniswapV2ERC20.sol: LPToken 代币合约
UniswapV2Factory.sol: 工厂合约，用于创建 Pair 合约
UniswapV2Pair.sol: 配对合约，每个交易对都是一个Pair合约，管理者流动性资金池

三者之间的关系

UniswapV2ERC20

基础属性已定义好

string public constant name = 'Uniswap V2';
string public constant symbol = 'UNI-V2';
uint8 public constant decimals = 18;

Pair合约继承了UniswapV2ERC20合约。每当创建一个新的交易对时，就会创建一个新的Pair合约。所以每个交易对对应不同的Pair合约地址，Pair合约发出来的LPToken名字一样，但是地址不同

LPToken: 流动性凭证，代表了用户所占池子的份额。

用户添加流动性: Pair 合约会给用户发放LPToken,代表了用户添加的流动性占当前交易对池的份额
用户移除流动性: 将LPToken转给Pair合约，Pair合约根据所占份额，将交易对代币转给用户，同时销毁LPToken。

每个配对合约都有对应的一种 LP Token 与之绑定。其实，UniswapV2Pair 继承了 UniswapV2ERC20，所以配对合约本身其实也是 LP Token 合约。

如果 A 将LPToken转给了 B，则 B 可以将 A 的流动性取出。所以要避免将LPToken进行转账或交易

UniswapV2Factory

工厂合约用户负责创建 Pair 合约，最核心的方法是createPair()

function createPair(address tokenA, address tokenB) external returns (address pair) {
    require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
    // 对两个Token进行排序
    (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
    // 如果Pair合约已经存在，不能重复创建，直接在已有的Pair合约上添加流动性即可
    require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
    // 获取Pair合约的byteCode
    bytes memory bytecode = type(UniswapV2Pair).creationCode;
    // 通过对排序后的两个Token的编码进行hash，得出create2方法的salt。只要两个Token地址一样，salt就会一样
    bytes32 salt = keccak256(abi.encodePacked(token0, token1));
    // 内联汇编
    assembly {
        // 通过create2方法创建的合约地址可以预先被计算出来。由于bytecode不变，salt也不变。所以计算出来的pair合约地址也不变
        pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
    }
    // 这里调用Pair合约的初始化方法，因为create2不支持constructor方法传参，所以Pair合约单独提供了initialize来初始化参数
    IUniswapV2Pair(pair).initialize(token0, token1);
    // 将Pair合约保存到mapping里，方便外部查询
    getPair[token0][token1] = pair;
    getPair[token1][token0] = pair; // populate mapping in the reverse direction
    // 将pair合约保存到数组里
    allPairs.push(pair);
    emit PairCreated(token0, token1, pair, allPairs.length);
}

创建合约的方法 通过合约创建合约一般有两种方法，

方法一:

UniswapV2Pair newPair = new UniswapV2Pair();

方法二:

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

通过 create2 方法创建的合约的好处是地址可以预先被计算出来。由于 bytecode 不变，salt 也不变。所以计算出来的 pair 合约地址也不变.

creationCode

UniswapV2Library库中硬编码设置的INIT_CODE_PAIR_HASH是通过Pair合约的creationCode进行 hash 运算以后获得

合约中获得INIT_CODE_PAIR_HASH的方法

bytes32 public constant INIT_CODE_PAIR_HASH = keccak256(abi.encodePacked(type(UniswapV2Pair).creationCode));

通过web3.js库获得INIT_CODE_PAIR_HASH的方法

const INIT_CODE_PAIR_HASH = await web3.utils.keccak256("0x" + pairContract.bytecode)

UniswapV2Pair

Pair合约是由Factory合约创建的，每个交易对有唯一的一个Pair合约地址 Pair合约主要包含一下三个操作方法

mint(): 添加流动性，同时给添加用户发送LPToken
burn(): 移除流动性，同时销毁LPToken
swap(): 兑换

初始化参数

// factory合约创建Pair合约，所以msg.sender是factory合约地址。
constructor() public {
    factory = msg.sender;
}

// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
    // 这里限定了只能由factory合约创建，并且只会初始化一次。因为factory合约里判定了，如果存在pair合约则报错
    require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
    token0 = _token0;
    token1 = _token1;
}

mint

合约注释解析

/**
 * 用户添加流动性
 * 1. 通过Router合约提前将代币转到当前Pair合约
 * 2. 调用mint方法，如果添加成功，Pair合约会发送LPToken给to地址
 */
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
    // 查询池子原有代币数量
    (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
    // 查询当前余额，用户添加流动性时，通过Router合约或者自己把对应的代币转到Pair合约
    uint balance0 = IERC20(token0).balanceOf(address(this));
    uint balance1 = IERC20(token1).balanceOf(address(this));
    // 用户转入的数量 = 当前余额 - 池子原有代币数量
    uint amount0 = balance0.sub(_reserve0);
    uint amount1 = balance1.sub(_reserve1);

    // 检查是否开启了手续费开关
    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
    // 通过LPToken的totalSupply是否为0，来判断是否是首次添加流动性
    if (_totalSupply == 0) {
        // 通过两个代币的乘积开根号，再减去MINIMUM_LIQUIDITY=1000固定最小流动性值，得出流动性数量
        liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
        // 将最小流动性MINIMUM_LIQUIDITY=1000销毁
        // 这里的具体原因可以参考UNI文档: https://docs.uniswap.org/protocol/V2/concepts/protocol-overview/smart-contracts#minimum-liquidity
        _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
    } else {
        // 不是首次添加流动性
        liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
    }
    require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
    // 将LPToken mint给to地址(即添加流动性的用户地址)
    _mint(to, liquidity);

    // 更新当前池子的流动性
    _update(balance0, balance1, _reserve0, _reserve1);
    // 如果开启了协议手续费，计算协议手续费并更新K值
    // UNI手续费是0.3%, 如果没有开启协议手续费，这些收入都是给流动性提供者，如果开启了，会有0.05%给UNI团队，0.25%给流动性提供者
    if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
    emit Mint(msg.sender, amount0, amount1);
}

这个mint方法是一个底层添加流动性的方法，由外围的Router合约调用或者用户直接调用

这里几点补充说明

代币是怎么添加到流动性池的

Router合约调用该mint方法前，已前置结算了需要转到Pair合约的tokenA和tokenB的数量
Router合约将两个token转到Pair合约，然后，调用该mint方法，进行铸造LPToken

协议手续费

UNI 默认手续0.3%的交易手续费。还有一个是否开启协议手续费的开关

如果没有开启协议手续费，则0.3%的交易手续费都会给流动性提供者
如果开启了协议手续费，则0.05%的交易手续费给 UNI 官方，0.25%的交易手续费给流动性提供者
交易手续费是在移除流动性时给流动性提供者，交易时只是计算

最小流动性: MINIMUM_LIQUIDITY

官方解释: MINIMUM_LIQUIDITY

To ameliorate rounding errors and increase the theoretical minimum tick size for liquidity provision, pairs burn the first MINIMUM_LIQUIDITY pool tokens. For the vast majority of pairs, this will represent a trivial value. The burning happens automatically during the first liquidity provision, after which point the totalSupply is forevermore bounded.

公式推导

首次添加流动性

liquidity = √(amount0*amount1) - MINIMUM_LIQUIDITY

不是首次添加流动性

取下面两个值中较小的那个

liquidity1 = amount0 * totalSupply / reserve0
liquidity2 = amount1 * totalSupply / reserve1

_update 方法

该方法主要处理两个事情

累加计算 price0CumulativeLast 和 price1CumulativeLast.这两个价格是用来计算TWAP的
更新 reserve0 和 reserve1

UNI 使用uint112是因为 UNI 的模型是一个恒定积公式。这样就保证了 k = uint112 * uint112计算以后，K 值不会超过uint256

// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
    // 确保最新的池子余额没有溢出
    // 在solidity0.5.16的版本里，uint112(-1) = 2 ** 112 -1
    require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
    // 这里block.timestamp % 2**32是因为上面blockTimestampLast定义的是uint32类型。
    // 当前时间戳可以用32位存下，2**32是到2106-02-07 14:28:16。这里由于取了模，所以顶多到时候重新从0开始计算
    // Math.floor(Date.now() / 1000) == 1657012087
    //                         2**32 == 4294967296
    // 所以为什么UNI使用了uint32来存储
    uint32 blockTimestamp = uint32(block.timestamp % 2**32);
    // 计算两次更新的时间间隔。用于计算TWAP价格
    uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
    if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
        // * never overflows, and + overflow is desired
        // 两个token的累加价格
        price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
        price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
    }
    // 更新当前池子的储备量
    reserve0 = uint112(balance0);
    reserve1 = uint112(balance1);
    blockTimestampLast = blockTimestamp;
    emit Sync(reserve0, reserve1);
}

burn

// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
    // 查询当前流动性池的两个代币的储备量。用于下面_update方法计算TWAP价格
    (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
    address _token0 = token0;                                // gas savings
    address _token1 = token1;                                // gas savings
    uint balance0 = IERC20(_token0).balanceOf(address(this));
    uint balance1 = IERC20(_token1).balanceOf(address(this));
    // 查询当前池子的LPToken数量，默认情况下这个数量为0，因为LPToken都在用户手里。
    // 当移除流动性时，用户需要先将LPToken转到Pair合约(这里就有值了)，然后在进行移除操作
    uint liquidity = balanceOf[address(this)];

    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
    // 这里通过用户的LPToken所占份额计算可领取的amount0的数量
    amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
    amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
    // 如果添加过交易对，amount0和amount1都会大于0
    require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
    // 销毁LPToken
    _burn(address(this), liquidity);
    _safeTransfer(_token0, to, amount0);
    _safeTransfer(_token1, to, amount1);
    balance0 = IERC20(_token0).balanceOf(address(this));
    balance1 = IERC20(_token1).balanceOf(address(this));

    // 1.更新提取后的池子余额 2. 计算TWAP价格
    _update(balance0, balance1, _reserve0, _reserve1);
    // 如果开启了协议手续费，更新K值
    if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
    emit Burn(msg.sender, amount0, amount1, to);
}

这里怎么计算两个代币分别可提取的数量

amount0 = liquidity.mul(balance0) / _totalSupply;
=>
amount = liquidity / totalSupply * balance
提取数量 = 用户流动性 / 总流动性 * 代币总余额

由于合约里遇到计算需要遵循先乘再除的原则。否则前面除法得出的是 0，再乘以后就会恒等于 0

swap

// swap方法中，用户首先通过Router合约将amountIn转入到合约，然后计算可以转入的代币数量
// amount0Out: 兑换结果转出的token0 amount1Out: 兑换结果转出的token1 (即用户买入的token之一)
// 正常兑换时，amount0Out | amount1Out 中有一个为0。 如果是FlashSwap，则两个可以都不为0
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
    // 要求至少要兑换一种代币
    require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
    (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
    // 要求用户买入的token数量不能大于池子的储备量
    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');

    uint balance0;
    uint balance1;
    // 这里使用{}括起来是防止堆栈调用太深导致报错(由于里面有闪电贷逻辑，在闪电贷合约中可能执行一些逻辑)
    { // scope for _token{0,1}, avoids stack too deep errors
    address _token0 = token0;
    address _token1 = token1;
    // 要求接收地址不能是0地址
    require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
    // 乐观转账，先把代币转给交易者，后面做数值正确性校验。如果校验不通过，则交易回滚，相当于什么都没发生
    if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
    if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
    // 如果data有值。相当于to地址是合约调用，to地址对应的合约要实现uniswapV2Call回调方法
    // 这里经常是FlashSwap闪电贷交易使用的关键。
    if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
    // 检查当前池子的余额
    balance0 = IERC20(_token0).balanceOf(address(this));
    balance1 = IERC20(_token1).balanceOf(address(this));
    }
    // 计算输入代币数量
    uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
    { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
    // 计算减去手续费后的余额
    uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
    uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
    // 校验交易结束后的恒定积K >= 交易之前的恒定积
    require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
    }

    // 更新池子的余额 && 更新TWAP价格
    _update(balance0, balance1, _reserve0, _reserve1);
    emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}

amountIn 公式计算

假设转入的是 token0，转出的是 token1，转入数量为 100，转出数量为 200。那么，下面几个值将如下：

amount0In = 100
amount1In = 0
amount0Out = 0
amount1Out = 200

而 reserve0 和 reserve1 假设分别为 1000 和 2000，没进行兑换交易之前，balance{0,1} 和 reserve{0,1} 是相等的。而完成了代币的转入和转出之后，其实，balance0 就变成了 1000 + 100 - 0 = 1100，balance1 变成了 2000 + 0 - 200 = 1800。整理成公式则如下：

balance0 = reserve0 + amount0In - amout0Out
balance1 = reserve1 + amount1In - amout1Out

可以推导出

amountIn = balance - (reserve - amountOut)

最后 K 值比较公式

减去手续费之前 K 值

K = uint(_reserve0).mul(_reserve1)

减去手续费之后 K 值

// 减去手续费以后的余额
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3)) / 1000;
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3)) / 1000;
K = balance0Adjusted * balance1Adjusted

要求交易后的 K >= 交易前的 K

(balance0.mul(1000).sub(amount0In.mul(3)) / 1000) * balance1.mul(1000).sub(amount1In.mul(3)) / 1000 >= uint(_reserve0).mul(_reserve1)
=>
balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2)

这里将除法转换成乘法比较是因为合约里除以123456 / 1000 = 123,会有精度丢失。所以转成乘法比较

核心合约

v2-core​

UniswapV2ERC20​

UniswapV2Factory​

UniswapV2Pair​

初始化参数​

mint​

burn​

swap​