TruncGeoOracle.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.19;

import {IPoolManager} from "@uniswap/core-next/contracts/interfaces/IPoolManager.sol";
import {PoolId} from "@uniswap/core-next/contracts/libraries/PoolId.sol";
import {Hooks} from "@uniswap/core-next/contracts/libraries/Hooks.sol";
import {TickMath} from "@uniswap/core-next/contracts/libraries/TickMath.sol";
import {TruncatedOracle} from "../libraries/TruncatedOracle.sol";
import {BaseHook} from "../BaseHook.sol";

/// @notice A hook for a pool that allows a Uniswap pool to act as an oracle. Pools that use this hook must have full range
///     tick spacing and liquidity is always permanently locked in these pools. This is the suggested configuration
///     for protocols that wish to use a V3 style geomean oracle.
contract TruncGeoOracle is BaseHook {
    using TruncatedOracle for TruncatedOracle.Observation[65535];
    using PoolId for IPoolManager.PoolKey;

    /// @notice Oracle pools do not have fees because they exist to serve as an oracle for a pair of tokens
    error OnlyOneOraclePoolAllowed();

    /// @notice Oracle positions must be full range
    error OraclePositionsMustBeFullRange();

    /// @notice Oracle pools must have liquidity locked so that they cannot become more susceptible to price manipulation
    error OraclePoolMustLockLiquidity();

    /// @member index The index of the last written observation for the pool
    /// @member cardinality The cardinality of the observations array for the pool
    /// @member cardinalityNext The cardinality target of the observations array for the pool, which will replace cardinality when enough observations are written
    struct ObservationState {
        uint16 index;
        uint16 cardinality;
        uint16 cardinalityNext;
    }

    /// @notice The list of observations for a given pool ID
    mapping(bytes32 => TruncatedOracle.Observation[65535]) public observations;
    /// @notice The current observation array state for the given pool ID
    mapping(bytes32 => ObservationState) public states;

    /// @notice Returns the observation for the given pool key and observation index
    function getObservation(IPoolManager.PoolKey calldata key, uint256 index)
        external
        view
        returns (TruncatedOracle.Observation memory observation)
    {
        observation = observations[keccak256(abi.encode(key))][index];
    }

    /// @notice Returns the state for the given pool key
    function getState(IPoolManager.PoolKey calldata key) external view returns (ObservationState memory state) {
        state = states[keccak256(abi.encode(key))];
    }

    /// @dev For mocking
    function _blockTimestamp() internal view virtual returns (uint32) {
        return uint32(block.timestamp);
    }

    constructor(IPoolManager _poolManager) BaseHook(_poolManager) {}

    function getHooksCalls() public pure override returns (Hooks.Calls memory) {
        return Hooks.Calls({
            beforeInitialize: true,
            afterInitialize: true,
            beforeModifyPosition: true,
            afterModifyPosition: false,
            beforeSwap: true,
            afterSwap: false,
            beforeDonate: false,
            afterDonate: false
        });
    }

    function beforeInitialize(address, IPoolManager.PoolKey calldata key, uint160)
        external
        view
        override
        poolManagerOnly
        returns (bytes4)
    {
        // This is to limit the fragmentation of pools using this oracle hook. In other words,
        // there may only be one pool per pair of tokens that use this hook. The tick spacing is set to the maximum
        // because we only allow max range liquidity in this pool.
        if (key.fee != 0 || key.tickSpacing != poolManager.MAX_TICK_SPACING()) revert OnlyOneOraclePoolAllowed();
        return TruncGeoOracle.beforeInitialize.selector;
    }

    function afterInitialize(address, IPoolManager.PoolKey calldata key, uint160, int24 tick)
        external
        override
        poolManagerOnly
        returns (bytes4)
    {
        bytes32 id = key.toId();
        (states[id].cardinality, states[id].cardinalityNext) = observations[id].initialize(_blockTimestamp(), tick);
        return TruncGeoOracle.afterInitialize.selector;
    }

    /// @dev Called before any action that potentially modifies pool price or liquidity, such as swap or modify position
    function _updatePool(IPoolManager.PoolKey calldata key) private {
        bytes32 id = key.toId();
        (, int24 tick,) = poolManager.getSlot0(id);

        uint128 liquidity = poolManager.getLiquidity(id);

        (states[id].index, states[id].cardinality) = observations[id].write(
            states[id].index, _blockTimestamp(), tick, liquidity, states[id].cardinality, states[id].cardinalityNext
        );
    }

    function beforeModifyPosition(
        address,
        IPoolManager.PoolKey calldata key,
        IPoolManager.ModifyPositionParams calldata params
    ) external override poolManagerOnly returns (bytes4) {
        if (params.liquidityDelta < 0) revert OraclePoolMustLockLiquidity();
        int24 maxTickSpacing = poolManager.MAX_TICK_SPACING();
        if (
            params.tickLower != TickMath.minUsableTick(maxTickSpacing)
                || params.tickUpper != TickMath.maxUsableTick(maxTickSpacing)
        ) revert OraclePositionsMustBeFullRange();
        _updatePool(key);
        return TruncGeoOracle.beforeModifyPosition.selector;
    }

    function beforeSwap(address, IPoolManager.PoolKey calldata key, IPoolManager.SwapParams calldata)
        external
        override
        poolManagerOnly
        returns (bytes4)
    {
        _updatePool(key);
        return TruncGeoOracle.beforeSwap.selector;
    }

    /// @notice Observe the given pool for the timestamps
    function observe(IPoolManager.PoolKey calldata key, uint32[] calldata secondsAgos)
        external
        view
        returns (int48[] memory tickCumulatives, uint144[] memory secondsPerLiquidityCumulativeX128s)
    {
        bytes32 id = key.toId();

        ObservationState memory state = states[id];

        (, int24 tick,) = poolManager.getSlot0(id);

        uint128 liquidity = poolManager.getLiquidity(id);

        return observations[id].observe(_blockTimestamp(), secondsAgos, tick, state.index, liquidity, state.cardinality);
    }

    /// @notice Increase the cardinality target for the given pool
    function increaseCardinalityNext(IPoolManager.PoolKey calldata key, uint16 cardinalityNext)
        external
        returns (uint16 cardinalityNextOld, uint16 cardinalityNextNew)
    {
        bytes32 id = keccak256(abi.encode(key));

        ObservationState storage state = states[id];

        cardinalityNextOld = state.cardinalityNext;
        cardinalityNextNew = observations[id].grow(cardinalityNextOld, cardinalityNext);
        state.cardinalityNext = cardinalityNextNew;
    }
}