Pool contract swap interface development

Author of this section: @Fish

this will be achieved. Pool in the contract swap trading methods.

Contract Introduction

in the previous lecture, we realized Pool the relevant method of liquidity addition and management of contracts, liquidity addition is essentially LP injecting tokens into Pool in the contract, so that users can use LP-injected tokens to trade. For example, we set the initial price to 10000,LP injected 100 Token0 and 1000000 Token1 into the pool, and users can pass swap method to swap Token0 and Token1. If the user exchanges 10 token0 for 100000 token1 according to the price 10000, there will be 110 token0 and 990000 token1 left in the pool. The corresponding is reflected in the increase in the price of token1, which allows us to implement the AMM (automated market maker) of the decentralized exchange.

Of course, the price in the example above in the actual transaction is not traded in 10000, in Uniswap, the price is calculated based on the number of tokens in the pool, the price is dynamic, when the user trades, the price will change with the transaction. In the implementation of this talk, we will refer Code for Uniswap V3 to implement this logic. swap the parameter received by the method is not a specified price, but a specified upper or lower price limit and the number of tokens to be obtained or paid.

Okay, then let's do it swap method.

Contract Development

the complete code is in demo-contract/contracts/wtfswap/Pool.sol in.

1. Incoming parameter verification

first we are in Pool.sol do a simple verification of the input parameters:

function swap(
    address recipient,
    bool zeroForOne,
    int256 amountSpecified,
    uint160 sqrtPriceLimitX96,
    bytes calldata data
) external override returns (int256 amount0, int256 amount1) {
    require(amountSpecified != 0, "AS");

    // zeroForOne: 如果从 token0 交换 token1 则为 true，从 token1 交换 token0 则为 false
    // 判断当前价格是否满足交易的条件
    require(
        zeroForOne
            ? sqrtPriceLimitX96 < sqrtPriceX96 &&
                sqrtPriceLimitX96 > TickMath.MIN_SQRT_PRICE
            : sqrtPriceLimitX96 > sqrtPriceX96 &&
                sqrtPriceLimitX96 < TickMath.MAX_SQRT_PRICE,
        "SPL"
    );
}

in the above code, we first verify that amountSpecified must not be 0, amountSpecified greater than 0 means that we have specified the amount of token0 to pay, amountSpecified if it is less than 0, it means that we have specified the number of token1 to obtain. zeroForOne for true It means that token0 is replaced by token1, and vice versa. If token0 is exchanged for token1, then the transaction will cause the token0 of the pool to increase and the price to fall, which we need to verify. sqrtPriceLimitX96 must be less than the current price, I .e. sqrtPriceLimitX96 is a lower price limit for the transaction. The price also needs to be greater than the minimum price available and less than the maximum price available.

The implementation here is also basically a reference. Code in Uniswap V3 .

2. Transaction calculation

then we need to calculate the number of token0 and token1 that the pool can provide transactions at the price and quantity specified by the user, where we call directly. SwapMath.computeSwapStep method, which is directly copied. Code for Uniswap V4 . Why not use V3 code? As we mentioned earlier, because the course uses solidity 0.8.0 + and the code of Uniswap V3 uses 0.7.6, it is not compatible with the Library of 0.8.0, so we need to use some code of Uniswap V4, but the code is basically the same as Uniswap V3 logically.

SwapMath.computeSwapStep The method needs to pass in the current price, limit price, liquidity quantity, volume and handling fee, and then returns the quantity that can be traded, as well as the handling fee for the procedure and the new price after the transaction. In this calculation, price and liquidity are both large numbers, which is actually to avoid accuracy problems. The specific calculation formula is as follows:

P t a r g e t − P c u r r e n t = Δ y / L

1 / P t a r g e t − 1 / Pc u r r e n t = Δ x / L

for specific instructions on the formula, you can refer to the previous course. Uniswap Code Analysis can be described in. If you just want to learn DApp development, you can ignore the details of this part and just use this method. What you need to know is that in DApp development, we need to carefully consider the calculation of numbers, overflow and precision in calculation. Also consider the difference in the processing of Solidity 0.7 and 0.8 in some computational logic.

Next, we add specific implementations.

First we define a SwapState structure, which is used to store variables that need to be temporarily stored in the transaction:

// 交易中需要临时存储的变量
struct SwapState {
    // the amount remaining to be swapped in/out of the input/output asset
    int256 amountSpecifiedRemaining;
    // the amount already swapped out/in of the output/input asset
    int256 amountCalculated;
    // current sqrt(price)
    uint160 sqrtPriceX96;
    // the global fee growth of the input token
    uint256 feeGrowthGlobalX128;
    // 该交易中用户转入的 token0 的数量
    uint256 amountIn;
    // 该交易中用户转出的 token1 的数量
    uint256 amountOut;
    // 该交易中的手续费，如果 zeroForOne 是 ture，则是用户转入 token0，单位是 token0 的数量，反正是 token1 的数量
    uint256 feeAmount;
}

and then we're in swap the specific value of the transaction is calculated in the method:

// amountSpecified 大于 0 代表用户指定了 token0 的数量，小于 0 代表用户指定了 token1 的数量
bool exactInput = amountSpecified > 0;

SwapState memory state = SwapState({
    amountSpecifiedRemaining: amountSpecified,
    amountCalculated: 0,
    sqrtPriceX96: sqrtPriceX96,
    feeGrowthGlobalX128: zeroForOne
        ? feeGrowthGlobal0X128
        : feeGrowthGlobal1X128,
    amountIn: 0,
    amountOut: 0,
    feeAmount: 0
});

// 计算交易的上下限，基于 tick 计算价格
uint160 sqrtPriceX96Lower = TickMath.getSqrtPriceAtTick(tickLower);
uint160 sqrtPriceX96Upper = TickMath.getSqrtPriceAtTick(tickUpper);
// 计算用户交易价格的限制，如果是 zeroForOne 是 true，说明用户会换入 token0，会压低 token0 的价格（也就是池子的价格），所以要限制最低价格不能超过 sqrtPriceX96Lower
uint160 sqrtPriceX96PoolLimit = zeroForOne
    ? sqrtPriceX96Lower
    : sqrtPriceX96Upper;

// 计算交易的具体数值
(
    state.sqrtPriceX96,
    state.amountIn,
    state.amountOut,
    state.feeAmount
) = SwapMath.computeSwapStep(
    sqrtPriceX96,
    (
        zeroForOne
            ? sqrtPriceX96PoolLimit < sqrtPriceLimitX96
            : sqrtPriceX96PoolLimit > sqrtPriceLimitX96
    )
        ? sqrtPriceLimitX96
        : sqrtPriceX96PoolLimit,
    liquidity,
    amountSpecified,
    fee
);

in the above code, we also use TickMath the method in to convert tick to price, if you haven't introduced TickMath if so, you need to be in Pool.sol introduced in TickMath it can only be used later. The same is true for other libraries. They are also code copied from Uniswap V3 or V4. Last lecture course it has already been introduced.

+ import "./libraries/TickMath.sol";
+ import "./libraries/SwapMath.sol";

3. Complete the transaction and update the status

after the calculation is completed, we need to update the status of the pool and call the callback method (the trading user should transfer the token to be sold in the callback) and transfer the exchanged token to the user. It should be noted that the calculation and update of the handling fee will be completed in the following courses, which can be ignored here.

// 更新新的价格
sqrtPriceX96 = state.sqrtPriceX96;
tick = TickMath.getTickAtSqrtPrice(state.sqrtPriceX96);

// 计算交易后用户手里的 token0 和 token1 的数量
if (exactInput) {
    state.amountSpecifiedRemaining -= (state.amountIn + state.feeAmount)
        .toInt256();
    state.amountCalculated = state.amountCalculated.sub(
        state.amountOut.toInt256()
    );
} else {
    state.amountSpecifiedRemaining += state.amountOut.toInt256();
    state.amountCalculated = state.amountCalculated.add(
        (state.amountIn + state.feeAmount).toInt256()
    );
}

(amount0, amount1) = zeroForOne == exactInput
    ? (
        amountSpecified - state.amountSpecifiedRemaining,
        state.amountCalculated
    )
    : (
        state.amountCalculated,
        amountSpecified - state.amountSpecifiedRemaining
    );


if (zeroForOne) {
    // callback 中需要给 Pool 转入 token
    uint256 balance0Before = balance0();
    ISwapCallback(msg.sender).swapCallback(amount0, amount1, data);
    require(balance0Before.add(uint256(amount0)) <= balance0(), "IIA");

    // 转 Token 给用户
    if (amount1 < 0)
        TransferHelper.safeTransfer(
            token1,
            recipient,
            uint256(-amount1)
        );
} else {
    // callback 中需要给 Pool 转入 token
    uint256 balance1Before = balance1();
    ISwapCallback(msg.sender).swapCallback(amount0, amount1, data);
    require(balance1Before.add(uint256(amount1)) <= balance1(), "IIA");

    // 转 Token 给用户
    if (amount0 < 0)
        TransferHelper.safeTransfer(
            token0,
            recipient,
            uint256(-amount0)
        );
}

emit Swap(
    msg.sender,
    recipient,
    amount0,
    amount1,
    sqrtPriceX96,
    liquidity,
    tick
);

In the above code, we also use ./libraries/SafeCast.sol provided in toInt256 methods. Correspondingly, you need Pool.sol introduced in SafeCast can be used later.

contract Pool is IPool {
+    using SafeCast for uint256;

We refer to the above code implementation of Uniswap V3But the whole is much simpler. In Uniswap V3, a pool itself has no upper and lower price limit, but each position in the pool has its own upper and lower limit. So when trading, you need to cycle through different positions to find the right position to trade. In our implementation, we limit the price of the pool, and each position in the pool is the same price range, so we don't need to pass a while move trades in different positions, but just one calculation. If you are interested, you can compare code for Uniswap V3 come and learn.

At this point, we have completed the logic development of the basic transaction, and in the next talk we will supplement the logic of fee collection.

Contract Testing

next, let's write swap first we need to create a contract for testing (involving callback function calls, only contracts can be called), we create a new contracts/wtfswap/test-contracts/TestSwap.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "../interfaces/IPool.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract TestSwap is ISwapCallback {
    function testSwap(
        address recipient,
        int256 amount,
        uint160 sqrtPriceLimitX96,
        address pool,
        address token0,
        address token1
    ) external returns (int256 amount0, int256 amount1) {
        (amount0, amount1) = IPool(pool).swap(
            recipient,
            true,
            amount,
            sqrtPriceLimitX96,
            abi.encode(token0, token1)
        );
    }

    function swapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external {
        // transfer token
        (address token0, address token1) = abi.decode(data, (address, address));
        if (amount0Delta > 0) {
            IERC20(token0).transfer(msg.sender, uint(amount0Delta));
        }
        if (amount1Delta > 0) {
            IERC20(token1).transfer(msg.sender, uint(amount1Delta));
        }
    }
}

in this contract we define the callback function swapCallback and it will be Pool contract call. In addition, we define a testSwap method, which can be called in the test sample.

Next, we are test/wtfswap/Pool.ts add in swap test sample:

it("swap", async function () {
  const { pool, token0, token1, sqrtPriceX96 } = await loadFixture(
    deployFixture
  );
  const testLP = await hre.viem.deployContract("TestLP");

  const initBalanceValue = 100000000000n * 10n ** 18n;
  await token0.write.mint([testLP.address, initBalanceValue]);
  await token1.write.mint([testLP.address, initBalanceValue]);

  // mint 多一些流动性，确保交易可以完全完成
  const liquidityDelta = 1000000000000000000000000000n;
  // mint 多一些流动性，确保交易可以完全完成
  await testLP.write.mint([
    testLP.address,
    liquidityDelta,
    pool.address,
    token0.address,
    token1.address,
  ]);

  const lptoken0 = await token0.read.balanceOf([testLP.address]);
  expect(lptoken0).to.equal(99995000161384542080378486215n);

  const lptoken1 = await token1.read.balanceOf([testLP.address]);
  expect(lptoken1).to.equal(1000000000000000000000000000n);

  // 通过 TestSwap 合约交易
  const testSwap = await hre.viem.deployContract("TestSwap");
  const minPrice = 1000;
  const minSqrtPriceX96: bigint = BigInt(
    encodeSqrtRatioX96(minPrice, 1).toString()
  );

  // 给 testSwap 合约中打入 token0 用于交易
  await token0.write.mint([testSwap.address, 300n * 10n ** 18n]);

  expect(await token0.read.balanceOf([testSwap.address])).to.equal(
    300n * 10n ** 18n
  );
  expect(await token1.read.balanceOf([testSwap.address])).to.equal(0n);
  const result = await testSwap.simulate.testSwap([
    testSwap.address,
    100n * 10n ** 18n, // 卖出 100 个 token0
    minSqrtPriceX96,
    pool.address,
    token0.address,
    token1.address,
  ]);
  expect(result.result[0]).to.equal(100000000000000000000n); // 需要 100个 token0
  expect(result.result[1]).to.equal(-996990060009101709255958n); // 大概需要 100 * 10000 个 token1

  await testSwap.write.testSwap([
    testSwap.address,
    100n * 10n ** 18n,
    minSqrtPriceX96,
    pool.address,
    token0.address,
    token1.address,
  ]);
  const costToken0 =
    300n * 10n ** 18n - (await token0.read.balanceOf([testSwap.address]));
  const receivedToken1 = await token1.read.balanceOf([testSwap.address]);
  const newPrice = (await pool.read.sqrtPriceX96()) as bigint;
  const liquidity = await pool.read.liquidity();
  expect(newPrice).to.equal(7922737261735934252089901697281n);
  expect(sqrtPriceX96 - newPrice).to.equal(78989690499507264493336319n); // 价格下跌
  expect(liquidity).to.equal(liquidityDelta); // 流动性不变

  // 用户消耗了 100 个 token0
  expect(costToken0).to.equal(100n * 10n ** 18n);
  // 用户获得了大约 100 * 10000 个 token1
  expect(receivedToken1).to.equal(996990060009101709255958n);
});

in the example above, we injected liquidity and completed a transaction, verifying the exact value of the transaction. The specific test logic will not be explained too much. You can refer to the above code to learn.

It should be noted that we also used it in the test sample @uniswap/v3-sdk we introduced the provided release in the previous lecture. If you haven't introduced it yet, you need to introduce it on the test file:

+ import { TickMath, encodeSqrtRatioX96 } from "@uniswap/v3-sdk ";

the full contract code is in contracts/wtfswap/Pool.sol view, the complete test code is in. test/wtfswap/Pool.ts view.