Uniswap Math

sqrtPriceX96 = √(price) × 2⁹⁶

token0 = WETH (18 decimals)
token1 = USDC (6 decimals)

Human-readable price: 1 ETH = 3000 USDC
Raw price (token1/token0) = 3000 × 10⁶ / 10¹⁸ = 3000 × 10⁻¹²

sqrtPrice = √(3000 × 10⁻¹²) = √(3 × 10⁻⁹) ≈ 5.47722558 × 10⁻⁵
sqrtPriceX96 = 5.47722558 × 10⁻⁵ × 2⁹⁶ ≈ 4_339_505_179_874_779_489_431_521

Raw price = 3000 (decimals cancel)
sqrtPrice = √3000 ≈ 54.7722558
sqrtPriceX96 = 54.7722558 × 2⁹⁶ ≈ 4_339_505_179_874_779_489_431_521_786_241

// In Solidity — use FullMath to avoid overflow
uint256 priceX192 = FullMath.mulDiv(sqrtPriceX96, sqrtPriceX96, 1);
// priceX192 is price * 2^192, divide by 2^192 to get raw price
// For display: rawPrice * 10^(decimals0 - decimals1) = human price

# In Python (offchain)
def sqrtPriceX96_to_price(sqrtPriceX96, decimals0, decimals1):
    price = (sqrtPriceX96 / 2**96) ** 2
    adjusted = price * 10 ** (decimals0 - decimals1)
    return adjusted

# ETH/USDC: sqrtPriceX96 = 4_339_505_179_874_779_489_431_521
sqrtPriceX96_to_price(4_339_505_179_874_779_489_431_521, 18, 6)
# ≈ 3000.0

int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = 887272;
int24 internal constant MIN_TICK_SPACING = 1;
int24 internal constant MAX_TICK_SPACING = type(int16).max; // 32767

uint160 internal constant MIN_SQRT_PRICE = 4295128739;
uint160 internal constant MAX_SQRT_PRICE =
    1461446703485210103287273052203988822378723970342;

/// @notice Returns the sqrt price at the given tick as a Q64.96
/// @dev Reverts if |tick| > MAX_TICK
function getSqrtPriceAtTick(int24 tick)
    internal pure returns (uint160 sqrtPriceX96);

/// @notice Returns the tick at the given sqrt price
/// @dev Returns the largest tick whose price ≤ sqrtPriceX96
/// @dev sqrtPriceX96 must be in (MIN_SQRT_PRICE, MAX_SQRT_PRICE)
function getTickAtSqrtPrice(uint160 sqrtPriceX96)
    internal pure returns (int24 tick);

/// @notice Returns the maximum usable tick for a given tick spacing
function maxUsableTick(int24 tickSpacing)
    internal pure returns (int24);

/// @notice Returns the minimum usable tick for a given tick spacing
function minUsableTick(int24 tickSpacing)
    internal pure returns (int24);

tick = 0      → price = 1.0
tick = 1      → price = 1.0001
tick = -1     → price = 0.99990001...
tick = 100    → price ≈ 1.01005
tick = 10000  → price ≈ 2.71828  (≈ e)
tick = 23028  → price ≈ 10.0
tick = 46054  → price ≈ 100.0
tick = 69082  → price ≈ 1000.0
tick = -69082 → price ≈ 0.001
tick = 887272 → price ≈ 3.40 × 10³⁸  (near uint128 max)

// Usable ticks for tickSpacing = 60:
// ..., -120, -60, 0, 60, 120, 180, ...
int24 maxUsable = TickMath.maxUsableTick(60);  // 887220
int24 minUsable = TickMath.minUsableTick(60);  // -887220

getSqrtPriceAtTick(tick) <= currentSqrtPrice < getSqrtPriceAtTick(tick + 1)

/// @notice Gets the token0 delta for a liquidity and price range
function getAmount0Delta(
    uint160 sqrtPriceAX96,
    uint160 sqrtPriceBX96,
    uint128 liquidity,
    bool roundUp
) internal pure returns (uint256 amount0);

/// @notice Gets the token1 delta for a liquidity and price range
function getAmount1Delta(
    uint160 sqrtPriceAX96,
    uint160 sqrtPriceBX96,
    uint128 liquidity,
    bool roundUp
) internal pure returns (uint256 amount1);

function getAmount0Delta(
    uint160 sqrtPriceAX96,
    uint160 sqrtPriceBX96,
    int128 liquidity
) internal pure returns (int256 amount0);

function getAmount1Delta(
    uint160 sqrtPriceAX96,
    uint160 sqrtPriceBX96,
    int128 liquidity
) internal pure returns (int256 amount1);

                 √P_b - √P_a
amount0 = L × ─────────────────
               √P_a × √P_b

amount1 = L × (√P_b - √P_a)

amount0 = L × (1/√P_a - 1/√P_b)
amount1 = L × (√P_b - √P_a)

/// @notice Gets next sqrt price given token0 input/output
function getNextSqrtPriceFromAmount0RoundingUp(
    uint160 sqrtPX96,
    uint128 liquidity,
    uint256 amount,
    bool add
) internal pure returns (uint160);

/// @notice Gets next sqrt price given token1 input/output
function getNextSqrtPriceFromAmount1RoundingDown(
    uint160 sqrtPX96,
    uint128 liquidity,
    uint256 amount,
    bool add
) internal pure returns (uint160);

/// @notice Gets next sqrt price from an exact input amount
function getNextSqrtPriceFromInput(
    uint160 sqrtPX96,
    uint128 liquidity,
    uint256 amountIn,
    bool zeroForOne
) internal pure returns (uint160);

/// @notice Gets next sqrt price from an exact output amount
function getNextSqrtPriceFromOutput(
    uint160 sqrtPX96,
    uint128 liquidity,
    uint256 amountOut,
    bool zeroForOne
) internal pure returns (uint160);

When adding token0 (buying token1): price decreases
√P_next = L × √P / (L + amount0 × √P)

When removing token0 (selling token1): price increases
√P_next = L × √P / (L - amount0 × √P)

When adding token1 (buying token0): price increases
√P_next = √P + amount1 / L

When removing token1 (selling token0): price decreases
√P_next = √P - amount1 / L

uint24 internal constant MAX_SWAP_FEE = 1e6; // 100% — denominated in hundredths of a bip

/// @notice Returns the target sqrt price, clamped to the price limit
function getSqrtPriceTarget(
    bool zeroForOne,
    uint160 sqrtPriceNextX96,
    uint160 sqrtPriceLimitX96
) internal pure returns (uint160 sqrtPriceTargetX96);

/// @notice Computes a single step within a swap
function computeSwapStep(
    uint160 sqrtPriceCurrentX96,
    uint160 sqrtPriceTargetX96,
    uint128 liquidity,
    int256 amountRemaining,
    uint24 feePips
) internal pure returns (
    uint160 sqrtPriceNextX96,
    uint256 amountIn,
    uint256 amountOut,
    uint256 feeAmount
);

1. Start at current sqrtPrice and tick
2. LOOP:
   a. Find the next initialized tick in the swap direction (via TickBitmap)
   b. Clamp the target price to the user's price limit
   c. Call computeSwapStep(current, target, liquidity, remaining, fee)
   d. Update amountRemaining by subtracting amountIn + feeAmount (exact input)
      or amountOut (exact output)
   e. Accumulate fee growth: feeGrowthGlobal += feeAmount / liquidity
   f. If sqrtPriceNext reached the tick boundary:
      - Cross the tick: add/subtract the tick's liquidityNet from active liquidity
      - Update current tick
   g. If amountRemaining == 0 or sqrtPrice hits limit → exit loop
3. Update pool state: sqrtPrice, tick, liquidity, feeGrowthGlobal

1. Calculate amountIn to move price from current to target
2. If amountIn + fee <= remaining:
   - Price reaches target: sqrtPriceNext = target
   - Fee = remaining - amountIn (entire remainder is fee, capped)
3. Else:
   - Only partial move: compute sqrtPriceNext from input (after fee deduction)
   - amountRemainingLessFee = amountRemaining * (1e6 - feePips) / 1e6
   - sqrtPriceNext = getNextSqrtPriceFromInput(current, liquidity, amountRemainingLessFee)
4. Compute amountOut from the actual price movement
5. Fee = amountIn calculated from movement, then:
   feeAmount = amountRemaining - amountIn (for exact input, fee is the delta)

1. Calculate amountOut to move price from current to target
2. If amountOut <= |remaining|:
   - Price reaches target
3. Else:
   - Partial move: compute sqrtPriceNext from output
4. Compute amountIn from the actual price movement
5. feeAmount = mulDivRoundingUp(amountIn, feePips, 1e6 - feePips)

/// @notice 512-bit multiply then divide: (a × b) / denominator
/// @dev Will not overflow for any inputs where the result fits in uint256
function mulDiv(
    uint256 a,
    uint256 b,
    uint256 denominator
) internal pure returns (uint256 result);

/// @notice Same as mulDiv but rounds up
function mulDivRoundingUp(
    uint256 a,
    uint256 b,
    uint256 denominator
) internal pure returns (uint256 result);

// amount0 = liquidity * (sqrtPriceB - sqrtPriceA) / (sqrtPriceA * sqrtPriceB)
amount0 = FullMath.mulDiv(
    uint256(liquidity) << FixedPoint96.RESOLUTION,  // L * 2^96
    sqrtPriceBX96 - sqrtPriceAX96,
    sqrtPriceBX96
) / sqrtPriceAX96;

function divRoundingUp(uint256 x, uint256 d) internal pure returns (uint256);

The bitmap is a mapping(int16 => uint256):
  - The key (wordPos) is the tick index divided by 256
  - Each bit in the uint256 represents one compressed tick
  - Compressed tick = actual tick / tickSpacing

tick → compressed = tick / tickSpacing
compressed → wordPos = compressed >> 8   (arithmetic shift, so int16)
compressed → bitPos  = compressed % 256  (uint8, always positive modulo)

/// @notice Compresses a tick by the tick spacing
function compress(int24 tick, int24 tickSpacing)
    internal pure returns (int24 compressed);

/// @notice Returns word position and bit position within the word
function position(int24 tick)
    internal pure returns (int16 wordPos, uint8 bitPos);

/// @notice Toggles the initialized state of a tick
function flipTick(
    mapping(int16 => uint256) storage self,
    int24 tick,
    int24 tickSpacing
) internal;

/// @notice Finds the next initialized tick within the same word
function nextInitializedTickWithinOneWord(
    mapping(int16 => uint256) storage self,
    int24 tick,
    int24 tickSpacing,
    bool lte
) internal view returns (int24 next, bool initialized);

struct State {
    uint128 liquidity;
    uint256 feeGrowthInside0LastX128;
    uint256 feeGrowthInside1LastX128;
}

function calculatePositionKey(
    address owner,
    int24 tickLower,
    int24 tickUpper,
    bytes32 salt
) internal pure returns (bytes32 positionKey);

function update(
    State storage self,
    int128 liquidityDelta,
    uint256 feeGrowthInside0X128,
    uint256 feeGrowthInside1X128
) internal returns (uint256 feesOwed0, uint256 feesOwed1);