剖析DeFi交易产品之UniswapV4：Swap

Keegan小钢
更新于 2023-12-05 11:06
阅读 2013

Swap可分为两种场景：单池交易和跨池交易。在PoolManager合约里，要完成交易流程，会涉及到lock()、swap()、settle()、take()四个函数。

文章首发于公众号：[Keegan小钢](https://mp.weixin.qq.com/s?__biz=MzA5OTI1NDE0Mw==&mid=2652494703&idx=1&sn=54b00ab8c2ad98d89a098e288f77bac9&chksm=8b68517fbc1fd86969d0e305e0064e3093f158b73b796bbd23795f874f3f1368cfa637e0cbe4&token=846491392&lang=zh_CN#rd)
***
Swap 可分为两种场景：**单池交易**和**跨池交易**。在 **PoolManager** 合约里，要完成交易流程，会涉及到 `lock()`、`swap()`、`settle()`、`take()` 四个函数。单池交易时只需要调一次 `swap()` 函数，而跨池交易时则需要多次调用 `swap()` 函数来完成。

我们先来聊聊单池交易如何实现，以下是流程图：

![image.png](https://img.learnblockchain.cn/attachments/2023/12/FAbGZChU656e935b504ac.png)

第一步，和其他操作一样，先执行 `lock()`，锁定住接下来的系列操作。

第二步，就是在 `lockAcquired()` 回调函数里执行 `swap()` 函数。这一步执行完之后，记账系统中会记录用户欠池子的资产数量，即用户需要支付的代币；以及池子欠用户的资产数量，即用户此次交易可得的代币。

第三步，执行 `settle()` 函数，完成代币的支付。

第四步，执行 `take()` 函数，取回所得的代币。

最后，`lock()` 函数完成，返回结果。

而如果是跨池交易的话，则需要在 Router 层面确定好交易路径，然后根据路径执行多次 `swap`。举个例子，现在要用 A 兑换成 C，但是 A 和 C 之间没有直接配对的池子，但是有中间代币 B，存在 A 和 B 配对的池子，也存在 B 和 C 配对的池子。那交易路径就可以先用 A 换成 B，再将 B 换成 C，最终实现了 A 换成 C。而不管中间经过了多少次 `swap`，最后，只需要完成一次 `settle` 操作，即支付 A，也只需要执行一次 `take` 操作，即取回最后所得的 C。整个流程大致如下图所示：

![image.png](https://img.learnblockchain.cn/attachments/2023/12/pvLiq84P656e93704825e.png)

下面，我们主要剖析讲解 `swap()` 函数的内部实现。

首先，看看其函数声明，如下：

```C++
function swap(PoolKey memory key, IPoolManager.SwapParams memory params, bytes calldata hookData)
  external
  override
  noDelegateCall
  onlyByLocker
  returns (BalanceDelta delta)
```

`key` 指定了要进行交易的池子，`params` 是具体的交易参数，`hookData` 即需要回传给 hooks 合约的数据。

来看看 `params` 具体有哪些参数：

```C++
struct SwapParams {
    bool zeroForOne;
    int256 amountSpecified;
    uint160 sqrtPriceLimitX96;
}
```

`zeroForOne` 指名了要用 `currency0` 兑换 `currency1`，为 `false` 的话则反过来用 `currency1` 兑换 `currency0`。`amountSpecified` 是指定的确定数额，正数表示输入，负数表示输出。`sqrtPriceLimitX96` 是滑点保护的限定价格。如果之前已经了解过 UniswapV3，那对这几个字段应该不陌生。

两个函数修饰器 `noDelegateCall` 和 `onlyByLocker`，和之前文章介绍的一样，就不赘述了。

返回值 `delta`，其组成里的两个数，正常情况下就是一个正数，一个负数。

接下来，看看函数体了。先看前面一段代码：

```C++
PoolId id = key.toId();
_checkPoolInitialized(id);

if (key.hooks.shouldCallBeforeSwap()) {
    bytes4 selector = key.hooks.beforeSwap(msg.sender, key, params, hookData);
    // Sentinel return value used to signify that a NoOp occurred.
    if (key.hooks.isValidNoOpCall(selector)) return BalanceDeltaLibrary.MAXIMUM_DELTA;
    else if (selector != IHooks.beforeSwap.selector) revert Hooks.InvalidHookResponse();
}
```

这部分逻辑很简单，前两行代码，检查池子是否已经初始化过了，未初始化的则 `revert`。之后是执行 hooks 合约的 `beforeSwap` 钩子函数。

接下来这段代码是执行 `swap` 的内部函数：

```C++
uint256 feeForProtocol;
uint256 feeForHook;
uint24 swapFee;
Pool.SwapState memory state;
(delta, feeForProtocol, feeForHook, swapFee, state) = pools[id].swap(
    Pool.SwapParams({
        tickSpacing: key.tickSpacing,
        zeroForOne: params.zeroForOne,
        amountSpecified: params.amountSpecified,
        sqrtPriceLimitX96: params.sqrtPriceLimitX96
    })
);
```

这个内部函数的具体实现比较复杂，我们待会再讲，先继续讲完外部函数剩下的代码。

接下来一行代码就是进行记账了：

```C++
_accountPoolBalanceDelta(key, delta);
```

之后是对协议费和 hook 费用的处理：

```C++
unchecked {
    if (feeForProtocol > 0) {
        protocolFeesAccrued[params.zeroForOne ? key.currency0 : key.currency1] += feeForProtocol;
    }
    if (feeForHook > 0) {
        hookFeesAccrued[address(key.hooks)][params.zeroForOne ? key.currency0 : key.currency1] += feeForHook;
    }
}
```

接着执行 `afterSwap` 的钩子函数：

```C++
if (key.hooks.shouldCallAfterSwap()) {
    if (key.hooks.afterSwap(msg.sender, key, params, delta, hookData) != IHooks.afterSwap.selector) {
        revert Hooks.InvalidHookResponse();
    }
}
```

最后，发送事件：

```C++
emit Swap(
    id, msg.sender, delta.amount0(), delta.amount1(), state.sqrtPriceX96, state.liquidity, state.tick, swapFee
);
```

整个外部函数的逻辑还是比较清晰的。复杂的其实是内部函数的实现。下面就来看看 `swap` 内部函数的实现逻辑。还是先看函数声明：

```C++
function swap(State storage self, SwapParams memory params)
  internal
  returns (
      BalanceDelta result,
      uint256 feeForProtocol,
      uint256 feeForHook,
      uint24 swapFee,
      SwapState memory state
  )
```

`self` 是 `storage` 类型的，其实就是外部函数的 `pools[id]`。而第二个参数的 `SwapParams` 不同于外部函数的同名参数，这个内部函数的此参数具体如下：

```C++
struct SwapParams {
    int24 tickSpacing;
    bool zeroForOne;
    int256 amountSpecified;
    uint160 sqrtPriceLimitX96;
}
```

相比外部函数的此参数，多了 `tickSpacing`，其他参数则和外部函数的一样。

返回值比较多。`result` 就是变动的净余额，`feeForProtocol` 是协议费，`feeForHook` 是 hook 费用，包括 hook 交易费用和提现费用，`swapFee` 就是池子本身的交易费，最后的 `state` 是最新的状态。

接着，开始查看函数体的代码实现，先看前面一段：

```C++
// 指定价格不能为0
if (params.amountSpecified == 0) revert SwapAmountCannotBeZero();
// 读取出swap前的状态
Slot0 memory slot0Start = self.slot0;
swapFee = slot0Start.swapFee;
if (params.zeroForOne) { // token0兑换token1
  	// 滑点价格的判断
    if (params.sqrtPriceLimitX96 >= slot0Start.sqrtPriceX96) {
        revert PriceLimitAlreadyExceeded(slot0Start.sqrtPriceX96, params.sqrtPriceLimitX96);
    }
    if (params.sqrtPriceLimitX96 <= TickMath.MIN_SQRT_RATIO) {
        revert PriceLimitOutOfBounds(params.sqrtPriceLimitX96);
    }
} else { // token1兑换token0
  	// 滑点价格的判断
    if (params.sqrtPriceLimitX96 <= slot0Start.sqrtPriceX96) {
        revert PriceLimitAlreadyExceeded(slot0Start.sqrtPriceX96, params.sqrtPriceLimitX96);
    }
    if (params.sqrtPriceLimitX96 >= TickMath.MAX_SQRT_RATIO) {
        revert PriceLimitOutOfBounds(params.sqrtPriceLimitX96);
    }
}
```

接下来是这段代码：

```C++
// 临时的缓存数据
SwapCache memory cache = SwapCache({
    liquidityStart: self.liquidity,
    protocolFee: params.zeroForOne
        ? (getSwapFee(slot0Start.protocolFees) % 64)
        : (getSwapFee(slot0Start.protocolFees) >> 6),
    hookFee: params.zeroForOne ? (getSwapFee(slot0Start.hookFees) % 64) : (getSwapFee(slot0Start.hookFees) >> 6)
});
// 是否为确定的输入
bool exactInput = params.amountSpecified > 0;
// 初始化返回值的state
state = SwapState({
    amountSpecifiedRemaining: params.amountSpecified,
    amountCalculated: 0,
    sqrtPriceX96: slot0Start.sqrtPriceX96,
    tick: slot0Start.tick,
    feeGrowthGlobalX128: params.zeroForOne ? self.feeGrowthGlobal0X128 : self.feeGrowthGlobal1X128,
    liquidity: cache.liquidityStart
});
```

`cache` 是一个临时状态的缓存数据，包括三个字段：

* `liquidityStart`：流动性
* `protocolFee`：协议费用
* `hookFee`：hook 费用

`amountSpecified` 大于 0 则说明是指定的输入，即 `exactInput` 为 `true`。

初始化返回值 `state` 也都是用当前状态的值进行初始化。这里前两个字段需要介绍一下，即 `amountSpecifiedRemaining` 和 `amountCalculated`。第一个字段表示当前还有多少指定的金额未进行交易计算的，第二个字段表示已经交易计算累加的数额。为了理解这两个字段，我们举个例子来说明。假设用户指定的是输出的数额，假设为 1000，那 `amountSpecifiedRemaining` 初始值即为 1000。但是，当前有效的流动性剩余量并不足 1000，假设只剩下 400，所以在当前 tick 下的计算只能用到 400，假设计算所得的输入数额为 200，那么，次轮计算后，`amountSpecifiedRemaining` 剩下 1000 - 400 = 600，而 `amountCalculated` 变为 200。之后，tick 会移动到下一个有流动性的区间内。剩下的 600 继续计算所得，假设这时的流动性剩余已经超过 600 了，这 600 计算所得的输入值为 250，那计算完后的 `amountSpecifiedRemaining` 就变成了 0，而 `amountCalculated` 则为 200 + 250 = 450，计算结束。这就是这两个字段的作用。

之后的代码会做循环判断，就是上面所说的计算逻辑：

```C++
StepComputations memory step;
// 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 != params.sqrtPriceLimitX96) {
	...
}
```

`while` 条件里除了判断 `amountSpecifiedRemaining` 不为 0 之外，还判断了最新价格不能等于滑点价格。如果等于滑点价格了，也会结束循环。

`step` 用来存储 `while` 循环里每一步的计算用到的临时变量，具体包含以下字段：

```C++
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;
}
```

接着，来看看 `while` 循环里面的逻辑，先来看前面一段代码：

```C++
// 初始化当前这一步的价格
step.sqrtPriceStartX96 = state.sqrtPriceX96;
// 获取出下一个tick
(step.tickNext, step.initialized) =
    self.tickBitmap.nextInitializedTickWithinOneWord(state.tick, params.tickSpacing, params.zeroForOne);
// 确保下一个tick不会超出边界
if (step.tickNext < TickMath.MIN_TICK) {
    step.tickNext = TickMath.MIN_TICK;
} else if (step.tickNext > TickMath.MAX_TICK) {
    step.tickNext = TickMath.MAX_TICK;
}
// 计算出下一个tick对应的根号价格
step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
```

之后，执行当前这步的具体计算：

```C++
// 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,
    (
        params.zeroForOne
            ? step.sqrtPriceNextX96 < params.sqrtPriceLimitX96
            : step.sqrtPriceNextX96 > params.sqrtPriceLimitX96
    ) ? params.sqrtPriceLimitX96 : step.sqrtPriceNextX96,
    state.liquidity,
    state.amountSpecifiedRemaining,
    swapFee
);
```

计算返回四个值，`sqrtPriceX96` 为计算后的最新价格，`amountIn` 为输入的数额，`amountOut` 为输出的金额，`feeAmount` 为需要支付的手续费。

继续看下一段代码：

```C++
if (exactInput) { //指定输入时
    unchecked {
      	//remaining减去输入额和手续费
        state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
    }
  	//calculated加上输出额，因为amountOut为负数，所以用减法
    state.amountCalculated = state.amountCalculated - step.amountOut.toInt256();
} else { //指定输出时
    unchecked {
      	//remaining减去输出额，因为amountOut为负数，所以用加法
        state.amountSpecifiedRemaining += step.amountOut.toInt256();
    }
  	//calculated加上输入额和手续费
    state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount).toInt256();
}
```

之后的一段代码则是计算几个费用了：

```C++
// 协议费用
if (cache.protocolFee > 0) {
    // A: calculate the amount of the fee that should go to the protocol
    uint256 delta = step.feeAmount / cache.protocolFee;
    // A: subtract it from the regular fee and add it to the protocol fee
    unchecked {
        step.feeAmount -= delta;
        feeForProtocol += delta;
    }
}
// hook费用
if (cache.hookFee > 0) {
    // step.feeAmount has already been updated to account for the protocol fee
    uint256 delta = step.feeAmount / cache.hookFee;
    unchecked {
        step.feeAmount -= delta;
        feeForHook += delta;
    }
}
// 更新全局费用跟踪器
if (state.liquidity > 0) {
    unchecked {
        state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
    }
}
```

`while` 循环体里的最后一段代码则如下：

```C++
// 如果计算后的新价格到达下一个tick价格就移动tick
if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
    // 如果tick已经初始化，则执行移动tick
    if (step.initialized) {
        int128 liquidityNet = Pool.crossTick(
            self,
            step.tickNext,
            (params.zeroForOne ? state.feeGrowthGlobalX128 : self.feeGrowthGlobal0X128),
            (params.zeroForOne ? self.feeGrowthGlobal1X128 : state.feeGrowthGlobalX128)
        );
        // 如果向左移动，把liquidityNet理解为相反的符号
        unchecked {
            if (params.zeroForOne) liquidityNet = -liquidityNet;
        }
				// 更新流动性
        state.liquidity = liquidityNet < 0
            ? state.liquidity - uint128(-liquidityNet)
            : state.liquidity + uint128(liquidityNet);
    }
		// 更新tick
    unchecked {
        state.tick = params.zeroForOne ? step.tickNext - 1 : step.tickNext;
    }
} else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
    // 重新计算，除非我们处于较低的刻度边界(即已经转换过刻度)，并且没有移动
    state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
}
```

整个 `while` 循环跑完之后，一般来说，可能会存在两种情况。第一种，指定的金额全部完成兑换，即 `amountSpecifiedRemaining` 没有剩余。第二种，兑换到一半，触发到了滑点保护价格，那 `amountSpecifiedRemaining` 将会有剩余，只有部分成交。

那么，循环结束之后，整个内部的 `swap` 函数就只剩下最后的一部分代码了，如下：

```C++
// 将临时状态的价格和tick转为storage状态
(self.slot0.sqrtPriceX96, self.slot0.tick) = (state.sqrtPriceX96, state.tick);

// 更新storage状态的流动性
if (cache.liquidityStart != state.liquidity) self.liquidity = state.liquidity;

// 更新全局的手续费跟踪器
if (params.zeroForOne) {
    self.feeGrowthGlobal0X128 = state.feeGrowthGlobalX128;
} else {
    self.feeGrowthGlobal1X128 = state.feeGrowthGlobalX128;
}
// 净余额变动值赋值给返回值result
unchecked {
    if (params.zeroForOne == exactInput) {
        result = toBalanceDelta(
            (params.amountSpecified - state.amountSpecifiedRemaining).toInt128(),
            state.amountCalculated.toInt128()
        );
    } else {
        result = toBalanceDelta(
            state.amountCalculated.toInt128(),
            (params.amountSpecified - state.amountSpecifiedRemaining).toInt128()
        );
    }
}
```

至此，就完成了 `swap` 的全部代码逻辑讲解了。

文章首发于公众号：Keegan小钢

Swap 可分为两种场景：单池交易和跨池交易。在 PoolManager 合约里，要完成交易流程，会涉及到 lock()、swap()、settle()、take() 四个函数。单池交易时只需要调一次 swap() 函数，而跨池交易时则需要多次调用 swap() 函数来完成。

我们先来聊聊单池交易如何实现，以下是流程图：

第一步，和其他操作一样，先执行 lock()，锁定住接下来的系列操作。

第二步，就是在 lockAcquired() 回调函数里执行 swap() 函数。这一步执行完之后，记账系统中会记录用户欠池子的资产数量，即用户需要支付的代币；以及池子欠用户的资产数量，即用户此次交易可得的代币。

第三步，执行 settle() 函数，完成代币的支付。

第四步，执行 take() 函数，取回所得的代币。

最后，lock() 函数完成，返回结果。

而如果是跨池交易的话，则需要在 Router 层面确定好交易路径，然后根据路径执行多次 swap。举个例子，现在要用 A 兑换成 C，但是 A 和 C 之间没有直接配对的池子，但是有中间代币 B，存在 A 和 B 配对的池子，也存在 B 和 C 配对的池子。那交易路径就可以先用 A 换成 B，再将 B 换成 C，最终实现了 A 换成 C。而不管中间经过了多少次 swap，最后，只需要完成一次 settle 操作，即支付 A，也只需要执行一次 take 操作，即取回最后所得的 C。整个流程大致如下图所示：

下面，我们主要剖析讲解 swap() 函数的内部实现。

首先，看看其函数声明，如下：

function swap(PoolKey memory key, IPoolManager.SwapParams memory params, bytes calldata hookData)
  external
  override
  noDelegateCall
  onlyByLocker
  returns (BalanceDelta delta)

key 指定了要进行交易的池子，params 是具体的交易参数，hookData 即需要回传给 hooks 合约的数据。

来看看 params 具体有哪些参数：

struct SwapParams {
    bool zeroForOne;
    int256 amountSpecified;
    uint160 sqrtPriceLimitX96;
}

zeroForOne 指名了要用 currency0 兑换 currency1，为 false 的话则反过来用 currency1 兑换 currency0。amountSpecified 是指定的确定数额，正数表示输入，负数表示输出。sqrtPriceLimitX96 是滑点保护的限定价格。如果之前已经了解过 UniswapV3，那对这几个字段应该不陌生。

两个函数修饰器 noDelegateCall 和 onlyByLocker，和之前文章介绍的一样，就不赘述了。

返回值 delta，其组成里的两个数，正常情况下就是一个正数，一个负数。

接下来，看看函数体了。先看前面一段代码：

PoolId id = key.toId();
_checkPoolInitialized(id);

if (key.hooks.shouldCallBeforeSwap()) {
    bytes4 selector = key.hooks.beforeSwap(msg.sender, key, params, hookData);
    // Sentinel return value used to signify that a NoOp occurred.
    if (key.hooks.isValidNoOpCall(selector)) return BalanceDeltaLibrary.MAXIMUM_DELTA;
    else if (selector != IHooks.beforeSwap.selector) revert Hooks.InvalidHookResponse();
}

这部分逻辑很简单，前两行代码，检查池子是否已经初始化过了，未初始化的则 revert。之后是执行 hooks 合约的 beforeSwap 钩子函数。

接下来这段代码是执行 swap 的内部函数：

uint256 feeForProtocol;
uint256 feeForHook;
uint24 swapFee;
Pool.SwapState memory state;
(delta, feeForProtocol, feeForHook, swapFee, state) = pools[id].swap(
    Pool.SwapParams({
        tickSpacing: key.tickSpacing,
        zeroForOne: params.zeroForOne,
        amountSpecified: params.amountSpecified,
        sqrtPriceLimitX96: params.sqrtPriceLimitX96
    })
);

这个内部函数的具体实现比较复杂，我们待会再讲，先继续讲完外部函数剩下的代码。

接下来一行代码就是进行记账了：

_accountPoolBalanceDelta(key, delta);

之后是对协议费和 hook 费用的处理：

unchecked {
    if (feeForProtocol > 0) {
        protocolFeesAccrued[params.zeroForOne ? key.currency0 : key.currency1] += feeForProtocol;
    }
    if (feeForHook > 0) {
        hookFeesAccrued[address(key.hooks)][params.zeroForOne ? key.currency0 : key.currency1] += feeForHook;
    }
}

接着执行 afterSwap 的钩子函数：

if (key.hooks.shouldCallAfterSwap()) {
    if (key.hooks.afterSwap(msg.sender, key, params, delta, hookData) != IHooks.afterSwap.selector) {
        revert Hooks.InvalidHookResponse();
    }
}

最后，发送事件：

emit Swap(
    id, msg.sender, delta.amount0(), delta.amount1(), state.sqrtPriceX96, state.liquidity, state.tick, swapFee
);

整个外部函数的逻辑还是比较清晰的。复杂的其实是内部函数的实现。下面就来看看 swap 内部函数的实现逻辑。还是先看函数声明：

function swap(State storage self, SwapParams memory params)
  internal
  returns (
      BalanceDelta result,
      uint256 feeForProtocol,
      uint256 feeForHook,
      uint24 swapFee,
      SwapState memory state
  )

self 是 storage 类型的，其实就是外部函数的 pools[id]。而第二个参数的 SwapParams 不同于外部函数的同名参数，这个内部函数的此参数具体如下：

struct SwapParams {
    int24 tickSpacing;
    bool zeroForOne;
    int256 amountSpecified;
    uint160 sqrtPriceLimitX96;
}

相比外部函数的此参数，多了 tickSpacing，其他参数则和外部函数的一样。

返回值比较多。result 就是变动的净余额，feeForProtocol 是协议费，feeForHook 是 hook 费用，包括 hook 交易费用和提现费用，swapFee 就是池子本身的交易费，最后的 state 是最新的状态。

接着，开始查看函数体的代码实现，先看前面一段：

// 指定价格不能为0
if (params.amountSpecified == 0) revert SwapAmountCannotBeZero();
// 读取出swap前的状态
Slot0 memory slot0Start = self.slot0;
swapFee = slot0Start.swapFee;
if (params.zeroForOne) { // token0兑换token1
    // 滑点价格的判断
    if (params.sqrtPriceLimitX96 >= slot0Start.sqrtPriceX96) {
        revert PriceLimitAlreadyExceeded(slot0Start.sqrtPriceX96, params.sqrtPriceLimitX96);
    }
    if (params.sqrtPriceLimitX96 &lt;= TickMath.MIN_SQRT_RATIO) {
        revert PriceLimitOutOfBounds(params.sqrtPriceLimitX96);
    }
} else { // token1兑换token0
    // 滑点价格的判断
    if (params.sqrtPriceLimitX96 &lt;= slot0Start.sqrtPriceX96) {
        revert PriceLimitAlreadyExceeded(slot0Start.sqrtPriceX96, params.sqrtPriceLimitX96);
    }
    if (params.sqrtPriceLimitX96 >= TickMath.MAX_SQRT_RATIO) {
        revert PriceLimitOutOfBounds(params.sqrtPriceLimitX96);
    }
}

接下来是这段代码：

// 临时的缓存数据
SwapCache memory cache = SwapCache({
    liquidityStart: self.liquidity,
    protocolFee: params.zeroForOne
        ? (getSwapFee(slot0Start.protocolFees) % 64)
        : (getSwapFee(slot0Start.protocolFees) >> 6),
    hookFee: params.zeroForOne ? (getSwapFee(slot0Start.hookFees) % 64) : (getSwapFee(slot0Start.hookFees) >> 6)
});
// 是否为确定的输入
bool exactInput = params.amountSpecified > 0;
// 初始化返回值的state
state = SwapState({
    amountSpecifiedRemaining: params.amountSpecified,
    amountCalculated: 0,
    sqrtPriceX96: slot0Start.sqrtPriceX96,
    tick: slot0Start.tick,
    feeGrowthGlobalX128: params.zeroForOne ? self.feeGrowthGlobal0X128 : self.feeGrowthGlobal1X128,
    liquidity: cache.liquidityStart
});

cache 是一个临时状态的缓存数据，包括三个字段：

liquidityStart：流动性
protocolFee：协议费用
hookFee：hook 费用

amountSpecified 大于 0 则说明是指定的输入，即 exactInput 为 true。

初始化返回值 state 也都是用当前状态的值进行初始化。这里前两个字段需要介绍一下，即 amountSpecifiedRemaining 和 amountCalculated。第一个字段表示当前还有多少指定的金额未进行交易计算的，第二个字段表示已经交易计算累加的数额。为了理解这两个字段，我们举个例子来说明。假设用户指定的是输出的数额，假设为 1000，那 amountSpecifiedRemaining 初始值即为 1000。但是，当前有效的流动性剩余量并不足 1000，假设只剩下 400，所以在当前 tick 下的计算只能用到 400，假设计算所得的输入数额为 200，那么，次轮计算后，amountSpecifiedRemaining 剩下 1000 - 400 = 600，而 amountCalculated 变为 200。之后，tick 会移动到下一个有流动性的区间内。剩下的 600 继续计算所得，假设这时的流动性剩余已经超过 600 了，这 600 计算所得的输入值为 250，那计算完后的 amountSpecifiedRemaining 就变成了 0，而 amountCalculated 则为 200 + 250 = 450，计算结束。这就是这两个字段的作用。

之后的代码会做循环判断，就是上面所说的计算逻辑：

StepComputations memory step;
// 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 != params.sqrtPriceLimitX96) {
    ...
}

while 条件里除了判断 amountSpecifiedRemaining 不为 0 之外，还判断了最新价格不能等于滑点价格。如果等于滑点价格了，也会结束循环。

step 用来存储 while 循环里每一步的计算用到的临时变量，具体包含以下字段：

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

接着，来看看 while 循环里面的逻辑，先来看前面一段代码：

// 初始化当前这一步的价格
step.sqrtPriceStartX96 = state.sqrtPriceX96;
// 获取出下一个tick
(step.tickNext, step.initialized) =
    self.tickBitmap.nextInitializedTickWithinOneWord(state.tick, params.tickSpacing, params.zeroForOne);
// 确保下一个tick不会超出边界
if (step.tickNext &lt; TickMath.MIN_TICK) {
    step.tickNext = TickMath.MIN_TICK;
} else if (step.tickNext > TickMath.MAX_TICK) {
    step.tickNext = TickMath.MAX_TICK;
}
// 计算出下一个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,
    (
        params.zeroForOne
            ? step.sqrtPriceNextX96 &lt; params.sqrtPriceLimitX96
            : step.sqrtPriceNextX96 > params.sqrtPriceLimitX96
    ) ? params.sqrtPriceLimitX96 : step.sqrtPriceNextX96,
    state.liquidity,
    state.amountSpecifiedRemaining,
    swapFee
);

计算返回四个值，sqrtPriceX96 为计算后的最新价格，amountIn 为输入的数额，amountOut 为输出的金额，feeAmount 为需要支付的手续费。

继续看下一段代码：

if (exactInput) { //指定输入时
    unchecked {
        //remaining减去输入额和手续费
        state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
    }
    //calculated加上输出额，因为amountOut为负数，所以用减法
    state.amountCalculated = state.amountCalculated - step.amountOut.toInt256();
} else { //指定输出时
    unchecked {
        //remaining减去输出额，因为amountOut为负数，所以用加法
        state.amountSpecifiedRemaining += step.amountOut.toInt256();
    }
    //calculated加上输入额和手续费
    state.amountCalculated = state.amountCalculated + (step.amountIn + step.feeAmount).toInt256();
}

之后的一段代码则是计算几个费用了：

// 协议费用
if (cache.protocolFee > 0) {
    // A: calculate the amount of the fee that should go to the protocol
    uint256 delta = step.feeAmount / cache.protocolFee;
    // A: subtract it from the regular fee and add it to the protocol fee
    unchecked {
        step.feeAmount -= delta;
        feeForProtocol += delta;
    }
}
// hook费用
if (cache.hookFee > 0) {
    // step.feeAmount has already been updated to account for the protocol fee
    uint256 delta = step.feeAmount / cache.hookFee;
    unchecked {
        step.feeAmount -= delta;
        feeForHook += delta;
    }
}
// 更新全局费用跟踪器
if (state.liquidity > 0) {
    unchecked {
        state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
    }
}

while 循环体里的最后一段代码则如下：

// 如果计算后的新价格到达下一个tick价格就移动tick
if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
    // 如果tick已经初始化，则执行移动tick
    if (step.initialized) {
        int128 liquidityNet = Pool.crossTick(
            self,
            step.tickNext,
            (params.zeroForOne ? state.feeGrowthGlobalX128 : self.feeGrowthGlobal0X128),
            (params.zeroForOne ? self.feeGrowthGlobal1X128 : state.feeGrowthGlobalX128)
        );
        // 如果向左移动，把liquidityNet理解为相反的符号
        unchecked {
            if (params.zeroForOne) liquidityNet = -liquidityNet;
        }
                // 更新流动性
        state.liquidity = liquidityNet &lt; 0
            ? state.liquidity - uint128(-liquidityNet)
            : state.liquidity + uint128(liquidityNet);
    }
        // 更新tick
    unchecked {
        state.tick = params.zeroForOne ? step.tickNext - 1 : step.tickNext;
    }
} else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
    // 重新计算，除非我们处于较低的刻度边界(即已经转换过刻度)，并且没有移动
    state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
}

整个 while 循环跑完之后，一般来说，可能会存在两种情况。第一种，指定的金额全部完成兑换，即 amountSpecifiedRemaining 没有剩余。第二种，兑换到一半，触发到了滑点保护价格，那 amountSpecifiedRemaining 将会有剩余，只有部分成交。

那么，循环结束之后，整个内部的 swap 函数就只剩下最后的一部分代码了，如下：

// 将临时状态的价格和tick转为storage状态
(self.slot0.sqrtPriceX96, self.slot0.tick) = (state.sqrtPriceX96, state.tick);

// 更新storage状态的流动性
if (cache.liquidityStart != state.liquidity) self.liquidity = state.liquidity;

// 更新全局的手续费跟踪器
if (params.zeroForOne) {
    self.feeGrowthGlobal0X128 = state.feeGrowthGlobalX128;
} else {
    self.feeGrowthGlobal1X128 = state.feeGrowthGlobalX128;
}
// 净余额变动值赋值给返回值result
unchecked {
    if (params.zeroForOne == exactInput) {
        result = toBalanceDelta(
            (params.amountSpecified - state.amountSpecifiedRemaining).toInt128(),
            state.amountCalculated.toInt128()
        );
    } else {
        result = toBalanceDelta(
            state.amountCalculated.toInt128(),
            (params.amountSpecified - state.amountSpecifiedRemaining).toInt128()
        );
    }
}

至此，就完成了 swap 的全部代码逻辑讲解了。

原创
学分: 24
分类: Uniswap
标签: DeFi uniswap v4

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

剖析DeFi交易产品之UniswapV4：Swap

0 条评论

文章目录