How Automated Market Makers Price Assets in Liquidity Pools

Detailed Instructions

Every Constant Product AMM pool is defined by the reserves of two assets, typically denoted as x (e.g., ETH) and y (e.g., DAI). The core invariant is the product of these reserves, a constant k. For a new pool, the initial k is set when the first liquidity provider deposits tokens. For example, depositing 10 ETH and 20,000 DAI creates an initial state where x = 10, y = 20000, and k = 200,000. This k value must be preserved by all subsequent trades, meaning any trade that changes x must result in a corresponding change to y such that the new product (x_new * y_new) still equals k.

• Sub-step 1: Identify current reserves x and y from the pool contract.
• Sub-step 2: Calculate the invariant k = x * y.
• Sub-step 3: Store k as the benchmark for pricing all future swaps.

solidityCopy
// Example: Calculating k in a contract
function getK() public view returns (uint256) {
    (uint112 reserve0, uint112 reserve1, ) = IUniswapV2Pair(poolAddress).getReserves();
    return uint256(reserve0) * reserve1;
}

Tip: The value of k increases only when liquidity is added (via minting new LP tokens) and decreases when liquidity is removed (via burning LP tokens). Trades do not change k.

Detailed Instructions

When a trader wants to swap Δx amount of token A for token B, the pool must calculate the output amount Δy such that the constant product is maintained. The formula is derived from the invariant: (x + Δx) * (y - Δy) = k. Solving for Δy gives Δy = y - (k / (x + Δx)). This ensures the new reserves are x_new = x + Δx and y_new = y - Δy. A 0.3% fee (common in Uniswap V2) is typically deducted from the input amount before this calculation, so the effective input for the constant product formula is Δx * (1 - fee). For large trades relative to pool size, Δy will be smaller due to the convexity of the curve, reflecting price impact.

• Sub-step 1: Apply the protocol fee to the input amount (e.g., effectiveΔx = Δx * 0.997).
• Sub-step 2: Compute the new reserve of the input token x_new = x + effectiveΔx.
• Sub-step 3: Solve for the output using Δy = y - (k / x_new).

solidityCopy
// Simplified output calculation logic
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
    uint amountInWithFee = amountIn * 997; // 0.3% fee
    uint numerator = amountInWithFee * reserveOut;
    uint denominator = (reserveIn * 1000) + amountInWithFee;
    amountOut = numerator / denominator;
}

Tip: The formula inherently provides slippage: the effective exchange rate Δy / Δx is worse than the current spot price y / x.

Detailed Instructions

The spot price is the instantaneous exchange rate for an infinitesimally small trade, defined as the ratio of the reserves P = y / x. After a trade changes the reserves to (x_new, y_new), the spot price updates to P_new = y_new / x_new. Because the constant product formula creates a hyperbolic curve, the price moves along the curve against the trade direction. If you buy token Y (spending X), x increases and y decreases, causing P (the price of X in terms of Y) to fall. This is the mechanism of automated price discovery. The price impact of a trade can be estimated by comparing the initial spot price P_initial to the effective price of the trade Δy / Δx.

• Sub-step 1: Record pre-trade reserves (x, y) and calculate P_initial = y / x.
• Sub-step 2: Calculate post-trade reserves (x_new, y_new) after the swap.
• Sub-step 3: Compute the new spot price P_new = y_new / x_new.

solidityCopy
// Calculating spot price from reserves (scaled by decimals)
// Assumes reserve0 and reserve1 are for tokens with 18 decimals.
function getSpotPrice(address pair, address tokenIn) public view returns (uint256) {
    (uint112 r0, uint112 r1, ) = IUniswapV2Pair(pair).getReserves();
    (uint112 reserveIn, uint112 reserveOut) = tokenIn == token0 ? (r0, r1) : (r1, r0);
    // Price of tokenIn in terms of tokenOut: (reserveOut / reserveIn)
    return (uint256(reserveOut) * 1e18) / reserveIn; // Scaled for precision
}

Tip: The spot price is only valid for the next vanishingly small trade. For any meaningful trade size, you must use the constant product formula directly.

Detailed Instructions

Impermanent Loss (IL) is the loss in dollar value experienced by a liquidity provider compared to simply holding the deposited assets, caused by divergence in the asset price ratio. It's a direct consequence of the constant product formula. When the price of asset X increases relative to Y, arbitrageurs will trade Y for X until the pool's spot price matches the external market. This drains the pool of the appreciating asset (X) and fills it with the depreciating one (Y). The LP's share of the pool is worth less than the original holdings would be. The IL can be calculated as: IL = (value in pool) / (value if held) - 1. For a price change r = P_new / P_initial, the IL for a 50/50 pool is 2 * sqrt(r) / (1 + r) - 1.

• Sub-step 1: Calculate the value of the LP's share using current reserves and market prices.
• Sub-step 2: Calculate the value of the initial deposit if it had simply been held.
• Sub-step 3: Compute the IL ratio and express it as a percentage loss.

solidityCopy
// Conceptual function to calculate impermanent loss magnitude
// r is the price ratio (new/old) scaled by 1e18
function calcImpermanentLoss(uint256 r) public pure returns (int256 loss) {
    // IL = 2 * sqrt(r) / (1 + r) - 1
    uint256 sqrtR = sqrt(r * 1e18); // sqrt function with precision
    uint256 numerator = 2 * sqrtR;
    uint256 denominator = 1e18 + r;
    uint256 ratio = (numerator * 1e18) / denominator;
    // Convert to a loss percentage (negative number)
    loss = int256(ratio) - 1e18; // Result is in basis points (1e18 = 0%)
}

Tip: Impermanent loss is 'impermanent' because it can be reversed if prices return to the original ratio. It becomes permanent upon withdrawal.

Detailed Instructions

Arbitrage is the force that aligns the AMM's internal price with external market prices. When the pool's spot price P_pool = y/x deviates from the global market price P_market, an arbitrage opportunity exists. An arbitrageur will trade in the profitable direction until P_pool ≈ P_market. For example, if P_pool for ETH/DAI is 1900 DAI per ETH while P_market is 2000 DAI, an arbitrageur can buy cheap ETH from the pool. They sell DAI into the pool, increasing the DAI reserve y and decreasing the ETH reserve x. This increases P_pool (since y/x gets larger). The trade continues until the profit margin is negligible, factoring in gas costs. This process is modeled by solving (x - Δx) * (y + Δy) = k where Δy / Δx = P_market.

• Sub-step 1: Identify the price discrepancy between P_pool and P_market.
• Sub-step 2: Calculate the optimal arbitrage trade size that maximizes profit, considering gas.
• Sub-step 3: Execute the trade, which moves the pool reserves along the curve.

solidityCopy
// Simplified logic to find arbitrage profit for a given market price
function calcArbitrageProfit(
    uint256 reserveETH,
    uint256 reserveDAI,
    uint256 marketPriceDAIperETH // e.g., 2000 * 1e18
) public pure returns (uint256 profitDAI, uint256 ethToSell) {
    uint256 k = reserveETH * reserveDAI;
    // Solve for new ETH reserve after arbitrage: newReserveETH = sqrt(k / marketPrice)
    // Using fixed-point math libraries for sqrt is necessary in practice.
    uint256 newReserveETH = sqrt((k * 1e18) / marketPriceDAIperETH);
    ethToSell = reserveETH - newReserveETH;
    uint256 daiReceived = (reserveDAI * ethToSell) / (newReserveETH + ethToSell); // From getAmountOut
    profitDAI = (daiReceived * marketPriceDAIperETH) / 1e18 - ethToSell; // Profit in DAI terms
}

Tip: Arbitrage ensures the AMM provides accurate market prices but is the primary source of impermanent loss for LPs.

Detailed Instructions

Constant product formula is the core pricing mechanism for pools like Uniswap V2, defined as x * y = k, where x and y are the reserves of two tokens and k is a constant. To calculate impact, you must first query the pool's current state.

• Sub-step 1: Query pool reserves. Use the pool contract's getReserves() function on-chain or via a subgraph to obtain the precise amounts of token A and token B, e.g., 1,000,000 USDC and 500 ETH.
• Sub-step 2: Identify the trade direction. Determine if you are swapping token A for token B (selling into the pool) or vice versa.
• Sub-step 3: Record the initial invariant. Calculate k using the fetched reserves: k = reserve_A * reserve_B. This value must remain constant after fees for the post-trade state.

solidityCopy
// Example: Querying reserves from a UniswapV2Pair
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(poolAddress).getReserves();
// Assume reserve0 = USDC (1,000,000 * 1e6), reserve1 = ETH (500 * 1e18)
uint k = uint(reserve0) * uint(reserve1);

Tip: Always use the reserve values after the last trade, accounting for any pending transactions in the mempool that could alter the state.

Detailed Instructions

Output amount is derived by solving the constant product formula for the new reserves. For an input amount Δx of token A (with a fee γ, typically 0.997 for a 0.3% fee), the output Δy of token B is calculated.

• Sub-step 1: Apply the trading fee. Multiply your input amount by the fee multiplier: inputAmountAfterFee = Δx * γ. For a 1000 USDC swap with a 0.3% fee, this is 1000 * 0.997 = 997.
• Sub-step 2: Compute new reserve of input token. Add the fee-adjusted input to its reserve: newReserveX = reserveX + inputAmountAfterFee.
• Sub-step 3: Solve for the new reserve of output token. Using the invariant k, calculate newReserveY = k / newReserveX.
• Sub-step 4: Derive the output. The output amount is the difference: Δy = reserveY - newReserveY. This is the amount of token B you will receive.

javascriptCopy
// JavaScript calculation example
const reserveX = 1000000; // USDC reserve
const reserveY = 500;     // ETH reserve
const k = reserveX * reserveY;
const inputX = 1000;
const fee = 0.997;
const inputAfterFee = inputX * fee;
const newReserveX = reserveX + inputAfterFee;
const newReserveY = k / newReserveX;
const outputY = reserveY - newReserveY; // Expected ETH received

Tip: This calculation assumes no other trades occur before yours. In practice, use a slippage tolerance (e.g., 0.5%) on outputY when submitting your transaction.

Detailed Instructions

Price impact is the percentage difference between the effective price of your trade and the initial spot price (reserveY / reserveX). It quantifies your market footprint.

• Sub-step 1: Calculate the initial spot price. spotPriceInitial = reserveY / reserveX. With 500 ETH and 1,000,000 USDC, the price is 0.0005 ETH per USDC, or 2000 USDC per ETH.
• Sub-step 2: Calculate the effective execution price. priceExecution = inputAmount / outputAmount. For 1000 USDC in and the calculated outputY ETH out, this is 1000 / outputY.
• Sub-step 3: Compute the percentage impact. priceImpact = (priceExecution - spotPriceInitial) / spotPriceInitial * 100. A positive result means you received a worse price (paid more per token).

Critical nuance: Price impact increases non-linearly with trade size relative to liquidity. A $10k swap in a $1M pool has minimal impact, while a $100k swap significantly moves the price.

pythonCopy
# Python calculation
reserveX = 1_000_000.0
reserveY = 500.0
spot_price_initial = reserveY / reserveX  # 0.0005
input_amount = 1000.0
output_amount = 4.975  # Example from previous step
price_execution = input_amount / output_amount  # ~201.01
price_impact_pct = ((price_execution - (1/spot_price_initial)) / (1/spot_price_initial)) * 100
# Compares USDC/ETH price, impact ~0.5%

Tip: High price impact (>1%) often indicates low liquidity, making the trade costly and potentially vulnerable to MEV.

Detailed Instructions

Slippage is the maximum acceptable price impact, defined by the user. It is a protective parameter set in the swap transaction to prevent execution at an unexpectedly bad price.

• Sub-step 1: Define your slippage tolerance. This is a percentage, e.g., 0.5%. For a calculated price impact of 0.2%, a 0.5% tolerance is safe.
• Sub-step 2: Calculate the minimum output amount. minOutput = outputAmount * (1 - slippageTolerance). If expected output is 4.975 ETH with 0.5% slippage, minOutput = 4.975 * 0.995 = 4.950 ETH.
• Sub-step 3: Construct the swap transaction. Pass minOutput (often called amountOutMin) as a parameter. In Uniswap's Router, this prevents the swap if the output is below this threshold.
• Sub-step 4: Account for deadline. Also set a deadline parameter (UNIX timestamp) to invalidate stale transactions that might execute after market conditions change.

solidityCopy
// Example Uniswap V2 Router call with slippage protection
router.swapExactTokensForTokens(
    amountIn,
    amountOutMin, // Calculated minOutput
    path, // Array of token addresses
    msg.sender,
    deadline // e.g., block.timestamp + 1200 (20 minutes)
);

Tip: Setting slippage too low may cause transaction reverts due to normal price volatility. Setting it too high exposes you to sandwich attacks. Use recent price impact calculations to inform your setting.

Detailed Instructions

Real pools have multiple fee tiers (e.g., 0.05%, 0.3%, 1%) and dynamic data from oracles. Your calculations must adapt.

• Sub-step 1: Identify the pool's fee. Check the pool factory or contract to get the exact fee. The fee multiplier γ is 1 - fee. For a 0.05% pool, γ = 0.9995.
• Sub-step 2: Use on-chain price oracles. For accurate pre-trade estimates, consult the pool's time-weighted average price (TWAP) from an oracle like Uniswap's, which smooths out volatility.
• Sub-step 3: Factor in protocol-specific mechanics. Some AMMs (e.g., Curve) use combined constant product and sum formulas, altering the impact calculation. Always refer to the protocol's whitepaper.
• Sub-step 4: Simulate using SDKs. Use libraries like the Uniswap SDK to simulate swaps precisely, handling all fee and math logic: Trade.createUncheckedTrade({ route, inputAmount, outputAmount, tradeType }).

typescriptCopy
// Example using Uniswap V3 SDK to get a quote with fees
import { Trade } from '@uniswap/v3-sdk';
const trade = await Trade.fromRoute(
  route, // Pre-defined Route object
  inputAmount,
  TradeType.EXACT_INPUT
);
console.log(trade.outputAmount.toSignificant(6));
console.log(trade.priceImpact.toSignificant(4)); // Price impact as Percent

Tip: Lower fee pools (0.05%) attract arbitrageurs, often leading to tighter spreads but may have less liquidity, creating a trade-off between fee cost and price impact.