Rebase Function

In a rebase token system, the total supply is expanded or contracted at regular intervals, often daily. This process is executed by a smart contract function, commonly named rebase(), which recalculates the balance of every holder's wallet. The key principle is that while the number of tokens in a wallet changes, the holder's percentage ownership of the total supply and the dollar value of their holdings relative to the target price remain constant. This is distinct from a traditional stablecoin like USDC, which maintains a fixed supply and a 1:1 reserve backing.

The rebase function operates by comparing the token's current market price to its intended price target, such as $1.00. If the price is above the target, the contract initiates a positive rebase, minting new tokens and distributing them proportionally to all holders, effectively increasing the total supply. Conversely, if the price is below the target, a negative rebase (or contraction) occurs, burning tokens from each wallet to reduce the supply. This elastic supply mechanism is designed to create arbitrage incentives that push the market price toward the peg.

A canonical example of this mechanism is Ampleforth (AMPL), which targets the 2019 US Dollar Consumer Price Index. Its rebase function executes once every 24 hours based on oracle-reported price data. The function's logic can be represented in simplified form as: newSupply = oldSupply * (priceOracle / targetPrice). This calculation determines the new total supply, and every wallet balance is multiplied by this same rebase coefficient. It's crucial to understand that rebase adjustments are not transactions; they are state updates recorded directly on the blockchain, which means they do not incur gas fees for users but do generate an event log.

For developers and integrators, rebase tokens present unique challenges. Exchanges, wallets, and DeFi protocols must listen for the Rebase event and update their internal accounting accordingly. A holder's balance can change between two block queries, so applications should use the token's balanceOfUnderlying or similar functions to get a rebase-adjusted value. Furthermore, the elastic supply can complicate liquidity provision in automated market makers (AMMs) like Uniswap, as the pool's token reserves are also subject to rebase, affecting the constant product formula k = x * y.

The rebase model is often contrasted with seigniorage or algorithmic stablecoin designs that use a multi-token system (e.g., governance and share tokens) to absorb volatility. In a pure rebase system, the elasticity is applied directly to the single circulating token. While designed for stability, rebase tokens can experience significant volatility in their market price during periods of high demand or sell pressure, as the supply adjustment mechanism operates with a time lag, typically of 24 hours.

A rebase function is a smart contract mechanism that algorithmically adjusts the total supply of a token in all holders' wallets to maintain a target price peg, typically to another asset like the US dollar. Unlike stablecoins that use collateral reserves or algorithmic minting/burning, a rebase achieves price stability by proportionally increasing or decreasing the number of tokens each holder possesses. This process, often called an elastic supply adjustment, occurs periodically (e.g., every 8 hours) based on the deviation of the token's market price from its target value. The key principle is that while the number of tokens in a wallet changes, the holder's percentage share of the total supply—and thus their share of the network's value—remains constant.

The function's logic is triggered by an oracle price feed. When the market price (P_market) is above the target peg (P_target), the contract calculates a positive rebase, increasing the total supply. Conversely, if P_market is below P_target, it executes a negative rebase, decreasing the supply. The adjustment is calculated as a rebase ratio: newSupply = oldSupply * (P_target / P_market). This ratio is then applied to every wallet and liquidity pool balance. For example, if the target is $1.00 and the market price is $1.20, a positive rebase would increase all balances by 20% to bring the per-token value back down toward the peg. Critically, this happens automatically and programmatically without requiring user interaction.

Implementing a rebase requires careful smart contract design to handle state changes across the entire ecosystem. The function must interact with key components like the token's balance mapping, decentralized exchange (DEX) liquidity pools, and staking contracts to ensure synchronized supply updates. A major technical challenge is ensuring composability—other DeFi protocols must be aware of the rebasing nature of the token to account for balance changes. Furthermore, negative rebases (supply contractions) can be psychologically challenging for users, as they see their token quantity decrease, even though the goal is to preserve the dollar value of their holdings. This distinguishes rebase tokens from more familiar fixed-supply assets.

A rebase function is a smart contract method that algorithmically adjusts the total token supply to maintain a target price peg, typically by proportionally increasing or decreasing the balance of every holder's wallet. This function is the core mechanism behind rebase tokens or elastic supply tokens. The logic is triggered periodically or by an oracle price feed, calculating a rebase ratio based on the deviation between the current market price and the target price. This ratio is then applied to the totalSupply and to each address's balance in the contract's internal accounting, leaving the holder's percentage of the total supply unchanged.

The core calculation involves determining a supply delta. For example, if the target price is $1.00 and the current price is $1.10, the contract needs to increase the supply to dilute the price downward. The delta might be calculated as (currentPrice - targetPrice) / targetPrice, resulting in a 10% positive delta. The new total supply becomes oldSupply * (1 + delta). Crucially, the function does not mint or burn tokens in the traditional sense for existing holders; instead, it updates the _balances mapping for every address by the same multiplier, a process often abstracted from users who see their token quantity change in their wallet while their portfolio's USD value relative to the peg remains stable.

A simplified Solidity code snippet illustrates the state update logic:

solidityCopy
function rebase(uint256 supplyDelta) external onlyOwner {
    uint256 oldTotalSupply = totalSupply;
    uint256 newTotalSupply;
    if (supplyDelta > 0) {
        newTotalSupply = oldTotalSupply + (oldTotalSupply * supplyDelta) / 1e18;
    } else {
        newTotalSupply = oldTotalSupply - (oldTotalSupply * (-supplyDelta)) / 1e18;
    }
    totalSupply = newTotalSupply;
    _gonsPerFragment = TOTAL_GONS / newTotalSupply;
    emit LogRebase(oldTotalSupply, newTotalSupply);
}

This example shows the adjustment of the global totalSupply and a key internal variable _gonsPerFragment, which is used to scale individual balances. The actual balance adjustment for a user is derived by dividing their stored gons balance by the new _gonsPerFragment.

Critical considerations in rebase logic include handling the precision of calculations with high decimal places (often using 1e18 for fixed-point math), ensuring the function is permissioned (e.g., onlyOwner or via an oracle) to prevent manipulation, and managing snapshotting for protocols that need historical data. Developers must also account for interactions with decentralized exchanges (DEXs); a rebase does not automatically adjust liquidity pool reserves, which can create arbitrage opportunities. This disconnect between the token's internal accounting and its DEX representation is a fundamental characteristic of the rebase design pattern.

Understanding this code-level logic is essential for developers integrating rebase tokens, as standard ERC-20 balance queries may not reflect the post-rebase amount until a state-changing transaction (like a transfer) triggers a recalculation. Analysts auditing such contracts must verify the rebase math is free of over/underflow errors and that the delta calculation is resistant to oracle manipulation. This transparent, algorithmic approach to supply elasticity contrasts with centralized stablecoins, offering a unique, if complex, tool for decentralized finance (DeFi) monetary policy.