Enter Platform
Resources
Back to Notebooks
Open in Colab
Crypto-Native·Staking & Yield Analysis·Intermediate

Liquid Staking Analysis

Analyze liquid staking derivative tokens including Lido stETH and Rocket Pool rETH by comparing yield rates, secondary market liquidity depth, redemption mechanisms, and historical de-peg event risks across competing liquid staking protocol providers.

cryptodefi

Liquid Staking Token Analysis — Crypto-Native

Category: Crypto-Native | Subcategory: Staking & Yield

What This Notebook Does

Liquid Staking Tokens (LSTs) represent staked ETH positions with accumulated rewards. The exchange rate between an LST and ETH increases over time as rewards accrue:

stETH/ETH rate ≈ 1.0 (rebasing model — balance increases)
wstETH/ETH rate = 1 + cumulative_apr  (accumulating model)
rETH/ETH rate   = 1 + cumulative_apr  (accumulating model)

This notebook analyses:

  1. Exchange rate evolution — how LST/ETH rates grow over time
  2. DeFi utilisation — how LSTs are used as collateral in Aave/Compound
  3. Concentration risk — Lido's dominance and systemic risk implications
  4. Depeg risk — historical depeg events and recovery speed
  5. Optimal LST selection — yield + peg stability + DeFi utility score
[1]
!pip install numpy pandas matplotlib seaborn requests --quiet
[2]
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import requests
import warnings

warnings.filterwarnings('ignore')
%matplotlib inline
plt.rcParams['figure.figsize'] = (14, 5)
print('Imports ready.')
Imports ready.

Section 1 — Configuration

This section configures the parameters for the LST simulation. It sets the SIMULATION_DAYS to define the duration of the simulation and specifies the MARKET_SHARES for various Liquid Staking Token protocols. These market share values are used to analyze concentration risk later in the notebook.

[3]
SIMULATION_DAYS = 730
# Current market share (approximate)
MARKET_SHARES = {'Lido (stETH)': 0.32, 'Rocket Pool (rETH)': 0.05,
                  'Coinbase (cbETH)': 0.11, 'Binance (wBETH)': 0.07,
                  'Other': 0.45}
print('Config ready.')
Config ready.

Section 2 — LST Exchange Rate Model

This function simulate_lst_exchange_rates simulates the growth of LST/ETH exchange rates over a specified number of days, including simulated depeg events. It generates daily exchange rates and peg spreads for wstETH, rETH, and cbETH based on their APYs, peg volatility, and a defined number of depeg events. The function returns a Pandas DataFrame containing the simulated data.

[4]
def simulate_lst_exchange_rates(n_days: int = 730, seed: int = 42) -> pd.DataFrame:
    """
    Simulate LST/ETH exchange rate growth and depeg events.

    Returns
    -------
    pd.DataFrame  Exchange rates and peg spreads for major LSTs.
    """
    rng = np.random.default_rng(seed)
    idx = pd.date_range('2023-01-01', periods=n_days, freq='D')

    lst_configs = {
        'wstETH': {'apr': 4.2, 'peg_vol': 0.002, 'depeg_events': 2},
        'rETH':   {'apr': 4.1, 'peg_vol': 0.003, 'depeg_events': 1},
        'cbETH':  {'apr': 3.9, 'peg_vol': 0.004, 'depeg_events': 1},
    }

    records = {'eth_price': 1_500 + np.cumsum(rng.normal(3, 35, n_days))}
    records['eth_price'] = np.maximum(records['eth_price'], 800)

    for name, cfg in lst_configs.items():
        daily_rate = (1 + cfg['apr'] / 100) ** (1/365) - 1
        exchange_rate = 1.0
        rates, peg_spreads = [], []
        peg_spread = np.zeros(n_days)

        # Inject depeg events
        for _ in range(cfg['depeg_events']):
            d = rng.integers(90, n_days - 60)
            peg_spread[d:d+30] += np.linspace(-0.03, 0, 30)  # depeg and recover

        for i in range(n_days):
            noise = rng.normal(0, cfg['peg_vol'])
            exchange_rate *= (1 + daily_rate + noise * 0.0001)
            rates.append(exchange_rate)
            peg_spreads.append(peg_spread[i] + rng.normal(0, cfg['peg_vol'] / 2))

        records[f'{name}_rate']  = rates
        records[f'{name}_peg']   = peg_spreads

    return pd.DataFrame(records, index=idx)


df = simulate_lst_exchange_rates(SIMULATION_DAYS)
print('Final exchange rates (relative to ETH start):')
for col in [c for c in df.columns if c.endswith('_rate')]:
    final = df[col].iloc[-1]
    gain  = (final - 1) * 100
    print(f'  {col.replace("_rate",""):10s}: {final:.4f} ETH (+{gain:.2f}%)')
Final exchange rates (relative to ETH start):
  wstETH    : 1.0858 ETH (+8.58%)
  rETH      : 1.0837 ETH (+8.37%)
  cbETH     : 1.0795 ETH (+7.95%)

Section 3 — Concentration Risk

This section analyzes the concentration risk within the Liquid Staking Token (LST) market. It visualizes the market share of major LST protocols using a pie chart, highlighting the dominance of certain providers like Lido (stETH). Additionally, it compares the cumulative APR accrued by different LSTs over time, showing their exchange rate growth against ETH. This helps in understanding the competitive landscape and potential systemic risks associated with high market concentration.

[5]
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
fig.suptitle('LST Market Analysis', fontsize=13, fontweight='bold')

# Pie chart: market share
ax1 = axes[0]
shares = list(MARKET_SHARES.values())
labels = list(MARKET_SHARES.keys())
colors = ['#1976d2','#43a047','#ff9800','#e53935','#9e9e9e']
wedges, texts, autotexts = ax1.pie(shares, labels=labels, autopct='%1.0f%%',
                                    colors=colors, startangle=140)
ax1.set_title('Staked ETH by Protocol (Market Share)')

# Exchange rate growth comparison
ax2 = axes[1]
for col in [c for c in df.columns if c.endswith('_rate')]:
    name = col.replace('_rate', '')
    ax2.plot(df.index, (df[col] - 1) * 100, lw=1.5, label=name)
ax2.set_ylabel('Cumulative APR Accrued (%)')
ax2.set_title('LST/ETH Exchange Rate Growth')
ax2.legend()

plt.tight_layout()
plt.show()
cell output

Section 4 — Depeg Risk Analysis

[6]
fig, ax = plt.subplots(figsize=(14, 4))
for col in [c for c in df.columns if c.endswith('_peg')]:
    name = col.replace('_peg', '')
    peg_pct = df[col] * 100
    ax.plot(df.index, peg_pct, lw=1, alpha=0.8, label=name)
ax.axhline(0, color='black', lw=0.8)
ax.axhline(-2, color='red', ls='--', lw=0.8, label='2% depeg threshold')
ax.set_ylabel('LST/ETH Peg Spread (%)')
ax.set_title('LST Peg Stability (Negative = Trading at Discount to ETH)')
ax.legend()
plt.tight_layout()
plt.show()
cell output

This section focuses on analyzing the depeg risk of Liquid Staking Tokens (LSTs) relative to ETH. It visualizes the LST/ETH peg spread over time for wstETH, rETH, and cbETH. The plot includes a horizontal line at 0% to indicate perfect peg and another at -2% to highlight a common depeg threshold. A negative spread indicates that the LST is trading at a discount to ETH. This analysis helps in understanding the historical stability of LST pegs and their recovery speeds after depeg events.

Section 5 — Export

This section is dedicated to exporting the processed data. The DataFrame containing all the simulated LST exchange rates, peg spreads, and other relevant information will be saved to a CSV file. This allows for further analysis or integration with other tools and dashboards outside of this notebook.

[7]
df.to_csv('liquid_staking_analysis.csv')
print('Saved: liquid_staking_analysis.csv')
Saved: liquid_staking_analysis.csv

Section 6 — Conclusion

This notebook provided a comprehensive analysis of Liquid Staking Tokens (LSTs), focusing on their exchange rate evolution, market concentration risk, and depeg risk. Through simulation, we observed how LST/ETH exchange rates grow based on their APYs and identified potential depeg events. The analysis highlighted the dominance of certain protocols like Lido and visualized the stability of LST pegs against ETH over time. This information is crucial for understanding the dynamics of the LST market and making informed decisions regarding LST selection and risk management.