Uniswap Code Analysis

Author of this section: @ Web3Pignard

in this talk, we officially entered the code parsing of Uniswap, to be precise, Uniswap V3. By reading this section, you can learn:

1. what is Uniswap, what versions has Uniswap released, and why do you want to parse V3 versions;
2. Uniswap V3 consists of which contracts, the main functions of each contract and the analysis of core processes.

Analyzing the code of Uniswap can help us better understand the following courses. Of course, you can also jump directly to the following actual combat development and refer to this lecture when necessary. However, we still suggest that you can spend some time learning the code implementation of Uniswap to prepare for the following courses. In addition, Uniswap's code will contain some complex mathematical calculation logic, which may not be well understood, and you can continue to learn in later courses. If you just want to learn the basic decentralized application development, you can skip the complicated mathematical calculation logic. Some code libraries of Uniswap V3 will be directly used in our course to reduce the complexity of the course.

Uniswap Basic Introduction

Uniswap is the largest decentralized exchange (DEX) on Ethernet Square. As we mentioned in the previous lecture, decentralized exchanges like Uniswap do not use the method of thin order trading, but LP provides liquidity to trade. How to price tokens in this liquidity pool becomes the key to decentralized exchanges. Uniswap constructs a specific automatic market maker (AM) mechanism on its liquidity pool. Known as Constant Product Market Makers (CPMM). As the name suggests, its core is a very simple product formula:

x * y = k

A liquidity pool is a contract that holds two different tokens, x and y represents the number of token0 and the number of token1, k is the product of them, and when swap occurs, the number of token0 and token1 will change, but the product of the two remains the same, still being k .

In addition, we generally refer to the price of token0 as the price relative to token1 in the liquidity pool, where the price and quantity are reciprocal, so the formula is:

P = y /x

for example, as LP, I put 1 ETH(token0) and 3000 USDT(token1) in the pool, then k is 1*3000=3000, and ETH price is 3000/1 = 3000U. Then you, as a counterparty, can put about 30 USDT in and take out 0.01 ETH. Then the pool became 3030 USDT and 0.99 ETH, and the price became 3030/0.99 ≈ 3030U. ETH's price has increased. Does this solve the pricing problem? Some people want to change ETH,ETH becomes scarce, so the price has increased. Next time you want to change ETH, you need more USDT. As long as you ensure that ETH * USDT in the pool is equal to a constant, it will naturally change and change. When ETH becomes less, you need to consume more USDT when you want to exchange ETH through USDT, and vice versa.

Of course, the above example does not take into account details such as slippage, fees, rounding, etc., and there are many details to consider when the actual contract is implemented. This is just to let everyone understand the basic logic, and the specific details will be discussed later.

Uniswap has iterated several versions so far. The following is the development process of each version:

Uniswap V1 was released in November 2018, which innovatively adopted the above CPMM and supported the exchange of ERC-20 and ETH, laying the foundation for the subsequent version of Uniswap and becoming the inspiration of other AMM agreements;

The release of Uniswap V2 in May 2020, which introduces conversions between ERC-20 on the basis of V1, as well as a time-weighted average price (TWAP) predictor, increases the flexibility of trading pairs and consolidates Uniswap's leading position in DEX;

the release of uniswap V3 in May 2021 introduces centralized Liquidity (centralized Liquidity), which allows LP to define specific price ranges in trading pairs for more precise price control and improves LP's asset utilization;

in June 2023, uniswap V4 released the draft version of the white paper, introducing many optimizations such as Hook, Singleton, Flash Accounting and native ETH. Hook is the most important innovative mechanism and provides developers with a high degree of customization.

Since Uniswap V4 is not MainNet as of now (2024.05.11) and its code is released under license from BSL 1.1, the license lasts for four years and limits the agreement to use only by entities approved by governance. Although V3 also uses the BSL 1.1, the license has expired in April 2023, so this course uses the V3 version.

Uniswap V3 code parsing

as mentioned above, the core of Uniswap is to implement an automated market maker based on CPMM. In addition to the trading contracts called by users, there are also contracts provided to LP to manage the liquidity pool, as well as the management of liquidity. These functions are implemented in different contracts. In the architecture of Uniswap, the contracts of Uniswap V3 are roughly divided into two categories, which are stored in different warehouses:

• Uniswap v3-periphery : User-oriented interface code, such as position management, swap routing and other functions, Uniswap's front-end interface interacts with the periphery contract, mainly contains three contracts:

• nonfungiblePositionManager.sol: corresponds to the position management function, including the creation of trading pools (also known as liquidity pools or pools, later uniformly represented by trading pools) and the addition and deletion of liquidity;
• . sol: a description of the position;
• swarouter. sol: corresponds to the swap routing function, including single transaction pool swap and multi-transaction pool swap.

• Uniswap v3-core : The core code of Uniswap v3 realizes all the functions defined by the protocol. External contracts can directly interact with core contracts, mainly including three contracts;

• uniswapV3Factory.sol: factory contract, used to create a trading pool, set the Owner and fee level;
• uniswapV3PoolDeployer.sol: The base class of the factory contract, which encapsulates the function of deploying the trading pool contract;
• uniswapV3Pool.sol: trading pool contract, holding the actual Token, realizing the management of price and liquidity, and the function of swap in the current trading pool.

We mainly analyze the core processes, including the following:

1. deploy transaction pools;
2. Create/add/reduce liquidity;
3. swap.

Where 1 and 2 are functions that the contract provides to LP operations to provide and manage liquidity by deploying trading pools and managing liquidity. And 3 is to provide ordinary users with the core function (or even the only function) of Uniswap swap, that is, trading. Next, we will explain the relevant code in Uniswap in turn.

Deploy transaction pools

in Uniswap V3, through the contract UniswapV3Pool to define a trading pool, the core trading function of Uniswap at the bottom is to call the swap method of the contract.

Different trading pairs, as well as different rates and price ranges (tickSpacing will be discussed later) will deploy different UniswapV3Pool the contract instance is responsible for the transaction. Deploying a transaction pool is to deploy a corresponding transaction pool for a pair of tokens and a specified rate and price range. When the transaction pool under the same conditions appears again after the deployment is completed, it is no longer necessary to repeat the deployment.

The deployment of the transaction pool calls NonfungiblePositionManager of the contract createAndInitializePoolIfNecessary and the parameters are:

• token0: the address of token0, which must be less than the address of token1 and not zero;
• token1: Address of token1;
• fee: The fee rate based on 1,000,000. The Uniswap v3 front-end interface supports four fee rates (0.01, 0.05, 0.30, and 1.00). For a general transaction recommend of 0.30, the fee value is 3000;
• sqrtPriceX96: The value of the arithmetic square root of the price of the current transaction to the left by 96 digits, in order to facilitate the calculation in the contract.

The code is:

/// @inheritdoc IPoolInitializer
function createAndInitializePoolIfNecessary(
    address token0,
    address token1,
    uint24 fee,
    uint160 sqrtPriceX96
) external payable override returns (address pool) {
    require(token0 < token1);
    pool = IUniswapV3Factory(factory).getPool(token0, token1, fee);

    if (pool == address(0)) {
        pool = IUniswapV3Factory(factory).createPool(token0, token1, fee);
        IUniswapV3Pool(pool).initialize(sqrtPriceX96);
    } else {
        (uint160 sqrtPriceX96Existing, , , , , , ) = IUniswapV3Pool(pool).slot0();
        if (sqrtPriceX96Existing == 0) {
            IUniswapV3Pool(pool).initialize(sqrtPriceX96);
        }
    }
}

the logic is very intuitive. First, take token0,token1 and fee as triples to take out the address pool of the transaction pool. If the address is zero, create the transaction pool and initialize it. Otherwise, continue to judge whether it has been initialized (current price) and initialize it if it has not been initialized.

We look at the method of creating a trading pool and the method of initializing the trading pool separately.

Create a transaction pool

the creation of the trading pool is called. UniswapV3Factory of the contract createPool and the parameters are:

• token0: Address of token0
• token1 address: Address of token1;
• fee: fee rate.

The code is:

/// @inheritdoc IUniswapV3Factory
function createPool(
    address token0,
    address token1,
    uint24 fee
) external override noDelegateCall returns (address pool) {
    require(token0 != token1);
    (address token0, address token1) = token0 < token1 ? (token0, token1) : (token1, token0);
    require(token0 != address(0));
    int24 tickSpacing = feeAmountTickSpacing[fee];
    require(tickSpacing != 0);
    require(getPool[token0][token1][fee] == address(0));
    pool = deploy(address(this), token0, token1, fee, tickSpacing);
    getPool[token0][token1][fee] = pool;
    // populate mapping in the reverse direction, deliberate choice to avoid the cost of comparing addresses
    getPool[token1][token0][fee] = pool;
    emit PoolCreated(token0, token1, fee, tickSpacing, pool);
}

Obtain the corresponding tickspacings through fee. To explain tickspacings, you must first explain ticks.

int24 tickSpacing = feeAmountTickSpacing[fee];

tick is the representation of the price in V3, as shown in the following figure:

in V3, the entire price range is calibrated by discrete, uniformly distributed ticks. Because when LP adds liquidity in Uniswap V3, it will provide a price range (in order for LP to better manage positions), in order to make liquidity in different price ranges better managed and utilized, ticks are needed to divide prices into one range after another, and each tick has an index and corresponding price:

P ( I ) = 1.0001 I

P ( I ) that is, the price of tick at position I. The price of the latter price point is one ten thousandth of the price of the previous price point. We can get the formula for I:

I = log 1.0001 ne (P ( I ) )

V3 stipulates that only ticks that are divisible by tickSpacing are allowed to be initialized. The larger the tickSpacing, the more liquidity each tick has, and the greater the slippage between ticks, but it will save gas for cross-tick operations.

It is then confirmed that the corresponding pool contract has not been created and called. deploy the parameter is the factory contract address, token0 address, token1 address, fee , and the above-mentioned tickSpacing .

pool = deploy(address(this), token0, token1, fee, tickSpacing);

deploy the code is as follows:

/// @dev Deploys a pool with the given parameters by transiently setting the parameters storage slot and then
/// clearing it after deploying the pool.
/// @param factory The contract address of the Uniswap V3 factory
/// @param token0 The first token of the pool by address sort order
/// @param token1 The second token of the pool by address sort order
/// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
/// @param tickSpacing The spacing between usable ticks
function deploy(
    address factory,
    address token0,
    address token1,
    uint24 fee,
    int24 tickSpacing
) internal returns (address pool) {
    parameters = Parameters({factory: factory, token0: token0, token1: token1, fee: fee, tickSpacing: tickSpacing});
    pool = address(new UniswapV3Pool{salt: keccak256(abi.encode(token0, token1, fee))}());
    delete parameters;
}

deploy method will first temporarily store the parameters of the transaction pool contract initialization parameters, the purpose of temporarily storing parameters is to allow the transaction pool contract. Construction methodReverse the parameters variable of the factory contract to complete the parameter transfer.

The trading pool contract is constructed with the following code:

constructor() {
    int24 _tickSpacing;
    (factory, token0, token1, fee, _tickSpacing) = IUniswapV3PoolDeployer(msg.sender).parameters();
    tickSpacing = _tickSpacing;

    maxLiquidityPerTick = Tick.tickSpacingToMaxLiquidityPerTick(_tickSpacing);
}

back deploy and then use new pass the salt parameter implementation in the method. CREATE2 opcode to create a trading pool contract, using CREATE2 the purpose of is to ensure that the same token0,token1, and fee can calculate the same and unique address.

Finally, save the trading pool contract address. getPool in the variable:

getPool[token0][token1][fee] = pool;
// populate mapping in the reverse direction, deliberate choice to avoid the cost of comparing addresses
getPool[token1][token0][fee] = pool;

this completes the creation of the trading pool contract.

Initialize the trading pool

the initialization of the trading pool is called. UniswapV3Factory of the contract initialize , the parameter is the current price sqrtPriceX96, the meaning has been described above.

The code is as follows:

/// @inheritdoc IUniswapV3PoolActions
/// @dev not locked because it initializes unlocked
function initialize(uint160 sqrtPriceX96) external override {
    require(slot0.sqrtPriceX96 == 0, 'AI');

    int24 tick = TickMath.getTickAtSqrtRatio(sqrtPriceX96);

    (uint16 cardinality, uint16 cardinalityNext) = observations.initialize(_blockTimestamp());

    slot0 = Slot0({
        sqrtPriceX96: sqrtPriceX96,
        tick: tick,
        observationIndex: 0,
        observationCardinality: cardinality,
        observationCardinalityNext: cardinalityNext,
        feeProtocol: 0,
        unlocked: true
    });

    emit Initialize(sqrtPriceX96, tick);
}

the value of tick is first converted from sqrtpricex96.

int24 tick = TickMath.getTickAtSqrtRatio(sqrtPriceX96);

then initialize the Oracle, cardinality represents the observation point array capacity of the current Oracle, and cardinalityNext represents the observation point array capacity of the Oracle after expansion, which will not be explained in detail here.

(uint16 cardinality, uint16 cardinalityNext) = observations.initialize(_blockTimestamp());

finally, the slot0 variable is initialized to record the global state of the trading pool, mainly the state of the price and predictor.

slot0 = Slot0({
    sqrtPriceX96: sqrtPriceX96,
    tick: tick,
    observationIndex: 0,
    observationCardinality: cardinality,
    observationCardinalityNext: cardinalityNext,
    feeProtocol: 0,
    unlocked: true
});

Slot0 the structure is as follows, and the source code has been annotated in detail.

struct Slot0 {
    // the current price
    uint160 sqrtPriceX96;
    // the current tick
    int24 tick;
    // the most-recently updated index of the observations array
    uint16 observationIndex;
    // the current maximum number of observations that are being stored
    uint16 observationCardinality;
    // the next maximum number of observations to store, triggered in observations.write
    uint16 observationCardinalityNext;
    // the current protocol fee as a percentage of the swap fee taken on withdrawal
    // represented as an integer denominator (1/x)%
    uint8 feeProtocol;
    // whether the pool is locked
    bool unlocked;
}

At this point, the initialization of the trading pool contract is completed.

Create/Add/Decrease Liquidity

create/add/reduce liquidity, that is, in the UI corresponding to Uniswap https://app.uniswap.org/pool the operation content of this page page is to provide LP with the function of managing liquidity.

Creating liquidity

the liquidity call is created NonfungiblePositionManager of the contract mint .

The parameters are as follows:

struct MintParams {
    address token0; // token0 地址
    address token1; // token1 地址
    uint24 fee; // 费率
    int24 tickLower; // 流动性区间下界
    int24 tickUpper; // 流动性区间上界
    uint256 amount0Desired; // 添加流动性中 token0 数量
    uint256 amount1Desired; // 添加流动性中 token1 数量
    uint256 amount0Min; // 最小添加 token0 数量
    uint256 amount1Min; // 最小添加 token1 数量
    address recipient; // 头寸接受者的地址
    uint256 deadline; // 过期的区块号
}

the code is as follows:

/// @inheritdoc INonfungiblePositionManager
function mint(MintParams calldata params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (
        uint256 tokenId,
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    )
{
    IUniswapV3Pool pool;
    (liquidity, amount0, amount1, pool) = addLiquidity(
        AddLiquidityParams({
            token0: params.token0,
            token1: params.token1,
            fee: params.fee,
            recipient: address(this),
            tickLower: params.tickLower,
            tickUpper: params.tickUpper,
            amount0Desired: params.amount0Desired,
            amount1Desired: params.amount1Desired,
            amount0Min: params.amount0Min,
            amount1Min: params.amount1Min
        })
    );

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

    bytes32 positionKey = PositionKey.compute(address(this), params.tickLower, params.tickUpper);
    (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, , ) = pool.positions(positionKey);

    // idempotent set
    uint80 poolId =
        cachePoolKey(
            address(pool),
            PoolAddress.PoolKey({token0: params.token0, token1: params.token1, fee: params.fee})
        );

    _positions[tokenId] = Position({
        nonce: 0,
        operator: address(0),
        poolId: poolId,
        tickLower: params.tickLower,
        tickUpper: params.tickUpper,
        liquidity: liquidity,
        feeGrowthInside0LastX128: feeGrowthInside0LastX128,
        feeGrowthInside1LastX128: feeGrowthInside1LastX128,
        tokensOwed0: 0,
        tokensOwed1: 0
    });

    emit IncreaseLiquidity(tokenId, liquidity, amount0, amount1);
}

to sort out the overall logic, the first is addLiquidity add liquidity and then call _Mint send a voucher (NFT) to the position recipient, then calculate a self-increasing poolId, index it with the trading pool address, and finally record all the information in the structure of the position.

addLiquidity method is defined in here. , the core is to calculate the liquidity and then call the trading pool contract. mint methods.

(amount0, amount1) = pool.mint(
    params.recipient,
    params.tickLower,
    params.tickUpper,
    liquidity,
    abi.encode(MintCallbackData({poolKey: poolKey, payer: msg.sender}))
);

liquidity, or liquidity, is an important concept in V3, just like tick.

In V2, if we set the product k = L 2 , L is what we often call liquidity, resulting in the following formula:

L = x * y

the liquidity of the V2 liquidity pool is distributed from 0 to positive infinity, as shown in the figure below:

In v3, each position provides a price range, assuming that the price of token0 fluctuates between the upper price bound a and the lower price bound B, in order to achieve concentrated liquidity, then the curve must be shifted on the x/Y axis so that the/B points coincide with the x/Y axis, as shown in the following figure:

we ignore the derivation process and give the mathematical formula directly:

( x + L / P B ) * ( y + L * P a ) = L 2

we divide the curve in the graph into two parts: the left side of the starting point and the right side of the starting point. In swap in the process, the current price will move in a certain direction: up or down. For price movement, only one token will work: when the current price rises, swap only token0 is required; When the current price decreases, swapOnly token1 is required.

When a liquidity provider provides Δ x when token0, it means that the following liquidity has been added to the left of the starting point:

L = Δ x P B * P c / ( P B − P c )

when a liquidity provider provides Δ y when token1, it means that the following liquidity is added to the right of the starting point:

L = Δ y / ( P c − P a)

if the current price exceeds the price range, only unilateral liquidity can be added.

When the current price is less than the lower bound B, only Δ y A token1 works, meaning that the following liquidity is added to the right of point B:

L = Δ y / ( P B − P a )

when the current price is greater than the upper bound a, only Δ x A token0 works, meaning that the following liquidity is added to the left of point A:

L = Δ x P B * P a / ( P B− P a )

back to the code, the steps to calculate the liquidity are as follows:

1. if the price is within the price range, calculate the liquidity on both sides separately and then take the minimum value;
2. if the current price exceeds the price range, unilateral liquidity is calculated.

Trading pool contracts mint methods.

The parameters are:

• recipient: position recipient address
• tickLower: the lower bound of the liquidity interval
• tickUpper: upper bound of the liquidity interval
• amount: amount of liquidity
• data: callback parameter

the code is:

/// @inheritdoc IUniswapV3PoolActions
/// @dev noDelegateCall is applied indirectly via _modifyPosition
function mint(
    address recipient,
    int24 tickLower,
    int24 tickUpper,
    uint128 amount,
    bytes calldata data
) external override lock returns (uint256 amount0, uint256 amount1) {
    require(amount > 0);
    (, int256 amount0Int, int256 amount1Int) =
        _modifyPosition(
            ModifyPositionParams({
                owner: recipient,
                tickLower: tickLower,
                tickUpper: tickUpper,
                liquidityDelta: int256(amount).toInt128()
            })
        );

    amount0 = uint256(amount0Int);
    amount1 = uint256(amount1Int);

    uint256 balance0Before;
    uint256 balance1Before;
    if (amount0 > 0) balance0Before = balance0();
    if (amount1 > 0) balance1Before = balance1();
    IUniswapV3MintCallback(msg.sender).uniswapV3MintCallback(amount0, amount1, data);
    if (amount0 > 0) require(balance0Before.add(amount0) <= balance0(), 'M0');
    if (amount1 > 0) require(balance1Before.add(amount1) <= balance1(), 'M1');

    emit Mint(msg.sender, recipient, tickLower, tickUpper, amount, amount0, amount1);
}

first call _Modifyposition method to modify the liquidity of the current price range, this method is relatively complex, put later specifically. The returned amount0Int and amount1Int indicate the number of token0 and token1 tokens corresponding to amount liquidity.

Call mint the contract for the method needs to implement IUniswapV3MintCallback The interface completes the transfer of tokens:

IUniswapV3MintCallback(msg.sender).uniswapV3MintCallback(amount0, amount1, data);

IUniswapV3MintCallback is implemented in LiquidityManagement.sol in the periphery repository. The purpose is to notify the caller to transfer to the transaction pool contract amount0 token0 and amount1 token2.

/// @inheritdoc IUniswapV3MintCallback
    function uniswapV3MintCallback(
        uint256 amount0Owed,
        uint256 amount1Owed,
        bytes calldata data
    ) external override {
        MintCallbackData memory decoded = abi.decode(data, (MintCallbackData));
        CallbackValidation.verifyCallback(factory, decoded.poolKey);

        if (amount0Owed > 0) pay(decoded.poolKey.token0, decoded.payer, msg.sender, amount0Owed);
        if (amount1Owed > 0) pay(decoded.poolKey.token1, decoded.payer, msg.sender, amount1Owed);
    }

After the callback is completed, it will check whether the corresponding balance of the trading pool contract has changed, and the increment should be greater than amount0 and amount1: this means that the caller has indeed transferred the required assets.

if (amount0 > 0) require(balance0Before.add(amount0) <= balance0(), 'M0');
if (amount1 > 0) require(balance1Before.add(amount1) <= balance1(), 'M1');

This completes the creation of liquidity.

Add liquidity

adding the liquidity call is NonfungiblePositionManager of the contract increaseLiquidity .

The parameters are as follows:

struct IncreaseLiquidityParams {
    uint256 tokenId; // 头寸 id
    uint256 amount0Desired; // 添加流动性中 token0 数量
    uint256 amount1Desired; // 添加流动性中 token1 数量
    uint256 amount0Min; // 最小添加 token0 数量
    uint256 amount1Min; // 最小添加 token1 数量
    uint256 deadline; // 过期的区块号
}

the code is as follows:

/// @inheritdoc INonfungiblePositionManager
function increaseLiquidity(IncreaseLiquidityParams calldata params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    )
{
    Position storage position = _positions[params.tokenId];

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];

    IUniswapV3Pool pool;
    (liquidity, amount0, amount1, pool) = addLiquidity(
        AddLiquidityParams({
            token0: poolKey.token0,
            token1: poolKey.token1,
            fee: poolKey.fee,
            tickLower: position.tickLower,
            tickUpper: position.tickUpper,
            amount0Desired: params.amount0Desired,
            amount1Desired: params.amount1Desired,
            amount0Min: params.amount0Min,
            amount1Min: params.amount1Min,
            recipient: address(this)
        })
    );

    bytes32 positionKey = PositionKey.compute(address(this), position.tickLower, position.tickUpper);

    // this is now updated to the current transaction
    (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, , ) = pool.positions(positionKey);

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

    position.feeGrowthInside0LastX128 = feeGrowthInside0LastX128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1LastX128;
    position.liquidity += liquidity;

    emit IncreaseLiquidity(params.tokenId, liquidity, amount0, amount1);
}

the overall logic and mint similarly, first get the position from tokeinId, and then addLiquidity Add liquidity, return the liquidity that was successfully added, the amount0 and amount1 consumed, and the pool contract pool. Update the position status based on the latest position information in the pool object.

Reduced liquidity

what reduces liquidity calls is NonfungiblePositionManager of the contract decreaseLiquidity .

The parameters are as follows:

struct DecreaseLiquidityParams {
    uint256 tokenId; // 头寸 id
    uint128 liquidity; // 减少流动性数量
    uint256 amount0Min; // 最小减少 token0 数量
    uint256 amount1Min; // 最小减少 token1 数量
    uint256 deadline; // 过期的区块号
}

the code is as follows:

/// @inheritdoc INonfungiblePositionManager
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
    external
    payable
    override
    isAuthorizedForToken(params.tokenId)
    checkDeadline(params.deadline)
    returns (uint256 amount0, uint256 amount1)
{
    require(params.liquidity > 0);
    Position storage position = _positions[params.tokenId];

    uint128 positionLiquidity = position.liquidity;
    require(positionLiquidity >= params.liquidity);

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];
    IUniswapV3Pool pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));
    (amount0, amount1) = pool.burn(position.tickLower, position.tickUpper, params.liquidity);

    require(amount0 >= params.amount0Min && amount1 >= params.amount1Min, 'Price slippage check');

    bytes32 positionKey = PositionKey.compute(address(this), position.tickLower, position.tickUpper);
    // this is now updated to the current transaction
    (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, , ) = pool.positions(positionKey);

    position.tokensOwed0 +=
        uint128(amount0) +
        uint128(
            FullMath.mulDiv(
                feeGrowthInside0LastX128 - position.feeGrowthInside0LastX128,
                positionLiquidity,
                FixedPoint128.Q128
            )
        );
    position.tokensOwed1 +=
        uint128(amount1) +
        uint128(
            FullMath.mulDiv(
                feeGrowthInside1LastX128 - position.feeGrowthInside1LastX128,
                positionLiquidity,
                FixedPoint128.Q128
            )
        );

    position.feeGrowthInside0LastX128 = feeGrowthInside0LastX128;
    position.feeGrowthInside1LastX128 = feeGrowthInside1LastX128;
    // subtraction is safe because we checked positionLiquidity is gte params.liquidity
    position.liquidity = positionLiquidity - params.liquidity;

    emit DecreaseLiquidity(params.tokenId, params.liquidity, amount0, amount1);
}

with increaseLiquidity is the reverse operation, and the core logic is to call the trading pool contract. burn methods.

(amount0, amount1) = pool.burn(position.tickLower, position.tickUpper, params.liquidity);

burn the parameters are the lower bound tickLower of the liquidity interval, the upper bound tickUpper of the liquidity interval, and the liquidity quantity amount, with the following code:

/// @inheritdoc IUniswapV3PoolActions
/// @dev noDelegateCall is applied indirectly via _modifyPosition
function burn(
    int24 tickLower,
    int24 tickUpper,
    uint128 amount
) external override lock returns (uint256 amount0, uint256 amount1) {
    (Position.Info storage position, int256 amount0Int, int256 amount1Int) =
        _modifyPosition(
            ModifyPositionParams({
                owner: msg.sender,
                tickLower: tickLower,
                tickUpper: tickUpper,
                liquidityDelta: -int256(amount).toInt128()
            })
        );

    amount0 = uint256(-amount0Int);
    amount1 = uint256(-amount1Int);

    if (amount0 > 0 || amount1 > 0) {
        (position.tokensOwed0, position.tokensOwed1) = (
            position.tokensOwed0 + uint128(amount0),
            position.tokensOwed1 + uint128(amount1)
        );
    }

    emit Burn(msg.sender, tickLower, tickUpper, amount, amount0, amount1);
}

is also called _Modifyposition Method to modify the liquidity of the current price range, the returned amount0Int and amount1Int represent the number of tokens of token0 and token1 corresponding to amount liquidity, and position represents the user's position information, which is mainly used to record the number of tokens to be retrieved.

if (amount0 > 0 || amount1 > 0) {
    (position.tokensOwed0, position.tokensOwed1) = (
        position.tokensOwed0 + uint128(amount0),
        position.tokensOwed1 + uint128(amount1)
    );
}

The user can call collect method: Take out the token0 of the number of tokensOwed0 and token1 corresponding to the number of tokensOwed1 in your position information record.

collect methods are expanded in the next section.

collect

withdrawing tokens to be collected is called NonfungiblePositionManager of the contract collect .

The parameters are as follows:

struct CollectParams {
    uint256 tokenId; // 头寸 id
    address recipient; // 接收者地址
    uint128 amount0Max; // 最大 token0 数量
    uint128 amount1Max; // 最大 token1 数量
}

the code is as follows:

/// @inheritdoc INonfungiblePositionManager
function collect(CollectParams calldata params)
    external
    payable
    override
    isAuthorizedForToken(params.tokenId)
    returns (uint256 amount0, uint256 amount1)
{
    require(params.amount0Max > 0 || params.amount1Max > 0);
    // allow collecting to the nft position manager address with address 0
    address recipient = params.recipient == address(0) ? address(this) : params.recipient;

    Position storage position = _positions[params.tokenId];

    PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];

    IUniswapV3Pool pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));

    (uint128 tokensOwed0, uint128 tokensOwed1) = (position.tokensOwed0, position.tokensOwed1);

    // trigger an update of the position fees owed and fee growth snapshots if it has any liquidity
    if (position.liquidity > 0) {
        pool.burn(position.tickLower, position.tickUpper, 0);
        (, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, , ) =
            pool.positions(PositionKey.compute(address(this), position.tickLower, position.tickUpper));

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

        position.feeGrowthInside0LastX128 = feeGrowthInside0LastX128;
        position.feeGrowthInside1LastX128 = feeGrowthInside1LastX128;
    }

    // compute the arguments to give to the pool#collect method
    (uint128 amount0Collect, uint128 amount1Collect) =
        (
            params.amount0Max > tokensOwed0 ? tokensOwed0 : params.amount0Max,
            params.amount1Max > tokensOwed1 ? tokensOwed1 : params.amount1Max
        );

    // the actual amounts collected are returned
    (amount0, amount1) = pool.collect(
        recipient,
        position.tickLower,
        position.tickUpper,
        amount0Collect,
        amount1Collect
    );

    // sometimes there will be a few less wei than expected due to rounding down in core, but we just subtract the full amount expected
    // instead of the actual amount so we can burn the token
    (position.tokensOwed0, position.tokensOwed1) = (tokensOwed0 - amount0Collect, tokensOwed1 - amount1Collect);

    emit Collect(params.tokenId, recipient, amount0Collect, amount1Collect);
}

first get the number of tokens to be retrieved, and if the position contains liquidity, trigger an update of the position status, where the trading pool contract is called. burn method, but the incoming liquidity parameter is 0. This is because V3 only mint and burn the position status is updated only when the position status is updated. collect method may be in swap after being called, the position status may not be up to date. Finally, the trading pool contract is called. collect method to retrieve tokens.

// the actual amounts collected are returned
(amount0, amount1) = pool.collect(
    recipient,
    position.tickLower,
    position.tickUpper,
    amount0Collect,
    amount1Collect
);

Trading pool contracts collect the logic of is relatively simple, so it will not be expanded here. The parameter amount0Requested is the number of requests to retrieve token0, and amount1Requested is the number of requests to retrieve token1. If amount0Requested is greater than position.tokensOwed0, all token0s are retrieved, and the same applies to token1.

_Modifyposition

_Modifyposition method is mint and burn the core approach.

The parameters are as follows:

struct ModifyPositionParams {
    // the address that owns the position
    address owner;
    // the lower and upper tick of the position
    int24 tickLower;
    int24 tickUpper;
    // any change in liquidity
    int128 liquidityDelta;
}

the code is as follows:

/// @dev Effect some changes to a position
/// @param params the position details and the change to the position's liquidity to effect
/// @return position a storage pointer referencing the position with the given owner and tick range
/// @return amount0 the amount of token0 owed to the pool, negative if the pool should pay the recipient
/// @return amount1 the amount of token1 owed to the pool, negative if the pool should pay the recipient
function _modifyPosition(ModifyPositionParams memory params)
    private
    noDelegateCall
    returns (
        Position.Info storage position,
        int256 amount0,
        int256 amount1
    )
{
    checkTicks(params.tickLower, params.tickUpper);

    Slot0 memory _slot0 = slot0; // SLOAD for gas optimization

    position = _updatePosition(
        params.owner,
        params.tickLower,
        params.tickUpper,
        params.liquidityDelta,
        _slot0.tick
    );

    if (params.liquidityDelta != 0) {
        if (_slot0.tick < params.tickLower) {
            // current tick is below the passed range; liquidity can only become in range by crossing from left to
            // right, when we'll need _more_ token0 (it's becoming more valuable) so user must provide it
            amount0 = SqrtPriceMath.getAmount0Delta(
                TickMath.getSqrtRatioAtTick(params.tickLower),
                TickMath.getSqrtRatioAtTick(params.tickUpper),
                params.liquidityDelta
            );
        } else if (_slot0.tick < params.tickUpper) {
            // current tick is inside the passed range
            uint128 liquidityBefore = liquidity; // SLOAD for gas optimization

            // write an oracle entry
            (slot0.observationIndex, slot0.observationCardinality) = observations.write(
                _slot0.observationIndex,
                _blockTimestamp(),
                _slot0.tick,
                liquidityBefore,
                _slot0.observationCardinality,
                _slot0.observationCardinalityNext
            );

            amount0 = SqrtPriceMath.getAmount0Delta(
                _slot0.sqrtPriceX96,
                TickMath.getSqrtRatioAtTick(params.tickUpper),
                params.liquidityDelta
            );
            amount1 = SqrtPriceMath.getAmount1Delta(
                TickMath.getSqrtRatioAtTick(params.tickLower),
                _slot0.sqrtPriceX96,
                params.liquidityDelta
            );

            liquidity = LiquidityMath.addDelta(liquidityBefore, params.liquidityDelta);
        } else {
            // current tick is above the passed range; liquidity can only become in range by crossing from right to
            // left, when we'll need _more_ token1 (it's becoming more valuable) so user must provide it
            amount1 = SqrtPriceMath.getAmount1Delta(
                TickMath.getSqrtRatioAtTick(params.tickLower),
                TickMath.getSqrtRatioAtTick(params.tickUpper),
                params.liquidityDelta
            );
        }
    }
}

pass first _Updateposition Update the position information, and then calculate the amount of token0 amount0 and the amount of token1 that liquidityDelta liquidity needs to provide, respectively, the liquidity calculation formula has been introduced when creating liquidity.

_Updateposition the method code is as follows:

/// @dev Gets and updates a position with the given liquidity delta
/// @param owner the owner of the position
/// @param tickLower the lower tick of the position's tick range
/// @param tickUpper the upper tick of the position's tick range
/// @param tick the current tick, passed to avoid sloads
function _updatePosition(
    address owner,
    int24 tickLower,
    int24 tickUpper,
    int128 liquidityDelta,
    int24 tick
) private returns (Position.Info storage position) {
    position = positions.get(owner, tickLower, tickUpper);

    uint256 _feeGrowthGlobal0X128 = feeGrowthGlobal0X128; // SLOAD for gas optimization
    uint256 _feeGrowthGlobal1X128 = feeGrowthGlobal1X128; // SLOAD for gas optimization

    // if we need to update the ticks, do it
    bool flippedLower;
    bool flippedUpper;
    if (liquidityDelta != 0) {
        uint32 time = _blockTimestamp();
        (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =
            observations.observeSingle(
                time,
                0,
                slot0.tick,
                slot0.observationIndex,
                liquidity,
                slot0.observationCardinality
            );

        flippedLower = ticks.update(
            tickLower,
            tick,
            liquidityDelta,
            _feeGrowthGlobal0X128,
            _feeGrowthGlobal1X128,
            secondsPerLiquidityCumulativeX128,
            tickCumulative,
            time,
            false,
            maxLiquidityPerTick
        );
        flippedUpper = ticks.update(
            tickUpper,
            tick,
            liquidityDelta,
            _feeGrowthGlobal0X128,
            _feeGrowthGlobal1X128,
            secondsPerLiquidityCumulativeX128,
            tickCumulative,
            time,
            true,
            maxLiquidityPerTick
        );

        if (flippedLower) {
            tickBitmap.flipTick(tickLower, tickSpacing);
        }
        if (flippedUpper) {
            tickBitmap.flipTick(tickUpper, tickSpacing);
        }
    }

    (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
        ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);

    position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);

    // clear any tick data that is no longer needed
    if (liquidityDelta < 0) {
        if (flippedLower) {
            ticks.clear(tickLower);
        }
        if (flippedUpper) {
            ticks.clear(tickUpper);
        }
    }
}

the two variables related to the observation point of the prediction machine are not explained in detail here.

(int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =
    observations.observeSingle(
        time,
        0,
        slot0.tick,
        slot0.observationIndex,
        liquidity,
        slot0.observationCardinality
    );

Then use ticks.update update the status of the price range low and the price range high, respectively. If the liquidity of the corresponding tick goes from nothing to nothing, or from nothing to nothing, it means that the tick needs to be flipped.

flippedLower = ticks.update(
    tickLower,
    tick,
    liquidityDelta,
    _feeGrowthGlobal0X128,
    _feeGrowthGlobal1X128,
    secondsPerLiquidityCumulativeX128,
    tickCumulative,
    time,
    false,
    maxLiquidityPerTick
);
flippedUpper = ticks.update(
    tickUpper,
    tick,
    liquidityDelta,
    _feeGrowthGlobal0X128,
    _feeGrowthGlobal1X128,
    secondsPerLiquidityCumulativeX128,
    tickCumulative,
    time,
    true,
    maxLiquidityPerTick
);

The accumulated liquidity fee for that price range is then calculated.

(uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
    ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);

Finally, update the position information and determine whether the tick is flipped, and call if the tick is flipped. ticks.clear clear tick status.

position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);
// clear any tick data that is no longer needed
if (liquidityDelta < 0) {
    if (flippedLower) {

    }
    if (flippedUpper) {
        ticks.clear(tickUpper);
    }
}

This completes the update position process.

swap

swap also refers to trading, which is the most commonly used and core function of Uniswap. Corresponding https://app.uniswap.org/swap let's take a look at how Uniswap's contract implements swap.

SwapRouter the contract contains the following four methods of exchanging tokens:

• exactInput : Multi-pool exchange, the user specifies the number of input tokens and gets as many output tokens as possible;
• exactInputSingle : Single pool exchange, the user specifies the number of input tokens and gets as many output tokens as possible;
• exactOutput : Multi-pool exchange, the user specifies the number of output tokens and provides as few input tokens as possible;
• exactOutputSingle single-pool Exchange, where the user specifies the number of output tokens and provides as few input tokens as possible.

Here, it is divided into "designated number of input tokens" and "designated number of output tokens.

Specify the number of input tokens

exactInput the method is responsible for multi-pool exchange, specifying the swap path and the number of input tokens, and getting as many output tokens as possible.

The parameters are as follows:

struct ExactInputParams {
    bytes path; // swap 路径，可以解析成一个或多个交易池
    address recipient; // 接收者地址
    uint256 deadline; // 过期的区块号
    uint256 amountIn; // 输入代币数量
    uint256 amountOutMinimum; // 最少输出代币数量
}

the code is as follows:

/// @inheritdoc ISwapRouter
function exactInput(ExactInputParams memory params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (uint256 amountOut)
{
    address payer = msg.sender; // msg.sender pays for the first hop

    while (true) {
        bool hasMultiplePools = params.path.hasMultiplePools();

        // the outputs of prior swaps become the inputs to subsequent ones
        params.amountIn = exactInputInternal(
            params.amountIn,
            hasMultiplePools ? address(this) : params.recipient, // for intermediate swaps, this contract custodies
            0,
            SwapCallbackData({
                path: params.path.getFirstPool(), // only the first pool in the path is necessary
                payer: payer
            })
        );

        // decide whether to continue or terminate
        if (hasMultiplePools) {
            payer = address(this); // at this point, the caller has paid
            params.path = params.path.skipToken();
        } else {
            amountOut = params.amountIn;
            break;
        }
    }

    require(amountOut >= params.amountOutMinimum, 'Too little received');
}

in a multi-pool swap, it is split into multiple single-pool swaps according to the swap path, and loops until the path ends. The first step is swap. payer is the contract caller, otherwise payer is the current SwapRouter contract.

exactInputSingleThe method is responsible for a single pool exchange, specifying the number of input tokens and getting as many output tokens as possible.

The parameters are as follows, specifying the input token address and the output token address:

struct ExactInputSingleParams {
    address tokenIn; // 输入代币地址
    address tokenOut; // 输出代币地址
    uint24 fee; // 手续费费率
    address recipient; // 接收者地址
    uint256 deadline; // 过期的区块号
    uint256 amountIn; // 输入代币数量
    uint256 amountOutMinimum; // 最少输出代币数量
    uint160 sqrtPriceLimitX96; // 限定价格，值为0则不限价
}

the code is as follows:

/// @inheritdoc ISwapRouter
function exactInputSingle(ExactInputSingleParams calldata params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (uint256 amountOut)
{
    amountOut = exactInputInternal(
        params.amountIn,
        params.recipient,
        params.sqrtPriceLimitX96,
        SwapCallbackData({path: abi.encodePacked(params.tokenIn, params.fee, params.tokenOut), payer: msg.sender})
    );
    require(amountOut >= params.amountOutMinimum, 'Too little received');
}

actual call exactInputInternal and the code is as follows:

/// @dev Performs a single exact input swap
function exactInputInternal(
    uint256 amountIn,
    address recipient,
    uint160 sqrtPriceLimitX96,
    SwapCallbackData memory data
) private returns (uint256 amountOut) {
    // allow swapping to the router address with address 0
    if (recipient == address(0)) recipient = address(this);

    (address tokenIn, address tokenOut, uint24 fee) = data.path.decodeFirstPool();

    bool zeroForOne = tokenIn < tokenOut;

    (int256 amount0, int256 amount1) =
        getPool(tokenIn, tokenOut, fee).swap(
            recipient,
            zeroForOne,
            amountIn.toInt256(),
            sqrtPriceLimitX96 == 0
                ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
                : sqrtPriceLimitX96,
            abi.encode(data)
        );

    return uint256(-(zeroForOne ? amount1 : amount0));
}

if no recipient address is specified, the default is current SwapRouter contract address. The purpose of this is to keep intermediate tokens in a multi-pool transaction. SwapRouter in the contract.

if (recipient == address(0)) recipient = address(this);

next, the transaction routing information tokenIn,tokenOut, and fee are parsed. And compare the addresses of tokenIn and tokenOut to get zeroForOne, which indicates whether token0 is exchanged for token1.

(address tokenIn, address tokenOut, uint24 fee) = data.path.decodeFirstPool();

bool zeroForOne = tokenIn < tokenOut;

Finally call the trading pool contract's swap method to obtain the amount0 and amount1 required to complete this exchange, and then return amountOut according to zeroForOne to further determine that amountOut meets the requirement of the minimum number of output tokens, and complete swap. swap the method is relatively complicated and will be specially discussed later.

Specify the number of output tokens

exactOutput the method is responsible for multi-pool exchanges, specifying the swap path and the number of output tokens, and providing as few input tokens as possible.

The parameters are as follows:

struct ExactOutputParams {
    bytes path; // swap 路径，可以解析成一个或多个交易池
    address recipient; // 接收者地址
    uint256 deadline; // 过期的区块号
    uint256 amountOut; // 输出代币数量
    uint256 amountInMaximum; // 最多输入代币数量
}

the code is as follows:

/// @inheritdoc ISwapRouter
function exactOutput(ExactOutputParams calldata params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (uint256 amountIn)
{
    // it's okay that the payer is fixed to msg.sender here, as they're only paying for the "final" exact output
    // swap, which happens first, and subsequent swaps are paid for within nested callback frames
    exactOutputInternal(
        params.amountOut,
        params.recipient,
        0,
        SwapCallbackData({path: params.path, payer: msg.sender})
    );

    amountIn = amountInCached;
    require(amountIn <= params.amountInMaximum, 'Too much requested');
    amountInCached = DEFAULT_AMOUNT_IN_CACHED;
}

in a multi-pool swap, it is split into multiple single-pool swaps according to the swap path, and loops until the path ends. The first step is swap. payer is the contract caller, otherwise payer is the current SwapRouter contract.

exactOutputSingle the method is responsible for a single pool exchange, specifying the number of output tokens and providing as few input tokens as possible.

The parameters are as follows, specifying the input token address and the output token address:

struct ExactOutputSingleParams {
    address tokenIn; // 输入代币地址
    address tokenOut; // 输出代币地址
    uint24 fee; // 手续费费率
    address recipient; // 接收者地址
    uint256 deadline; // 过期的区块号
    uint256 amountOut; // 输出代币数量
    uint256 amountInMaximum; // 最多输入代币数量
    uint160 sqrtPriceLimitX96; // 限定价格，值为0则不限价
}

the code is as follows:

/// @inheritdoc ISwapRouter
function exactOutputSingle(ExactOutputSingleParams calldata params)
    external
    payable
    override
    checkDeadline(params.deadline)
    returns (uint256 amountIn)
{
    // avoid an SLOAD by using the swap return data
    amountIn = exactOutputInternal(
        params.amountOut,
        params.recipient,
        params.sqrtPriceLimitX96,
        SwapCallbackData({path: abi.encodePacked(params.tokenOut, params.fee, params.tokenIn), payer: msg.sender})
    );

    require(amountIn <= params.amountInMaximum, 'Too much requested');
    // has to be reset even though we don't use it in the single hop case
    amountInCached = DEFAULT_AMOUNT_IN_CACHED;
}

actual call exactOutputInternal and the code is as follows:

/// @dev Performs a single exact output swap
function exactOutputInternal(
    uint256 amountOut,
    address recipient,
    uint160 sqrtPriceLimitX96,
    SwapCallbackData memory data
) private returns (uint256 amountIn) {
    // allow swapping to the router address with address 0
    if (recipient == address(0)) recipient = address(this);

    (address tokenOut, address tokenIn, uint24 fee) = data.path.decodeFirstPool();

    bool zeroForOne = tokenIn < tokenOut;

    (int256 amount0Delta, int256 amount1Delta) =
        getPool(tokenIn, tokenOut, fee).swap(
            recipient,
            zeroForOne,
            -amountOut.toInt256(),
            sqrtPriceLimitX96 == 0
                ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
                : sqrtPriceLimitX96,
            abi.encode(data)
        );

    uint256 amountOutReceived;
    (amountIn, amountOutReceived) = zeroForOne
        ? (uint256(amount0Delta), uint256(-amount1Delta))
        : (uint256(amount1Delta), uint256(-amount0Delta));
    // it's technically possible to not receive the full output amount,
    // so if no price limit has been specified, require this possibility away
    if (sqrtPriceLimitX96 == 0) require(amountOutReceived == amountOut);
}

with exactInputInternal the logic of is almost identical, except that the trading pool contract is called because the number of output tokens is specified. swap method takes-amountOut.toInt256() as a parameter.

(int256 amount0Delta, int256 amount1Delta) =
    getPool(tokenIn, tokenOut, fee).swap(
        recipient,
        zeroForOne,
        -amountOut.toInt256(),
        sqrtPriceLimitX96 == 0
            ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
            : sqrtPriceLimitX96,
        abi.encode(data)
    );

The returned amount0Delta and amount1Delta are the number of token0 required to complete the swap and the number of token1 actually output. It is further determined that the amountOut meets the requirement of the minimum number of output tokens to complete the swap.

swap

A typical V3 trading pool has many positions with overlapping price ranges, as shown in the following figure:

each trading pool tracks the current price, as well as the total liquidity provided by all price ranges that contain the current price. Record on the tick at the boundary of each interval Δ L when the price fluctuates and crosses a tick, the liquidity increases or decreases according to the direction of the price fluctuation. For example, the price crosses the range from left to right, and when it crosses the first tick of the range, liquidity needs to increase Δ L , when the last tick is worn out, liquidity needs to be reduced. Δ L the liquidity of the middle tick remains unchanged.

The liquidity within a tick is constant, and the swap formula is as follows:

P t a r g e t−Pcurrent=Δy/L

1/Ptarget−1/Pcurrent=Δx/L

Pcu r r e n t is the pre-swap price, P t a r g e t is the price after swap, and $L $is the liquidity within the tick.

From the above formula, the number of token1 can be entered Δ y deriving the target price P t a r g e t and then derive the number of output token0 Δ x ; Or by entering the number of token0 Δ x deriving the target price P ta r g e t and then derive the number of output token1 Δ y .

If it is a cross-tick transaction, it needs to be broken down into multiple ticks: if the liquidity of the current tick does not meet the requirements, the price will move to the boundary of the current range. At this time, the left section is put to sleep, and the next section is activated. And it will start the next cycle and look for the next mobile tick until the number of user requirements is met.

Finish the theory and return to the code. swap the method is the core and most complex method of trading on swap.

The parameters are:

• recipient: the address of the recipient;
• zeroForOne: true if token1 is swapped from token0, false if token0 is swapped from token1;
• amountSpecified: the number of tokens specified, the number of tokens specified for input is positive, and the number of tokens specified for output is negative;
• sqrtPriceLimitX96: limit the price. If token1 is exchanged from token0, the lower price limit is limited. If token0 is exchanged from token1, the upper price limit is limited;
• data: callback parameter.

The code is:

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

    Slot0 memory slot0Start = slot0;

    require(slot0Start.unlocked, 'LOK');
    require(
        zeroForOne
            ? sqrtPriceLimitX96 < slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO
            : sqrtPriceLimitX96 > slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO,
        'SPL'
    );

    slot0.unlocked = false;

    SwapCache memory cache =
        SwapCache({
            liquidityStart: liquidity,
            blockTimestamp: _blockTimestamp(),
            feeProtocol: zeroForOne ? (slot0Start.feeProtocol % 16) : (slot0Start.feeProtocol >> 4),
            secondsPerLiquidityCumulativeX128: 0,
            tickCumulative: 0,
            computedLatestObservation: false
        });

    bool exactInput = amountSpecified > 0;

    SwapState memory state =
        SwapState({
            amountSpecifiedRemaining: amountSpecified,
            amountCalculated: 0,
            sqrtPriceX96: slot0Start.sqrtPriceX96,
            tick: slot0Start.tick,
            feeGrowthGlobalX128: zeroForOne ? feeGrowthGlobal0X128 : feeGrowthGlobal1X128,
            protocolFee: 0,
            liquidity: cache.liquidityStart
        });

    // continue swapping as long as we haven't used the entire input/output and haven't reached the price limit
    while (state.amountSpecifiedRemaining != 0 && state.sqrtPriceX96 != sqrtPriceLimitX96) {
        StepComputations memory step;

        step.sqrtPriceStartX96 = state.sqrtPriceX96;

        (step.tickNext, step.initialized) = tickBitmap.nextInitializedTickWithinOneWord(
            state.tick,
            tickSpacing,
            zeroForOne
        );

        // ensure that we do not overshoot the min/max tick, as the tick bitmap is not aware of these bounds
        if (step.tickNext < TickMath.MIN_TICK) {
            step.tickNext = TickMath.MIN_TICK;
        } else if (step.tickNext > TickMath.MAX_TICK) {
            step.tickNext = TickMath.MAX_TICK;
        }

        // get the price for the next tick
        step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);

        // compute values to swap to the target tick, price limit, or point where input/output amount is exhausted
        (state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount) = SwapMath.computeSwapStep(
            state.sqrtPriceX96,
            (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96)
                ? sqrtPriceLimitX96
                : step.sqrtPriceNextX96,
            state.liquidity,
            state.amountSpecifiedRemaining,
            fee
        );

        if (exactInput) {
            state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
            state.amountCalculated = state.amountCalculated.sub(step.amountOut.toInt256());
        } else {
            state.amountSpecifiedRemaining += step.amountOut.toInt256();
            state.amountCalculated = state.amountCalculated.add((step.amountIn + step.feeAmount).toInt256());
        }

        // if the protocol fee is on, calculate how much is owed, decrement feeAmount, and increment protocolFee
        if (cache.feeProtocol > 0) {
            uint256 delta = step.feeAmount / cache.feeProtocol;
            step.feeAmount -= delta;
            state.protocolFee += uint128(delta);
        }

        // update global fee tracker
        if (state.liquidity > 0)
            state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);

        // shift tick if we reached the next price
        if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
            // if the tick is initialized, run the tick transition
            if (step.initialized) {
                // check for the placeholder value, which we replace with the actual value the first time the swap
                // crosses an initialized tick
                if (!cache.computedLatestObservation) {
                    (cache.tickCumulative, cache.secondsPerLiquidityCumulativeX128) = observations.observeSingle(
                        cache.blockTimestamp,
                        0,
                        slot0Start.tick,
                        slot0Start.observationIndex,
                        cache.liquidityStart,
                        slot0Start.observationCardinality
                    );
                    cache.computedLatestObservation = true;
                }
                int128 liquidityNet =
                    ticks.cross(
                        step.tickNext,
                        (zeroForOne ? state.feeGrowthGlobalX128 : feeGrowthGlobal0X128),
                        (zeroForOne ? feeGrowthGlobal1X128 : state.feeGrowthGlobalX128),
                        cache.secondsPerLiquidityCumulativeX128,
                        cache.tickCumulative,
                        cache.blockTimestamp
                    );
                // if we're moving leftward, we interpret liquidityNet as the opposite sign
                // safe because liquidityNet cannot be type(int128).min
                if (zeroForOne) liquidityNet = -liquidityNet;

                state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
            }

            state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
        } else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
            // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
            state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
        }
    }

    // update tick and write an oracle entry if the tick change
    if (state.tick != slot0Start.tick) {
        (uint16 observationIndex, uint16 observationCardinality) =
            observations.write(
                slot0Start.observationIndex,
                cache.blockTimestamp,
                slot0Start.tick,
                cache.liquidityStart,
                slot0Start.observationCardinality,
                slot0Start.observationCardinalityNext
            );
        (slot0.sqrtPriceX96, slot0.tick, slot0.observationIndex, slot0.observationCardinality) = (
            state.sqrtPriceX96,
            state.tick,
            observationIndex,
            observationCardinality
        );
    } else {
        // otherwise just update the price
        slot0.sqrtPriceX96 = state.sqrtPriceX96;
    }

    // update liquidity if it changed
    if (cache.liquidityStart != state.liquidity) liquidity = state.liquidity;

    // update fee growth global and, if necessary, protocol fees
    // overflow is acceptable, protocol has to withdraw before it hits type(uint128).max fees
    if (zeroForOne) {
        feeGrowthGlobal0X128 = state.feeGrowthGlobalX128;
        if (state.protocolFee > 0) protocolFees.token0 += state.protocolFee;
    } else {
        feeGrowthGlobal1X128 = state.feeGrowthGlobalX128;
        if (state.protocolFee > 0) protocolFees.token1 += state.protocolFee;
    }

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

    // do the transfers and collect payment
    if (zeroForOne) {
        if (amount1 < 0) TransferHelper.safeTransfer(token1, recipient, uint256(-amount1));

        uint256 balance0Before = balance0();
        IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
        require(balance0Before.add(uint256(amount0)) <= balance0(), 'IIA');
    } else {
        if (amount0 < 0) TransferHelper.safeTransfer(token0, recipient, uint256(-amount0));

        uint256 balance1Before = balance1();
        IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
        require(balance1Before.add(uint256(amount1)) <= balance1(), 'IIA');
    }

    emit Swap(msg.sender, recipient, amount0, amount1, state.sqrtPriceX96, state.liquidity, state.tick);
    slot0.unlocked = true;
}

the overall logic consists of a while loop that breaks down the swap process into multiple small steps, adjusting the current tick bit by bit until the volume required by the user is met or the price reaches the limit price (at which point it will be partially traded).

while (state.amountSpecifiedRemaining! = 0 && state.sqrtPriceX96! = sqrtPriceLimitX96) {

use 'tickBitmap. 'to find the next initialized tick

(step.tickNext, step.initialized) = tickBitmap.nextInitializedTickWithinOneWord(
    state.tick,
    tickSpacing,
    zeroForOne
);

use SwapMath.computeSwapStep swap within the tick. This method will calculate the number of inputs that the current interval can satisfy, amountIn, if it is smaller than the amountreining, we will say that the current interval cannot satisfy the entire transaction, so the next sqrtPriceX96 is the upper/lower bound of the current interval, that is, we have consumed the liquidity of the entire interval. If the amountIn is greater than the amountreining, the sqrtPriceX96 we calculate is still in the current range.

// compute values to swap to the target tick, price limit, or point where input/output amount is exhausted
(state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount) = SwapMath.computeSwapStep(
    state.sqrtPriceX96,
    (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96)
        ? sqrtPriceLimitX96
        : step.sqrtPriceNextX96,
    state.liquidity,
    state.amountSpecifiedRemaining,
    fee
);

Save the amountIn and amountOut for this transaction:

• If the number of input tokens is specified. amountSpecifiedRemaining indicates the number of available input tokens, and amountCalculated indicates the number of output tokens (expressed as negative numbers);
• if the number of output tokens is specified. amountSpecifiedRemaining represents the number of tokens that need to be output (initially negative, so step.amountOut needs to be added after each exchange until it is 0), and amountCalculated represents the number of input tokens that have been used.

if (exactInput) {
    state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
    state.amountCalculated = state.amountCalculated.sub(step.amountOut.toInt256());
} else {
    state.amountSpecifiedRemaining += step.amountOut.toInt256();
    state.amountCalculated = state.amountCalculated.add((step.amountIn + step.feeAmount).toInt256());
}

If the price after this swap reaches the target price, if the tick has been initialized, it is passed. ticks.cross the method traverses the tick, returns the newly added net liquidity liquidityNet, updates the available liquidity state.liquidity, and moves the current tick to the next tick.

If the price after the swap reaches the target price, but is not equal to the initial price, it means that the swap is over at this time, and the latest tick value is calculated using the price after the swap.

if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
    // if the tick is initialized, run the tick transition
    if (step.initialized) {
        // check for the placeholder value, which we replace with the actual value the first time the swap
        // crosses an initialized tick
        if (!cache.computedLatestObservation) {
            (cache.tickCumulative, cache.secondsPerLiquidityCumulativeX128) = observations.observeSingle(
                cache.blockTimestamp,
                0,
                slot0Start.tick,
                slot0Start.observationIndex,
                cache.liquidityStart,
                slot0Start.observationCardinality
            );
            cache.computedLatestObservation = true;
        }
        int128 liquidityNet =
            ticks.cross(
                step.tickNext,
                (zeroForOne ? state.feeGrowthGlobalX128 : feeGrowthGlobal0X128),
                (zeroForOne ? feeGrowthGlobal1X128 : state.feeGrowthGlobalX128),
                cache.secondsPerLiquidityCumulativeX128,
                cache.tickCumulative,
                cache.blockTimestamp
            );
        // if we're moving leftward, we interpret liquidityNet as the opposite sign
        // safe because liquidityNet cannot be type(int128).min
        if (zeroForOne) liquidityNet = -liquidityNet;

        state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
    }

    state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
} else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
    // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
    state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
}

Repeat the above steps until swap is completely finished.

When swap is complete, update the status and global liquidity of slot0.

// update tick and write an oracle entry if the tick change
if (state.tick != slot0Start.tick) {
    (uint16 observationIndex, uint16 observationCardinality) =
        observations.write(
            slot0Start.observationIndex,
            cache.blockTimestamp,
            slot0Start.tick,
            cache.liquidityStart,
            slot0Start.observationCardinality,
            slot0Start.observationCardinalityNext
        );
    (slot0.sqrtPriceX96, slot0.tick, slot0.observationIndex, slot0.observationCardinality) = (
        state.sqrtPriceX96,
        state.tick,
        observationIndex,
        observationCardinality
    );
} else {
    // otherwise just update the price
    slot0.sqrtPriceX96 = state.sqrtPriceX96;
}

// update liquidity if it changed
if (cache.liquidityStart != state.liquidity) liquidity = state.liquidity;

Finally, calculate the specific amount0 and amount1 required for this swap, call IUniswapV3SwapCallback interface. The output token has been sent to the recipient before the callback.

// do the transfers and collect payment
if (zeroForOne) {
    if (amount1 < 0) TransferHelper.safeTransfer(token1, recipient, uint256(-amount1));

    uint256 balance0Before = balance0();
    IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
    require(balance0Before.add(uint256(amount0)) <= balance0(), 'IIA');
} else {
    if (amount0 < 0) TransferHelper.safeTransfer(token0, recipient, uint256(-amount0));

    uint256 balance1Before = balance1();
    IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
    require(balance1Before.add(uint256(amount1)) <= balance1(), 'IIA');
}

IUniswapV3SwapCallback the implementation of IS in swarouter. sol of the periphery warehouse, which is responsible for paying for the token entered.

/// @inheritdoc IUniswapV3SwapCallback
function uniswapV3SwapCallback(
    int256 amount0Delta,
    int256 amount1Delta,
    bytes calldata _data
) external override {
    require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
    SwapCallbackData memory data = abi.decode(_data, (SwapCallbackData));
    (address tokenIn, address tokenOut, uint24 fee) = data.path.decodeFirstPool();
    CallbackValidation.verifyCallback(factory, tokenIn, tokenOut, fee);

    (bool isExactInput, uint256 amountToPay) =
        amount0Delta > 0
            ? (tokenIn < tokenOut, uint256(amount0Delta))
            : (tokenOut < tokenIn, uint256(amount1Delta));
    if (isExactInput) {
        pay(tokenIn, data.payer, msg.sender, amountToPay);
    } else {
        // either initiate the next swap or pay
        if (data.path.hasMultiplePools()) {
            data.path = data.path.skipToken();
            exactOutputInternal(amountToPay, msg.sender, 0, data);
        } else {
            amountInCached = amountToPay;
            tokenIn = tokenOut; // swap in/out because exact output swaps are reversed
            pay(tokenIn, data.payer, msg.sender, amountToPay);
        }
    }
}

At this point, the overall swap process is completed.