22 min

The thirty-year-old machine

An ETF keeps its price honest through participants who create and redeem shares against the underlying basket, and the mint-and-burn machine is that same mechanism with a fixed one-dollar promise instead of a floating value, which turns tracking error into crisis.

Where you are. You have built a peg, watched it hold and watched it break twice. This lesson steps back and points out that you have been building something the fund industry has run since 1993, and that nothing in the mechanism is new. What is new is the promise it points at.

An exchange-traded fund holds a basket of assets and its shares trade on an exchange all day. The shares can trade at any price the market likes, and the basket is worth what it is worth. Nothing forces the two together.

Except that a short list of vetted institutions can hand the fund a basket and receive new shares, or hand back shares and receive the basket. So when the shares trade above the basket, those firms buy the basket, create shares and sell them; when the shares trade below, they buy shares, redeem them for the basket and sell that.

You have read this paragraph before. It was lesson 7, with different nouns.

The idea in one paragraph

The creation and redemption machine is the same in both worlds: a vetted set of firms with a contractual right to exchange the wrapper for the underlying at a known value, who profit from closing any gap between the two. What differs is what the machine points at. An ETF points at a value that moves all day, so a gap between price and value is a routine tracking error that nobody outside the fund’s operations team notices. A stablecoin points at a fixed one dollar, so the identical gap is a failure of the product’s only promise. Same mechanism, same participants, same arbitrage; a number that floats in one and is nailed down in the other.

the ETF machine the stablecoin machine authorised participant authorised dealer create and redeem baskets mint and burn net asset value, floating one dollar, fixed tracking error, routine a depeg, a crisis the same machine, and only the last row differs
The four parts of the ETF creation and redemption machine mapped one to one onto the parts of a stablecoin issuer

Wider than the screen; scroll it sideways.

The one row that differs

The exercise runs the same convergence loop three times.

An ETF trading at 102 against a value of 100 converges to 100. A token trading at 0.97 against its fixed promise converges to 1. And then the case that makes the point: an ETF trading at 102 whose underlying value itself falls to 96 converges neatly to 96, and that is not a failure of anything. The fund tracked its holdings down. Its holders lost money because the assets lost value, which is what holding assets means.

image/svg+xml Matplotlib v3.11.1, https://matplotlib.org/ 100 101 102 103 ETF and NAV net asset value ETF price 0 10 20 30 40 50 60 day −0.5 0.0 0.5 1.0 tracking error, percent routine here; against a fixed one-dollar promise the identical wobble is a depeg
An ETF price following a moving net asset value, with the resulting tracking error below

There is no equivalent of that third run for a stablecoin. A token whose target moved from 1.00 to 0.96 has not tracked anything down; it has broken the only promise it made.

Why a fixed target is harder

Two reasons, and both follow directly from the previous lessons.

A floating target absorbs shocks. If the fund’s holdings fall in value, the target falls with them and the machine keeps working normally. A fixed target absorbs nothing: any shortfall in the backing shows up immediately as a gap the machine cannot close, because closing it would mean paying out more than the assets are worth.

And a fixed target invites a run in a way a floating one does not. Nobody rushes to redeem an ETF because its value fell; the value is the value, and redeeming realises exactly the same loss as selling. A token promising a dollar rewards whoever redeems first, because the first redemptions are paid at par out of the most liquid assets. That is the money market fund problem, and lesson 16 puts the two side by side properly.

Check yourself

1. Describe the ETF’s create-and-redeem machine, and name its stablecoin equivalent.

A vetted set of firms may hand the fund a basket of assets and receive new shares, or return shares and receive the basket, so any gap between the share price and the value of the holdings is a profitable trade. The stablecoin equivalent is mint and burn with authorised dealers, and the two are the same mechanism.

2. An ETF’s value falls from 100 to 96 and its price follows. Why is that not a failure?

Because the fund promises to be worth what it holds, and it is. Its holders lost money because the assets lost value, which is what holding assets means. The machine did exactly its job by keeping the price on the value the whole way down.

3. What does the thirty-year history of ETFs actually establish, and what does it not?

It establishes that the create-and-redeem mechanism works, through several crises and a great deal of scrutiny. It does not establish that a fixed promise works, because ETFs have never made one. The machine is proven; the target it has been pointed at is the untested part.

4. Why does a fixed target invite a run when a floating one does not?

Because redeeming first is rewarded. Early redemptions are paid at par out of the most liquid assets, so whoever is slow gets whatever is left. With a floating target there is no advantage to being first, since redeeming realises the same value as selling. That asymmetry is the money market fund problem.

Do this

Run the same loop at both targets.

python3 code/etf_machine.py

The starter leaves you creation_redemption: one step of the participant’s action, which moves the price a fraction of the way towards the target and reports whether the profitable move was to create or to redeem. The assertions check that an ETF converges on its value, that a token converges on par, and that an ETF whose value falls tracks it down without anything having gone wrong.

The completed version is in solutions/etf_machine.py.

What you can now do. You can map the stablecoin machine onto the ETF machine part by part, explain why one produces routine tracking error and the other a crisis, and say precisely which part of the thirty-year track record transfers. The next lesson turns to a competing design that puts the token on a bank’s balance sheet instead.

What you can now do

You can run the same convergence loop against a floating target and a fixed one and say why only the second produces a crisis.