Understanding the Invariant

The Constant Product Formula, expressed as x * y = k, is the fundamental rule for many AMMs like Uniswap V2. Here, x and y represent the reserves of two tokens (e.g., ETH and DAI) in a liquidity pool, and k is a constant product that must remain unchanged before and after any trade. This formula ensures the pool always has liquidity, as the product of the reserves is fixed. The price of one token in terms of the other is determined by the ratio of the reserves (price_of_x = y / x). This creates a predictable, automated pricing mechanism without order books.

• Key Insight: The pool's price adjusts automatically based on the relative size of its reserves.
• Visualize: If you increase the amount of token x you want to buy, the formula dictates you must pay an increasing amount of token y, leading to slippage.
• Constant k: This value is only recalculated when liquidity is added or removed by providers, not during swaps.

Tip: The invariant k is like the 'gravity' of the pool, pulling the price back towards equilibrium after each trade.

Executing a Swap Calculation

Let's calculate a swap in a pool with 1000 ETH (x) and 2,000,000 DAI (y), making k = 2,000,000,000. If a trader wants to buy Δx = 1 ETH, we must find how much DAI (Δy) they must pay. The new reserves after the trade must satisfy (x - Δx) * (y + Δy) = k. We solve for Δy: Δy = y - (k / (x - Δx)). Plugging in our numbers: Δy = 2,000,000 - (2,000,000,000 / (1000 - 1)).

codeCopy
// JavaScript calculation
let x = 1000; // ETH reserve
let y = 2000000; // DAI reserve
let k = x * y; // 2,000,000,000
let deltaX = 1; // ETH to buy
let deltaY = y - (k / (x - deltaX));
console.log(`DAI to pay: ${deltaY}`); // Output: ~2002.002 DAI

• Sub-step 1: Define initial reserves x and y, and calculate the constant k.
• Sub-step 2: Determine the desired input amount (Δx or Δy).
• Sub-step 3: Apply the constant product formula to solve for the unknown output amount.
• Result: The price for 1 ETH is about 2002 DAI, slightly above the initial 2000 DAI/ETH price due to slippage.

Tip: The effective price paid is Δy / Δx. For small swaps relative to pool size, slippage is minimal.

Quantifying Trade Impact

Price impact is the percentage change in the price caused by your trade. Using our previous pool (1000 ETH, 2M DAI), the initial price P_i = y / x = 2000. After buying 1 ETH, new reserves are 999 ETH and ~2,002,002 DAI. The new price P_f = 2,002,002 / 999 ≈ 2004.006. The price impact is (P_f - P_i) / P_i * 100 ≈ 0.2%. Slippage is the difference between the expected mid-price and the executed price. If you expected to pay exactly 2000 DAI per ETH but paid ~2002, your slippage is ~2 DAI or 0.1%.

• Sub-step 1: Calculate Mid-Price: This is simply the ratio of reserves (y / x).
• Sub-step 2: Determine Final Price: Use the constant product formula to find the new reserves and new price after your trade.
• Sub-step 3: Compute Impact: Apply ((Final_Price / Mid_Price) - 1) * 100 for percentage impact.
• Critical Factor: The larger Δx is relative to x, the greater the price impact. A 100 ETH swap would drastically increase the price.

Tip: Traders often set a maximum slippage tolerance (e.g., 0.5%) in their wallet to prevent unfavorable trades in volatile markets.

The Role of Liquidity Providers (LPs)

LPs deposit an equal value of both tokens (e.g., 10 ETH and 20,000 DAI at a 1 ETH = 2000 DAI price) into the pool. They receive LP tokens representing their share. The constant k increases upon deposit. For example, adding 10 ETH and 20,000 DAI to our initial pool changes reserves to 1010 ETH and 2,020,000 DAI, making the new k ≈ 2,040,200,000. Each swap charges a protocol fee (e.g., 0.3% for Uniswap V2). This fee is added to the reserves, slowly increasing k and the value of each LP token. LPs earn fees proportional to their share when they withdraw.

• Sub-step 1: Providing Liquidity: Deposit two tokens in a ratio equal to the current pool ratio.
• Sub-step 2: Minting LP Tokens: Receive a pool-specific token (e.g., UNI-V2) representing your ownership stake.
• Sub-step 3: Earning Fees: Trading fees are added to the pool's reserves, incrementally raising the value of the underlying assets backing your LP tokens.
• Sub-step 4: Withdrawing: Burn your LP tokens to reclaim your share of the (now larger) pooled assets.

Tip: LPs face impermanent loss if the price ratio of the deposited tokens changes significantly compared to holding them separately.

Inspecting a Live Contract

Let's examine the Uniswap V2 USDC/WETH pool on Ethereum Mainnet at address 0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc. On Etherscan, you can view the contract's state. The key functions are getReserves() and kLast. Calling getReserves() returns three values: reserve0 (USDC), reserve1 (WETH), and the timestamp of the last block. As of a recent block, values might be reserve0 = 100,000,000 USDC and reserve1 = 50,000 WETH. The constant k is not stored but is reserve0 * reserve1 = 5e12. The current price of WETH in USDC is reserve0 / reserve1 = 2000.

• Sub-step 1: Navigate to etherscan.io/address/0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc.
• Sub-step 2: Go to the Contract tab and click Read Contract.
• Sub-step 3: Call getReserves() to see the latest token reserves.
• Sub-step 4: Manually calculate k and the current price from these reserves.
• Sub-step 5: Check token0() and token1() to confirm which asset is which.

Tip: The kLast variable is used internally to calculate protocol fees for liquidity providers. Comparing it to the current product of reserves shows accrued fees.

Detailed Instructions

Begin by analyzing the Constant Product Market Maker (CPMM) model, the bedrock of protocols like Uniswap V2. The invariant x * y = k ensures liquidity is always available, but price impact increases with trade size. This model suffers from impermanent loss for liquidity providers when asset prices diverge.

• Sub-step 1: Set up a pool with initial reserves: 1000 ETH (x) and 2,000,000 USDC (y), establishing k = 2,000,000,000.
• Sub-step 2: Calculate the price of ETH as y/x = 2000 USDC. Simulate a swap of 50 ETH into the pool.
• Sub-step 3: Use the formula Δy = (k / (x + Δx)) - y to compute the USDC output. For Δx=50, new y = 2e9 / 1050 ≈ 1,904,762, so Δy ≈ 95,238 USDC.
• Sub-step 4: Observe the new price becomes 1,904,762 / 1050 ≈ 1814 USDC/ETH, demonstrating significant slippage.

Tip: Use a spreadsheet or a simple script to model different swap sizes and visualize the convexity of the price curve.

Detailed Instructions

Concentrated Liquidity is a paradigm shift that improves capital efficiency. Instead of providing liquidity across the entire price range (0, ∞), LPs specify a price range [P_a, P_b] where their funds are active. This creates a piecewise bonding curve with higher depth where it's needed.

• Sub-step 1: Define a position for ETH/USDC with a price range of 1500 to 2500 USDC/ETH. Your liquidity is only used when the market price is within this band.
• Sub-step 2: Calculate the required amounts of ETH (x) and USDC (y) for your position using the formulas derived from x * y = L^2, where L is the provided liquidity. For a deposit of $10,000 at a current price of 2000, you would compute L = sqrt(x * y).
• Sub-step 3: Monitor the pool's current tick (a discrete price point). The tick for price P is calculated as tick = floor(log_{1.0001}(P)). A price of 2000 corresponds to tick 207243.
• Sub-step 4: Use a contract like UniswapV3Pool at address 0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8 on Ethereum Mainnet to query liquidity and ticks.

Tip: Impermanent loss is magnified in concentrated positions if the price exits your range, but fee income can be higher while price stays within it.

Detailed Instructions

Advanced AMMs move beyond static 0.3% fees. Dynamic fee AMMs like Curve V2 adjust fees based on market volatility to protect LPs. Furthermore, oracle integration is critical for accurate pricing and reducing arbitrage lag. Protocols use time-weighted average prices (TWAP) from their own pools or external oracles like Chainlink.

• Sub-step 1: Examine a Curve V2 pool (e.g., tricrypto2). Its fee γ dynamically adjusts with the internal oracle's reported price deviation from equilibrium.
• Sub-step 2: Query a TWAP oracle on-chain. For a Uniswap V3 pool, you can call observe on the pool contract to get an array of cumulative tick values over the last 30 minutes.
• Sub-step 3: Calculate a 30-minute TWAP in Solidity:

solidityCopy
function getTWAP() external view returns (uint256 twap) {
    uint32[] memory secondsAgos = new uint32[](2);
    secondsAgos[0] = 1800; // 30 minutes ago
    secondsAgos[1] = 0; // now
    (int56[] memory tickCumulatives, ) = IUniswapV3Pool(pool).observe(secondsAgos);
    int56 tickCumulativeDiff = tickCumulatives[1] - tickCumulatives[0];
    int24 avgTick = int24(tickCumulativeDiff / 1800);
    twap = TickMath.getSqrtRatioAtTick(avgTick);
}

• Sub-step 4: Compare this TWAP to a spot price from a decentralized exchange aggregator like 1inch to identify potential arbitrage opportunities.

Tip: Dynamic fees help stabilize pools during high volatility, while oracles are essential for derivative protocols and lending markets that rely on accurate collateral pricing.

Detailed Instructions

Hybrid Function Market Makers (HFMM) like Curve's StableSwap combine a constant sum (for stability) and constant product (for liquidity) invariant to enable efficient stablecoin trading with low slippage. Multi-Asset Pools like Balancer's Weighted Pools generalize the AMM to n-tokens with customizable weights.

• Sub-step 1: Analyze the Curve V1 StableSwap invariant: A * n^n * sum(x_i) + product(x_i) = A * n^n * D + (D/n)^n, where A is the amplification coefficient, n is the number of coins, and D is the total deposits in peg value. A high A (e.g., 100) makes the curve flatter near equilibrium.
• Sub-step 2: Deploy a test Balancer V2 weighted pool with 3 assets: 50% WETH, 30% WBTC, 20% USDC. The invariant is ∏ (balance_i ^ weight_i) >= k. The swap fee is deducted proportionally.
• Sub-step 3: Calculate the spot price between two tokens in a Balancer pool. For token i and j, SP(i,j) = (balance_j / weight_j) / (balance_i / weight_i).
• Sub-step 4: Interact with the Balancer Vault mainnet contract (0xBA12222222228d8Ba445958a75a0704d566BF2C8) to query pool balances and weights for a specific Pool ID.

Tip: These models solve specific problems: HFMMs for correlated assets minimize slippage, while multi-asset pools allow for complex portfolio exposure and efficient multi-token swaps.