DAPP區塊鏈商城開發（多語言）丨DAPP區塊鏈商城系統開發（海外版）及案例原始碼

ransferHelper.safeTransferFrom(

path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]

);
將代幣path[0]，開發原始碼I35成品7O98案例O7I8  轉入到交易對，數量為amounts[0]。轉入代幣後，進行真正的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操作。

Core邏輯
Core邏輯實現了單個交易對的邏輯。透過UniswapV2Factory可以建立一個個Pair（交易池）。每個具體實現邏輯在UniswapV2Pair中。

1. mint

每個交易對建立流動性。

function mint(address to) external lock returns (uint liquidity) {
因為在呼叫mint函式之前，在addLiquidity函式已經完成了轉賬，所以，從這個函式的角度，兩種代幣數量的計算方式如下：

    uint balance0 = IERC20(token0).balanceOf(address(this));
    uint balance1 = IERC20(token1).balanceOf(address(this));
    uint amount0 = balance0.sub(_reserve0);
    uint amount1 = balance1.sub(_reserve1);

當前的balance是當前的reserve加上注入的流動性的代幣數量。

    uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
    if (_totalSupply == 0) {
        liquidity = Math.sqrt(amount0.mul(amount1)).sub(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);
    }    _mint(to, liquidity);

流動性liquidity的計算方式在第一次提供流動性時和其他時候稍稍不同。第一次提供流動性的計算公式如下：

liquidity = sqrt(x0*y0) - min

其中min是10^3。也就是說，第一次提供流動性是有最小流動性要求的。其他提供流動性的計算公式如下：

liquidity = min((x0/reserve0 totalsupply), (y0/reserve1totalsupply))

也就說，按照注入的流動性和當前的reserve的佔比一致。

1. burn

burn函式用在抽取流動性。burn邏輯和mint邏輯類似。

function burn(address to) external lock returns (uint amount0, uint amount1) {

1. swap

swap函式實現兩種代幣的兌換。

function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
一個交易池的swap操作支援兩個方向的兌換，可以從TokenA換到TokenB，或者TokenB換到TokenA。

if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
因為在swapExactTokensForTokens的getAmountOut函式已經確定兌換處的金額。所以，先直接轉賬。

在不做swap之前，balance應該和reserve相等的。透過balance和reserve的差值，可以反推出輸入的代幣數量：

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');