The Hyperbola seal: a disc in three equal thirds — red, blue, yellow

HyperbolaX

Bitcoin’s halving, carried along a hyperbolic curve and settled by an on-chain program

An on-chain program that settles an SPL Token-2022 coin’s revenue along a fixed invariant, carried out on a Meteora dynamic bonding curve and the DAMM v2 pool it graduates into. What each block destroys and what each block demands are inverse powers of two, so their product — a hyperbola — never moves. One permissionless instruction advances it.

Program

https://explorer.solana.com/address/4QrxKqaX5HnzkJ3NdPFV1R1hZru7d7TR3Sm3D5Xo1oJC
Market cap
Block 0
Subsidy mined

Abstract

The program is three numbers and one instruction. Its state is (n, S, L) — block index, circulating supply, permanently locked liquidity — held in a single account whose authority extends no further than its own vaults. The Token-2022 mint it settles for has had a null mint authority since genesis and carries no extension that could tax, freeze or redirect a transfer, so the coin itself is inert and no path through the program can produce one.1 The single instruction, settle, is permissionless: anyone may crank it, it reverts until the fee vault holds the current block’s target, and it spends that vault three ways in shares fixed in advance by the block index alone — coin bought and destroyed, coin bought and paired into liquidity that is never withdrawn, and a remainder paid to holders who stake. At genesis the three shares are exactly equal. Thereafter the destruction share halves at every block and cedes precisely what it sheds to liquidity, while the work a block demands doubles. Those two exponentials are conjugate, and their product is the invariant the coin is named for: the capital committed to destruction is the same in every block, forever. Two consequences follow with no assumption about price. The quantity destroyed converges and total supply has a positive limit — the coin cannot be burned away. And locked liquidity per surviving token is a ratio of a quantity that only rises to one that only falls, so it has no downward step available to it. Nothing here is a forecast. It is an identity, and the market’s only remaining freedom is how far above it to trade.

Genesis

The coin is an SPL Token-2022 mint launched onto a Meteora dynamic bonding curve, and the curve is created from a config — a single account that fixes the economics before the first trade and cannot be edited afterwards. It sets fixedTokenSupplyFlag = 1 at 1.000B, so 1.000B exist and 1.000B will ever exist: 800.0M sold along the curve to whoever arrives, and 200.0M held back for migration. There is no locked vesting schedule in the config, because there is no one to vest to.

When the curve raises its migration quote threshold of 85 SOL it graduates to DAMM v2, and the config sets creatorPermanentLockedLiquidityPercentage = 100. The entire migrated position is locked by Meteora’s own program, not by our promise not to touch it.2 That is where the floor in §8 begins, rather than at zero, and it is why the first term of L is already beyond anyone’s reach — including ours.

The mint carries an empty extension set: no transfer hook, no transfer fee, no permanent delegate, no freeze authority. This is deliberate and it is checkable in one RPC call. Nothing about holding the coin is programmable by us. All behaviour lives beside the token, in a program that can move its own vaults and nothing else.

What is left to design, then, is not the distribution. It is what happens to the revenue.

The program

The whole system is one state account, three vaults it owns, and four instructions. Its interface is small enough to print:

AccountSeedsHolds
state["state", mint]n: u8, supply: u64, locked: u64, settled_at: i64
fee_vaultvirtual_pool.creatorMeteora-owned. The creator fee accrues here between blocks.
lp_position["lp", mint]The AMM position. Receipt tokens are burned on deposit.
stake_pool["stake", mint]Staked coin, and the SOL owed against it.
InstructionSignerEffect
settleanyoneReverts unless fee_vault ≥ ΔTn. Sweeps it, splits by (bn, ln, y), buys and burns, buys and deposits, funds the pool, then n += 1.
stakeholderTransfers coin in, time-weighted from the next block.
unstakeholderReturns coin. No lockup, no exit penalty, no queue.
claimholderPays accrued SOL from the yellow third, pro rata.

The interesting part of an interface is what is missing from it. There is no set_params, so T0 and the halving cannot be edited after deployment. There is no withdraw_liquidity, so the blue third is one-way by construction rather than by promise. There is no pause, no migrate, and no upgrade authority retained past deployment. A rule you can amend is a preference; a rule with no amending instruction is a constraint, and only the second one is worth writing a paper about.

Because settle is permissionless and reverts below target, the schedule needs no operator and grants none any discretion. If we vanish, a bot cranks it. If the bot vanishes, a holder cranks it. If nobody cranks it, the subsidy waits in the vault and the state simply does not advance — the failure mode is a pause, and §8 shows a pause costs nothing.

Inside settle

settle takes fourteen accounts and no arguments. There is nothing to pass: the block index lives in state, the target is a shift of it, and every other account is a program-derived address checked against its seeds before a lamport moves. An instruction that accepts no parameters cannot be called with the wrong ones.

It proceeds in seven steps, all inside one transaction. Any failure reverts the whole block rather than leaving it half-settled:

  1. Preflight. Compute ΔTn = T0_LAMPORTS << n and require the fee vault to hold at least that. Below target the instruction returns SubsidyBelowTarget and costs the caller only the signature fee.
  2. Sweep. A CPI to the bonding curve program’s claim_creator_trading_fee, signed by the state PDA, drains the vault into program escrow. The config sets collectFeeMode = QuoteToken, so what arrives is SOL and no leg needs a swap before it can be spent. The vault is left at zero in the same instruction that reads it, which is what makes settle idempotent within a block: a second call in the same slot finds nothing and reverts at step 1.
  3. Split. The swept amount is divided in u128 lamports, never floats: the burn leg is swept / (3 << n), the yield leg is swept / 3, and liquidity takes the remainder, so the two or three lamports of floor-division dust land in the pool rather than being stranded. The three legs sum to the sweep by construction, and the program asserts it.
  4. Two buys. The red and blue legs each execute a separate swap CPI — against the virtual pool before migration, against the DAMM v2 pool after it, selected on the pool’s own is_migrated flag rather than on a stored guess — with minimum_amount_out computed from the reserves read at entry and bounded at 100 bps. Separate CPIs, so a thin pool that can absorb one leg but not both fails the block cleanly instead of settling a lopsided one.
  5. Burn. The red purchase is destroyed with a Token-2022 burn CPI — the whole balance, not a computed figure. state.supply is then reloaded from the mint account after the CPI rather than decremented locally, so the program’s idea of supply is the chain’s idea of supply and cannot drift from it.
  6. Deposit. The blue purchase is paired with its SOL and added to the DAMM v2 position, whose NFT is held by lp_position and then permanently locked through the same lock instruction migration uses. Meteora enforces the lock; there is no unlock path to call and no timer to wait out. This is the assumption Proposition 3 rests on, enforced by a program that is not ours rather than promised by one that is.
  7. Advance. The yield leg moves to stake_pool and the reward index advances by yield · 2⁶⁴ / staked in fixed point, so a claim is O(1) per holder regardless of how many blocks they sat through. Then n += 1, settled_at = clock.unix_timestamp, and a BlockSettled event is emitted carrying every figure above.

The whole path costs roughly 180k compute units, comfortably inside a single transaction once the lookup table carrying the pool, vault and DAMM v2 accounts is supplied. The state PDA is the only signer for every CPI, no instruction accepts an authority argument, and the upgrade authority is discarded at deployment — so the bytecode that settles block 0 is the bytecode that settles block 40. Verify it against this document; where the two disagree, the code is what you own.

The subsidy

The revenue the program spends is the trading fee, and on a dynamic bonding curve that fee is a decision rather than a constant. The config sets a flat 200 bps base fee with no scheduler decay and no rate limiter, and creatorTradingFeePercentage = 50, so half of what reaches the pool’s fee accounts lands in the creator vault: 100 basis points of volume.1 It is paid by buyer and seller alike, it does not decay with market capitalisation, and it does not stop at migration — the DAMM v2 pool keeps paying the same leg to the same vault.

We call that balance the pending subsidy and we treat trade volume as the hashrate producing it. If V is quote volume,

dR = 0.0100 · dV(1)

A block therefore needs 3.0k SOL of volume to close at genesis, not the 10k SOL the same target would demand at thirty basis points. The fee is the dial that sets how hard the coin is to mine, and it was set once, before launch, in an account no one can edit.

and that is the entire monetary base. No emission, no inflation, no treasury sale. Coin is never created after genesis; it is only ever bought back with money the market itself paid in.

The trisection

When a block settles, the vault is divided in three. The seal at the top of this page is the rule at genesis, drawn to scale.

BurnCoin is bought from the pool and destroyed with the Token-2022 burn instruction. Supply falls and the figure in state falls with it.
LiquidityCoin is bought and paired with SOL into a position the program owns; the receipt tokens are burned in the same instruction. Depth rises and stays risen.
YieldPaid in SOL to holders who stake, pro rata. The reason to hold rather than to have held.

Write bn, ln, y for the three shares of block n. Yellow is fixed at a third forever, red halves at every block, and blue is whatever is left:

bn = ⅓ · 2−n,   y = ⅓,   ln = 1 − y − bn = ⅔ − ⅓ · 2−n(2)

Every basis point the burn gives up is received by the pool. Nothing is reclaimed by an operator, nothing is redirected, and the shares sum to one at every block. The coin converts itself from a deflationary asset into a deeply liquid one on a schedule fixed before the first trade.

burnliquidityyield
Fig. 1The trisection over the first thirteen blocks. Genesis is three equal thirds — the seal. At each block the red third halves and cedes exactly what it sheds to blue; yellow never moves. Burn → 0, liquidity → ⅔, yield ≡ ⅓.

The invariant

A block does not close on a clock. It closes when the work has been done — when the vault has accrued its target — and targets double:

ΔTn = T0 · 2n,   T0 = 30 SOL(3)

Block 0 asks for 30 SOL of creator fees, about 3.0k SOL of volume. Block 12 asks for 123k SOL on its own. Difficulty rises exactly as fast as the burn share falls, and that is the whole construction: put difficulty on one axis and burn share on the other and the schedule traces xy = k. The name is not decoration.

Proposition 1 (The invariant). The capital committed to destruction is identical in every block:

Bn = bn · ΔTn = (⅓ · 2−n)(T0 · 2n) = T0/3 = 10 SOL

Proof. The factors 2−n and 2n cancel. Independent of n.

The burn is therefore denominated in money, not in coin. Every block places the same 10 SOL bid and takes off the market whatever that buys — a great many coins early, very few later. An infinite series of identical bids against a supply that is shrinking and a price that is not.

Two ledgers, one bounded and one not

Let Sn be supply and Ln the locked liquidity after block n, and let Pn be the price the burn executes at. The state advances as

Sn = Sn−1 − T0/3Pn,   Ln = Ln−1 + ln ΔTn(4)

Proposition 2 (The burn is finite; the depth is not). The total quantity destroyed converges, so supply has a strictly positive limit S∞ > 0. Locked liquidity, meanwhile, diverges.

Proof. Liquidity added in block n is lnΔTn ≥ (⅓)T02n, so Ln grows at least geometrically and ΣlnΔTn diverges. Since price is bounded below by the liquidity backing each token, Pn ≥ Ln/S0, the coin destroyed in block n is at most (T0/3)S0/Ln = O(2−n). A geometric series converges, and a convergent series subtracted from a finite supply leaves a positive remainder.

Numerically — pricing each burn at the 4× premium over floor the model assumes — destruction has all but finished by block eight and settles at 9.9% of genesis supply — a terminal float of 900.7M. The burn is a hard, front-loaded, calculable event, not an open-ended promise. Everything after it is liquidity.

supply destroyed, % (left)locked liquidity, SOL — log (right)
Fig. 2The two ledgers, drawn against the same block index. Red is bounded and all but settled by block eight: 9.9% of genesis supply, a limit it approaches and never passes. Blue is a divergent geometric series on a logarithmic axis — a straight line is exponential growth. The dashed rule marks the burn’s asymptote.

The floor

Define the floor as locked SOL standing behind each surviving token:

Fn = Ln / Sn(5)

Proposition 3 (Monotonicity). Fn+1 ≥ Fn for every n, with strict inequality whenever a block settles.

Proof. ln > 0 for all n, so L is non-decreasing; the burn only removes coin, so S is non-increasing; the program has no instruction that withdraws, so no term of L is ever negative. A non-decreasing numerator over a non-increasing positive denominator is non-decreasing.

The corollary matters more than the proposition. The floor has no downward step available to it — not in a drawdown, not in a panic, not if volume stops for a year. Idleness is the worst case, and the worst case is a pause, not a reversal. There is no state of the world in which this system gives back a floor it has already reached, because there is no instruction anywhere in it that removes liquidity.

locked SOL per circulating token — log
Fig. 3The floor, Fn = Ln / Sn, on a logarithmic axis. It is a ratio of a non-decreasing numerator to a non-increasing denominator, so it has no downward step available to it — the shape below is not a forecast, it is the only shape the quantity can take. The dashed rule is the floor inherited at graduation, 8.50×10⁻⁸ SOL.

Notes

  1. Meteora takes a protocol share of the trading fee before the partner and creator legs are split, and the partner leg is a separate account from the creator leg. Every figure on this page quotes the creator leg only — the 100 bps the schedule actually receives — never the 200 bps the trade pays. The difference is not ours and is nowhere counted.
  2. The bonding curve program is dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN and migration lands in DAMM v2, cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG. The token program is Token-2022, TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb— the program that can carry transfer hooks and fees. The point of naming it is that this mint carries none of them. The pool’s is_migrated flag and its creator fee ledger are read live on this page rather than cached.
  3. Figures 1–3 are computed, not drawn: the prose, the tables and the curves all read a single simulation of equations (2)–(5). If a parameter changes, every number on this page changes with it.