The law of the core.

01The toll

Every swap in the pool pays the same toll: a published share t of its size, in the quote asset. A buy pays it on what it puts in; a sale pays it on what it takes out. The hook takes it inside the same swap, and all of it goes to the reserve, whatever the swap and whoever made it.

toll = t × size a buy: on the ETH going in a sale: on the ETH coming out t is set at deploy

02The core

The core is a price, the one the square is built around: the pool's price at the start of the second in which the square last locked, before any swap of that second. On the first day, before any lock, it is the pool's opening price.

Nobody sets it and no swap can choose it. It changes at one moment only, when the square locks (rule 05). It is kept as the pool's own square root price and compared with the pool's state before every swap, so there is no division and no rounding at the line. In this pool ETH is the first currency, so the pool's own number counts QUAD per ETH and runs the other way round: a swap is above the core when that number is at or under the core's.

03The half and the side

A swap is above the core when the pool's price before it is at or above the core, and below the core otherwise. The price is read from the pool in the hook's beforeSwap, before anything moves. Where the swap ends does not matter: a large buy that starts below the core and ends above it is a buy below.

A swap that takes QUAD out of the pool is a buy. A swap that puts QUAD in is a sale.

above: price before ≥ core below: price before < core buy: QUAD leaves the pool sale: QUAD enters the pool

04The four blocks

The side and the half name one block. The blocks are numbered the way a chart numbers its quadrants: up is above the core, right is a buy.

A swap's toll is added to its own block's count and to no other. A block is full when its count reaches the block size B, the same for all four. A full block keeps sending its tolls to the reserve, but its count stops at B, so the block that is still short stays the one everybody can see the square waiting on.

05The lock

The swap that makes the fourth block full locks the square. In that same swap, three things happen: the reserve pours into the wave, up to a ceiling of t times the pool's ETH side, and whatever is above the ceiling stays in the reserve for the next lock; the four counts go back to zero; and the core moves to the pool's price at the start of that second, before any swap of it.

Why the start of the second. If the core were the price after the locking swap, that swap would choose it by its size: a large buy that locks and sells back at once would leave the core far above the market, and the next round would wait for nothing. The price before the second began is one no swap inside that second can move; to place it, a swap would have to hold the price across the turn of the second, exposed to everyone.

The lock pays nobody. Not the swap that caused it, not the holders, not the team.

Every toll is burned at a lock. At the lock each count stands at B, so the reserve holds at least 4 × B, and more, since full blocks keep collecting. A lock moves into the wave what fits under the ceiling, less what the wave still holds; the rest waits for the next lock. Nothing leaves the reserve any other way.

reserve at a lock ≥ 4 × B the wave holds at most t × the pool's ETH side volume that fills a block ≥ B ÷ t

06The wave

The pour is burned as the wave, in slices. Each slice buys QUAD from the pool with the reserve's ETH and sends it to the dead address. There is never more than one slice per interval Δ of block.timestamp, and no slice is larger than a share σ of the pool's ETH side, so the buy behind a lock arrives as a trickle.

Why nobody can stand in front of a slice. On the pool's curve, a slice of a share σ of its ETH lifts the price by a factor (1 + σ)². Whoever buys just before it and sells just after pays the toll twice, on the way in and on the way out, a factor (1 − t)². The deployment fixes σ no larger than t, and then (1 − t)(1 + σ) is at most 1 − t², below one: the round trip loses money at every size, before gas. Worked exactly on a pool of the same shape for tolls of 0.3%, 1% and 3%, every sandwich around a slice of t of the ETH side loses, and a slice of 1.5 t feeds one, which is why no slice is ever larger than t of the pool as it stands.

Anyone can push the next slice by calling pour(). It pays nobody, the caller included; it only moves the wave along. The wave's own swaps pay no toll and count in no block.

slice ≤ σ × the pool's ETH side σ ≤ t one slice per Δ, at most Δ is read on block.timestamp pour(): anyone · pays nobody

And not the whole wave either. A lock is visible a little before it comes: three blocks full, the fourth nearly. Someone could buy then and sell after the whole wave. The ceiling of rule 05 answers it the same way: the wave never holds more than t of the pool's ETH side, so it lifts the price by at most (1 + t)², and the round trip still pays (1 − t)²: it keeps at most (1 − t²)² of its stake. If the pool shrinks while the wave pours, whatever rises above the ceiling goes back to the reserve, so the bound holds at every moment, not only at the lock. The ceiling is not a detail: without it, a 2.5 ETH pour into a pool with 30 ETH on its side would let one trader who buys ahead and sells after take about 1.3 ETH of it, half the burn.

Selling into the wave is not standing in front of it. A holder who sells while a slice buys takes the reserve's ETH for QUAD that is then burned: that is the burn reaching the market, and it pays the toll like any sale.

On Robinhood Chain, block.number inside a contract is Ethereum's block, which moves every fifteen seconds and sometimes by two. The wave reads block.timestamp, never block.number.

07A new round

Tolls paid while a wave is pouring belong to the next round: they fill its blocks around the new core and build its reserve. If the next lock comes before the wave is done, its reserve tops up what the wave has left, to the same ceiling.

08The token

$QUAD is a plain token with nothing behind it but the rule. Its whole supply is created once, at deployment, into the protocol's own position in the pool; there is no mint after that, no owner, no blacklist and no pause. Every wallet trades the same, through the same pool, under the same hook.

The position is full range, with a sum of ETH E₀ put in beside the supply by the deployer, locked with it and never coming back. A position of $QUAD alone would open at the first price and could never go below it: with the first core at that price, no swap could ever be below the core, and blocks III and IV could never fill. Full range keeps both halves open from the first swap.

The protocol's position sits in a locker that has no withdraw function, so the liquidity the pool opens with stays there for good. The team holds no allocation and takes no fee: 0%, in the token as in the toll. Any $QUAD the team holds, it will have bought in this pool, at the toll, like anyone.

The rule binds this pool. Anyone who holds $QUAD can open another pool for it without this hook and trade there without the toll; the hook refuses outside liquidity here, it cannot forbid it elsewhere. Every $QUAD was first bought here, and this site links this pool alone.

mint after deploy · none position · full range, supply + E₀ ETH owner · none blacklist, pause · none liquidity · locked for good team · 0%

09What the contracts enforce

• I1 · Every swap pays the same toll, and every toll goes to the reserve.
• I2 · A toll counts in one block only: the block of its own side and its own half.
• I3 · Nothing burns until all four blocks are full.
• I4 · The reserve leaves only through the wave, at a lock, into a burn, and nothing is paid to anyone, the caller of pour() included.
• I5 · The core is the price at the start of the last lock's second, and nothing else can move it.
• I6 · The toll, the block size, the slice, its interval and the pool's fee are constants. There is no owner and no setter, and liquidity from anyone else is refused.
• I7 · No slice is larger than σ ≤ t of the pool and the wave never holds more than t of it, so buying ahead of the burn and selling after it always loses.

Every number is fixed at deployment and published in the table below. The team keeps nothing.

10What can go wrong

• A one-way market never locks. If the crowd only buys, or only sells, three blocks can sit full for weeks while the fourth stays empty. The reserve waits. The site says which block is missing and how far it is, and never dresses the wait up as progress.
• The core can be left far behind. After a violent move every swap lands on the same side of the core, and the other half fills only when the price comes back. The square shows the distance; it does not pretend it is small.
• Someone can close the square on purpose. It costs real tolls in the missing quadrant, paid by whoever does it, and the burn belongs to every holder. It is allowed, and it is said here.
• Standing in front of the burn. A burn bought in one piece inside the swap that fired it could be front run. The wave answers that: slices no larger than σ of the pool, spaced by Δ, with σ ≤ t, so a sandwich of a slice pays more in tolls than the slice moves the price (rule 06).
• Nobody calls pour(). Then the wave waits, and the reserve waits with it, in the hook, where it can only ever leave as a burn. The hook is also built to push a slice at the end of a swap when one is due; if that does not hold up before launch, this line will say so.
• The core can still be pushed, at a price. Moving the price in an earlier second and holding it there until the lock is the one way left to place the next core. It costs tolls both ways and leaves the mover exposed to the market for as long as it holds, and it moves only where the next round is centred.
• Other pools. The rule binds this pool alone. A pool for $QUAD without this hook would trade without the toll, and nothing here can stop one being opened.
• Nobody can fix it. No owner means no key for anyone, and no way to repair a mistake: a bug in the hook stays for good, and a hook that failed would stop this pool for good. That is the price of having nobody to trust, and the reason the code has to be read by others before launch.
• The wave lifts the price above the new core. The core is set at the lock, and then the wave buys: a full wave, the toll's share of the pool's ETH, lifts the price by about twice the toll: 2% at a 1% toll. So a round usually starts above its core, and its lower blocks are the usual wait. Nothing is lost while it waits.
• Wash trading to fill a block pays the toll on both legs. It is paying to burn.
• Rounding. Tolls round up, counts round down, dust stays in the reserve.

11Parameters

The toy on the home page runs on its own numbers and says so; none of them is a figure of the protocol. Worked on them, as an example: a toll of 1%, blocks of 0.009 ETH, slices of 0.08% and a 30 ETH side. A block then fills on 0.9 ETH of trading in its own quadrant, the reserve holds at least 0.036 ETH at a lock, the wave holds at most 0.3 ETH, and a slice is at most 0.024 ETH.

12Chain and venue

• Robinhood Chain, chain id 4663 (0x1237); gas ran between 0.02 and 0.64 gwei from July to September 2026.
• Uniswap v4: the pool lives inside the PoolManager 0x8366a39CC670B4001A1121B8F6A443A643e40951, under the Quadra hook.
• Liquidity: the protocol's own position, in a locker with no withdraw function. The hook refuses liquidity from anyone else, because the rule is about how the market trades, not about who provides it.
• Explorer: robinhoodchain.blockscout.com.
• The token's and the hook's addresses are published on quadrafi.xyz at launch, nowhere else.

13Check it yourself

None of this asks to be believed. Before launch, five things have to be true, and this board says where each one stands; the home page shows the same states in one line.

At launch, every line of this page can be read on the explorer, from the addresses published here and nowhere else.

1. The token. Verified source on Blockscout. No function that mints after deployment, no owner() or one that returns the zero address, nothing that blacklists or pauses.
2. The hook. Verified source. The toll, the block size, the slice share and the interval are constants, the same as the table above, with σ ≤ t and the ceiling of a lock at t of the ETH side. Its address carries the permission flags of a hook that reads before and after a swap, returns a delta on both, and checks liquidity before it is added.
3. The pool. In the PoolManager, the pool's key has native ETH as its first currency, names this hook, and has a fee of 0, a plain 0 and not the flag of a dynamic fee (0x800000).
4. The liquidity. One position, from the lowest tick to the highest, holding the supply and E₀, held by the locker; the locker has no function that can take it out.
5. The reserve. The hook's ETH balance and its views (the four counts, the core, the wave) read the same as the app shows them.

If any line does not hold on chain, it comes off this site the same day.

14Get $QUAD

Four steps, each read live where it can be. The last one opens at launch.

1. 01

   A wallet

   Any wallet that can add a network of its own.

   NOT CONNECTED CONNECT
2. 02

   Robinhood Chain

   Chain 4663. One press adds it to the wallet and switches to it.

   NOT ADDED YET ADD ROBINHOOD CHAIN
3. 03

   ETH for gas

   Bring ETH to Robinhood Chain from wherever you keep it. Gas ran between 0.02 and 0.64 gwei from July to September 2026: a swap costs cents at most.

   READ ONCE CONNECTED
4. 04

   The swap

   ETH for $QUAD in the pool, from the address published here and nowhere else, through any interface that routes Uniswap v4. This site's own swap key opens once it quotes the pool itself.

   AT LAUNCH SWAP · NOT YET

15Questions