Restaking Rebasing LSTs vs. Restaking Non-Rebasing LSTs

Automatic yield compounding: Your token balance increases in-wallet, reflecting accrued staking rewards. This matters for simplicity and direct yield visibility, as users don't need to manually claim or reinvest. Ideal for protocols like Aave or Compound where a growing collateral balance can improve health factors.

Price-appreciation model: The token's price increases relative to the underlying asset (e.g., ETH), while your balance stays constant. This matters for DeFi composability, as it's compatible with all ERC-20 integrations (like Uniswap V3 concentrated liquidity) without special handling for balance changes.

Integration overhead: DApps and smart contracts must account for balance changes on every transfer, requiring special logic (like balanceOf snapshots). This matters for protocol architects building complex systems (e.g., perpetuals on GMX forks) where predictable state is critical.

Indirect yield tracking: Users must monitor the exchange rate (e.g., wstETH:ETH) to calculate accrued rewards, not their token balance. This matters for treasury managers and accountants who prefer the straightforward ledger entries provided by rebasing tokens.

• End-user simplicity: Holding in a wallet or basic savings app.
• Collateral in lending markets where increasing balance auto-reduces risk.
• Protocols that natively support rebasing (e.g., some Curve pools, Aave).

• Maximizing DeFi composability: Using in any standard AMM, yield vault (like Yearn), or as collateral in MakerDAO.
• Building complex smart contracts that require stable token balances.
• Ecosystems where it's the standard (e.g., wstETH in the broader L2 and Arbitrum DeFi landscape).

Direct yield accrual: The token balance in your wallet increases daily, providing a clear, on-chain signal of staking rewards. This simplifies portfolio tracking for users and protocols that need to verify real-time yield generation. This matters for user-facing dashboards and accounting systems that prioritize transparency.

Eliminates price oracle reliance: Since 1 stETH always represents 1 staked ETH + accrued rewards, DeFi integrations don't require complex price feeds to calculate underlying value. This reduces integration overhead and smart contract risk. This matters for rapid protocol development and minimizing oracle failure points.

Stable token balance: The token amount is fixed, while its value relative to the underlying asset appreciates. This prevents collateral value from automatically increasing within lending protocols, which can create unsafe leverage cycles. This matters for risk-averse money markets like Aave and Compound where stable debt positions are critical.

ERC-20 compliance: Non-rebasing tokens behave like standard assets, making them compatible with all DeFi legos without special handling for balance changes. Rebasing tokens can break approvals and cause integrations with yield-bearing vaults (like Yearn) to fail. This matters for maximizing DeFi strategy flexibility and cross-protocol interoperability.

Higher baseline gas fees: Daily balance updates require frequent state changes, leading to marginally higher gas costs for simple transfers compared to static-balance tokens. For users making frequent small transactions, this can add up. This matters for high-frequency traders and applications optimizing for L2 fee minimization.

Introduces price feed dependency: To determine the underlying value (e.g., rETH/ETH rate), protocols must trust oracles like Chainlink. This adds a centralization vector and smart contract risk. A stale or manipulated oracle could misprice collateral. This matters for protocols designing for maximum censorship resistance and minimizing external dependencies.

Token balance remains static: Your principal amount (e.g., 1 wstETH) doesn't change, while its value in underlying ETH increases. This simplifies smart contract logic for yield tracking, as there's no need to handle balance rebasing events. This matters for protocols building on top (like lending markets or structured products) that require stable token balances for collateral calculations.

Seamless DeFi integration: Wrapped tokens like wstETH are the standard for liquidity pools (e.g., Curve, Balancer) and money markets (e.g., Aave). Their static balance design prevents integration issues common with rebasing tokens. This matters for maximizing capital efficiency by using your restaked position as collateral elsewhere without complex adapters.

Yield is auto-compounded in-wallet: Your token balance (e.g., stETH) increases daily, providing a clear, visual representation of accrued rewards without manual claims. This matters for end-users and stakers who prioritize simplicity and want to see their rewards accumulating directly in their wallet balance.

Direct compatibility with issuer ecosystems: Using stETH natively on Lido's platform (e.g., for simple staking/unstaking) is more straightforward. Some protocols, like Aave V3, have built-in support for rebasing stETH as collateral. This matters if your primary use case is interacting directly with the LST issuer's native suite of products.