PositionManager contract development

2025-03-27

Author of this section: @Fish

this will be achieved. PositionManager contract.

Contract Introduction

PositionManager contracts are not a core feature, and Uniswap V3 NonfungiblePositionManager.sol contracts are similar. In theory, you can't trade through Uniswap V3. NonfungiblePositionManager contracts, you can write a contract yourself to call the trading pool directly to trade. This is why this contract is placed. v3-periphery in, not in v3-core in.

Our tutorial has a similar design, PositionManager contracts are designed to make it easier for users to manage their own liquidity, rather than calling trading pool contracts directly. And NonfungiblePositionManager the same, PositionManager is also a satisfaction ERC721 standard contracts, so that users can easily manage their own contracts through NFT, and at the same time, it is convenient for our front end to be based on common ERC721 the specifications can be developed and even traded on an exchange.

Let's get this contract done.

Contract Development

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

1. Add liquidity

first, we need a way to add liquidity. Overall logic reference of Uniswap V3 NonfungiblePositionManager.sol the contract code. But our implementation is simpler because each trading pool we design in our course has only one price upper and lower limit, and the liquidity within the corresponding pool is also in the same price upper and lower limit range.

We have defined it in the previous lesson. PositionInfo and MintParams , as follows:

struct PositionInfo {
    address owner;
    address token0;
    address token1;
    uint32 index;
    uint24 fee;
    uint128 liquidity;
    int24 tickLower;
    int24 tickUpper;
    uint128 tokensOwed0;
    uint128 tokensOwed1;
    // feeGrowthInside0LastX128 和 feeGrowthInside1LastX128 用于计算手续费
    uint256 feeGrowthInside0LastX128;
    uint256 feeGrowthInside1LastX128;
}

function getPositionInfo(
    uint256[] memory positionId
) external view returns (PositionInfo[] memory positionInfo);

struct MintParams {
    address token0;
    address token1;
    uint32 index;
    uint256 amount0Desired;
    uint256 amount1Desired;
    address recipient;
    uint256 deadline;
}

mint what needs to be done in the method is that, according to MintParams Parameter in, calling Pool of the contract mint method to add liquidity. And through PositionInfo structure to record liquidity information. For Pool for contracts, liquidity is PositionManager contracts in charge, PositionManager equivalent to escrow LP the flow of things, so need to store the relevant information inside it.

First, we write the call Pool the relevant code of the contract:

// mint 一个 NFT 作为 position 发给 LP
// NFT 的 tokenId 就是 positionId
// 通过 MintParams 里面的 token0 和 token1 以及 index 获取对应的 Pool
// 调用 poolManager 的 getPool 方法获取 Pool 地址
address _pool = poolManager.getPool(
    params.token0,
    params.token1,
    params.index
);
IPool pool = IPool(_pool);

// 通过获取 pool 相关信息，结合 params.amount0Desired 和 params.amount1Desired 计算这次要注入的流动性
uint160 sqrtPriceX96 = pool.sqrtPriceX96();
uint160 sqrtRatioAX96 = TickMath.getSqrtPriceAtTick(pool.tickLower());
uint160 sqrtRatioBX96 = TickMath.getSqrtPriceAtTick(pool.tickUpper());

liquidity = LiquidityAmounts.getLiquidityForAmounts(
    sqrtPriceX96,
    sqrtRatioAX96,
    sqrtRatioBX96,
    params.amount0Desired,
    params.amount1Desired
);

// data 是 mint 后回调 PositionManager 会额外带的数据
// 需要 PoistionManger 实现回调，在回调中给 Pool 打钱
bytes memory data = abi.encode(
    params.token0,
    params.token1,
    params.index,
    msg.sender
);
(amount0, amount1) = pool.mint(address(this), liquidity, data);

in the above code, we pass TickMath calculated sqrtRatioAX96 and sqrtRatioBX96 and then through LiquidityAmounts calculated liquidity . Last call pool.mint method to add liquidity. Correspondingly, you need to introduce the relevant dependencies in the contract:

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

among them LiquidityAmounts.sol copy From v3-periphery , you need to modify the two lines of its head. import statement:

- import '@uniswap/v3-core/contracts/libraries/FullMath.sol';
- import '@uniswap/v3-core/contracts/libraries/FixedPoint96.sol';
+ import './FullMath.sol';
+ import './FixedPoint96.sol';

call mint after the method, Pool contracts will pull back PositionManager contract, so we need to implement a callback function and give it in the callback. Pool contract money:

function mintCallback(
    uint256 amount0,
    uint256 amount1,
    bytes calldata data
) external override {
    // 检查 callback 的合约地址是否是 Pool
    (address token0, address token1, uint32 index, address payer) = abi
        .decode(data, (address, address, uint32, address));
    address _pool = poolManager.getPool(token0, token1, index);
    require(_pool == msg.sender, "Invalid callback caller");

    // 在这里给 Pool 打钱，需要用户先 approve 足够的金额，这里才会成功
    if (amount0 > 0) {
        IERC20(token0).transferFrom(payer, msg.sender, amount0);
    }
    if (amount1 > 0) {
        IERC20(token1).transferFrom(payer, msg.sender, amount1);
    }
}

in the above implementation, we need to check the call. mintCallback is the contract address Pool contract, and then give Pool contract money. You need users first. approve A sufficient amount to be successful.

Next we need PositionManager update the relevant status in the contract, and mint an NFT as position to LP:

_mint(params.recipient, (positionId = _nextId++));

(
    ,
    uint256 feeGrowthInside0LastX128,
    uint256 feeGrowthInside1LastX128,
    ,

) = pool.getPosition(address(this));

positions[positionId] = PositionInfo({
    owner: params.recipient,
    token0: params.token0,
    token1: params.token1,
    index: params.index,
    fee: pool.fee(),
    liquidity: liquidity,
    tickLower: pool.tickLower(),
    tickUpper: pool.tickUpper(),
    tokensOwed0: 0,
    tokensOwed1: 0,
    feeGrowthInside0LastX128: feeGrowthInside0LastX128,
    feeGrowthInside1LastX128: feeGrowthInside1LastX128
});

in the above code, we pass import "@openzeppelin/contracts/token/ERC721/ERC721.sol "; provided _Mint method can easily implement the logic associated with an NFT contract. In addition, we need to call Pool of the contract getPosition method to get the relevant information, and then update positions the State.

getPosition method is implemented as follows (in Pool.sol implemented in):

function getPosition(
    address owner
)
    external
    view
    override
    returns (
        uint128 _liquidity,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        uint128 tokensOwed0,
        uint128 tokensOwed1
    )
{
    return (
        positions[owner].liquidity,
        positions[owner].feeGrowthInside0LastX128,
        positions[owner].feeGrowthInside1LastX128,
        positions[owner].tokensOwed0,
        positions[owner].tokensOwed1
    );
}

it also references implementation of Uniswap V3 we just wrote it directly. Pool.sol the contract is simpler. Through this method, you can obtain the relevant information of the handling fee, which needs to be recorded, and the subsequent calculation of the handling fee needs.

So far, mint The method is complete.

2. Remove liquidity

next we need to implement burn method, used to remove liquidity. And mint method, we need to call Pool of the contract burn method to remove liquidity.

First introduce a dependency (required to calculate the fee):

+ import "./libraries/FixedPoint128.sol ";

then in PositionManager realization in contract burn methods:

function burn(
    uint256 positionId
)
    external
    override
    isAuthorizedForToken(positionId)
    returns (uint256 amount0, uint256 amount1)
{
    PositionInfo storage position = positions[positionId];
    // 通过 isAuthorizedForToken 检查 positionId 是否有权限
    // 移除流动性，但是 token 还是保留在 pool 中，需要再调用 collect 方法才能取回 token
    // 通过 positionId 获取对应 LP 的流动性
    uint128 _liquidity = position.liquidity;
    // 调用 Pool 的方法给 LP 退流动性
    address _pool = poolManager.getPool(
        position.token0,
        position.token1,
        position.index
    );
    IPool pool = IPool(_pool);
    (amount0, amount1) = pool.burn(_liquidity);

    // 计算这部分流动性产生的手续费
    (
        ,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        ,

    ) = pool.getPosition(address(this));

    position.tokensOwed0 +=
        uint128(amount0) +
        uint128(
            FullMath.mulDiv(
                feeGrowthInside0LastX128 -
                    position.feeGrowthInside0LastX128,
                position.liquidity,
                FixedPoint128.Q128
            )
        );

    position.tokensOwed1 +=
        uint128(amount1) +
        uint128(
            FullMath.mulDiv(
                feeGrowthInside1LastX128 -
                    position.feeGrowthInside1LastX128,
                position.liquidity,
                FixedPoint128.Q128
            )
        );

    // 更新 position 的信息
    position.feeGrowthInside0LastX128 = feeGrowthInside0LastX128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1LastX128;
    position.liquidity = 0;
}

in this method, we do two things:

call Pool of the contract burn method to remove liquidity.
Update position status, update tokensOwed0 and tokensOwed1 , they represent the tokens that LP can withdraw, including handling fees.

The calculation of the fee still involves passing. FullMath.mulDiv to do multiplication and division of large numbers and solve the problem of rounding, please refer last talk the logic of the fee. For the relevant code, we refer to the Uniswap V3 decreaseLiquidity .

In addition, it should be noted that we have added a isAuthorizedForToken decorator, used to check whether the caller has permission to operate positionId , the specific implementation is as follows:

modifier isAuthorizedForToken(uint256 tokenId) {
    address owner = ERC721.ownerOf(tokenId);
    require(_isAuthorized(owner, msg.sender, tokenId), "Not approved");
    _;
}

it is used to ensure that the contract Caller has the permissions of the NFT corresponding to the liquidity. For a detailed description of the modifier, please refer relevant contents in the Solidity course of WTF .

3. Withdrawal of tokens

and Pool contracts are similar, we also need to implement collect method to provide LP to extract tokens.

function collect(
    uint256 positionId,
    address recipient
)
    external
    override
    isAuthorizedForToken(positionId)
    returns (uint256 amount0, uint256 amount1)
{
    // 通过 isAuthorizedForToken 检查 positionId 是否有权限
    // 调用 Pool 的方法给 LP 退流动性
    address _pool = poolManager.getPool(
        positions[positionId].token0,
        positions[positionId].token1,
        positions[positionId].index
    );
    IPool pool = IPool(_pool);
    (amount0, amount1) = pool.collect(
        recipient,
        positions[positionId].tokensOwed0,
        positions[positionId].tokensOwed1
    );

    // position 已经彻底没用了，销毁
    _burn(positionId);
}

In the above code, we call Pool of the contract collect method to extract tokens and then destroy them. positionId the corresponding NFT. We also need decorators. isAuthorizedForToken to ensure that the caller has permission to operate positionId .

Contract Testing

again, we still need to write test cases to test our contracts. In the process of implementing this course, I found many major bugs by writing test samples. Writing unit tests is also a good and efficient way to ensure the correctness of the contract. For PositionManager contract, the author tried to write a complete from mint test cases from the generation of transactions to the final extraction of liquidity.

The specific test code is no longer all posted, you can PositionManager.ts view.

It should be noted that in the test sample, we obtained the user address of the current transaction initiation through the following code, which is very useful in the test sample preparation:

const [owner] = await hre.viem.getWalletClients();
const [sender] = await owner.getAddresses();

for specific instructions, you can refer to Hardhat's viem plug-in documentation.

So we're done PositionManager this contract is also the contract that we need to call directly in the front-end development. We will also come into contact with it in some courses of front-end development.