Liquidity pools vs lending protocols: what you're actually selling

Both put your tokens in a smart contract. Both pay you a yield. Both show an APY on a dashboard.

That’s where the similarity ends. Strip away the UI and you get two very different trades:

• Liquidity provider (LP) in an AMM → you are a market maker. You are short volatility.
• Supplier in a lending protocol → you are a secured lender. You are short tail risk on the collateral.

The yield is the premium you collect for the risk you take. If you don’t know which risk you’re holding, you don’t know what the APY is paying you for.

AMMs: market making with a formula

A classic automated market maker (Uniswap v2) holds reserves of two tokens, x and y, and enforces one rule:

x * y = k

The pool’s price is P = y / x. Every swap moves reserves along that curve. When the external market price moves, arbitrageurs trade against the pool until its price matches. That’s the only thing keeping the pool honest.

The payoff of an LP position

Solve the invariant for reserves as a function of price and the value of your position (in the quote token) becomes:

V(P) = 2 * sqrt(k * P)

That’s a concave function of price. In derivatives terms, concave payoff means negative gamma: you lose relative to holding when the price moves — in either direction.

What the pool does mechanically: it sells the token that’s going up and buys the token that’s going down. It rebalances against the trend, automatically, and the counterparty is whoever is better informed about the price — usually an arbitrageur.

This is the same profile as selling options. Fees are your premium.

Impermanent loss, in numbers

Compare LP value against simply holding the 50/50 deposit. With r = P_final / P_initial:

IL(r) = 2 * sqrt(r) / (1 + r) - 1

import math

def impermanent_loss(r: float) -> float:
    """LP value vs. holding, for a 50/50 constant-product pool, ignoring fees."""
    return 2 * math.sqrt(r) / (1 + r) - 1

for r in [0.25, 0.5, 1.5, 2, 4, 10]:
    print(f"price x{r:<5} -> IL {impermanent_loss(r):7.2%}")

price x0.25  -> IL -20.00%
price x0.5   -> IL  -5.72%
price x1.5   -> IL  -2.02%
price x2     -> IL  -5.72%
price x4     -> IL -20.00%
price x10    -> IL -42.50%

Note the symmetry: a 2x and a 0.5x move cost the same. That’s what short volatility looks like.

LVR: the better metric

Impermanent loss only compares endpoints. If price goes 2x and comes back, IL is zero — but you still lost money along the way to arbitrageurs trading against stale prices.

Milionis, Moallemi, Roughgarden and Zhang formalized this as Loss-Versus-Rebalancing (LVR): the cost of an LP position versus a portfolio that rebalances to the same holdings at market prices. For a constant-product pool, the instantaneous rate is:

LVR ≈ (σ² / 8) * V     per unit of time

With 80% annualized volatility, that’s 0.64 / 8 = 8% of pool value per year. Fees have to clear that bar before an LP makes a cent. That’s the real break-even, not the APY on the dashboard.

Concentrated liquidity makes it sharper

Uniswap v3 lets LPs place liquidity in a price range. More capital efficiency, more fees per dollar — and proportionally more negative gamma. A narrow range behaves like a range order or a covered call: once price exits the range, you end up holding 100% of the worse-performing token.

Curve’s StableSwap takes the opposite approach: a curve that’s close to x + y = k near the peg and falls back to constant-product away from it. Good for assets that should trade 1:1. Bad when they stop doing that.

Lending protocols: secured credit with an algorithm

Aave and Compound are pooled money markets. Suppliers deposit into a shared pool, borrowers draw from it. No one-to-one matching.

Three mechanisms do all the work.

1. Overcollateralization

To borrow 100 you deposit more than 100 in another asset. Each collateral type has a liquidation threshold. Aave summarizes position safety as the health factor:

health_factor = Σ(collateral_value * liquidation_threshold) / total_debt

Below 1, anyone can liquidate the position — repay part of the debt and seize collateral at a discount (the liquidation bonus).

2. Utilization-based interest rates

U = total_borrowed / total_supplied

The borrow rate is a piecewise-linear curve with a kink at an “optimal” utilization. Below the kink, rates rise slowly. Above it, they rise steeply — to pull in new deposits and push borrowers to repay before the pool runs dry.

Suppliers earn approximately:

supply_rate ≈ borrow_rate * U * (1 - reserve_factor)

The reserve factor is the protocol’s cut.

3. Liquidations as the credit backstop

There’s no credit scoring. The only thing protecting suppliers is that liquidators act before collateral value falls below debt value. That depends on fast price feeds (oracles), liquid markets for the collateral, and a network that isn’t congested at exactly the wrong moment.

The payoff of a supplier position

You keep exposure to the asset you supplied. Deposit USDC, you still hold USDC — plus interest. No rebalancing, no impermanent loss.

What you’re exposed to is the gap: a price move fast enough that collateral can’t be liquidated before it’s worth less than the debt. When that happens, the loss becomes bad debt shared by the pool.

In options terms, a supplier is roughly:

long bond + short deep-OTM put on the borrowers' collateral

Steady income in normal conditions, losses concentrated in tail events. The borrower, symmetrically, is long leveraged collateral plus an implicit option to default when liquidation fails.

Side by side

Shared risks for both: smart contract bugs, oracle dependence (critical for lending), governance changes, and stablecoin depegs.

Takeaway

The mechanics are new. The finance isn’t. An AMM replicates market making; a lending pool replicates secured credit. The innovation is in implementation — permissionless access, composability, atomic execution — not in the risk underneath.

So before reading the APY, answer one question: what am I short? For an LP, it’s volatility. For a supplier, it’s the tail.

References

• Adams, Zinsmeister, Robinson — Uniswap v2 Core whitepaper
• Adams et al. — Uniswap v3 Core whitepaper
• Uniswap documentation
• Egorov — StableSwap: efficient mechanism for Stablecoin liquidity
• Milionis, Moallemi, Roughgarden, Zhang (2022) — Automated Market Making and Loss-Versus-Rebalancing
• Angeris, Chitra (2020) — Improved Price Oracles: Constant Function Market Makers
• Aave documentation
• Leshner, Hayes — Compound whitepaper
• Gudgeon, Werner, Perez, Knottenbelt (2020) — DeFi Protocols for Loanable Funds