UniSwap V3协议浅析(下)

2023年5月6日19:19:04评论100 views字数 58195阅读193分59秒阅读模式

NoDelegateCall

NoDelegateCall合约的主要功能是提供一个修饰器来阻止对使用修饰器修饰过的函数进行delegatecall调用，合约代码如下：

// SPDX-License-Identifier: BUSL-1.1pragma solidity =0.7.6;
/// @title Prevents delegatecall to a contract/// @notice Base contract that provides a modifier for preventing delegatecall to methods in a child contractabstract contract NoDelegateCall {    /// @dev The original address of this contract    address private immutable original;
    constructor() {        // Immutables are computed in the init code of the contract, and then inlined into the deployed bytecode.        // In other words, this variable won't change when it's checked at runtime.        original = address(this);    }
    /// @dev Private method is used instead of inlining into modifier because modifiers are copied into each method,    ///     and the use of immutable means the address bytes are copied in every place the modifier is used.    function checkNotDelegateCall() private view {        require(address(this) == original);    }
    /// @notice Prevents delegatecall into the modified method    modifier noDelegateCall() {        checkNotDelegateCall();        _;    }}

UniswapV3Factory

UniswapV3Factory的主要功能是提供创建pool的接口并且跟踪所有的pool，完整代码如下所示：

// SPDX-License-Identifier: BUSL-1.1pragma solidity =0.7.6;
import './interfaces/IUniswapV3Factory.sol';
import './UniswapV3PoolDeployer.sol';import './NoDelegateCall.sol';
import './UniswapV3Pool.sol';
/// @title Canonical Uniswap V3 factory/// @notice Deploys Uniswap V3 pools and manages ownership and control over pool protocol feescontract UniswapV3Factory is IUniswapV3Factory, UniswapV3PoolDeployer, NoDelegateCall {    /// @inheritdoc IUniswapV3Factory    address public override owner;
    /// @inheritdoc IUniswapV3Factory    mapping(uint24 => int24) public override feeAmountTickSpacing;    /// @inheritdoc IUniswapV3Factory    mapping(address => mapping(address => mapping(uint24 => address))) public override getPool;
    constructor() {        owner = msg.sender;        emit OwnerChanged(address(0), msg.sender);
        feeAmountTickSpacing[500] = 10;        emit FeeAmountEnabled(500, 10);        feeAmountTickSpacing[3000] = 60;        emit FeeAmountEnabled(3000, 60);        feeAmountTickSpacing[10000] = 200;        emit FeeAmountEnabled(10000, 200);    }
    /// @inheritdoc IUniswapV3Factory    function createPool(        address tokenA,        address tokenB,        uint24 fee) external override noDelegateCall returns (address pool) {        require(tokenA != tokenB);        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);        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);    }
    /// @inheritdoc IUniswapV3Factory    function setOwner(address _owner) external override {        require(msg.sender == owner);        emit OwnerChanged(owner, _owner);        owner = _owner;    }
    /// @inheritdoc IUniswapV3Factory    function enableFeeAmount(uint24 fee, int24 tickSpacing) public override {        require(msg.sender == owner);        require(fee < 1000000);        // tick spacing is capped at 16384 to prevent the situation where tickSpacing is so large that        // TickBitmap#nextInitializedTickWithinOneWord overflows int24 container from a valid tick        // 16384 ticks represents a >5x price change with ticks of 1 bips        require(tickSpacing > 0 && tickSpacing < 16384);        require(feeAmountTickSpacing[fee] == 0);
        feeAmountTickSpacing[fee] = tickSpacing;        emit FeeAmountEnabled(fee, tickSpacing);    }}

合约最初声明当前工程合约的owner、费用的TrickSpacing(刻度间距，如果为0则表示未启用，一经添加无法删除)、根据token与fee检索交易池的映射：

    /// @inheritdoc IUniswapV3Factory    address public override owner;
    /// @inheritdoc IUniswapV3Factory    mapping(uint24 => int24) public override feeAmountTickSpacing;    /// @inheritdoc IUniswapV3Factory    mapping(address => mapping(address => mapping(uint24 => address))) public override getPool;

之后通过构造函数初始化的合约的owner以及三个TickSpace：

    constructor() {        owner = msg.sender;        emit OwnerChanged(address(0), msg.sender);
        feeAmountTickSpacing[500] = 10;        emit FeeAmountEnabled(500, 10);        feeAmountTickSpacing[3000] = 60;        emit FeeAmountEnabled(3000, 60);        feeAmountTickSpacing[10000] = 200;        emit FeeAmountEnabled(10000, 200);    }

上面定义的三个TickSpace与费率的关系如下所示：

UniSwap V3协议浅析(下)

之后通过createPool来创建交易池，此时需要提供以下三个参数：

fee:期望的费率
tokenA：交易池中的两个Token之一
tokenB：交易池中的两个Token之一

在createPool函数中首先会检查tokenA与tokenB是否是同一Token，之后将TokenA与TokenB根据地址进行升序排列，之后检查token0地址是否为空地址，之后根据费率检索TickSpace并检查TickSpace是否为0(构造函数会进行初始化一次)，之后检查当前新建的池子是否已经存在，之后通过deploy创建池子，然后新增池子记录，在新增记录时可以看到也提供了反向映射，这样做的好处是在减少后期检索时比较地址的成本，最后通过emit触发池子创建事件

    /// @inheritdoc IUniswapV3Factory    function createPool(        address tokenA,        address tokenB,        uint24 fee) external override noDelegateCall returns (address pool) {        require(tokenA != tokenB);        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);        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);    }

之后的setOwner函数用于更新工厂合约的owner，该函数只能由合约的owner调用，在更新时通过emit来触发owner变更事件：

    /// @inheritdoc IUniswapV3Factory    function setOwner(address _owner) external override {        require(msg.sender == owner);        emit OwnerChanged(owner, _owner);        owner = _owner;    }

enableFeeAmount函数用于新增tickSpacing(刻度间距)的费率，该函数只能由合约的owner调用，在函数中首先对参数进行合法性检查，在这里要求费率不得超过1000000(即:100%)，tickSpacing不得超过16384以防止tickSpacing过大，之后检查该费率是否已经存在，之后对给定tickSpacing设置费率，之后通过emit触发事件：

    /// @inheritdoc IUniswapV3Factory    function enableFeeAmount(uint24 fee, int24 tickSpacing) public override {        require(msg.sender == owner);        require(fee < 1000000);        // tick spacing is capped at 16384 to prevent the situation where tickSpacing is so large that        // TickBitmap#nextInitializedTickWithinOneWord overflows int24 container from a valid tick        // 16384 ticks represents a >5x price change with ticks of 1 bips        require(tickSpacing > 0 && tickSpacing < 16384);        require(feeAmountTickSpacing[fee] == 0);
        feeAmountTickSpacing[fee] = tickSpacing;        emit FeeAmountEnabled(fee, tickSpacing);    }

UniswapV3PoolDeployer

UniswapV3PoolDeployer合约主要提供deploy函数来创建UniswapV3Pool智能合约并设置两个token信息，交易费用信息和tick的步长信息，完整代码如下：

// SPDX-License-Identifier: BUSL-1.1pragma solidity =0.7.6;
import './interfaces/IUniswapV3PoolDeployer.sol';
import './UniswapV3Pool.sol';
contract UniswapV3PoolDeployer is IUniswapV3PoolDeployer {    struct Parameters {        address factory;        address token0;        address token1;        uint24 fee;        int24 tickSpacing;    }
    /// @inheritdoc IUniswapV3PoolDeployer    Parameters public override parameters;
    /// @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函数首先将参数再次作为参数初始化为一个Parameters的结构体变量，之后通过keccak256(abi.encode(token0, token1, fee)将token0、token1、fee作为参数得到一个哈希值，之后将其作为salt来创建合约，故而solidity会使用EVM的CREATE2指令来创建合约，这里使用CREATE2指令的一个好处就是，只要合约的bytecode及salt不变，那么创建出来的地址也将不变，也就是说每个交易池都有一个唯一的地址，之后清空结构体变量：

    /// @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;    }

UniswapV3Pool

UniswapV3Pool合约主要实现代币交易、流动性管理、交易手续费收取、Oracle管理等，由于代码太多这里暂不全部贴出来，我们直接进行分析：

首先，声明了合约中使用到的全局变量，之后定义了结构体Slot0(当前最新price、当前tick、协议费用、池子状态(开启或关闭))、结构体ProtocolFees等：

    using LowGasSafeMath for uint256;    using LowGasSafeMath for int256;    using SafeCast for uint256;    using SafeCast for int256;    using Tick for mapping(int24 => Tick.Info);    using TickBitmap for mapping(int16 => uint256);    using Position for mapping(bytes32 => Position.Info);    using Position for Position.Info;    using Oracle for Oracle.Observation[65535];
    /// @inheritdoc IUniswapV3PoolImmutables    address public immutable override factory;    /// @inheritdoc IUniswapV3PoolImmutables    address public immutable override token0;    /// @inheritdoc IUniswapV3PoolImmutables    address public immutable override token1;    /// @inheritdoc IUniswapV3PoolImmutables    uint24 public immutable override fee;
    /// @inheritdoc IUniswapV3PoolImmutables    int24 public immutable override tickSpacing;      // 刻度间隔
    /// @inheritdoc IUniswapV3PoolImmutables    uint128 public immutable override maxLiquidityPerTick; // 可使用范围内任何刻度的头寸流动性的最大金额
    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;    }    /// @inheritdoc IUniswapV3PoolState    Slot0 public override slot0;
    /// @inheritdoc IUniswapV3PoolState    uint256 public override feeGrowthGlobal0X128;    /// @inheritdoc IUniswapV3PoolState    uint256 public override feeGrowthGlobal1X128;
    // accumulated protocol fees in token0/token1 units    struct ProtocolFees {        uint128 token0;        uint128 token1;    }    /// @inheritdoc IUniswapV3PoolState    ProtocolFees public override protocolFees;
    /// @inheritdoc IUniswapV3PoolState    uint128 public override liquidity;
    /// @inheritdoc IUniswapV3PoolState    mapping(int24 => Tick.Info) public override ticks;    /// @inheritdoc IUniswapV3PoolState    mapping(int16 => uint256) public override tickBitmap;    /// @inheritdoc IUniswapV3PoolState    mapping(bytes32 => Position.Info) public override positions;    /// @inheritdoc IUniswapV3PoolState    Oracle.Observation[65535] public override observations;

修饰器lock用于提供锁机制来规避重入攻击，此方法还可以防止在初始化池之前调用函数，重入保护在整个合约中是必需的，因为我们经常使用余额检查来确定交互(如铸币、掉期和闪存)的支付状态：

    /// @dev Mutually exclusive reentrancy protection into the pool to/from a method. This method also prevents entrance    /// to a function before the pool is initialized. The reentrancy guard is required throughout the contract because    /// we use balance checks to determine the payment status of interactions such as mint, swap and flash.    modifier lock() {        require(slot0.unlocked, 'LOK');        slot0.unlocked = false;        _;        slot0.unlocked = true;    }

修饰器onlyFactoryOwner用于检测函数的调用者是否为工程合约的owner地址

    /// @dev Prevents calling a function from anyone except the address returned by IUniswapV3Factory#owner()    modifier onlyFactoryOwner() {        require(msg.sender == IUniswapV3Factory(factory).owner());        _;    }

构造函数用于初始化一个池子，其实完整的流程应该为：

UniswapV3Factory.sol(createPool)—>UniswapV3PoolDeployer.sol(deploy)—>UniswapV3Pool.sol(constructor)

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

checkTicks函数用于检测流动性的价格上限与流动性的价格下限的合法性：

    /// @dev Common checks for valid tick inputs.    function checkTicks(int24 tickLower, int24 tickUpper) private pure {        require(tickLower < tickUpper, 'TLU');        require(tickLower >= TickMath.MIN_TICK, 'TLM');        require(tickUpper <= TickMath.MAX_TICK, 'TUM');    }

函数_blockTimestamp用于返回截断后(32位)的区块时间戳信息：

    /// @dev Returns the block timestamp truncated to 32 bits, i.e. mod 2**32. This method is overridden in tests.    function _blockTimestamp() internal view virtual returns (uint32) {        return uint32(block.timestamp); // truncation is desired    }

balance0与balance1函数用于检索池子中token0与token1的资产数量：

    /// @dev Get the pool's balance of token0    /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize    /// check    function balance0() private view returns (uint256) {        (bool success, bytes memory data) =            token0.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));        require(success && data.length >= 32);        return abi.decode(data, (uint256));    }
    /// @dev Get the pool's balance of token1    /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize    /// check    function balance1() private view returns (uint256) {        (bool success, bytes memory data) =            token1.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));        require(success && data.length >= 32);        return abi.decode(data, (uint256));    }

initialize函数用于对交易池进行初始化，主要涉及池子价格、trick、协议费用等，这里的sqrtPriceX96为sqrt(amountToken1/amountToken0)Q64.96精度的定点数值，在这里首先检查池子价格是否未初始化，之后调用getTickAtSqrtRatio函数以sqrtPriceX96为参数来计算最大的trick，之后调用observations.initialize获取cardinality(基数)与cardinalityNext(下一个基数)的数值，之后对slot0进行初始化操作，完成交易池的创建，当然此时交易池里面还没有流动性：

    /// @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);    }

mint函数用于增加流动性，相关参数如下：

recipient：创建流动性的地址
tickLower：流动性头寸下限
tickUpper：流动性头寸上限
amount：增加的流动性数量
data：回调函数的参数

在这里首先检查增加的流动性的数量是否大于0，之后调用ModifyPositionParams初始化一个Position结构体的示例，之后再次调用_modifyPosition来调整Position，该函数调用完之后会返回应投入的token0和token1的数量，之后获取当前池子之前的token0和token1的数量，之后将需要投入的token0和token1的数量传给回调函数，这里的回调函数会将指定数量的token0和token1发送到合约中，回调函数执行完成后会进一步检查投入的token0和token1是否符合预期的数量，如果不符合则直接回滚交易，如果满足则通过emit触发事件：

    /// @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);    }

下面对上述涉及到的相关函数方法进行简易拆分：

ModifyPositionParams——用于存储Position(流动性)相关的数据信息，包括流动性所有者地址、流动性的上下限、流动性的改动：

    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;    }

_modifyPosition——用于更新当前Position，在这里首先通过checkTicks来检查流动性上下限是否满足条件，之后将其读入内存(Slot0 memory _slot0 = slot0;)，后续通过MLOAD直接访问而不用重新去加载LOAD，从而节省gas，紧接着又调用了_updatePosition来更新position，这里我们先继续向下解读，后面专门简介这一个函数，紧接着检查当前流动性的变更是否为0，如果不为0则检查当前的trick是否小于tricklower，如果是则所有的token1将转变为token0，之后计算token0的变更，如果当前trick小于trickupper，则通过observations.write增加Oracle条目，之后计算amout0和amount1的增量，最后当前trick范围内的流动性总量，如果trick超过了trickupper则此时所有的token0将转变为token1，之后计算amount1的变更，需要注意的是这里的amount0与amount1为int256类型，也就是说这里的amount0与amount1这两个返回值可正可负，如果为正则表示流动性提供至需要给池子给予的数量，为负数则表示池子需要给流动性提供者给予的数量：

    /// @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                );            }        }    }

这里我们再稍微补充一下上面的_updatePosition函数，该函数代码如下，在这里首先通过get函数来获取用户的position信息，之后检查流动性变更是否为0，如果不为零则获取当前时间戳信息并通过observations.observeSingle来获取请求时间点的Oracle数据，之后更新position对应的tricklower/trickupper的数据，之后检查flippedLower是否是第一次被引用，或者移除了所有引用(移除流动性操作时)，如果是则更新trick位图，之后更新position数据，并清除之前的记录：

    /// @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);            }        }    }

uniswapV3MintCallback——即回调函数，该函数会将指定数量的token0与token1发送到合约中去：

    function uniswapV3MintCallback(        uint256 amount0Owed,        uint256 amount1Owed,        bytes calldata data    ) external override {        address sender = abi.decode(data, (address));
        emit MintCallback(amount0Owed, amount1Owed);        if (amount0Owed > 0)            IERC20Minimal(IUniswapV3Pool(msg.sender).token0()).transferFrom(sender, msg.sender, amount0Owed);        if (amount1Owed > 0)            IERC20Minimal(IUniswapV3Pool(msg.sender).token1()).transferFrom(sender, msg.sender, amount1Owed);    }

collect函数用于收取手续费，相关参数如下所示：

recipient：手续费接受地址
tickLower：接受手续费的position的trick下限
tickUpper‘：接受手续费的position的trick上限
amount0Requested：从所欠费用中提取token0的数量
amount1Requested：从所欠费用中提取token0的数量

首先通过positions.get获取当前用户position信息，之后根据参数调整需要收取的手续费，并将手续费发送给流动性提供者指定的用于接受手续费的地址：

    /// @inheritdoc IUniswapV3PoolActions    function collect(        address recipient,        int24 tickLower,        int24 tickUpper,        uint128 amount0Requested,        uint128 amount1Requested) external override lock returns (uint128 amount0, uint128 amount1) {        // we don't need to checkTicks here, because invalid positions will never have non-zero tokensOwed{0,1}        Position.Info storage position = positions.get(msg.sender, tickLower, tickUpper);
        amount0 = amount0Requested > position.tokensOwed0 ? position.tokensOwed0 : amount0Requested;        amount1 = amount1Requested > position.tokensOwed1 ? position.tokensOwed1 : amount1Requested;
        if (amount0 > 0) {            position.tokensOwed0 -= amount0;            TransferHelper.safeTransfer(token0, recipient, amount0);        }        if (amount1 > 0) {            position.tokensOwed1 -= amount1;            TransferHelper.safeTransfer(token1, recipient, amount1);        }
        emit Collect(msg.sender, recipient, tickLower, tickUpper, amount0, amount1);    }

burn函数用于移除流动性，和之前的mint函数正好相逆，相关参数如下：

tickLower：要移除流动性的Position的trick下限
tickUpper：要移除流动性的Position的trick上限
amount：要移除流动性的数量

函数首先初始化一个ModifyPositionParams结构体类型的示例，之后调用_modifyPosition来修改position，之后获取调整后移除的token0与token1的数量并

将其添加到position中标记为池子欠position所有者的资产数量：

    /// @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);    }

swap函数主要用于处理交易，相关参数说明：

recipient：用于接受兑换出的token的地址
zeroForOne：代币交换方向，token0/token为true，token1/token0为false
amountSpecified：交换的数量，数值可正可负
sqrtPriceLimitX96：价格平方根的Q64.96，如果是token0/token1方向的兑换，价格不能低于sqrtPriceLimitX96，如果是token1/token0方向，则不能大于
data：回调函数的参数

在这里首先检查交易数量是否为0，之后将交易前的数据保存在内存中，之后检查是否有正在进行的token交易操作，如果没有则根据交易方向检查价格是否满足在条件，之后更新slot0.unlocked的状态，之后缓存交易的数据，之之后检查交换的数量是否大于0，并将其赋值于exactInput，之后存储交易状态信息：

    /// @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            });

只有还有剩余的input/output同时没有超过价格限制则正常进行交易操作，在这里示例化了一个StepComputations变量，该变量存储了交易过程中的信息：

    struct StepComputations {        // the price at the beginning of the step        uint160 sqrtPriceStartX96;        // the next tick to swap to from the current tick in the swap direction        int24 tickNext;        // whether tickNext is initialized or not        bool initialized;        // sqrt(price) for the next tick (1/0)        uint160 sqrtPriceNextX96;        // how much is being swapped in in this step        uint256 amountIn;        // how much is being swapped out        uint256 amountOut;        // how much fee is being paid in        uint256 feeAmount;    }

之后获取交易的起始价格，然后通过位图找到下一个可选的交易价格，这里的下一个可选的交易价格可能会到下一个流动性中，也可能还是在本流动性中，之后需要确保我们不会超过最小和最大Trick，因为trick位图不知道这些边界：

        // 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;            }

之后获取下一个trick的价格，之后计算要交换目标价格、输入/输出量、费用等：

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

如果exactInput为true则表示input不为负数，之后更新amountSpecifiedRemaining(剩余期望兑换的数量)与amountCalculated(已经兑换的数量)，如果exactInput为false则表示input为负数，之后更新amountSpecifiedRemaining(剩余期望兑换的数量)与amountCalculated(已经兑换的数量)，不过需要注意的是这里的符号有所变化，运算逻辑也有所改变，之后检查协议费用是否开启，如果开启则计算欠费多少，并减少feetAmount，增加protocolFee：

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

当更新到下一个价格时更新trick，检查trick是否已经初始化，如果是则进行trick过渡处理，具体的方法是检查占位符的值，并使用第一次穿过初始化刻度时的实际值来替换它，之后更新tick的值，如果tokenIn被耗尽，则直接计算当前价格对应的tick：

            // 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);            }

之后当trick改变时写入一个oracle条目，否则只更新价格，如果流动性发生变化则更新流动性，以及更新费用等，最后进行转账和费用收取操作：

        // 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;    }

flash函数主要用于实现闪电贷，相关参数说明如下：

recipient：借贷方地址，可调用回调函数
amount0：借贷的token0的数量
amount1：借贷的token1的数量
data：回调函数的参数

在该函数中首先计算借贷需要扣除的手续费，之后记录当前的余额，之后将借贷的token发送给借贷方，之后调用借贷方地址的回调函数将用户传入的data参数传递给该回调函数，之后再次记录调用完后的余额，之后检查回调函数调用完后余额的数量，每一个token的余额只可多不可少，之后计算借出的token0与token1的数量以及费用等：

    /// @inheritdoc IUniswapV3PoolActions    function flash(        address recipient,        uint256 amount0,        uint256 amount1,        bytes calldata data    ) external override lock noDelegateCall {        uint128 _liquidity = liquidity;        require(_liquidity > 0, 'L');
        uint256 fee0 = FullMath.mulDivRoundingUp(amount0, fee, 1e6);        uint256 fee1 = FullMath.mulDivRoundingUp(amount1, fee, 1e6);        uint256 balance0Before = balance0();        uint256 balance1Before = balance1();
        if (amount0 > 0) TransferHelper.safeTransfer(token0, recipient, amount0);        if (amount1 > 0) TransferHelper.safeTransfer(token1, recipient, amount1);
        IUniswapV3FlashCallback(msg.sender).uniswapV3FlashCallback(fee0, fee1, data);
        uint256 balance0After = balance0();        uint256 balance1After = balance1();
        require(balance0Before.add(fee0) <= balance0After, 'F0');        require(balance1Before.add(fee1) <= balance1After, 'F1');
        // sub is safe because we know balanceAfter is gt balanceBefore by at least fee        uint256 paid0 = balance0After - balance0Before;        uint256 paid1 = balance1After - balance1Before;
        if (paid0 > 0) {            uint8 feeProtocol0 = slot0.feeProtocol % 16;            uint256 fees0 = feeProtocol0 == 0 ? 0 : paid0 / feeProtocol0;            if (uint128(fees0) > 0) protocolFees.token0 += uint128(fees0);            feeGrowthGlobal0X128 += FullMath.mulDiv(paid0 - fees0, FixedPoint128.Q128, _liquidity);        }        if (paid1 > 0) {            uint8 feeProtocol1 = slot0.feeProtocol >> 4;            uint256 fees1 = feeProtocol1 == 0 ? 0 : paid1 / feeProtocol1;            if (uint128(fees1) > 0) protocolFees.token1 += uint128(fees1);            feeGrowthGlobal1X128 += FullMath.mulDiv(paid1 - fees1, FixedPoint128.Q128, _liquidity);        }
        emit Flash(msg.sender, recipient, amount0, amount1, paid0, paid1);    }

setFeeProtocol用于设置协议的费用份额的分母，相关参数说明如下：

feeProtocol0：池中token0的新协议费用
feeProtocol1：池中token1的新协议费用

    /// @inheritdoc IUniswapV3PoolOwnerActions    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external override lock onlyFactoryOwner {        require(            (feeProtocol0 == 0 || (feeProtocol0 >= 4 && feeProtocol0 <= 10)) &&                (feeProtocol1 == 0 || (feeProtocol1 >= 4 && feeProtocol1 <= 10))        );        uint8 feeProtocolOld = slot0.feeProtocol;        slot0.feeProtocol = feeProtocol0 + (feeProtocol1 << 4);        emit SetFeeProtocol(feeProtocolOld % 16, feeProtocolOld >> 4, feeProtocol0, feeProtocol1);    }

collectProtocol函数用于收取协议费用，相关参数说明如下：

recipient：接受协议费用的地址
amount0Requested：在token0中收取的协议费用
amount1Requested：在token1中收取的协议费用

    /// @inheritdoc IUniswapV3PoolOwnerActions    function collectProtocol(        address recipient,        uint128 amount0Requested,        uint128 amount1Requested    ) external override lock onlyFactoryOwner returns (uint128 amount0, uint128 amount1) {        amount0 = amount0Requested > protocolFees.token0 ? protocolFees.token0 : amount0Requested;        amount1 = amount1Requested > protocolFees.token1 ? protocolFees.token1 : amount1Requested;
        if (amount0 > 0) {            if (amount0 == protocolFees.token0) amount0--; // ensure that the slot is not cleared, for gas savings            protocolFees.token0 -= amount0;            TransferHelper.safeTransfer(token0, recipient, amount0);        }        if (amount1 > 0) {            if (amount1 == protocolFees.token1) amount1--; // ensure that the slot is not cleared, for gas savings            protocolFees.token1 -= amount1;            TransferHelper.safeTransfer(token1, recipient, amount1);        }
        emit CollectProtocol(msg.sender, recipient, amount0, amount1);    }

snapshotCumulativesInside函数用于返回分时累计的快照、每个流动性的秒数和分时范围内的秒数，快照只能与其他快照进行比较，这些快照在头寸存在的时间段内拍摄，如果在拍摄第一个快照和拍摄第二个快照之间的整个时间段内没有持有仓位，则无法比较快照，相关参数如下：

tickLower：范围下限
tickUpper：范围上限

返回值说明：

tickCumulativeInside：对应范围的刻度累加器的快照
secondsPerLiquidityInsideX128：范围内每个流动性的秒数快照
secondsInside：范围内每个流动性的秒数快照

    /// @inheritdoc IUniswapV3PoolDerivedState    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)        external        view        override        noDelegateCall        returns (            int56 tickCumulativeInside,            uint160 secondsPerLiquidityInsideX128,            uint32 secondsInside        )    {        checkTicks(tickLower, tickUpper);
        int56 tickCumulativeLower;        int56 tickCumulativeUpper;        uint160 secondsPerLiquidityOutsideLowerX128;        uint160 secondsPerLiquidityOutsideUpperX128;        uint32 secondsOutsideLower;        uint32 secondsOutsideUpper;
        {            Tick.Info storage lower = ticks[tickLower];            Tick.Info storage upper = ticks[tickUpper];            bool initializedLower;            (tickCumulativeLower, secondsPerLiquidityOutsideLowerX128, secondsOutsideLower, initializedLower) = (                lower.tickCumulativeOutside,                lower.secondsPerLiquidityOutsideX128,                lower.secondsOutside,                lower.initialized            );            require(initializedLower);
            bool initializedUpper;            (tickCumulativeUpper, secondsPerLiquidityOutsideUpperX128, secondsOutsideUpper, initializedUpper) = (                upper.tickCumulativeOutside,                upper.secondsPerLiquidityOutsideX128,                upper.secondsOutside,                upper.initialized            );            require(initializedUpper);        }
        Slot0 memory _slot0 = slot0;
        if (_slot0.tick < tickLower) {            return (                tickCumulativeLower - tickCumulativeUpper,                secondsPerLiquidityOutsideLowerX128 - secondsPerLiquidityOutsideUpperX128,                secondsOutsideLower - secondsOutsideUpper            );        } else if (_slot0.tick < tickUpper) {            uint32 time = _blockTimestamp();            (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =                observations.observeSingle(                    time,                    0,                    _slot0.tick,                    _slot0.observationIndex,                    liquidity,                    _slot0.observationCardinality                );            return (                tickCumulative - tickCumulativeLower - tickCumulativeUpper,                secondsPerLiquidityCumulativeX128 -                    secondsPerLiquidityOutsideLowerX128 -                    secondsPerLiquidityOutsideUpperX128,                time - secondsOutsideLower - secondsOutsideUpper            );        } else {            return (                tickCumulativeUpper - tickCumulativeLower,                secondsPerLiquidityOutsideUpperX128 - secondsPerLiquidityOutsideLowerX128,                secondsOutsideUpper - secondsOutsideLower            );        }    }

observe函数用于请求前N秒之前的历史数据，这里的参数secondsAgos为一个动态数组，故而可以一次请求多个历史数据，返回变量tickCumulatives和 liquidityCumulatives也是动态数组，用于记录请求参数中对应时间戳的tick index累积值和流动性累积值，之后调用observations.observe()处理数据：

    /// @inheritdoc IUniswapV3PoolDerivedState    function observe(uint32[] calldata secondsAgos)        external        view        override        noDelegateCall        returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s){        return            observations.observe(                _blockTimestamp(),                secondsAgos,                slot0.tick,                slot0.observationIndex,                liquidity,                slot0.observationCardinality            );    }

observe代码如下所示，该函数通过遍历请求参数获取每一个请求时间点的Oracle数据，数据获取通过observeSingle来实现：

    /// @notice Returns the accumulator values as of each time seconds ago from the given time in the array of `secondsAgos`    /// @dev Reverts if `secondsAgos` > oldest observation    /// @param self The stored oracle array    /// @param time The current block.timestamp    /// @param secondsAgos Each amount of time to look back, in seconds, at which point to return an observation    /// @param tick The current tick    /// @param index The index of the observation that was most recently written to the observations array    /// @param liquidity The current in-range pool liquidity    /// @param cardinality The number of populated elements in the oracle array    /// @return tickCumulatives The tick * time elapsed since the pool was first initialized, as of each `secondsAgo`    /// @return secondsPerLiquidityCumulativeX128s The cumulative seconds / max(1, liquidity) since the pool was first initialized, as of each `secondsAgo`    function observe(        Observation[65535] storage self,        uint32 time,        uint32[] memory secondsAgos,        int24 tick,        uint16 index,        uint128 liquidity,        uint16 cardinality    ) internal view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s) {        require(cardinality > 0, 'I');
        tickCumulatives = new int56[](secondsAgos.length);        secondsPerLiquidityCumulativeX128s = new uint160[](secondsAgos.length);        for (uint256 i = 0; i < secondsAgos.length; i++) {            (tickCumulatives[i], secondsPerLiquidityCumulativeX128s[i]) = observeSingle(                self,                time,                secondsAgos[i],                tick,                index,                liquidity,                cardinality            );        }    }

Uniswap-v3-periphery

LiquidityManagement

addLiquidity函数用于向初始化后的池子中增加流动性，AddLiquidityParams为相关流动性添加的参数，在这里首先根据传入的参数的params.token0、 params.token1、fee来检索对应的流动性池，之后通过调用PoolAddress.computeAddress函数将工程合约地址以及poolKey作为参数计算流动性池子的合约地址，之后通过getLiquidityForAmounts计算流动性数量，最后通过mint函数来增加流动性：

    struct AddLiquidityParams {        address token0;        address token1;        uint24 fee;        address recipient;        int24 tickLower;        int24 tickUpper;        uint256 amount0Desired;        uint256 amount1Desired;        uint256 amount0Min;        uint256 amount1Min;    }
    /// @notice Add liquidity to an initialized pool    function addLiquidity(AddLiquidityParams memory params)        internal        returns (            uint128 liquidity,            uint256 amount0,            uint256 amount1,            IUniswapV3Pool pool)    {        PoolAddress.PoolKey memory poolKey =            PoolAddress.PoolKey({token0: params.token0, token1: params.token1, fee: params.fee});
        pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));
        // compute the liquidity amount        {            (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();            uint160 sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(params.tickLower);            uint160 sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(params.tickUpper);
            liquidity = LiquidityAmounts.getLiquidityForAmounts(                sqrtPriceX96,                sqrtRatioAX96,                sqrtRatioBX96,                params.amount0Desired,                params.amount1Desired            );        }
        (amount0, amount1) = pool.mint(            params.recipient,            params.tickLower,            params.tickUpper,            liquidity,            abi.encode(MintCallbackData({poolKey: poolKey, payer: msg.sender}))        );
        require(amount0 >= params.amount0Min && amount1 >= params.amount1Min, 'Price slippage check');    }

getLiquidityForAmounts函数代码如下所示，相关参数介绍如下：

sqrtRatioX96：代表当前矿池价格的sqrt价格
sqrtRatioAX96：代表第一个tick边界的sqrt价格
sqrtRatioBX96：代表第二个tick边界的sqrt价格
amount0：发送的token0的数量
amount1：发送的token1的数量
liquidity：收到的最大流动性金额

    /// @notice Computes the maximum amount of liquidity received for a given amount of token0, token1, the current    /// pool prices and the prices at the tick boundaries    /// @param sqrtRatioX96 A sqrt price representing the current pool prices    /// @param sqrtRatioAX96 A sqrt price representing the first tick boundary    /// @param sqrtRatioBX96 A sqrt price representing the second tick boundary    /// @param amount0 The amount of token0 being sent in    /// @param amount1 The amount of token1 being sent in    /// @return liquidity The maximum amount of liquidity received    function getLiquidityForAmounts(        uint160 sqrtRatioX96,        uint160 sqrtRatioAX96,        uint160 sqrtRatioBX96,        uint256 amount0,        uint256 amount1) internal pure returns (uint128 liquidity) {        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
        if (sqrtRatioX96 <= sqrtRatioAX96) {            liquidity = getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);        } else if (sqrtRatioX96 < sqrtRatioBX96) {            uint128 liquidity0 = getLiquidityForAmount0(sqrtRatioX96, sqrtRatioBX96, amount0);            uint128 liquidity1 = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioX96, amount1);
            liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;        } else {            liquidity = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);        }    }

PeripheryPayments

unwrapWETH9用于提取WETH9

    /// @inheritdoc IPeripheryPayments    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable override {        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
        if (balanceWETH9 > 0) {            IWETH9(WETH9).withdraw(balanceWETH9);            TransferHelper.safeTransferETH(recipient, balanceWETH9);        }    }

sweepToken用于转账操作：

    /// @inheritdoc IPeripheryPayments    function sweepToken(        address token,        uint256 amountMinimum,        address recipient) external payable override {        uint256 balanceToken = IERC20(token).balanceOf(address(this));        require(balanceToken >= amountMinimum, 'Insufficient token');
        if (balanceToken > 0) {            TransferHelper.safeTransfer(token, recipient, balanceToken);        }    }

refundETH函数用于接收外部先当前合约转的资产：

    /// @inheritdoc IPeripheryPayments    function refundETH() external payable override {        if (address(this).balance > 0) TransferHelper.safeTransferETH(msg.sender, address(this).balance);    }

play函数也用于转账操作，但是它会鉴别转账的token的类型并根据不同类型走不同的逻辑：

    /// @param token The token to pay    /// @param payer The entity that must pay    /// @param recipient The entity that will receive payment    /// @param value The amount to pay    function pay(        address token,        address payer,        address recipient,        uint256 value) internal {        if (token == WETH9 && address(this).balance >= value) {            // pay with WETH9            IWETH9(WETH9).deposit{value: value}(); // wrap only what is needed to pay            IWETH9(WETH9).transfer(recipient, value);        } else if (payer == address(this)) {            // pay with tokens already in the contract (for the exact input multihop case)            TransferHelper.safeTransfer(token, recipient, value);        } else {            // pull payment            TransferHelper.safeTransferFrom(token, payer, recipient, value);        }    }

PeripheryPaymentsWithFee

unwrapWETH9WithFee函数用于提现：

    /// @inheritdoc IPeripheryPaymentsWithFee    function unwrapWETH9WithFee(        uint256 amountMinimum,        address recipient,        uint256 feeBips,        address feeRecipient) public payable override {        require(feeBips > 0 && feeBips <= 100);
        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
        if (balanceWETH9 > 0) {            IWETH9(WETH9).withdraw(balanceWETH9);            uint256 feeAmount = balanceWETH9.mul(feeBips) / 10_000;            if (feeAmount > 0) TransferHelper.safeTransferETH(feeRecipient, feeAmount);            TransferHelper.safeTransferETH(recipient, balanceWETH9 - feeAmount);        }    }

sweepTokenWithFee用于转账：

    /// @inheritdoc IPeripheryPaymentsWithFee    function sweepTokenWithFee(        address token,        uint256 amountMinimum,        address recipient,        uint256 feeBips,        address feeRecipient) public payable override {        require(feeBips > 0 && feeBips <= 100);
        uint256 balanceToken = IERC20(token).balanceOf(address(this));        require(balanceToken >= amountMinimum, 'Insufficient token');
        if (balanceToken > 0) {            uint256 feeAmount = balanceToken.mul(feeBips) / 10_000;            if (feeAmount > 0) TransferHelper.safeTransfer(token, feeRecipient, feeAmount);            TransferHelper.safeTransfer(token, recipient, balanceToken - feeAmount);        }    }

NonfungiblePositionManager

NonfungiblePositionManager提供了与非同质化Position相关的操作，例如：增加/移除/修改Pool的流动性，并且通过NFT token将流动性代币化，使用ERC721 token的原因是同一个池的多个流动性并不能等价替换，合约开头首先定义了相关数据结构，包括：position结构体、用于交易池ID检索的mapping、Pool Keys检索的mapping等：

    // details about the uniswap position    struct Position {        // the nonce for permits        uint96 nonce;        // the address that is approved for spending this token        address operator;        // the ID of the pool with which this token is connected        uint80 poolId;        // the tick range of the position        int24 tickLower;        int24 tickUpper;        // the liquidity of the position        uint128 liquidity;        // the fee growth of the aggregate position as of the last action on the individual position        uint256 feeGrowthInside0LastX128;        uint256 feeGrowthInside1LastX128;        // how many uncollected tokens are owed to the position, as of the last computation        uint128 tokensOwed0;        uint128 tokensOwed1;    }
    /// @dev IDs of pools assigned by this contract    mapping(address => uint80) private _poolIds;
    /// @dev Pool keys by pool ID, to save on SSTOREs for position data    mapping(uint80 => PoolAddress.PoolKey) private _poolIdToPoolKey;
    /// @dev The token ID position data    mapping(uint256 => Position) private _positions;
    /// @dev The ID of the next token that will be minted. Skips 0    uint176 private _nextId = 1;    /// @dev The ID of the next pool that is used for the first time. Skips 0    uint80 private _nextPoolId = 1;
    /// @dev The address of the token descriptor contract, which handles generating token URIs for position tokens    address private immutable _tokenDescriptor;

构造函数进行初始化操作：

    constructor(        address _factory,        address _WETH9,        address _tokenDescriptor_) ERC721Permit('Uniswap V3 Positions NFT-V1', 'UNI-V3-POS', '1') PeripheryImmutableState(_factory, _WETH9) {        _tokenDescriptor = _tokenDescriptor_;    }

positions用于检索与tokenid相关position信息：

    /// @inheritdoc INonfungiblePositionManager    function positions(uint256 tokenId)        external        view        override        returns (            uint96 nonce,            address operator,            address token0,            address token1,            uint24 fee,            int24 tickLower,            int24 tickUpper,            uint128 liquidity,            uint256 feeGrowthInside0LastX128,            uint256 feeGrowthInside1LastX128,            uint128 tokensOwed0,            uint128 tokensOwed1        )    {        Position memory position = _positions[tokenId];        require(position.poolId != 0, 'Invalid token ID');        PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];        return (            position.nonce,            position.operator,            poolKey.token0,            poolKey.token1,            poolKey.fee,            position.tickLower,            position.tickUpper,            position.liquidity,            position.feeGrowthInside0LastX128,            position.feeGrowthInside1LastX128,            position.tokensOwed0,            position.tokensOwed1        );    }

mint函数用于创建一个NFT类的Positon

    /// @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);    }

tokenURI函数用于为position管理者生成描述特定TokenID的URI(源自ERC721):

    function tokenURI(uint256 tokenId) public view override(ERC721, IERC721Metadata) returns (string memory) {        require(_exists(tokenId));        return INonfungibleTokenPositionDescriptor(_tokenDescriptor).tokenURI(this, tokenId);    }

increaseLiquidity函数用于增加流动性：

    /// @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);    }

decreaseLiquidity函数用于缩减流动性

    /// @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);    }

collect函数用于收取费用：

    /// @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);    }

burn函数用于销毁TokenID：

    /// @inheritdoc INonfungiblePositionManager    function burn(uint256 tokenId) external payable override isAuthorizedForToken(tokenId) {        Position storage position = _positions[tokenId];        require(position.liquidity == 0 && position.tokensOwed0 == 0 && position.tokensOwed1 == 0, 'Not cleared');        delete _positions[tokenId];        _burn(tokenId);    }

PoolInitializer

createAndInitializePoolIfNecessary函数用于创建并初始化流动性池子，相关代码如下所示：

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

SwapRouter

SwapRouter提供代币交易的接口，它是对UniswapV3Pool合约中交易相关接口的进一步封装，前端界面主要与这个合约来进行对接，下面进行简单介绍：

getPool函数用于根据tokenA、TokenB以及fee来获取对应的池子信息：

    /// @dev Returns the pool for the given token pair and fee. The pool contract may or may not exist.    function getPool(        address tokenA,        address tokenB,        uint24 fee) private view returns (IUniswapV3Pool) {        return IUniswapV3Pool(PoolAddress.computeAddress(factory, PoolAddress.getPoolKey(tokenA, tokenB, fee)));    }

uniswapV3SwapCallback函数用于回调操作：

    /// @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);            }        }    }

exactInputSingle函数用于计算将一种指定数量的token兑换成另一种token时可以做多获得多少的输出量：

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

这里调用的函数exactInputInternal代码如下，它是exactInputSingle的具体实现：

    /// @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));    }

exactOutputSingle用于根据指定的最小输出量来计算需要投入token的量：

    /// @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;    }

exactOutputInternal代码如下所示：

    /// @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);    }

V3Migrator

migrate函数的作用主要就是进行流动性迁移

    function migrate(MigrateParams calldata params) external override {        require(params.percentageToMigrate > 0, 'Percentage too small');        require(params.percentageToMigrate <= 100, 'Percentage too large');
        // burn v2 liquidity to this address        IUniswapV2Pair(params.pair).transferFrom(msg.sender, params.pair, params.liquidityToMigrate);        (uint256 amount0V2, uint256 amount1V2) = IUniswapV2Pair(params.pair).burn(address(this));
        // calculate the amounts to migrate to v3        uint256 amount0V2ToMigrate = amount0V2.mul(params.percentageToMigrate) / 100;        uint256 amount1V2ToMigrate = amount1V2.mul(params.percentageToMigrate) / 100;
        // approve the position manager up to the maximum token amounts        TransferHelper.safeApprove(params.token0, nonfungiblePositionManager, amount0V2ToMigrate);        TransferHelper.safeApprove(params.token1, nonfungiblePositionManager, amount1V2ToMigrate);
        // mint v3 position        (, , uint256 amount0V3, uint256 amount1V3) =            INonfungiblePositionManager(nonfungiblePositionManager).mint(                INonfungiblePositionManager.MintParams({                    token0: params.token0,                    token1: params.token1,                    fee: params.fee,                    tickLower: params.tickLower,                    tickUpper: params.tickUpper,                    amount0Desired: amount0V2ToMigrate,                    amount1Desired: amount1V2ToMigrate,                    amount0Min: params.amount0Min,                    amount1Min: params.amount1Min,                    recipient: params.recipient,                    deadline: params.deadline                })            );
        // if necessary, clear allowance and refund dust        if (amount0V3 < amount0V2) {            if (amount0V3 < amount0V2ToMigrate) {                TransferHelper.safeApprove(params.token0, nonfungiblePositionManager, 0);            }
            uint256 refund0 = amount0V2 - amount0V3;            if (params.refundAsETH && params.token0 == WETH9) {                IWETH9(WETH9).withdraw(refund0);                TransferHelper.safeTransferETH(msg.sender, refund0);            } else {                TransferHelper.safeTransfer(params.token0, msg.sender, refund0);            }        }        if (amount1V3 < amount1V2) {            if (amount1V3 < amount1V2ToMigrate) {                TransferHelper.safeApprove(params.token1, nonfungiblePositionManager, 0);            }
            uint256 refund1 = amount1V2 - amount1V3;            if (params.refundAsETH && params.token1 == WETH9) {                IWETH9(WETH9).withdraw(refund1);                TransferHelper.safeTransferETH(msg.sender, refund1);            } else {                TransferHelper.safeTransfer(params.token1, msg.sender, refund1);            }        }    }

参考链接

https://uniswap.org/blog/uniswap-v3/

https://uniswap.org/whitepaper-v3.pdf

https://baijiahao.baidu.com/s?id=1699002785866852290&wfr=spider&for=pc

免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉。

左青龙
微信扫一扫

右白虎
微信扫一扫

UniSwap V3协议浅析(下)

NoDelegateCall

UniswapV3Factory

UniswapV3PoolDeployer

UniswapV3Pool

Uniswap-v3-periphery

LiquidityManagement

PeripheryPayments

PeripheryPaymentsWithFee

NonfungiblePositionManager

PoolInitializer

SwapRouter

V3Migrator

参考链接

【AutoCS】智能汽车安全-漏洞挖掘到控车攻击

卫星互联网安全：机遇、挑战与未来方向

SecOC 报文在AUTOSAR架构软件中传递流程图示例

AUTOSAR 存储栈分析MemIf\Fee

智能汽车漏洞挖掘案例分享

网联车CAN协议分析之流量监听与重放研究

E26 和 E27—— 弥合法规与实施之间的差距：连接解决方案提供商的视角

AB PLC固件提取与逆向分析

嵌入式系统中Flash寿命预测与监控

点亮你的ST7789屏幕

发表评论

在线咨询

微信