✨ Uniswap V3 notes

IUniswapV3Pool.Slot0 memory slot0 = pool.slot0();
// 1 / P = X / Y = USDC / WETH
//               = price of WETH in terms of USDC

// P has 1e18 / 1e6 = 1e12 decimals
// 1 / P has 1e6 / 1e18 = 1e-12 decimals

// sqrtPriceX96 * sqrtPriceX96 might overflow
// So use FullMath.mulDiv to do uint256 * uint256 / uint256 without overflow

// price = sqrt(P) * Q96 * sqrt(P) * Q96 / Q96
price = FullMath.mulDiv(slot0.sqrtPriceX96, slot0.sqrtPriceX96, Q96);
// 1 / price = 1 / (P * Q96)
price = 1e12 * 1e18 * Q96 / price;

/// @return amount0 Amount of currency0 required to cover a position of size liquidity between the two passed prices
    function getAmount0Delta(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity,
        bool roundUp
    ) internal pure returns (uint256 amount0)

    /// @return amount1 Amount of currency1 required to cover a position of size liquidity between the two passed prices
    function getAmount1Delta(
        uint160 sqrtRatioAX96,
        uint160 sqrtRatioBX96,
        uint128 liquidity,
        bool roundUp
    ) internal pure returns (uint256 amount1)

/// @notice Gets the next sqrt price given an input amount of currency0 or currency1
    /// @dev Throws if price or liquidity are 0, or if the next price is out of bounds
    /// @param sqrtPX96 The starting price, i.e., before accounting for the input amount
    /// @param liquidity The amount of usable liquidity
    /// @param amountIn How much of currency0, or currency1, is being swapped in
    /// @param zeroForOne Whether the amount in is currency0 or currency1
    /// @return sqrtQX96 The price after adding the input amount to currency0 or currency1
    function getNextSqrtPriceFromInput(
        uint160 sqrtPX96,
        uint128 liquidity,
        uint256 amountIn,
        bool zeroForOne
    ) internal pure returns (uint160 sqrtQX96)

    function getNextSqrtPriceFromOutput(
        uint160 sqrtPX96,
        uint128 liquidity,
        uint256 amountOut,
        bool zeroForOne
    ) internal pure returns (uint160 sqrtQX96)

// NOTE:
if (state.liquidity > 0) {
    // fee growth += fee amount * (1 << 128) / liquidity
    state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
}

//NOTE: Calculate fee growth below
uint256 feeGrowthBelow0X128;
uint256 feeGrowthBelow1X128;
if (tickLower <= tickCurrent) {
    feeGrowthBelow0X128 = lower.feeGrowthOutside0X128;
    feeGrowthBelow1X128 = lower.feeGrowthOutside1X128;
} else {
    feeGrowthBelow0X128 = feeGrowthGlobal0X128 - lower.feeGrowthOutside0X128;
    feeGrowthBelow1X128 = feeGrowthGlobal1X128 - lower.feeGrowthOutside1X128;
}

//NOTE: Calculate fee growth above
uint256 feeGrowthAbove0X128;
uint256 feeGrowthAbove1X128;
if (tickCurrent < tickUpper) {
    feeGrowthAbove0X128 = upper.feeGrowthOutside0X128;
    feeGrowthAbove1X128 = upper.feeGrowthOutside1X128;
} else {
    feeGrowthAbove0X128 = feeGrowthGlobal0X128 - upper.feeGrowthOutside0X128;
    feeGrowthAbove1X128 = feeGrowthGlobal1X128 - upper.feeGrowthOutside1X128;
}

if (liquidityGrossBefore == 0) {
    // NOTE: initialize feeGrowthOutside
    // TODO: why initialize below tick?
    if (tick <= tickCurrent) {
        info.feeGrowthOutside0X128 = feeGrowthGlobal0X128;
        info.feeGrowthOutside1X128 = feeGrowthGlobal1X128;
    }
    info.initialized = true;
}

info.feeGrowthOutside0X128 = feeGrowthGlobal0X128 - info.feeGrowthOutside0X128;
info.feeGrowthOutside1X128 = feeGrowthGlobal1X128 - info.feeGrowthOutside1X128;
liquidityNet = info.liquidityNet;

//NOTE: Fee inside position (fee growth inside)
feeGrowthInside0X128 = feeGrowthGlobal0X128 - feeGrowthBelow0X128 - feeGrowthAbove0X128;
feeGrowthInside1X128 = feeGrowthGlobal1X128 - feeGrowthBelow1X128 - feeGrowthAbove1X128;

// get fee growth inside
(uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
    ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);
// pass fee growth inside then calc tokensOwed
position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);

if (state.liquidity > 0) {
    // fee growth += fee amount * (1 << 128) / liquidity
    state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
}

// NOTE: liquidityNet (left +, right -)
if (zeroForOne) {
    liquidityNet = -liquidityNet;
}
// How will liquidity change after crossing the current liquidityNet
state.liquidity = liquidityNet < 0
    ? state.liquidity - uint128(-liquidityNet)
    : state.liquidity + uint128(liquidityNet);

// function exactInput:
address payer = hasAlreadyPaid ? address(this) : msg.sender;

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

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

    // decide whether to continue or terminate
    if (hasMultiplePools) {
        payer = address(this);
        // [A, fee, B, fee, C, fee, D] -> [B, fee, C, fee, D] -> [C, fee, D]
        params.path = params.path.skipToken();
    } else {
        // [C, fee, D]
        amountOut = params.amountIn;
        break;
    }
}

// function uniswapV3SwapCallback:
if (isExactInput) {
    pay(tokenIn, data.payer, msg.sender, amountToPay);
} else {
    // if is ExactOutput making a recursive call.
    if (data.path.hasMultiplePools()) {
        //@ztmy remove the first token from the path.
        data.path = data.path.skipToken();
        //@ztmy NOTE: making a recursive call.
        // Here message sender to this callback is the pool itself.
        exactOutputInternal(amountToPay, msg.sender, 0, data);
    } else {
        amountInCached = amountToPay;
        // note that because exact output swaps are executed in reverse order, tokenOut is actually tokenIn
        pay(tokenOut, data.payer, msg.sender, amountToPay);
    }
}

// function mint:
_mint(params.recipient, (tokenId = _nextId++));

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

// @ztmy in this contract, we borrow dai and repey, don't do arbitrage
function flash(uint256 amount0, uint256 amount1) external {
    bytes memory data = abi.encode(
        FlashCallbackData({
            amount0: amount0,
            amount1: amount1,
            // know who called into the function called Flash
            caller: msg.sender
        })
    );

    //---------------------- UNISWAP_V3 [borrow DAI] ------------------------
    IUniswapV3Pool(pool).flash(address(this), amount0, amount1, data);
}

// 1. Flash swap on pool0 (receive WETH)
// 2. Swap on pool1 (WETH -> DAI)
// 3. Repay pool0 with DAI
//---------------------- [borrow WETH from pool0] ------------------------
// here we call swap function which can do a flash loan same as function flash
// different between swap and flash when do a flash loan:
// 1. Different parameter list
// 2. swap call uniswapV3SwapCallback with amount0, which is (amount0 + fee0)

IUniswapV3Pool(pool0).swap({
    recipient: address(this),
    zeroForOne: zeroForOne,
    amountSpecified: int256(amountIn),
    sqrtPriceLimitX96: sqrtPriceLimitX96,
    data: data
});

// @ztmy call to get the tick cumulative.
// For the input you re passing an array of seconds, seconds ago from now.
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
    );
}

//@ztmy this function will do is return the average tick over some time duration.
function consult(address pool, uint32 secondsAgo)
    internal
    view
    returns (int24 arithmeticMeanTick, uint128 harmonicMeanLiquidity)

// tick: TWAT (time weighed average tick)
function getQuoteAtTick(int24 tick, uint128 baseAmount, address baseToken, address quoteToken)
    internal
    pure
    returns (uint256 quoteAmount)
{
    // Calculate sqrtRatioX96
    uint160 sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);

    // Calculate quoteAmount with better precision if it doesn't overflow when multiplied by itself
    if (sqrtRatioX96 <= type(uint128).max) {
        uint256 ratioX192 = uint256(sqrtRatioX96) * sqrtRatioX96;

        quoteAmount = baseToken < quoteToken
            // @ztmy
            // P = ratioX192 = (3000 USDC / 1 ETH), baseAmount = 1
            // P * baseAmount = (3000 USDC / 1 ETH) * 1 = 3000 USDC
            ? FullMath.mulDiv(ratioX192, baseAmount, 1 << 192)

            // P = 1 / ratioX192, baseAmount = 6000 USDC
            // baseAmount / ratioX192 = 6000 USDC * (1 ETH / 3000 USDC) = 2 ETH
            : FullMath.mulDiv(1 << 192, baseAmount, ratioX192);
    } else {
        uint256 ratioX128 = FullMath.mulDiv(sqrtRatioX96, sqrtRatioX96, 1 << 64);
        quoteAmount = baseToken < quoteToken
            ? FullMath.mulDiv(ratioX128, baseAmount, 1 << 128)
            : FullMath.mulDiv(1 << 128, baseAmount, ratioX128);
    }
}