Aerodrome Pool

Pool Types

Volatile Pool (vAMM)

Standard x * y = k constant product formula:

// Volatile pool naming
_name = "Volatile AMM - TOKEN0/TOKEN1";
_symbol = "vAMM-TOKEN0/TOKEN1";

// Invariant calculation
function _k(uint256 x, uint256 y) internal view returns (uint256) {
    if (!stable) {
        return x * y;  // Simple xy = k
    }
    // ...stable calculation
}

// Price calculation for volatile
function _getAmountOut(uint256 amountIn, address tokenIn, uint256 _reserve0, uint256 _reserve1)
    internal view returns (uint256)
{
    if (!stable) {
        (uint256 reserveA, uint256 reserveB) = tokenIn == token0
            ? (_reserve0, _reserve1)
            : (_reserve1, _reserve0);
        return (amountIn * reserveB) / (reserveA + amountIn);
    }
    // ...stable calculation
}

Stable Pool (sAMM)

Uses the x³y + y³x = k curve for low-slippage swaps between correlated assets:

// Stable pool naming
_name = "Stable AMM - TOKEN0/TOKEN1";
_symbol = "sAMM-TOKEN0/TOKEN1";

// Invariant calculation for stable
function _k(uint256 x, uint256 y) internal view returns (uint256) {
    if (stable) {
        uint256 _x = (x * 1e18) / decimals0;
        uint256 _y = (y * 1e18) / decimals1;
        uint256 _a = (_x * _y) / 1e18;
        uint256 _b = ((_x * _x) / 1e18 + (_y * _y) / 1e18);
        return (_a * _b) / 1e18;  // x³y + y³x >= k
    }
    return x * y;
}

Pool Initialization

contract Pool is IPool, ERC20Permit, ReentrancyGuard {
    uint256 internal constant MINIMUM_LIQUIDITY = 10 ** 3;
    uint256 internal constant MINIMUM_K = 10 ** 10;

    function initialize(address _token0, address _token1, bool _stable) external {
        if (factory != address(0)) revert FactoryAlreadySet();
        factory = _msgSender();
        _voter = IPoolFactory(factory).voter();
        (token0, token1, stable) = (_token0, _token1, _stable);
        poolFees = address(new PoolFees(_token0, _token1));

        string memory symbol0 = ERC20(_token0).symbol();
        string memory symbol1 = ERC20(_token1).symbol();

        if (_stable) {
            _name = string(abi.encodePacked("Stable AMM - ", symbol0, "/", symbol1));
            _symbol = string(abi.encodePacked("sAMM-", symbol0, "/", symbol1));
        } else {
            _name = string(abi.encodePacked("Volatile AMM - ", symbol0, "/", symbol1));
            _symbol = string(abi.encodePacked("vAMM-", symbol0, "/", symbol1));
        }

        decimals0 = 10 ** ERC20(_token0).decimals();
        decimals1 = 10 ** ERC20(_token1).decimals();
    }
}

Minting Liquidity

function mint(address to) external nonReentrant returns (uint256 liquidity) {
    (uint256 _reserve0, uint256 _reserve1) = (reserve0, reserve1);
    uint256 _balance0 = IERC20(token0).balanceOf(address(this));
    uint256 _balance1 = IERC20(token1).balanceOf(address(this));
    uint256 _amount0 = _balance0 - _reserve0;
    uint256 _amount1 = _balance1 - _reserve1;

    uint256 _totalSupply = totalSupply();
    if (_totalSupply == 0) {
        // First deposit: liquidity = sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY
        liquidity = Math.sqrt(_amount0 * _amount1) - MINIMUM_LIQUIDITY;
        _mint(address(1), MINIMUM_LIQUIDITY);  // Lock minimum liquidity forever

        if (stable) {
            // Stable pools require equal value deposits initially
            if ((_amount0 * 1e18) / decimals0 != (_amount1 * 1e18) / decimals1)
                revert DepositsNotEqual();
            if (_k(_amount0, _amount1) <= MINIMUM_K) revert BelowMinimumK();
        }
    } else {
        // Subsequent deposits: proportional to existing liquidity
        liquidity = Math.min(
            (_amount0 * _totalSupply) / _reserve0,
            (_amount1 * _totalSupply) / _reserve1
        );
    }

    if (liquidity == 0) revert InsufficientLiquidityMinted();
    _mint(to, liquidity);
    _update(_balance0, _balance1, _reserve0, _reserve1);

    emit Mint(_msgSender(), _amount0, _amount1);
}

Burning Liquidity

function burn(address to) external nonReentrant returns (uint256 amount0, uint256 amount1) {
    (uint256 _reserve0, uint256 _reserve1) = (reserve0, reserve1);
    uint256 _balance0 = IERC20(token0).balanceOf(address(this));
    uint256 _balance1 = IERC20(token1).balanceOf(address(this));
    uint256 _liquidity = balanceOf(address(this));

    uint256 _totalSupply = totalSupply();
    // Pro-rata distribution
    amount0 = (_liquidity * _balance0) / _totalSupply;
    amount1 = (_liquidity * _balance1) / _totalSupply;

    if (amount0 == 0 || amount1 == 0) revert InsufficientLiquidityBurned();

    _burn(address(this), _liquidity);
    IERC20(token0).safeTransfer(to, amount0);
    IERC20(token1).safeTransfer(to, amount1);

    _update(
        IERC20(token0).balanceOf(address(this)),
        IERC20(token1).balanceOf(address(this)),
        _reserve0,
        _reserve1
    );

    emit Burn(_msgSender(), to, amount0, amount1);
}

Swapping

function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data)
    external nonReentrant
{
    if (IPoolFactory(factory).isPaused()) revert IsPaused();
    if (amount0Out == 0 && amount1Out == 0) revert InsufficientOutputAmount();

    (uint256 _reserve0, uint256 _reserve1) = (reserve0, reserve1);
    if (amount0Out >= _reserve0 || amount1Out >= _reserve1) revert InsufficientLiquidity();

    // Optimistically transfer tokens
    if (amount0Out > 0) IERC20(token0).safeTransfer(to, amount0Out);
    if (amount1Out > 0) IERC20(token1).safeTransfer(to, amount1Out);

    // Flash loan callback
    if (data.length > 0) IPoolCallee(to).hook(_msgSender(), amount0Out, amount1Out, data);

    uint256 _balance0 = IERC20(token0).balanceOf(address(this));
    uint256 _balance1 = IERC20(token1).balanceOf(address(this));

    uint256 amount0In = _balance0 > _reserve0 - amount0Out
        ? _balance0 - (_reserve0 - amount0Out) : 0;
    uint256 amount1In = _balance1 > _reserve1 - amount1Out
        ? _balance1 - (_reserve1 - amount1Out) : 0;

    if (amount0In == 0 && amount1In == 0) revert InsufficientInputAmount();

    // Accrue fees (moved to PoolFees)
    if (amount0In > 0) _update0((amount0In * IPoolFactory(factory).getFee(address(this), stable)) / 10000);
    if (amount1In > 0) _update1((amount1In * IPoolFactory(factory).getFee(address(this), stable)) / 10000);

    _balance0 = IERC20(token0).balanceOf(address(this));
    _balance1 = IERC20(token1).balanceOf(address(this));

    // Verify invariant
    if (_k(_balance0, _balance1) < _k(_reserve0, _reserve1)) revert K();

    _update(_balance0, _balance1, _reserve0, _reserve1);
    emit Swap(_msgSender(), to, amount0In, amount1In, amount0Out, amount1Out);
}

Fee Mechanism

Fees are separated from reserves and stored in PoolFees:

// Fee accrual (in Pool.sol)
function _update0(uint256 amount) internal {
    if (amount == 0) return;
    IERC20(token0).safeTransfer(poolFees, amount);  // Move to PoolFees
    uint256 _ratio = (amount * 1e18) / totalSupply();
    if (_ratio > 0) {
        index0 += _ratio;  // Track fee index for LP claims
    }
    emit Fees(_msgSender(), amount, 0);
}

// Fee claiming
function claimFees() external returns (uint256 claimed0, uint256 claimed1) {
    address sender = _msgSender();
    _updateFor(sender);

    claimed0 = claimable0[sender];
    claimed1 = claimable1[sender];

    if (claimed0 > 0 || claimed1 > 0) {
        claimable0[sender] = 0;
        claimable1[sender] = 0;
        PoolFees(poolFees).claimFeesFor(sender, claimed0, claimed1);
        emit Claim(sender, sender, claimed0, claimed1);
    }
}

Price Oracle

Pools maintain TWAP (Time-Weighted Average Price) observations:

uint256 public constant periodSize = 1800;  // 30-minute observation period

struct Observation {
    uint256 timestamp;
    uint256 reserve0Cumulative;
    uint256 reserve1Cumulative;
}

Observation[] public observations;

function _update(uint256 balance0, uint256 balance1, uint256 _reserve0, uint256 _reserve1) internal {
    uint256 blockTimestamp = block.timestamp;
    uint256 timeElapsed = blockTimestamp - blockTimestampLast;

    if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
        reserve0CumulativeLast += _reserve0 * timeElapsed;
        reserve1CumulativeLast += _reserve1 * timeElapsed;
    }

    Observation memory _point = lastObservation();
    timeElapsed = blockTimestamp - _point.timestamp;

    // Record new observation every 30 minutes
    if (timeElapsed > periodSize) {
        observations.push(Observation(blockTimestamp, reserve0CumulativeLast, reserve1CumulativeLast));
    }

    reserve0 = balance0;
    reserve1 = balance1;
    blockTimestampLast = blockTimestamp;
    emit Sync(reserve0, reserve1);
}

// Get TWAP quote
function quote(address tokenIn, uint256 amountIn, uint256 granularity)
    external view returns (uint256 amountOut)
{
    uint256[] memory _prices = sample(tokenIn, amountIn, granularity, 1);
    uint256 priceAverageCumulative;
    for (uint256 i = 0; i < _prices.length; i++) {
        priceAverageCumulative += _prices[i];
    }
    return priceAverageCumulative / granularity;
}

PoolFactory

contract PoolFactory is IPoolFactory {
    mapping(address => mapping(address => mapping(bool => address))) public getPool;

    function createPool(address tokenA, address tokenB, bool stable)
        external returns (address pool)
    {
        if (tokenA == tokenB) revert SameAddress();
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        if (token0 == address(0)) revert ZeroAddress();
        if (getPool[token0][token1][stable] != address(0)) revert PoolAlreadyExists();

        bytes32 salt = keccak256(abi.encodePacked(token0, token1, stable));
        pool = Clones.cloneDeterministic(implementation, salt);
        IPool(pool).initialize(token0, token1, stable);

        getPool[token0][token1][stable] = pool;
        getPool[token1][token0][stable] = pool;
        allPools.push(pool);

        emit PoolCreated(token0, token1, stable, pool, allPools.length);
    }

    // Custom fee per pool (max 3%)
    function setFee(address pool, bool stable, uint256 fee) external {
        if (msg.sender != feeManager) revert NotFeeManager();
        if (fee > 300) revert FeeTooHigh();  // Max 3%
        _customFee[pool] = fee;
    }
}

Key View Functions

// Get current reserves
function getReserves() public view returns (uint256 _reserve0, uint256 _reserve1, uint256 _blockTimestampLast);

// Get pool metadata
function metadata() external view returns (
    uint256 dec0, uint256 dec1,
    uint256 r0, uint256 r1,
    bool st,
    address t0, address t1
);

// Get output amount for a swap
function getAmountOut(uint256 amountIn, address tokenIn) external view returns (uint256);

// Get invariant K
function getK() external nonReentrant returns (uint256);

Reference Files

• contracts/Pool.sol - Main pool implementation
• contracts/PoolFees.sol - Fee storage contract
• contracts/factories/PoolFactory.sol - Pool creation
• contracts/interfaces/IPool.sol - Pool interface