Algorithmic Peg

A rebasing algorithmic peg adjusts the token supply held in every wallet to maintain the target price. If the price is above the peg, the protocol mints and distributes new tokens to all holders, diluting the value per token. If below, it burns tokens from all wallets, increasing scarcity. This creates a dilutionary or contractionary effect directly in user balances, as seen in early designs like Ampleforth.

This model uses a multi-token system to absorb volatility. A stable asset (e.g., UST, FRAX) aims for the peg. A governance/volatility token (e.g., LUNA, FXS) acts as the shock absorber. When the stablecoin trades above peg, the protocol mints and sells new stablecoins, using the profit (seigniorage) to buy back and burn the governance token. When below peg, the protocol mints new governance tokens to sell for collateral, burning the stablecoin to reduce supply.

Algorithmic pegs are vulnerable to reflexivity, where market sentiment directly impacts the fundamental mechanism. In a seigniorage model, a falling stablecoin price forces the minting of more governance tokens, diluting their value. If confidence collapses, this creates a death spiral: more minting leads to more selling pressure on the governance token, which undermines the collateral backing, making it impossible to restore the peg. This is a critical design failure mode.

All algorithmic pegs rely on price oracles to determine if their token is above or below the target price. This creates a critical centralization and security point. A delayed, manipulated, or corrupted oracle feed can trigger incorrect supply contractions or expansions, breaking the peg. Protocols often use a time-weighted average price (TWAP) from multiple decentralized exchanges to mitigate flash price manipulation.

Algorithmic pegs contrast with collateralized stablecoins. Key differences:

• Backing: Algorithmic uses code & incentives; Collateralized uses off-chain assets (USDC) or crypto (DAI).
• Capital Efficiency: Algorithmic aims for high efficiency (low/no collateral); Collateralized requires over-collateralization for safety.
• Risk Profile: Algorithmic carries smart contract and reflexivity risk; Collateralized carries custodial (for fiat-backed) or liquidation risk (for crypto-backed).

A mechanism where the token supply expands or contracts in all holders' wallets to adjust the market price toward the target peg. When price is above peg, new tokens are minted and distributed to shareholders or stakers, increasing supply. When below peg, supply is reduced via a negative rebase, burning tokens from all wallets proportionally. Example: Ampleforth (AMPL).

A two-token system where a stable asset is backed by a volatile governance/equity token. The volatile token absorbs price volatility and is minted/burned to stabilize the peg. Common during contraction: users burn the stablecoin to mint the volatile token at a premium, creating buy pressure. Examples: Terra's UST (with LUNA), the original Basis Cash model.

A peg stabilized by a combination of collateral and algorithms. A portion of the supply is backed by off-chain or crypto assets, while the remainder is stabilized algorithmically. This creates a collateral buffer to defend the peg during volatility, reducing reliance on pure market confidence. Example: Frax Finance (FRAX), which dynamically adjusts its collateral ratio based on market conditions.

A mechanism using bond sales and redemption to create price floors and ceilings. Users can purchase bonds with the stablecoin when it is below peg, locking funds for a future premium payout if the peg recovers. This burns stablecoin, reducing supply. Conversely, treasury reserves are sold when above peg to increase supply. Example: Olympus DAO's (OHM) treasury-backed stability mechanisms.

A protocol that acts as a decentralized market maker with an on-chain treasury. It uses algorithms to manage a portfolio of assets (like foreign exchange reserves) and executes open market operations. It buys the stablecoin when below peg using treasury assets and sells treasury assets to mint more stablecoin when above peg. Conceptual model inspired by traditional central banking.

A control theory approach using a Proportional-Integral-Derivative (PID) feedback loop to adjust monetary policy. The algorithm continuously measures the price error (deviation from peg) and uses the three terms to calculate a response:

• Proportional: Immediate reaction to current error.
• Integral: Reaction to accumulated past error.
• Derivative: Prediction of future error based on rate of change. This aims for smoother, more responsive supply adjustments.

A prominent example of a multi-token seigniorage model. It used a three-token system:

• Basis Cash (BAC): The stablecoin pegged to $1.
• Basis Shares (BAS): Received newly minted BAC when the peg was above $1.
• Basis Bonds (BAB): Could be purchased at a discount when BAC was below $1, to be redeemed later for BAC at $1. The protocol failed to maintain its peg during market downturns, as demand for bonds evaporated, demonstrating the reflexivity risk inherent in these designs.

These were governance token-backed algorithmic stablecoins that popularized the bonding mechanism. Key features:

• Used epochs (8-hour periods) for rebasing.
• If ESD traded above $1, holders could bond their ESD to receive new tokens in the next epoch.
• If below $1, users were incentivized to buy coupons (debt) for future redemption. The model suffered from bank run dynamics; during extended de-pegs, the growing coupon debt became unsustainable, leading to collapse.

A dual-token, burn-and-mint peg that maintained stability through arbitrage with its sister token, LUNA. Mechanism:

• To mint $1 of UST, $1 worth of LUNA was burned.
• To redeem 1 UST for $1, it was burned to mint $1 worth of LUNA. This created a death spiral in May 2022: as UST de-pegged, massive redemptions inflated LUNA's supply, crashing its price and destroying the system's collateral value, erasing over $40B in market cap.

A partial-collateral algorithmic model that collapsed in June 2021, an early warning for Terra. Its structure:

• IRON was intended to be backed 75% by USDC and 25% by its native token, TITAN.
• Redemptions allowed users to claim the USDC portion, burning TITAN.
• During a de-peg, a run on the bank occurred as users rushed to redeem, causing hyperinflation of TITAN and rendering the 25% algorithmic backing worthless.

The primary risk is a death spiral, a self-reinforcing depegging event. If the stablecoin's price falls below its peg (e.g., $0.99), the protocol's rebasing or seigniorage mechanism typically incentivizes users to burn the stablecoin to mint a more valuable governance or share token. This reduces supply but can fail to restore confidence, leading to a bank run where users exit en masse, collapsing the peg. Examples include Terra's UST depeg from $1 to near zero in May 2022, erasing tens of billions in value.

Algorithmic peg stability depends entirely on a reliable price feed oracle (e.g., Chainlink, or a decentralized exchange's time-weighted average price). An attacker who manipulates this price feed can trigger the protocol's mint/burn mechanisms based on false data. This can:

• Artificially depeg the stablecoin.
• Allow the attacker to mint unlimited stablecoins or share tokens at an incorrect price.
• Drain protocol reserves via arbitrage against the real market price.

These systems are governed by decentralized autonomous organizations (DAOs) holding governance tokens. Critical risks include:

• Governance attacks: A malicious actor acquiring enough tokens to pass proposals that alter peg mechanisms, fees, or asset controls.
• Suboptimal parameters: Incorrectly set expansion/contraction rates, fee structures, or amplification coefficients can make the system too slow to respond to volatility or too aggressive, causing instability.
• Upgrade risks: Smart contract upgrades to fix issues can introduce new bugs or be exploited if not properly audited.

Algorithmic pegs rely on rational actor assumptions and specific market behaviors that may not hold during crises. Key vulnerabilities:

• Reflexivity: The token's value is based on belief in the system itself, creating a feedback loop.
• Liquidity dependency: Requires deep, constant liquidity on decentralized exchanges (DEXs) for the peg mechanism to function. Liquidity provider (LP) flight during stress exacerbates depegging.
• Arbitrage lag: The profit incentive for arbitrageurs to restore the peg may be insufficient or too slow during extreme volatility.

Like all DeFi protocols, algorithmic stablecoins inherit smart contract risk. A bug in the core minting, burning, or bonding contract can lead to total loss of funds. Furthermore, they create systemic risk within DeFi:

• They are often used as collateral in lending protocols (e.g., UST in Anchor). A depeg causes cascading liquidations.
• They are integral to yield farming strategies. Failure triggers widespread losses across interconnected protocols.
• Their composability means a failure propagates instantly through the ecosystem.

Algorithmic stablecoins face existential regulatory risk as authorities scrutinize "unbacked" payment stablecoins. A regulatory crackdown could cripple liquidity or demand. They are also vulnerable to black swan events:

• Extreme, correlated market crashes that overwhelm the protocol's designed economic incentives.
• Flash loan attacks to manipulate governance or oracle prices in a single transaction.
• Network congestion on the underlying blockchain (high gas fees) preventing timely arbitrage or redemptions, breaking the peg mechanism.

The economic concept of profit from issuing currency, central to algorithmic stablecoin design. In crypto, it refers to the system's ability to create (mint) or destroy (burn) tokens to maintain the peg.

• Minting: New tokens are created and sold when the price is above the target, increasing supply to lower the price.
• Burning: Tokens are removed from circulation when the price is below the target, reducing supply to raise the price.

A method for maintaining a peg by proportionally adjusting the token balance in every holder's wallet. Instead of trading a secondary token, the protocol changes the supply each holder owns.

• Example: If the token is at $0.90, a rebase might increase all wallets by 11.1%, so 1,000 tokens become 1,111 tokens, aiming to restore a $1 value per token.
• Key Feature: The unit price targets $1, while the number of tokens in a wallet fluctuates.

A stablecoin backed by reserve assets, contrasting with algorithmic models. The peg is maintained by the promise of redemption, not just supply algorithms.

• Fiat-Collateralized: Backed 1:1 by bank reserves (e.g., USDC, USDT).
• Crypto-Collateralized: Over-collateralized with crypto assets (e.g., DAI, which uses a mix of collateral and algorithmic feedback).
• Key Difference: These have direct asset backing, while pure algorithmic pegs rely on future demand.

The catastrophic failure mode of an algorithmic peg, a downward reflexive cycle where loss of confidence triggers peg failure.

• Mechanism: 1) Price falls below peg. 2) The system attempts to burn supply or incentivize buying. 3) If demand doesn't respond, selling pressure increases. 4) The incentive token's value collapses, destroying the mechanism's economic foundation.
• Historical Example: The UST depeg in May 2022 demonstrated this risk, where the linked LUNA token entered hyperinflation.

A critical data feed that provides the external market price to the algorithmic protocol. The peg mechanism cannot function without accurate, tamper-resistant price data.

• Function: Continuously reports the token's current market value from decentralized exchanges (DEXs) or aggregators.
• Risk: If the oracle is manipulated or lags (stale price), the protocol will execute incorrect mint/burn actions, potentially breaking the peg.

A control loop feedback mechanism (Proportional-Integral-Derivative) used in advanced algorithmic designs to calculate the required supply change. It aims for a smooth, responsive adjustment.

• Proportional (P): Reacts to the current size of the peg deviation.
• Integral (I): Accounts for past deviations to correct steady-state error.
• Derivative (D): Predicts future error based on the rate of change, damping oscillations.
• Application: Used by protocols like Frax Finance to modulate its hybrid stablecoin minting.