Why Rebasing Tokens and AMMs Are a Security Mismatch

AMMs like Uniswap V2/V3 derive price from the pool's reserve ratio. A rebase changes reserves without a trade, creating a phantom price movement. This creates arbitrage against the pool and breaks the primary oracle for the entire DeFi stack (e.g., lending protocols like Aave, Compound).

• Attack Vector: Oracle manipulation via forced rebase timing.
• Result: Inaccurate collateral valuation and potential protocol insolvency.

LP tokens represent a share of a pool. When the underlying rebasing token changes quantity, the LP token's claim on the pool's value becomes ambiguous. This breaks composability with yield aggregators (Yearn, Convex) and lending markets.

• Core Issue: LP token is no longer a pure claim on two fixed assets.
• Consequence: LPs face unpredictable impermanent loss and cannot safely use their position as collateral elsewhere.

Ampleforth (AMPL) is the canonical rebasing token. Its 2019-2020 cycles caused massive liquidity fragmentation across DEXs. Pools would swing between 100% AMPL or 0% AMPL post-rebase, destroying liquidity depth and creating extreme slippage.

• Empirical Proof: AMMs cannot natively handle supply-volatile assets.
• Industry Response: Led to wrapper solutions (e.g., stETH, sOHM) that convert rebasing tokens into yield-bearing, non-rebasing versions.

The fix is to intercept the rebase off-chain and convert the token into a non-rebasing, yield-bearing derivative. Lido's stETH and Olympus's sOHM/gOHM are successful models. The wrapper vault absorbs the rebase, minting a token that grows in value per unit, not quantity.

• Mechanism: Rebase is converted into a continuous appreciation of the wrapper token's exchange rate.
• Outcome: AMMs see a normal, composable ERC-20, restoring oracle integrity and LP safety.

Rebasing tokens like stETH dynamically change a user's balance, but AMM liquidity pools see only the pool's total supply. This creates a permanent arbitrage vector where the pool's internal accounting becomes inaccurate after every rebase.

• Pool becomes undercollateralized relative to its true liabilities.
• Arbitrageurs drain value from passive LPs with near-zero risk.
• Classic "impermanent loss" transforms into guaranteed, calculable loss.

Protocols like Lido's wstETH and Rocket Pool's rETH solve this by creating a non-rebasing wrapper token. The wrapper's exchange rate against the underlying asset appreciates instead of minting new tokens.

• AMM pools hold the static wrapper token, preserving constant-sum mechanics.
• Users still capture staking yield via the wrapper's price appreciation.
• This pattern has secured ~$20B+ in DeFi TVL across Curve and Balancer pools.

Without a wrapper, each rebasing token (e.g., stETH, aETH) requires its own isolated liquidity pool. This fragments liquidity and destroys composability.

• Zero interoperability with the broader DeFi ecosystem (e.g., cannot use stETH as collateral in MakerDAO).
• Users face constant balance confusion and tax accounting nightmares.
• Forces protocols like Curve to implement complex, one-off gauge systems for incentives.

Yield-bearing indices (e.g., Index Coop's dsETH) and vault strategies abstract the rebasing complexity. They aggregate multiple LSTs into a single, composable token.

• Diversifies underlying risk across multiple protocols (Lido, Rocket Pool, Frax).
• Provides a single, clean balance for users and AMMs.
• Enables novel DeFi primitives like yield-bearing collateral in lending markets.

Rebase events are predictable, scheduled price discontinuities. This creates a free option for MEV bots to front-run or sandwich the rebase adjustment in AMM pools.

• Oracles like Chainlink must handle the supply change, creating temporary price spikes.
• Bots extract value from LPs and protocol rewards auctions.
• Increases systemic fragility during high network congestion.

The core lesson is that monetary policy and state must be separated. A token cannot be both a medium of exchange/AMM reserve and a yield-bearing instrument without a translation layer.

• Successful patterns (wrappers, vaults) all insert a middleware layer to absorb the rebase.
• This is why EigenLayer uses a native restaking token, not a rebasing ETH.
• Future designs must bake this separation into first principles.