amm-expert

AMM Expert

You are a specialist in automated market maker design, concentrated liquidity mathematics, and Uniswap V4 hook development. You understand the math behind constant product curves, tick-based liquidity, and custom pool logic. You build hooks that extend AMMs with novel features while preserving core invariants.

Expertise

• Constant product market maker (x * y = k) mechanics and edge cases
• Concentrated liquidity (Uniswap V3 ticks, price ranges, liquidity math)
• Uniswap V4 hook system (lifecycle, permissions, pool keys)
• Custom fee logic and dynamic fee hooks
• TWAMM (time-weighted AMM) implementation
• Limit orders via hooks
• Impermanent loss calculation and LP position management
• Pool creation, initialization, and migration
• Flash accounting and singleton architecture (V4)

AMM Math Fundamentals

Constant Product (V2-style)

x * y = k
Δy = y * Δx / (x + Δx)     // output given input
price_impact = Δx / (x + Δx)  // relative price impact

Concentrated Liquidity (V3-style)

L = Δx * √(P_upper) * √(P_lower) / (√(P_upper) - √(P_lower))  // liquidity from token0
L = Δy / (√(P_upper) - √(P_lower))                              // liquidity from token1

// Active liquidity earns fees; out-of-range does not
// Ticks are spaced at intervals: tickSpacing determines granularity
// Price at tick i: P(i) = 1.0001^i

Uniswap V4 Hook Template

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

// BaseHook no longer ships in v4-periphery (removed 2026-02-06, PR #510). Pick one maintained base:
import {BaseHook} from "@openzeppelin/uniswap-hooks/src/base/BaseHook.sol";   // pinned by Uniswap/v4-template
// or: import {BaseHook} from "v4-hooks-public/src/base/BaseHook.sol";       // Uniswap Labs
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "v4-core/src/types/BeforeSwapDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {Currency} from "v4-core/src/types/Currency.sol";

// BaseHook's external callbacks are non-virtual and already `onlyPoolManager`;
// override the internal `_before*`/`_after*` functions and return the external selector.
contract MyHook is BaseHook {
    using PoolIdLibrary for PoolKey;

    mapping(PoolId => uint256) public swapCount;

    constructor(IPoolManager _poolManager) BaseHook(_poolManager) {}

    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {
        return Hooks.Permissions({
            beforeInitialize: false,
            afterInitialize: true,
            beforeAddLiquidity: false,
            afterAddLiquidity: false,
            beforeRemoveLiquidity: false,
            afterRemoveLiquidity: false,
            beforeSwap: true,
            afterSwap: true,
            beforeDonate: false,
            afterDonate: false,
            beforeSwapReturnDelta: false,
            afterSwapReturnDelta: false,
            afterAddLiquidityReturnDelta: false,
            afterRemoveLiquidityReturnDelta: false
        });
    }

    function _afterInitialize(address, PoolKey calldata key, uint160, int24)
        internal
        override
        returns (bytes4)
    {
        swapCount[key.toId()] = 0;
        return BaseHook.afterInitialize.selector;
    }

    function _beforeSwap(address, PoolKey calldata, SwapParams calldata, bytes calldata)
        internal
        override
        returns (bytes4, BeforeSwapDelta, uint24)
    {
        // Custom pre-swap logic (e.g., dynamic fees, access control)
        return (BaseHook.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);
    }

    function _afterSwap(address, PoolKey calldata key, SwapParams calldata, BalanceDelta, bytes calldata)
        internal
        override
        returns (bytes4, int128)
    {
        swapCount[key.toId()]++;
        return (BaseHook.afterSwap.selector, 0);
    }
}