Vitalik: Building Index-Tracking Assets Based on Options Rather Than Debt

Original article by Ethereum founderVitalik Buterin

Compiled by Odaily Planet Daily Qin Xiaofeng (@QinXiaofeng 888 )

Special thanks to Vladimir Novakovski, Curve developers, and others who provided feedback and review for this article.

Suppose you have a price index T, which represents a price index denominated in ETH. For example, T could be the USD/ETH price (i.e., the inverse of ETH/USD), or CPI/ETH (i.e., CPI/USD * USD/ETH), or the price index of any other commodity, or even more exotic indices (like the average rent in a certain city). You want to allow users to gain exposure to T.

Simply put, your goal is to create a synthetic asset tracking T within an ecosystem where only ETH is a "trustless" asset (or could be extended to other trustless assets), without relying on a centralized issuer. The only trust dependency is the oracle, which can be trust-minimized, whereas an issuer cannot.

If you consider T as the USD/ETH price, this problem is essentially the same as "algorithmic stablecoins." In reality, it is a perpetual future.

All methods attempting to provide this functionality must face a fundamental problem: the entire system can only hold ETH, and its assets and liabilities denominated in T must sum to zero. Therefore, for every user holding a positive T position, there must be another user holding an equal amount of negative T positions. What happens if T rises too high, causing negative T holders to become "insolvent"?

In traditional algorithmic stablecoins, this problem is solved through forced liquidations.

For example, suppose the ETH price is $2500, and a user holds a position (1 ETH, -2000 USD). If the ETH price drops to $2000 (in practice, triggered at a slightly higher price for a safety margin), the system must be able to "force-liquidate" the user: allow anyone else to put in $2000 and take the underlying 1 ETH, so the entire system is not left with an undercollateralized debt of $2000.

The problem with relying on liquidations is that liquidations depend on real-time oracles. You need an oracle that can provide a binding ETH/USD price value in real-time.

Real-time oracles are difficult to secure. You can only rely on a limited number of participants observing real-time signals in an automated manner. You cannot use any mechanism with recourse. You also cannot adopt the currently most effective technology to build secure and cheap oracles: placing a prediction market in front of a secure but expensive oracle, and only using the expensive oracle when significant disagreements arise.

This article proposes a paradigm-shifting approach that can make synthetic assets depend only on "slow" oracles: we completely remove the concept of liquidation and transform the system's "basic building block" from debt to options. On this basis, you can choose to build an index-tracking asset as a higher-level structure, or not do so at all, allowing users to rebalance themselves. Decoupling these two mechanisms brings greater stability and flexibility.

Synthetic Options

We define two assets: P and N.

Parameters include: (i) Ticker T, (ii) Strike price S, (iii) Maturity date M.

At any time, one can create a pair (P, N) by splitting 1 ETH. Similarly, you can merge P and N at any time to redeem 1 ETH.

At time M, the oracle is called to determine the value of T. Let this value be x. After the oracle is determined:

• P receives min(1, S / x) ETH
• N receives max(0, 1 - S / x) ETH

Note: P + N = 1. Therefore, there is no possibility of liquidation.

Additionally, for ease of understanding, here is the same chart denominated in USD:

An interesting feature of this design is that it is "effectively" a prediction market, and such prediction markets have already existed and been traded for years. See: Scalar Markets (Seer).

This means the design can share the same oracle with prediction market systems, thereby improving security.

How to Use Synthetic Options

Assume the current price is 2500, and you, as a user, want to build a portfolio with some USD exposure. You buy some (P 1500), which is a P asset with a strike price far below 2500 (here 1500). Is this enough?

Not quite. Although the current price is well above 1500, by maturity, the price could still fall below 1500. The greater this risk, the more the USD-denominated value of (P 1500) deviates from its maximum. In fact, it begins to deviate from $1 in a quadratic manner. The chart is as follows:

Note that this is just a smoothed version of the curve above. The degree of smoothing depends both on the distance of the current price from 1500 and the market's expectations of future price volatility.

To understand the principle, assume M is two weeks away, and the current price is 1499. How much is (P 1500) worth? It represents the probability that "the ETH/USD price will be above 1500 in two weeks." ETH is sometimes very volatile, so this value could be high or low, say $50. What if the current price drops to 1399? The price of P would fall but not to zero, because the price could still recover above 1500 before M arrives.

When ETH/USD is far below 1500, the value of N approaches zero. When ETH/USD is far above 1500, the value of N approaches price - 1500. In the middle region, it is a smooth curve transitioning from one mode to another.

The Black-Scholes model is a mathematical method attempting to estimate the fair pricing of (P 1500) (at least when index T represents a price, not more exotic underlyings like weather). However, since 2008, Black-Scholes has become synonymous with excessive reliance on mathematical models leading to catastrophic fragility—not without reason. Therefore, we should not be overly superstitious about the specifics of the curve, not least because we do not want to introduce another oracle to measure expected volatility, skewness, or kurtosis. 

Instead, we should remember the chart below, which is the derivative of the previous one. It tells you: at the current price level, how much ETH exposure does each unit of (P 1500) correspond to?

Remember, as the holder of (P 1500), your goal is to "hold" USD with no exposure to ETH. The strategy this chart suggests is: a safe approach is to hold deeply "in-the-money" options, and once the price approaches the strike price, roll them into options with a lower strike price.

For example, you could follow an algorithm: if the current price is X, buy P with a strike price S < X/2 and a maturity of 1-2 months from now. If the price drops below S * 1.5, roll into P with a strike price S' < X/4. Do not hold to maturity, as you would be exposed to ETH risk when the oracle determines the price.

Let speculators and market makers hold N and provide you with liquidity.

We can compare the properties of liquidation-based synthetic assets and option-based synthetic assets as follows:

In both systems, action must be taken against significant price movements: in one system, the protocol performs liquidations; in the other, users perform rebalancing. The key difference with option-based synthetic assets is that users can choose how to execute this operation.

Rebalancing can be done by a fully automated on-chain DAO (note: fully automated. All rules are set by the DAO, no voting, no AI needed). Such a DAO would be a "wrapper" around the options system, providing a "stablecoin." Alternatively, users can choose to rebalance locally using a daemon on their own device.

By shifting the decision point of "when to {liquidate/rebalance}" from on-chain tools to users, we gain two advantages:

1. Reducing users' MEV risk, as transactions are not visible in advance.
2. Eliminating reliance on a global canonical oracle. Users still need an oracle faster than (e.g.,) two weeks, but they can hide which oracle they use (e.g., a locally running agent queries dozens of financial news websites—no one knows which ones—and takes the median). This helps protect the system from oracle attacks.

The user's main choice revolves around timing and thresholds. If users rebalance frequently, they are more susceptible to counterparty short-term price fluctuations. If users rebalance conservatively, they bear more quadratic drift.

I believe that accepting moderate quadratic drift (e.g., annualized standard deviation of ~1-4%) is an underestimated strategy. This cost is indeed significant, and it is counterintuitive, making this design unusable as an "accounting stablecoin" (i.e., not allowing receivers, senders, or capital gains tax authorities to "pretend it is USD").

However, if you view it not from the perspective of "I want to simulate USD" but from "I want price stability" (i.e., being able to pay for future expenses of a known amount), it becomes much more reasonable. The annualized volatility between fiat currencies far exceeds 1-4%. The annualized volatility of expected future expenses denominated in each individual's or business's local fiat currency also far exceeds 1-4%. Furthermore, the equilibrium return of algorithmic stablecoins like RAI also frequently fluctuates by roughly comparable magnitudes.

An important decision to be made is: even if you rebalance conservatively, what is the market mechanism for rebalancing? It is very easy to lose 2% or more per year through slippage over multiple rounds, which is the biggest risk that this entire scheme could lose competitiveness.

Fortunately, users' time preferences are almost always very low. Users don't care whether they rebalance today, tomorrow, or in three days. We should leverage this to design an ideal market structure with far lower slippage than traditional automated market makers. Rebalancing will be more like single-sided market making rather than an immediate sale.