Lp Analyst

IL(r) = 2√r / (1 + r) - 1

If Pa ≤ P ≤ Pb (in range):
  amount0 = L × (1/√P - 1/√Pb)
  amount1 = L × (√P - √Pa)

If P < Pa (below range — 100% token0):
  amount0 = L × (1/√Pa - 1/√Pb)
  amount1 = 0

If P > Pb (above range — 100% token1):
  amount0 = 0
  amount1 = L × (√Pb - √Pa)

value(P) = amount0 × P + amount1

value(P) = L × (P/√P - P/√Pb + √P - √Pa)
         = L × (√P - √Pa + √P - P/√Pb)
         = L × (2√P - √Pa - P/√Pb)

a0 = L × (1/√P₀ - 1/√Pb)
a1 = L × (√P₀ - √Pa)

value_HODL(P) = a0 × P + a1
              = L × (P/√P₀ - P/√Pb + √P₀ - √Pa)

IL = value_LP(P) / value_HODL(P) - 1

√3000 ≈ 54.772
√2500 = 50.000
√3500 ≈ 59.161

Liquidity L from 1 ETH + equivalent USDC:
  From token0: L = amount0 / (1/√P - 1/√Pb)
  From token1: L = amount1 / (√P - √Pa)

Using the ratio to find L for a balanced deposit of value V at price P₀:
  V = L × (2√P₀ - √Pa - P₀/√Pb)
  V = L × (2 × 54.772 - 50.000 - 3000/59.161)
  V = L × (109.544 - 50.000 - 50.709)
  V = L × 8.835

For V = 6000 USDC (1 ETH at $3000 + 3000 USDC):
  L = 6000 / 8.835 ≈ 679.0

P = 3500 = Pb → position is 100% USDC (token1)

amount0 = 0
amount1 = L × (√Pb - √Pa) = 679.0 × (59.161 - 50.000) = 679.0 × 9.161 ≈ 6220

value_LP = 6220 USDC

Initial amounts at P₀ = 3000:
  a0 = 679.0 × (1/54.772 - 1/59.161) = 679.0 × (0.01826 - 0.01690) = 679.0 × 0.001359 ≈ 0.923 ETH
  a1 = 679.0 × (54.772 - 50.000) = 679.0 × 4.772 ≈ 3240 USDC

value_HODL = 0.923 × 3500 + 3240 = 3230 + 3240 = 6470 USDC

IL = 6220 / 6470 - 1 ≈ -3.86%

IL_v2 = 2√1.167 / (1 + 1.167) - 1 = 2 × 1.0801 / 2.167 - 1 ≈ -0.28%

fee_revenue = volume_in_range × fee_tier × (1 - protocol_share) × (position_liquidity / total_liquidity_in_range)

annual_fees = daily_fee_revenue × 365
fee_APR = annual_fees / position_value

net_return = fee_APR + IL

effective_fee_APR = fee_APR × α

feeGrowthGlobal0X128  — cumulative token0 fees per unit liquidity (pool-wide)
feeGrowthGlobal1X128  — cumulative token1 fees per unit liquidity (pool-wide)

uncollected0 = (feeGrowthInside0CurrentX128 - feeGrowthInside0LastX128) × liquidity / 2^128
uncollected1 = (feeGrowthInside1CurrentX128 - feeGrowthInside1LastX128) × liquidity / 2^128

// Pseudocode for feeGrowthInside
if currentTick >= tickUpper:
    feeGrowthInside = feeGrowthOutside[tickUpper] - feeGrowthOutside[tickLower]
elif currentTick < tickLower:
    feeGrowthInside = feeGrowthOutside[tickLower] - feeGrowthOutside[tickUpper]
else:
    feeGrowthInside = feeGrowthGlobal - feeGrowthOutside[tickLower] - feeGrowthOutside[tickUpper]

efficiency = 1 / (1 - √(Pa / Pb))

tick = floor(log(price) / log(1.0001))
price = 1.0001^tick

tickLower = floor(desired_tick / tickSpacing) × tickSpacing
tickUpper = ceil(desired_tick / tickSpacing) × tickSpacing

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {INonfungiblePositionManager} from "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

interface IPositionReader {
    function analyzePosition(uint256 tokenId) external view returns (
        address token0,
        address token1,
        uint24 fee,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity
    );
}

contract V3PositionReader {
    INonfungiblePositionManager public immutable NPM;

    constructor(address npm_) {
        NPM = INonfungiblePositionManager(npm_);
    }

    function getPosition(uint256 tokenId) external view returns (
        address token0,
        address token1,
        uint24 fee,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        uint128 tokensOwed0,
        uint128 tokensOwed1
    ) {
        (
            ,              // nonce
            ,              // operator
            token0,
            token1,
            fee,
            tickLower,
            tickUpper,
            liquidity,
            feeGrowthInside0LastX128,
            feeGrowthInside1LastX128,
            tokensOwed0,
            tokensOwed1
        ) = NPM.positions(tokenId);
    }
}

import {IPositionManager} from "v4-periphery/src/interfaces/IPositionManager.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PositionInfo} from "v4-periphery/src/libraries/PositionInfoLibrary.sol";

contract V4PositionReader {
    IPositionManager public immutable PM;

    constructor(address pm_) {
        PM = IPositionManager(pm_);
    }

    /// @notice Reads a V4 LP position's pool key, tick range, and liquidity
    function getPosition(uint256 tokenId) external view returns (
        PoolKey memory poolKey,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity
    ) {
        PositionInfo info;
        (poolKey, info) = PM.getPoolAndPositionInfo(tokenId);
        tickLower = info.tickLower();
        tickUpper = info.tickUpper();
        liquidity = PM.getPositionLiquidity(tokenId);
    }
}

import {TickMath} from "v4-core/src/libraries/TickMath.sol";

/// @notice Convert a tick to a human-readable price
/// @dev price = 1.0001^tick, adjusted for token decimals
function tickToPrice(int24 tick, uint8 decimals0, uint8 decimals1) pure returns (uint256) {
    uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(tick);
    // price = (sqrtPriceX96 / 2^96)^2 × 10^(decimals0 - decimals1)
    uint256 priceX192 = uint256(sqrtPriceX96) * uint256(sqrtPriceX96);
    return priceX192 * (10 ** decimals0) / (10 ** decimals1) >> 192;
}

import {LiquidityAmounts} from "v4-periphery/src/libraries/LiquidityAmounts.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

/// @notice Calculate the token amounts for a position
function getAmounts(
    int24 tickCurrent,
    int24 tickLower,
    int24 tickUpper,
    uint128 liquidity
) pure returns (uint256 amount0, uint256 amount1) {
    uint160 sqrtPriceCurrent = TickMath.getSqrtPriceAtTick(tickCurrent);
    uint160 sqrtPriceLower = TickMath.getSqrtPriceAtTick(tickLower);
    uint160 sqrtPriceUpper = TickMath.getSqrtPriceAtTick(tickUpper);

    (amount0, amount1) = LiquidityAmounts.getAmountsForLiquidity(
        sqrtPriceCurrent,
        sqrtPriceLower,
        sqrtPriceUpper,
        liquidity
    );
}

value_usd = amount0 × price0_usd + amount1 × price1_usd

value_usd = amount0 × 1.0 + amount1 × eth_price_usd

/// @notice Collect all accrued fees from a V3 position
/// @dev A zero-liquidity decrease pokes the position to update fee snapshots
function collectFees(
    INonfungiblePositionManager npm,
    uint256 tokenId
) external returns (uint256 collected0, uint256 collected1) {
    npm.decreaseLiquidity(INonfungiblePositionManager.DecreaseLiquidityParams({
        tokenId: tokenId,
        liquidity: 0,
        amount0Min: 0,
        amount1Min: 0,
        deadline: block.timestamp
    }));

    (collected0, collected1) = npm.collect(INonfungiblePositionManager.CollectParams({
        tokenId: tokenId,
        recipient: msg.sender,
        amount0Max: type(uint128).max,
        amount1Max: type(uint128).max
    }));
}

trigger_lower = Pa + buffer
trigger_upper = Pb - buffer

if |IL| > threshold:
    rebalance()