Rebasing Token

What Is a Rebasing Token?

A rebasing token (also called an elastic supply token) is a cryptocurrency whose circulating supply is algorithmically adjusted on a recurring basis. Instead of price absorbing all market forces, the protocol changes the number of tokens in every wallet. If the supply expands, you wake up with more tokens. If it contracts, you have fewer.

The key insight is that your ownership percentage never changes. If you hold 1% of the total supply before a rebase, you still hold 1% after it. What changes is the absolute number of tokens and, by extension, the price per token. This is the opposite of how most token standards behave: standard ERC-20 tokens have a fixed supply where price alone fluctuates.

Rebasing serves two primary purposes. For yield-bearing tokens, positive rebases distribute earnings directly into holder wallets: your staked ETH balance grows daily as validator rewards accrue. For algorithmic stablecoins, rebases expand or contract supply to push the token price toward a target peg.

How It Works

Under the hood, rebasing tokens use share-based accounting rather than storing simple balance integers. The contract tracks each holder's "shares" (an internal unit), and the visible balance returned by balanceOf() is computed dynamically by multiplying shares by a global index.

Share-Based Accounting

The core formula is:

userBalance = totalTokens * (userShares / totalShares)

// Or equivalently:
userBalance = userShares * index
// where index = totalTokens / totalShares

When a rebase occurs, only the global totalTokens value (or an equivalent index scalar) needs updating. This is a single storage slot write, making rebases O(1) in gas cost regardless of how many holders exist. Individual share balances remain untouched.

Ampleforth Model: Gons and Fragments

Ampleforth (AMPL), the first major rebasing token, uses a variant called "gons." The contract defines a fixed constant TOTAL_GONS and assigns each holder a portion of these gons. The rebase() function adjusts _totalSupply and recalculates a global divisor:

// Simplified Ampleforth rebase logic
function rebase(uint256 epoch, int256 supplyDelta) external {
    _totalSupply = _totalSupply + supplyDelta;
    _gonsPerFragment = TOTAL_GONS / _totalSupply;
}

function balanceOf(address who) public view returns (uint256) {
    return _gonBalances[who] / _gonsPerFragment;
}

AMPL rebases once daily at 02:00 UTC. The rebase percentage is calculated as one-tenth of the deviation from the $1.009 price target (a smoothing factor), applied only when the price falls outside a neutral band of +/-5%.

Aave and Lido Model: Continuous vs. Epoch-Based

Not all rebasing tokens use fixed epochs. Two common patterns exist:

• Epoch-based rebasing: supply adjusts at fixed intervals. AMPL rebases daily. Lido stETH rebases once daily at approximately 12:30 UTC when an oracle committee (9 operators, 5/9 quorum) reports updated validator rewards.
• Continuous rebasing: balances update on every interaction. Aave aTokens accrue interest per-block via a liquidityIndex that updates on every deposit, withdrawal, borrow, or repayment event. The balanceOf() function computes accrued interest using the current block timestamp.

Rounding and Precision

Share-to-token conversions introduce rounding behavior that varies by implementation. Aave V3 rounds shares up on deposit, meaning a transfer can debit slightly more from the sender than the receiver gains. Lido rounds shares down, which can leave 1-2 wei of dust behind when transferring an entire balance. These small discrepancies are documented in the precision decay phenomenon and can compound in protocols that perform many sequential operations.

Positive vs. Negative Rebasing

Positive Rebasing (Expansion)

Positive rebases increase the token supply, adding tokens to every wallet. This is the dominant use case in modern DeFi:

• Aave aTokens: depositing 1,000 USDC mints 1,000 aUSDC. At 5% APR, your balance reads approximately 1,050 aUSDC after one year as borrower interest accrues
• Lido stETH: represents staked ETH where validator rewards are socialized across all holders. Lido caps the maximum daily rebase at approximately 0.074% (27% annualized) as a safety measure
• Ondo rOUSG: a newer example of real-world asset (RWA) backed rebasing, distributing US Treasury yield as daily balance increases while maintaining a stable $1 price

Negative Rebasing (Contraction)

Negative rebases reduce the token supply, removing tokens from wallets. This mechanism is primarily used by algorithmic stablecoins attempting to restore a price peg from below:

• AMPL contraction: when the price drops below the target, all wallet balances shrink proportionally. The intent is to reduce circulating supply until price recovers
• Empty Set Dollar (ESD): used rebasing to maintain a $1 peg. Repeated negative rebases during sell-offs created a reflexive death spiral where shrinking balances triggered more selling, permanently breaking the peg

The failure modes of negative rebasing are well-documented. Contraction creates a psychological dynamic where holders see their balances shrinking, prompting panic selling that drives the price further below peg. This feedback loop is a core risk in any peg mechanism that relies on supply contraction. For a deeper analysis, see stablecoin peg mechanisms compared.

DeFi Composability Challenges

Rebasing tokens violate a fundamental assumption embedded in nearly every DeFi protocol: that balanceOf() only changes through explicit transfers, mints, or burns. This creates serious integration problems.

AMM Incompatibility

Uniswap V3 and V4 do not support rebasing tokens. Liquidity providers cannot withdraw tokens earned through rebasing: the extra tokens become permanently trapped in the pool contract. Uniswap V2 technically supports rebasing (via a sync() function that updates reserves), but LPs absorb all losses from negative rebases with no recovery mechanism.

Vault and Lending Protocol Issues

Smart contracts that cache token balances (standard practice for gas efficiency) become desynchronized after a rebase. The cached balance no longer matches the actual balance, leading to incorrect collateral valuations, failed withdrawals, or exploitable arbitrage. Protocols integrating rebasing tokens must query live balances on every operation rather than relying on internal accounting.

Cross-Chain Bridge Problems

Sending rebasing stETH through a bridge causes yield to accumulate in the bridge contract on the source chain. The destination wallet receives a static snapshot and never benefits from subsequent rebases. This is a primary reason Lido recommends bridging wstETH (the non-rebasing wrapper) rather than stETH for any cross-chain operation.

ERC-20 Standard Violations

Rebasing tokens break several implicit ERC-20 guarantees:

• Balances change without emitting Transfer events, confusing indexers and block explorers
• Transfers are not zero-sum: rounding differences mean the amount debited from the sender may not equal the amount credited to the receiver
• Transferring balanceOf(user) may fail or leave dust behind due to share-to-token rounding
• Allowance-based approvals become stale immediately as the balance changes between transactions

Why Wrapped Versions Exist

The composability problems above led to the creation of non-rebasing wrapped versions that convert the rebasing behavior into a static-balance, increasing-exchange-rate model.

How Wrapping Works

Wrapping locks rebasing tokens in a contract and mints a non-rebasing receipt token. The wrapper's balance stays constant while the exchange rate between wrapper and underlying grows over time:

// Wrapping stETH -> wstETH
// User deposits 10 stETH when 1 wstETH = 1.1 stETH
wstETH_received = stETH_deposited / exchangeRate
// 10 / 1.1 = 9.09 wstETH

// Unwrapping after yield accrual (rate now 1.15)
stETH_received = wstETH_balance * exchangeRate
// 9.09 * 1.15 = 10.45 stETH

The yield is captured in the rising exchange rate rather than changing token counts. This pattern aligns with the ERC-4626 Tokenized Vault Standard, which has become the default interface for yield-bearing assets. Most DeFi protocols launched after 2023 implement ERC-4626 natively rather than using rebasing.

Common Wrapped Tokens

Use Cases

Yield Distribution

The most successful application of rebasing is distributing protocol yield directly to holder wallets. Lido stETH and Aave aTokens collectively hold tens of billions in value. Users see their balances grow in real time without needing to claim, stake, or interact with any contract. For a comprehensive overview of how this fits into the broader stablecoin yield landscape, see yield-bearing stablecoins explained.

Algorithmic Peg Maintenance

Rebasing can maintain a target price by expanding supply when the price is above peg and contracting when below. While this approach has a mixed track record (AMPL continues to operate, but many algorithmic stablecoins using rebase mechanics have failed), it remains an active area of research. See the stablecoin trilemma for why maintaining a peg through supply adjustment alone is inherently difficult.

Native L2 Yield

Blast, launched in 2024, pioneered natively rebasing ETH and USDB at the Layer 2 level. ETH deposited to Blast earns approximately 4% via Lido staking on L1, and USDB earns approximately 5% via MakerDAO T-Bill yield. This represents a new pattern: entire chains where the base asset itself rebases. For context on how stablecoins operate across Bitcoin layers, see stablecoins on Bitcoin.

Risks and Considerations

Death Spiral Risk

Negative rebasing creates a reflexive feedback loop: contraction reduces balances, holders panic sell, price drops further, triggering more contraction. Empty Set Dollar and multiple other algorithmic stablecoins have entered permanent death spirals through this mechanism. The UST collapse in May 2022, while not a pure rebase token, demonstrated a similar dynamic through its mint-burn mechanism with LUNA, destroying approximately $45 billion in value.

Smart Contract Integration Risk

Any protocol holding rebasing tokens must account for balance changes between transactions. Failure to do so creates exploitable vulnerabilities. Origin Protocol's OTokens address this by defaulting to non-rebasing behavior when held by smart contracts: contracts must explicitly call rebaseOptIn() to receive balance adjustments.

Tax and Accounting Complexity

Each rebase is potentially a taxable event in many jurisdictions, creating thousands of micro-transactions per year for holders. Tracking cost basis across daily rebases is operationally burdensome and often impractical without specialized software.

Oracle Dependency

Epoch-based rebasing tokens depend on external oracles to trigger rebases accurately. A compromised or manipulated oracle can trigger incorrect supply adjustments. Lido mitigates this with a 5/9 oracle quorum and a maximum daily rebase cap, but oracle manipulation remains a systemic risk for any protocol relying on external price feeds to determine rebase magnitude.

Industry Shift Toward Non-Rebasing

The DeFi ecosystem has increasingly favored the ERC-4626 vault model over rebasing for new yield-bearing tokens. This shift reflects hard-won lessons about composability: static balances with rising exchange rates integrate seamlessly with AMMs, lending protocols, and bridges. While existing rebasing tokens like stETH retain massive adoption, new protocol designs predominantly choose the non-rebasing approach.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.