EN

PoolManager contract development

Author of this section: @yeezo , @Ethan

this talk we will guide you through PoolManager.sol development of contracts.

Contract Introduction

PoolManager the main role of the contract is to control the pool and provide information about the pool for front-end display. PoolManger the contract was inherited. Factory contracts, developers don't need to go to the lower level when they want to get pool information. Factory to interact, it is only necessary to perceive PoolManager you can.

PoolManager and Factory the contract is so close that it can be considered the same contract, but we split it for the sake of clarity of the boundaries of the contract function. Their relationship can be as follows:

PoolManager the Main functions required by the contract are relatively simple, but we can learn some interesting details in it.

Contract Development

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

Before we start writing a contract, we can stop and think about what methods our contract should contain. On the front page, we have a table showing some information about the pool, so we need a way to return the pool information. In addition, there is a function to add pools on the position front page, so we also need to design a method to add pools.

Of course, this contract is not necessary, it is only to provide data to the front end, this tutorial saves the data on the server side just for teaching. In actual development, it is more recommend to store these data on the server (Uniswap's practice), and save and obtain these data by calling the interface of the server, which can not only improve the response speed of the operation data, but also reduce the gas overhead of the contract storage data.

1. Contract inheritance

in the previous introduction, we designed PoolManager contracts need to be inherited Factory contracts (see the previous section), so we need to inherit before writing the contract method. 

import "./Factory.sol";
import "./interfaces/IPoolManager.sol";

contract PoolManager is Factory, IPoolManager {
  // ...
}

After inheritance, we can use Factory the method designed in the contract.

2. Create a pool

First we consider the function of creating a pool. In the previous introduction, we learned that the uniqueness of a pool is determined by token pairs, price ranges, and fees, so the input parameters of the method should contain these items, and the function should return the contract address corresponding to the pool. In the type definition of the contract, we can design it like this: 

import "./IFactory.sol";

interface IPoolManager is IFactory {
  // ...

  struct CreateAndInitializeParams {
    address token0;
    address token1;
    uint24 fee;
    int24 tickLower;
    int24 tickUpper;
    uint160 sqrtPriceX96;
  }

  function createAndInitializePoolIfNecessary(
      CreateAndInitializeParams calldata params
  ) external payable returns (address pool);
}

now we consider the specific function implementation in Factory the contract exposed a createPool method, we can call that method to create the pool. It should be noted that for repeated creation, it is not in PoolManager processing, but in Factory processing. 

import "./Factory.sol";
import "./interfaces/IPoolManager.sol";

contract PoolManager is Factory, IPoolManager {
  // ...

  function createAndInitializePoolIfNecessary(
        CreateAndInitializeParams calldata params
    ) external payable override returns (address poolAddress) {
        require(params.token0 < params.token1);

        poolAddress = this.createPool(
            params.token0,
            params.token1,
            params.tickLower,
            params.tickUpper,
            params.fee
        );

        //...
    }
}

After the pool is created, we need to maintain the information of the overall DEX pool, which contains two parts: the types of transaction pairs supported by DEX and the specific information of the transaction pairs. The former is mainly to provide which Token transactions our DEX supports, while the latter is mainly to provide complete pool information.

In Factory in a contract, every time a pool is created, its information is recorded, so we don't need to record this information, we need to record the type of trading pair, that is, when a new trading pair is obtained, dynamically maintain a pairs array.

Because we inherited Factory, so we can easily get Factory in pools , so the logic for recording information can be implemented as follows: 

import "./Factory.sol";
import "./interfaces/IPool.sol";
import "./interfaces/IPoolManager.sol";

contract PoolManager is Factory, IPoolManager {
  Pair[] public pairs;
  // ...

  function createAndInitializePoolIfNecessary(
        CreateAndInitializeParams calldata params
    ) external payable override returns (address poolAddress) {
        require(params.token0 < params.token1);

        poolAddress = this.createPool(
            params.token0,
            params.token1,
            params.tickLower,
            params.tickUpper,
            params.fee
        );

        // 获取池子合约
        IPool pool = IPool(poolAddress);

        // 获取同一交易对的数量
        uint256 index = pools[pool.token0()][pool.token1()].length;

        // 新创建的池子，没有初始化价格，需要初始化价格
        if (pool.sqrtPriceX96() == 0) {
          pool.initialize(params.sqrtPriceX96);

          if (index == 1) {
              // 如果是第一次添加该交易对，需要记录下来
              pairs.push(
                  Pair({token0: pool.token0(), token1: pool.token1()})
              );
          }
        }
    }
}

it should be noted that although createPool the input parameter tokenA and tokenB there is no order requirement, but in createAndInitializePoolIfNecessary when we created it, we asked token0 &lt; token1 . Because the initialized price needs to be passed in in this method, the price in the trading pool is based on. token0/token1 the way to calculate, do this limit can avoid LP accidentally initializing the wrong price. In subsequent code and tests, we also agreed tokenA and tokenB is unsorted, and token0 and token1 it is sorted, which is also easy for us to understand the code.

At this point, we have completed the implementation of the method of creating the pool.

3. Return all pool information

since the pool's information is in Factory it is saved in the contract, so when we return all the pool information, we also need Factory the saved information is processed into the data format we want.

This part of the logic is clear, by traversing all the pool information, do some data conversion on the line. 

import "./Factory.sol";
import "./interfaces/IPool.sol";
import "./interfaces/IPoolManager.sol";

contract PoolManager is Factory, IPoolManager {
  function getAllPools()
    external
    view
    override
    returns (PoolInfo[] memory poolsInfo)
  {
    uint32 length = 0;
    // 先算一下大小，从 pools 获取
    for (uint32 i = 0; i < pairs.length; i++) {
        length += uint32(pools[pairs[i].token0][pairs[i].token1].length);
    }

    // 再填充数据
    poolsInfo = new PoolInfo[](length);
    uint256 index
    for (uint32 i = 0; i < pairs.length; i++) {
      address[] memory addresses = pools[pairs[i].token0][
          pairs[i].token1
      ];
      for (uint32 j = 0; j < addresses.length; j++) {
        IPool pool = IPool(addresses[j]);
        poolsInfo[index] = PoolInfo({
          token0: pool.token0(),
          token1: pool.token1(),
          index: j,
          fee: pool.fee(),
          feeProtocol: 0,
          tickLower: pool.tickLower(),
          tickUpper: pool.tickUpper(),
          tick: pool.tick(),
          sqrtPriceX96: pool.sqrtPriceX96()
        });
        index++;
      }
    }
    return poolsInfo;
  }
}

The important thing to note here is that we first calculate the size of the return pool and then add data to it. This seems very unreasonable, but in the contract method, the memory array cannot dynamically add data. This is a limitation of the Solidity syntax. For performance optimization, the array defined by memory needs to allocate memory in advance. So this is a helpless move.

4. Return pairs data

pairs the data is mainly used to query whether our DEX supports the transaction of a certain transaction pair. We have already maintained it when introducing 2. Creating the pool sub-chapter pairs , So we just need to return it. 

import "./Factory.sol";
import "./interfaces/IPoolManager.sol";

contract PoolManager is Factory, IPoolManager {
  Pair[] public pairs;

  function getPairs() external view override returns (Pair[] memory) {
    return pairs;
  }

  //...
}

You can see that we designed a getPairs Method is used to return data. Some students may have such questions, why design a function method to return, the variables in the contract will not automatically generate the corresponding getter method to obtain its value?

Yes, there is nothing wrong. solidity automatically generates a corresponding getter method for the public variable defined in the contract. Developers do not need to design additional methods to obtain values. However, for the special case that the variable is an array, the getter method generated by solidity does not return the entire data, but requires the caller to specify the index and only return the value corresponding to the index. The reason for this design is to avoid returning too much data at one time, resulting in uncontrollable gas fees when other contracts use this data.

Therefore, for the special case of an array, if we need it to return all its contents, we need to write a contract method to return it.

Contract Testing

we need to test whether the creation was successful and whether the returned pool information is correct. The code is as follows: 

import { loadFixture } from "@nomicfoundation/hardhat-toolbox-viem/network-helpers";
import { expect } from "chai";
import hre from "hardhat";
import { TickMath, encodeSqrtRatioX96 } from "@uniswap/v3-sdk";

describe("PoolManager", function () {
  async function deployFixture() {
    const manager = await hre.viem.deployContract("PoolManager");
    const publicClient = await hre.viem.getPublicClient();
    return {
      manager,
      publicClient,
    };
  }

  it("getPairs & getAllPools", async function () {
    const { manager } = await loadFixture(deployFixture);
    const tokenA: `0x${string}` = "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984";
    const tokenB: `0x${string}` = "0xEcd0D12E21805803f70de03B72B1C162dB0898d9";
    const tokenC: `0x${string}` = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
    const tokenD: `0x${string}` = "0x6B175474E89094C44Da98b954EedeAC495271d0F";

    // 创建 tokenA-tokenB
    await manager.write.createAndInitializePoolIfNecessary([
      {
        token0: tokenA,
        token1: tokenB,
        fee: 3000,
        tickLower: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(1, 1)),
        tickUpper: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(10000, 1)),
        sqrtPriceX96: BigInt(encodeSqrtRatioX96(100, 1).toString()),
      },
    ]);

    // 由于和前一个参数一样，会被合并
    await manager.write.createAndInitializePoolIfNecessary([
      {
        token0: tokenA,
        token1: tokenB,
        fee: 3000,
        tickLower: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(1, 1)),
        tickUpper: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(10000, 1)),
        sqrtPriceX96: BigInt(encodeSqrtRatioX96(100, 1).toString()),
      },
    ]);

    await manager.write.createAndInitializePoolIfNecessary([
      {
        token0: tokenC,
        token1: tokenD,
        fee: 2000,
        tickLower: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(100, 1)),
        tickUpper: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(5000, 1)),
        sqrtPriceX96: BigInt(encodeSqrtRatioX96(200, 1).toString()),
      },
    ]);

    // 判断返回的 pairs 的数量是否正确
    const pairs = await manager.read.getPairs();
    expect(pairs.length).to.equal(2);

    // 判断返回的 pools 的数量、参数是否正确
    const pools = await manager.read.getAllPools();
    expect(pools.length).to.equal(2);
    expect(pools[0].token0).to.equal(tokenA);
    expect(pools[0].token1).to.equal(tokenB);
    expect(pools[0].sqrtPriceX96).to.equal(
      BigInt(encodeSqrtRatioX96(100, 1).toString())
    );
    expect(pools[1].token0).to.equal(tokenC);
    expect(pools[1].token1).to.equal(tokenD);
    expect(pools[1].sqrtPriceX96).to.equal(
      BigInt(encodeSqrtRatioX96(200, 1).toString())
    );
  });
});

you can add a test example of an abnormal situation: 

it("require token0 < token1", async function () {
  const { manager } = await loadFixture(deployFixture);
  const tokenA: `0x${string}` = "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984";
  const tokenB: `0x${string}` = "0xEcd0D12E21805803f70de03B72B1C162dB0898d9";

  await expect(
    manager.write.createAndInitializePoolIfNecessary([
      {
        token0: tokenB,
        token1: tokenA,
        fee: 3000,
        tickLower: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(1, 1)),
        tickUpper: TickMath.getTickAtSqrtRatio(encodeSqrtRatioX96(10000, 1)),
        sqrtPriceX96: BigInt(encodeSqrtRatioX96(100, 1).toString()),
      },
    ])
  ).to.be.rejected;
});

the complete single test code is in demo-contract/test/wtfswap/PoolManager.ts in the actual project, your single test should cover all logical branches to ensure the security of the contract.