Uniswap V2 TWAP 预言机（数学推导 & 源码解读）¶

price_ETH = reserve1 / reserve0 = 200,000 / 100 = 2,000 USDC/ETH

一笔原子交易内发生的事情：

1. 从 Aave 借出 1,000,000 USDC（闪电贷，零抵押）

2. 用 1,000,000 USDC 在 Uniswap 买入 ETH 
   → 池子里 USDC 暴增，ETH 骤减 
   → ETH 瞬时价格被推高到 10,000 USDC/ETH

3. 调用受害协议（比如一个借贷平台）
   → 受害协议读取 Uniswap 瞬时价格 = 10,000 USDC/ETH
   → 攻击者的 ETH 抵押品被高估，借出超额资金

4. 把 ETH 卖回 Uniswap，换回 USDC 
   → 价格恢复正常          

5. 归还闪电贷本金 + 利息
   → 攻击者净赚受害协议的超额借款  

时间段        价格           持续时间
────────────────────────────────────
0-8 小时     2,000 USDC/ETH   8 小时
8-16 小时    2,100 USDC/ETH   8 小时
16-24 小时   1,900 USDC/ETH   8 小时

TWAP = (2000 × 8 + 2100 × 8 + 1900 × 8) / (8 + 8 + 8)
     = (16000 + 16800 + 15200) / 24
     = 48000 / 24
     = 2000 USDC/ETH

累加器 = Σ (价格 × 持续时间)

时间段 [t₁, τ₁]：价格 = P₁
时间段 [τ₁, τ₂]：价格 = P₂
时间段 [τ₂, t₂]：价格 = P₃

区块 1：ETH/USDC = 2000（即 1 ETH = 2000 USDC）
区块 2：ETH/USDC = 3000（即 1 ETH = 3000 USDC）

ETH/USDC 的算术平均 = (2000 + 3000) / 2 = 2500

USDC/ETH 在区块 1 = 1/2000 = 0.0005
USDC/ETH 在区块 2 = 1/3000 = 0.000333...

USDC/ETH 的算术平均 = (0.0005 + 0.000333) / 2 = 0.000417

但 1/2500 = 0.0004 ≠ 0.000417

┌─────────────────────────────────────────────────────────────┐
│        112 位整数部分        │        112 位小数部分            │
│     (最大约 5.19 × 10³³)    │      (精度约 1.93 × 10⁻³⁴)       │
└─────────────────────────────────────────────────────────────┘
                          共 224 位

// 即使 A2 < A1（发生了溢出），这个减法仍然给出正确结果
uint256 priceDiff = priceAccumulator2 - priceAccumulator1;

uint32 timeElapsed = blockTimestamp - blockTimestampLast; // 溢出是期望的

// 储备量，使用 uint112 以便与时间戳一起打包
uint112 private reserve0;               // token0 上次记录的储备
uint112 private reserve1;               // token1 上次记录的储备
uint32  private blockTimestampLast;     // 上次更新的区块时间戳（mod 2^32）

// 累加器，使用 uint256 允许溢出
uint public price0CumulativeLast;       // 累积的 price(token0 in token1)
uint public price1CumulativeLast;       // 累积的 price(token1 in token0)

Storage Slot 0:
┌──────────────────────────────────────────────────────────────────┐
│ reserve0 (112 bits) │ reserve1 (112 bits) │ timestamp (32 bits)  │
└──────────────────────────────────────────────────────────────────┘

Storage Slot 1: price0CumulativeLast (256 bits)
Storage Slot 2: price1CumulativeLast (256 bits)

// contracts/libraries/UQ112x112.sol

library UQ112x112 {
    uint224 constant Q112 = 2**112;

    // 将 uint112 编码为 UQ112.112
    function encode(uint112 y) internal pure returns (uint224 z) {
        z = uint224(y) * Q112; // 左移 112 位
    }

    // UQ112.112 除以 uint112，结果仍为 UQ112.112
    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
        z = x / uint224(y);
    }
}

假设 reserve1 = 200000，reserve0 = 100

1. encode(200000) = 200000 × 2¹¹² = 一个很大的数
2. uqdiv(上述结果, 100) = (200000 × 2¹¹²) / 100 = 2000 × 2¹¹²

最终 price0 以 UQ112.112 格式存储，代表价格 2000

// contracts/UniswapV2Pair.sol

function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
    // 确保余额不会溢出 uint112
    require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');

    // 获取当前区块时间戳，模 2^32 只取低位（允许溢出，因为我们只关心时间差）
    uint32 blockTimestamp = uint32(block.timestamp % 2**32);

    // 计算距离上次更新的时间（溢出是期望的）
    uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired

    // 如果是该区块内的第一次操作（timeElapsed > 0），且池子内有流动性，则更新价格累加器
    if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
        // * never overflows, and + overflow is desired
        // 价格计算使用 UQ112x112 库进行定点数运算，保证精度
        // price0 = reserve1 / reserve0（token0 的价格，以 token1 计价）
        price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
        // price1 = reserve0 / reserve1（token1 的价格，以 token0 计价）
        price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
    }

    // 更新储备量和时间戳
    reserve0 = uint112(balance0);
    reserve1 = uint112(balance1);
    blockTimestampLast = blockTimestamp;

    emit Sync(reserve0, reserve1);
}

require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');

uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast;

假设 blockTimestampLast = 4,294,967,290（接近 uint32 最大值）
假设 blockTimestamp = 5（已经溢出回绕）

timeElapsed = 5 - 4,294,967,290
            = 5 + (2³² - 4,294,967,290)  // 无符号下溢变成加法
            = 11  ✓ 正确的时间差

if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
    price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
    price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}

price0 的计算步骤：
1. UQ112x112.encode(_reserve1)     → _reserve1 × 2¹¹²
2. .uqdiv(_reserve0)               → (_reserve1 × 2¹¹²) / _reserve0
3. × timeElapsed                   → 乘以经过的秒数
4. += 到累加器                      → 累加到总和

reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;

// 1. mint()：添加流动性时
function mint(address to) external lock returns (uint liquidity) {
    // ... 计算流动性代币数量 ...
    _update(balance0, balance1, _reserve0, _reserve1);
}

// 2. burn()：移除流动性时
function burn(address to) external lock returns (uint amount0, uint amount1) {
    // ... 计算退还的代币数量 ...
    _update(balance0, balance1, _reserve0, _reserve1);
}

// 3. swap()：交换代币时
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
    // ... 执行交换逻辑 ...
    _update(balance0, balance1, _reserve0, _reserve1);
}

// contracts/libraries/UniswapV2OracleLibrary.sol

library UniswapV2OracleLibrary {
    using FixedPoint for *;

    function currentCumulativePrices(address pair)
        internal
        view
        returns (
            uint price0Cumulative,
            uint price1Cumulative,
            uint32 blockTimestamp
        )
    {
        blockTimestamp = currentBlockTimestamp();
        price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
        price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

        // 获取储备量和上次更新时间
        (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = 
            IUniswapV2Pair(pair).getReserves();

        // 如果上次更新不在当前区块，需要"反事实地"计算累加器
        if (blockTimestampLast != blockTimestamp) {
            uint32 timeElapsed = blockTimestamp - blockTimestampLast;

            // 模拟 _update() 的累加逻辑
            price0Cumulative += uint(
                FixedPoint.fraction(reserve1, reserve0)._x
            ) * timeElapsed;

            price1Cumulative += uint(
                FixedPoint.fraction(reserve0, reserve1)._x
            ) * timeElapsed;
        }
    }
}

// contracts/examples/ExampleOracleSimple.sol

contract ExampleOracleSimple {
    using FixedPoint for *;

    uint public constant PERIOD = 24 hours;  // TWAP 窗口

    IUniswapV2Pair immutable pair;
    address public immutable token0;
    address public immutable token1;

    uint public price0CumulativeLast;
    uint public price1CumulativeLast;
    uint32 public blockTimestampLast;

    FixedPoint.uq112x112 public price0Average;
    FixedPoint.uq112x112 public price1Average;

    constructor(address factory, address tokenA, address tokenB) public {
        IUniswapV2Pair _pair = IUniswapV2Pair(
            UniswapV2Library.pairFor(factory, tokenA, tokenB)
        );
        pair = _pair;
        token0 = _pair.token0();
        token1 = _pair.token1();

        price0CumulativeLast = _pair.price0CumulativeLast();
        price1CumulativeLast = _pair.price1CumulativeLast();

        (, , blockTimestampLast) = _pair.getReserves();
    }

    function update() external {
        (
            uint price0Cumulative,
            uint price1Cumulative,
            uint32 blockTimestamp
        ) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));

        uint32 timeElapsed = blockTimestamp - blockTimestampLast;

        // 确保至少经过了 PERIOD 时间
        require(timeElapsed >= PERIOD, 'ExampleOracleSimple: PERIOD_NOT_ELAPSED');

        // 计算 TWAP
        // 累加器差值 / 时间差 = 平均价格
        price0Average = FixedPoint.uq112x112(
            uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)
        );
        price1Average = FixedPoint.uq112x112(
            uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)
        );

        // 更新检查点
        price0CumulativeLast = price0Cumulative;
        price1CumulativeLast = price1Cumulative;
        blockTimestampLast = blockTimestamp;
    }

    // 根据输入数量计算输出数量
    function consult(address token, uint amountIn) 
        external 
        view 
        returns (uint amountOut) 
    {
        if (token == token0) {
            amountOut = price0Average.mul(amountIn).decode144();
        } else {
            require(token == token1, 'ExampleOracleSimple: INVALID_TOKEN');
            amountOut = price1Average.mul(amountIn).decode144();
        }
    }
}

contract FixedWindowOracle {
    uint public constant PERIOD = 1 hours;
    uint public lastUpdateTime;
    uint public lastCumulativePrice;
    uint public averagePrice;

    function update() external {
        uint currentCumulative = getCurrentCumulativePrice();
        uint timeElapsed = block.timestamp - lastUpdateTime;

        require(timeElapsed >= PERIOD, "Period not elapsed");

        averagePrice = (currentCumulative - lastCumulativePrice) / timeElapsed;
        lastCumulativePrice = currentCumulative;
        lastUpdateTime = block.timestamp;
    }
}

contract SlidingWindowOracle {
    struct Observation {
        uint timestamp;
        uint priceCumulative;
    }

    Observation[] public observations;

    function update() external {
        observations.push(Observation({
            timestamp: block.timestamp,
            priceCumulative: getCurrentCumulativePrice()
        }));
    }

    function getTWAP(uint lookbackSeconds) external view returns (uint) {
        // 找到 lookbackSeconds 前的观察点
        // 计算 TWAP
    }
}

contract LendingProtocol {
    mapping(address => uint) public userPriceCumulativeAtDeposit;
    mapping(address => uint) public userTimestampAtDeposit;

    function deposit() external {
        userPriceCumulativeAtDeposit[msg.sender] = getCurrentCumulativePrice();
        userTimestampAtDeposit[msg.sender] = block.timestamp;
        // ... 存款逻辑
    }

    function liquidate(address user) external {
        uint currentCumulative = getCurrentCumulativePrice();
        uint timeElapsed = block.timestamp - userTimestampAtDeposit[user];

        uint twapPrice = (currentCumulative - userPriceCumulativeAtDeposit[user]) / timeElapsed;
        // ... 使用 twapPrice 进行清算判断
    }
}