Bitcoin Stock-to-Flow Model Chart and Predictions

Introduction and scope of the report

This article explains how the stock-to-flow (S2F) model is built for Bitcoin, how it performs historically, and what its strengths and limits are. I keep the math simple and show practical steps for data cleaning, model construction, calibration, and testing.

This is not investment advice. The goal is to explain concepts, methods, and reasonable ways to test the model so you can form your own view.

Bitcoin supply mechanics and halving schedule

Bitcoin supply grows when miners add new blocks and receive the block reward. Key facts:

• Genesis (2009) started with a 50 BTC block reward.
• Rewards halve every 210,000 blocks (about every 4 years). Past reward steps: 50 → 25 → 12.5 → 6.25 → 3.125 BTC.
• Block time averages ~10 minutes, so ~144 blocks/day or ~52,560 blocks/year (use 365.25 days for higher accuracy).
• “Stock” = cumulative supply of BTC in circulation at a point in time.
• “Flow” = newly minted BTC per year (annual new supply). After each halving, flow is roughly cut in half.

Because halvings are predictable and built into the protocol, Bitcoin’s supply inflation rate declines in discrete steps.

Concept and mathematics of the stock-to-flow model

Stock-to-flow (S2F) measures scarcity:

• S2F = stock / flow

Intuition: Higher S2F means more existing units relative to new supply, i.e., greater scarcity.

The S2F model for price usually assumes a power-law relationship between price and S2F. That is commonly written in log-linear form:

• log(price) = a + b * log(S2F) + ε

where a and b are parameters fit by regression, and ε is the residual (error).

Why log-log? It stabilizes variance, makes multiplicative relationships linear, and often fits asset prices better than a raw linear fit.

Note: “price” can mean market price (USD close) or realized price; use consistent definitions.

Data sources, cleaning, and preprocessing

Recommended data sources

• On-chain supply and block reward: Blockchain.com, CoinMetrics, Glassnode.
• Historical price: CoinGecko, CoinMarketCap, CryptoCompare, or exchange data (e.g., Coinbase, Bitstamp).
• Block counts and reward schedule: Bitcoin blockchain via a node or public aggregators.

Cleaning steps

• Align timestamps: use daily resolution (UTC) or monthly if you need smoother signals.
• Missing data: forward-fill short gaps; drop long gaps or source alternate feeds.
• Units: ensure price in USD and supply in BTC (not satoshis), or convert consistently.
• Outliers: check for exchange-specific spikes (use multiple sources or median price across exchanges).
• Time windows: include entire history but be aware of structural breaks (early illiquid years).

Computing stock and flow

• Stock(t) = cumulative BTC supply at time t (on-chain).
• Flow(t) ≈ block_reward(t) * blocks_per_year. Use blocks_per_year = 144 * 365 = 52,560 (or 365.25 basis).
• For daily S2F, compute flow based on current block reward, then S2F(t) = Stock(t) / Flow(t).

Log transforms

• Compute ln_price = ln(price) and ln_s2f = ln(S2F) for regression.

Constructing the S2F model for Bitcoin

Steps to construct

1. Load cleaned daily data: date, BTC_supply, price_usd, block_reward.
2. Compute Flow = block_reward * 52560 (annualized).
3. Compute S2F = BTC_supply / Flow.
4. Compute log transforms: ln_price, ln_s2f.
5. Fit linear regression: ln_price ~ 1 + ln_s2f.

Simple Python pseudocode

• Use pandas to load time series.
• Use numpy.log for transforms.
• Fit with statsmodels.api.OLS or scikit-learn LinearRegression.

Example (conceptual)

• X = ln_s2f values (with constant)
• y = ln_price
• model = OLS(y, X_const).fit()
• Extract parameters a, b, R^2

Model choices

• Fit using full history or split into training and testing windows.
• Consider rolling-window fits to test parameter stability.
• Test heteroskedasticity and autocorrelation in residuals.

Charting the S2F ratio against historical price

What to chart

• Time series chart with price (log scale) and S2F (secondary axis).
• Scatter plot of ln(S2F) vs ln(price) with regression line.
• Residual plot: fitted ln_price minus actual ln_price over time.

How to read charts

• If ln(price) and ln(S2F) align closely along a line, the log-log fit captures a lot of variance.
• Look for periods where price deviates strongly (large residuals) — these are times other factors dominated price.
• Use vertical markers for halving dates to see structural shifts.

Practical tips

• Use log-scale for price charts to display long-term growth and cycles clearly.
• Smooth S2F with a 7- or 30-day average only if noisy early data misleads visual interpretation.

Model calibration, statistical fit, and metrics

Common calibration approach

• Ordinary least squares (OLS) on ln(price) vs ln(S2F).

Key metrics to report

• R-squared: proportion of variance explained in ln(price). High R^2 suggests good fit but can be misleading with non-stationary series.
• Coefficients a (intercept) and b (slope): b is elasticity — percent change in price for a percent change in S2F.
• Standard errors and p-values: test parameter significance.
• RMSE or MAE on ln(price): average prediction error on log scale.
• Out-of-sample MAE/RMSE: fit on training, evaluate on holdout to check overfitting.

Diagnostics

• Residual autocorrelation (Durbin-Watson) — time series residuals often autocorrelated.
• Heteroskedasticity tests (Breusch-Pagan).
• Stability tests: fit parameters across subperiods or rolling windows.

Interpreting fit

• Strong fit on log-log does not prove causation.
• Bitcoin history has a few clear regime shifts (halvings). Small number of regime changes can lead to overconfident fits.

Historical backtesting and performance analysis

How to backtest

• Fit model on data up to a date (e.g., right before a halving).
• Forecast forward and compare predicted ln(price) to actual ln(price).
• Repeat across multiple points to obtain out-of-sample error distribution.

What backtests typically show

• S2F aligns with long-run price trends across multi-year cycles.
• The model often underestimates short-term volatility — price can overshoot or undershoot for months.
• Some bull runs coincided with rising S2F after halvings, suggesting supply-side scarcity matters.

Common backtesting pitfalls

• Using the whole history to fit parameters and then claiming predictive power without out-of-sample testing.
• Small sample of halvings: only a few structural shifts make robust inference difficult.
• Survivorship bias and data-snooping: choosing modeling choices after seeing outcomes can overstate reliability.

Criticisms, limitations, and confounding factors

Major criticisms

• Correlation vs causation: S2F captures supply-side scarcity, but price is also driven by demand, macro factors, and investor sentiment.
• Small sample size: only a handful of halvings produce distinct regimes to fit.
• Spurious regression risk: price and S2F are trending series, which can inflate correlation measures.
• Anticipation: halvings are known in advance; markets may price them earlier, reducing causal impact at the halving moment.
• Ignoring demand-side variables: adoption, regulation, macro liquidity, and exchange flows matter.
• Structural shifts: derivatives, institutional adoption, ETFs, and market microstructure can change price dynamics.

Technical limitations

• Residuals often show autocorrelation and changing variance — violating OLS assumptions.
• Parameter instability: elasticity b may shift over time.
• Model assumes scarcity is the main long-run driver; that may not remain true as the market matures.

Alternative models and complementary indicators

Models to consider alongside S2F

• Metcalfe’s Law: price ∝ (network size)^2; uses active addresses or users.
• NVT (Network Value to Transactions): price vs on-chain transaction volume.
• Realized Price / Realized Cap: measures based on UTXO ages and realized value.
• MVRV and on-chain investor metrics: measure potential selling pressure.
• Macro and risk-on indicators: equities, rates, liquidity, inflation expectations.
• Derivatives-implied metrics: options skew and futures open interest.

Why combine models

• Scarcity is only one input. Combining on-chain activity, macro conditions, and liquidity measures gives a fuller picture.
• Multivariate models reduce omitted-variable bias and can improve predictive stability.

Scenario-based price predictions and timelines

Framing scenarios

I present three illustrative scenarios based on S2F influence plus plausible demand outcomes. These are hypothetical and not investment advice.

1. Conservative (S2F matters moderately)

• Assumption: S2F remains positively correlated with price, but demand growth is slow.
• Implication: Price gradually increases over years post-halving. Volatility continues. Long-term upside limited compared to bullish cases.

2. Baseline (S2F is a dominant long-run driver)

• Assumption: S2F elasticity stays similar to historical fits and demand grows steadily.
• Implication: Multi-year S2F-driven appreciation after halvings, with cyclical overshoots during speculative phases.

3. Bullish (S2F plus accelerating adoption)

• Assumption: Scarcity plus strong institutional and retail demand amplify effects.
• Implication: Larger and faster price advances post-halving; higher likelihood of new nominal highs within a 12–36 month window after halving.

How to convert S2F to price ranges (method)

• Fit ln(price) = a + b*ln(S2F) on historical data.
• For a future time t, compute projected S2F(t) using scheduled block rewards and projected stock.
• Use forecast ln_price(t) = a + b*ln(S2F(t)) and exponentiate.
• Add uncertainty bands by using historical residual standard deviation to build confidence intervals.

Important caveats

• Small changes in assumed elasticity or residual variance create wide price ranges.
• Non-S2F shocks (regulation, liquidity events) can move price far outside scenario bands.

Risk assessment, conclusions, and directions for further research

Risk assessment

• Model risk: S2F may lose explanatory power as market structure changes.
• Data risk: inaccurate or inconsistent data sources bias estimates.
• External shocks: policy changes, security events, or macro crises can override S2F effects.
• Over-reliance on scarcity: ignoring demand dynamics leads to blind spots.

Conclusions

• S2F is a clear, simple measure of Bitcoin’s supply-side scarcity.
• The log-log S2F model can explain large parts of historical multi-year price trends, but it is not a complete causal model.
• Use S2F as one tool among several — especially for long-term framing, not short-term trading.

Directions for further research

• Multivariate cointegration testing: combine S2F with demand-side variables and test for stable long-run relationships.
• Rolling-window and regime-switching models: check parameter stability across cycles.
• Bayesian updating: allow model parameters to evolve as new data arrive.
• Monte Carlo stress tests: simulate price under shocks to supply, demand, and liquidity.
• Use on-chain microstructure: analyze miner selling pressure, exchange inflows, and realized capitalization.

Final note

If you want, I can:

• Provide a clean Python notebook template to compute S2F, fit the regression, and produce charts.
• Run a simple calibration on a chosen data source and return the fit stats and plots (you provide data or allow me to fetch public feeds).