Anatomy of a Fill: PropAMMs on Ethereum

Authors: @santidipaolo, @jpinasco, @agustinpolfinance (POL Finance)

On Uniswap, the first trade of a block is often an arbitrageur hitting a price up to 12 seconds old, and liquidity providers pay for it. PropAMMs on Ethereum avoid this by having the market maker stream prices to block builders, at the cost of trusting those builders to keep their word on ordering. This post follows one trade through that system, second by second.

Highlights

  • AMM vs propAMM. On a classic AMM the price only moves when someone trades, so arbitrageurs pick off stale prices and liquidity providers pay. On a propAMM one market maker streams new prices to the builders, the companies that assemble Ethereum blocks, and they write the latest price into the block right before your trade.
  • Your trade fills at a current price. What you see when you sign is an estimate. The price you get is the maker’s latest update, written into the block. In one swap we traced, that update was signed 0.8 s after the block’s slot started. A late update still gets in because builders keep bidding for a block for a second or more into its slot. The trade had been built almost 10 s earlier; that includes the user’s time to sign, so the mechanism itself is faster. Through the LambdaClass router, a trade goes to the best offer standing when the block is built. A direct trade is protected only by its minimum-output limit.
  • The maker finds out late. The maker learns it was filled only when it sees the block, a median 1.23 s after it signed its price, against milliseconds on a centralized exchange. Until then it cannot hedge. That gap is what the spread pays for: the shorter it gets, the tighter the maker can quote.

What a propAMM is

A propAMM (proprietary AMM) is an on-chain pool whose liquidity and price belong to a single market maker. The maker rewrites the price whenever it wants, hundreds of times per Ethereum block (LambdaClass). To the trader, the taker, it looks like any AMM: call a contract, get tokens. To the maker it works like an order book: it quotes a bid and an ask around its own fair value, instead of along a reserve curve.

PropAMMs went live on Ethereum mainnet in May 2026. In the week of 14–20 September 2026 the two largest, Fermi and Metric, traded 280M and 178M USD: together 7.6% of Uniswap’s 6.0B USD that week. ethresear.ch puts propAMMs at 5–10% of mainnet swap volume, and at ~40% of volume across the largest venues on Solana, where the model started (ethresear.ch).


Figure 1. ethresear.ch 26129, week of 14–20 Sep 2026

Two designs it is easy to confuse it with:

  • A curve AMM (Uniswap) prices from the pool’s reserves, so the price changes only when someone trades. A propAMM’s price changes when the maker decides, using the maker’s own closed-source model.
  • An RFQ (Hashflow, 0x RFQ) has the taker request a signed quote by API and carry it inside its own transaction. On a propAMM the price sits in the contract, and the taker executes against whatever it says when the transaction runs.

On Ethereum the line between the two is blurrier than on Solana, and that is what this post is about.

Why it started on Solana, and what breaks on Ethereum

A propAMM works only if the maker’s price update runs before an arbitrageur can trade against the old price.

On Solana the chain gives that for free. Blocks come every ~400 ms (a slot). A price update costs ~500–700 compute units (CU, Solana’s measure of execution cost) against ≥17,000 for a swap (arXiv 2609.38056), and the leader orders transactions by fee per CU. The maker pays little, lands first, and can update many times per second.


Figure 2. arXiv 2609.38056

On Ethereum that breaks for three reasons (ethresear.ch 25543):

  1. Slots are 12 s. By the end of a slot, any price set at its start is stale.
  2. Every update pays the network’s base fee, whether anyone trades or not.
  3. Block builders choose the order. Ethereum blocks are assembled by specialised companies, the builders, that bid for the right to build each block through MEV-Boost; the validator who proposes the block (the proposer) takes the highest bid. A builder could drop the maker’s update and sell the arbitrage against the old price.

The fix moved the guarantee to the builders. Titan published a propAMM API, later adopted by Quasar, BuilderNet and Bombora (ethresear.ch). The maker streams signed updates to them instead of sending transactions (Titan docs). Each builder keeps only the latest update per pool, writes it into the block immediately before the first trade against that pool, and skips it if nobody trades. That ordering is a promise by four companies, enforced by nothing in the protocol. Proposals to standardise it exist, such as ERC-8324, but none is live.

Layer 2s are a different case. Base produces 200 ms sub-blocks (Flashblocks) ordered by fee (Base docs), so the Solana approach roughly works there. This post is about Ethereum L1.

One trade, step by step

Five parties take part: the maker, the taker, an aggregator that finds the taker a price, the builder, and the proposer. The price the taker gets is the last update the maker sent the builder before the trade; what was on-chain when the taker signed plays no part.


Figure 3. One Ethereum slot · illustrative timing; rule from ethresear.ch 26129 and Titan docs

  1. Before anyone trades. The maker reads exchange prices, runs its pricing model, signs a price update and streams it to Titan, Quasar, BuilderNet and Bombora, hundreds of times per block, one every few tens of milliseconds (PropAMM Factory). None of it touches the chain yet.
  2. Quote. The taker’s wallet or aggregator asks for a price. The pool’s on-chain price is stale, so the aggregator simulates the trade against a preview the builder publishes: the pool as it would look with the latest update (LambdaClass).
  3. Sign and send. The taker signs an ordinary transaction with a minimum output, minOut: if the trade would return less, it reverts. The transaction goes privately to the builders and skips the public mempool, where everyone could see it (Bombora docs).
  4. Wait for a block. A new block comes every 12 s, so a trade that makes the next one waits up to 12 s, ~6 s on average. One that misses it waits for the following block. Meanwhile the maker keeps repricing, and the builder matches the trade only against an update at least 50 ms newer than the trade itself.
  5. Block building. The builder writes the maker’s latest update immediately before the first trade against that pool; later trades in the same block use the same update. A trade sent through the LambdaClass PropAMM Router is requoted at this point against every propAMM, goes to the best offer, and falls back to Uniswap v3 if none beats minOut.
  6. Inclusion. The block is proposed at the start of the next slot and reaches most of the network 1.5–2 s later. Titan built 44% of blocks in the period that A. Fuller’s memo covers, and carried 69% of propAMM trades (data memo).
  7. Settlement. Tokens move inside the swap itself. The block becomes final two epochs later: 2 × 32 slots × 12 s, ~12.8 minutes.

Here is one real trade against El Zorro, the propAMM run by Zonda Markets.


Figure 4. Swap 0x395370f11681ae554d7308bd93be60ad8530a638727e617e75ac5b73fea04ed7 · El Zorro on-chain data

The fill is at a current price. The swap was built at 07:50:14 UTC; we read that from the transaction’s own deadline (method in the appendix). Its block’s slot started 9 s later, and the update it executed against was signed 0.8 s after that. The user signs after the transaction is built, and the chain does not record when, so part of those 9 s is the user reading the wallet pop-up and the mechanism itself took less than 9 s. What the user saw at signing was an estimate; the price came from an update signed at execution.

What stops the maker from showing one price and filling at a worse one depends on the route. Through the LambdaClass router, the trade goes to the best offer standing when the block is built. A direct trade to one propAMM is protected only by its minOut, which caps the loss at the trader’s slippage tolerance but does not guarantee the best price inside it.

Figure 5 shows the same three timestamps for every swap against El Zorro in one day, labelled by the wallet or app that created the trade. Orders that settle through CoW wait for its batch auction, and take longer. Each line starts when the transaction was built, before the user signed, so it overstates how long the mechanism itself takes.


Figure 5. El Zorro on-chain data, 14–15 Oct 2026; origins from on-chain markers (integrator strings, CoW appData, smart-account factories)

When the maker finds out, and why that sets the spread

The block is proposed at the start of the next slot, but nobody sees it at that moment. The proposer keeps collecting builder bids for up to ~1 s, sometimes longer, and the median node receives the block 1.5–2.1 s into the slot (ethPandaOps, 50,318 blocks). No builder sends the maker a fill notification, so the maker learns of its trade only when the block reaches its own node.


Figure 6. beaconcha.in (winning-bid categories, 950 ms timeout), ethPandaOps (50,318 blocks, 25 Apr–2 May 2026), Bombora docs; maker lane: El Zorro medians

El Zorro measured this over 24 hours of mainnet (14–15 October 2026, 404 WETH trades). Its quote was signed a median 0.76 s into the slot, and its node saw the block 1.23 s after the signature; for the slowest 10% of trades it took 2.18 s or more. For those ~1.2 s the maker holds a position it does not know about and cannot hedge it on an exchange. The taker is in the same spot on the other side: it cannot act on its new tokens until the block is visible.

That window is what the spread pays for. The maker quotes wide enough to cover how far the market can move before it hedges. Price moves grow roughly with the square root of elapsed time, so a shorter window lets the maker quote tighter for the same risk. In El Zorro’s data, Binance moved by more than its half-spread (0.90 bps; one basis point, bps, is 0.01%) during the window in 16% of trades; a 2 bps half-spread would have covered all but ~5%. Every part of the window that goes away is spread that can go back to traders: a later signature, faster block propagation, or a fill signal from the builder the moment the proposer picks its block. The relay that passes the block to the proposer knows the winner before the network does, but no builder offers that signal today.

Whether the trade lands is less of a question. Trades go privately to Titan, Quasar, BuilderNet and Bombora, so a trade usually lands in the next block. The residual risk is a slot won by a builder without the API; Titan alone built 44% of blocks in the memo’s period, and we have not measured the four together.

Why the stale-price problem goes away

Compare the same trade on Uniswap. The wallet simulates the swap against the pool’s current reserves, the user signs with a slippage limit, and the swap runs against whatever the pool holds when the block is built. If the output falls below the limit the swap reverts, and the user still pays gas.

The price at the top of each block is whatever the last trade left. When ETH moves on Binance, the pool stays at the old price until an arbitrageur trades it back, and that arbitrageur pays the builder to go first. The liquidity providers’ loss to these trades is called LVR, loss-versus-rebalancing (Milionis et al. 2022). Two more costs come with the design: a swap sent to the public mempool can be sandwiched, with a searcher buying just before and selling just after inside the user’s slippage limit, and the fee is fixed per pool tier (1, 5, 30 or 100 bps on v3) whoever is trading.


Figure 7. Illustrative path, no data; LVR as in Milionis et al. (2022)

On a propAMM the builder matches a trade only against an update at least 50 ms newer than the trade (ethresear.ch; Titan calls it freshness protection and lets the threshold be configured). The taker gets a price computed after it sent its transaction, and the maker is never stuck with the previous block’s price. The 12-second-old price that arbitrageurs pick off on Uniswap does not exist; what remains is the ~1 s window from the previous section. LambdaClass puts the consequence directly: “Because makers no longer carry the risk of stale prices, they can tighten spreads and improve their quotes” (LambdaClass).

A fresh price cuts both ways: if the market moves against the taker in the meantime, the taker gets the worse price, as with a market order on an exchange. It is still not a “last look”, where the maker sees an order and decides whether to fill it. The maker never sees the trade; the builder does the pairing.

The same trade on a centralized exchange

On a centralized exchange (CEX) the trade is an internal event. The taker sends a market order; the exchange checks the balance it already holds in custody, matches the order against its book in microseconds to ~1 ms, and confirms in milliseconds. Settlement is a database entry; nothing moves on-chain until the user withdraws, hours or days later. The maker’s orders sit in the book at a known place in the queue, so the race is to get there first and cancel fast. The trade is final the moment the matching engine writes it, and the risk is the exchange itself.

The clock, side by side

On time to fill, an Ethereum propAMM is about four orders of magnitude (~10,000×) slower than a CEX (12 s against ~1 ms) and 30× slower than Solana. On the age of the price it executes against, the gap is much smaller: in El Zorro’s data the update was signed ~0.6 s before the builder sealed the block (median).


Figure 8. ethresear.ch 26129 (Solana, Ethereum slots), Base docs (Flashblocks), Ethereum finality = 2 epochs × 32 slots × 12 s; CEX range is a third-party estimate

There are two clocks. The slot clock, 12 s, sets when the trade settles. The quote clock sets how old the price is: ~0.6 s when the block is sealed, ~1.2 s when the maker sees it. On Uniswap the two are the same clock, so a slow block means a stale price; a propAMM separates them, and that is what lets it work at Ethereum’s block time. The quote clock is also the one the spread pays for.

CEX Uniswap propAMM (Ethereum)
Where the price lives The exchange’s order book Pool reserves (curve) Contract, rewritten by the maker
Who sets the order of trades Matching engine, price-time Builder, for its own profit Builder, update before trade
Age of the price at fill Microseconds Up to 12 s Signed after the trade arrives
Time to fill Microseconds to ms Next block (12 s) or later Next block (12 s) or later
Maker learns of the fill Milliseconds Not applicable (passive pool) ~1.2 s after its quote (median)
What you trust The exchange Nothing on ordering Builders to honour the rule

In numbers

Sources here are a single-author memo or interested parties.

Metric Value Source
ETH/USDC full spread (ask − bid) around the maker’s own mid, smallest size, single snapshot 1 Sep 2026 0.86 bps (Metric) to 4.20 bps (bopAMM); Fermi 2.34 bps A. Fuller memo
Capital turnover per day Fermi ~23× its 5.4M USD of liquidity; Uniswap v3 on the same pairs 0.6× its 319M USD. Memo’s own period: with the September volume above, Fermi’s would be ~7× A. Fuller memo
Gas, price update vs swap (measured on Base) ~27–33K vs 200–400K arXiv
LambdaClass Router flow ~13M USD across ~1,000 swaps per day (22 Sep 2026) LambdaClass

The turnover row is the business model: the maker does not park liquidity in the pool, it refills from its exchange inventory, so a few million dollars of capital carry volume of the same order as Uniswap’s pools on those pairs.

The trade-off

The underlying difference is who controls the order between the maker’s price and the trade: the matching engine on a CEX, nobody on Uniswap, the builder on an Ethereum propAMM. The propAMM gives the maker back its ability to react, and shrinks its exposure from a 12-second-old price to the ~1 second until it sees the block. The cost is an intermediary back in the ordering: four private builders that promise to write the update first, with nothing in the protocol enforcing it.

Appendix: for builders and market makers

A1. The slot boundary, step by step

  1. End of slot N: last updates and takes. Each maker update is valid for a single block, the next one (Bombora docs). A take is eligible only against a quote received more than the freshness buffer after it: taker_received_at + freshness_buffer < quote_received_at, using only the builder’s own receive timestamps.
  2. t = 0: getHeader. The proposer of slot N+1 asks the relays for the best header. The MEV-Boost default timeout is 950 ms, under a hard limit of ~1 s (beaconcha.in). Until the winning bid is committed, builders keep re-bidding, and Titan re-evaluates candidates on every quote update (Titan docs).
  3. 0 to 3.5 s: winning bid committed. beaconcha.in classifies the time from slot start to the committed winning bid as on-time (≤ 1,200 ms), timing games (1,201–2,600 ms) or aggressive (> 2,600 ms). Proposers who wait collect higher bids.
  4. Sign, getPayload, broadcast. The proposer signs the blinded header, calls getPayload, and the relay publishes the block. No per-step latency is published. The relay knows which bid won at getPayload, before anyone else sees the block.
  5. ~1.5–2.1 s: the network sees the block. The median node sees it 104 ms (9 KB block) to 348 ms (238 KB) after first sighting, p99 427–1,248 ms; from slot start, the median is 1,505–2,122 ms (ethPandaOps).
  6. t = 4 s: attestation deadline. Attesters vote with or without the block. Proposing at ~3–3.5 s already costs ~10% wrong-head votes (ethresear.ch 20272, Jul–Aug 2024).
  7. The maker learns of the fill. Neither Titan nor Bombora documents a fill notification; Bombora’s ACK only confirms the update was forwarded, and stale or reverting quotes are dropped silently. PropAMM Factory runs per-block landing checks (LambdaClass). In El Zorro’s 24 h sample its node saw the block a median 1.99 s into slot N+1 (p10 1.62 s, p90 3.41 s) and its pusher ~160 ms later. Blocks arrive in two regimes, around 1.7–1.8 s and 3.2–3.4 s; when the block is sealed late the builder takes a later signature, so the quote’s age stays the same.
  8. Rebalance. The maker hedges on a CEX in milliseconds or tops up on-chain inventory. No public source measures maker hedging latency. On Base, Tessera refills from opposite on-chain flow without hedging (arXiv).

A2. How fresh in practice

El Zorro, 24 h of mainnet, 14–15 Oct 2026, 404 WETH inclusions. The included quote was signed a median 0.76 s after the slot started. The builder sealed ~0.61 s after the signature (an upper bound, from Titan’s public stream). El Zorro’s node saw the block 1.23 s after the signature (p10 0.84 s, p90 2.18 s). Titan, BuilderNet and Quasar give the same distribution, and nothing is included younger than 0.5 s.

Over that window ETHUSDT on Binance moved a median 0.04 bps and 1.72 bps at p90, against a published half-spread of 0.90 bps (median). The move exceeded the half-spread in 16% of inclusions; a 2 bps half-spread would cut that to ~5%. Stablecoin pairs are a separate population: the quote is re-signed only when the price moves, so a median age of 6.9 s costs nothing.

A3. How a maker implements it: El Zorro

El Zorro runs on PropAMM Factory, LambdaClass’s open-source kit:

  • a quote updater reads exchange feeds, runs a pricing model per pair, signs updates and streams them to builders, repricing “throughout the block”;
  • pricing models range from a fixed price to exchange prices with spreads that widen with volatility and inventory;
  • the propAMM contract reads the price from a Priority Update Registry and fills the trade;
  • operations: landing checks, circuit breakers, alerts, and a Postgres record of every published quote.

A4. How we time a transaction

The chain does not record when a transaction was built or signed. Wallets and aggregators set a swap’s deadline to the moment they build it plus a round time-to-live (TTL): 600, 1,200, 1,800 or 3,600 s. Taking the round value just above deadline − block time recovers the TTL, and deadline − TTL gives when the transaction was built. Bot flow drops out, because bots do not set the deadline that way. That leaves 39 WETH swaps: 24 direct and 15 CoW orders, whose time also includes CoW’s batch auction. The deadline is set before the wallet asks the user to sign, so any time measured from it includes the user’s signing time and is an upper bound on the mechanism’s own latency.

A5. Full comparison

CEX AMM (Uniswap v3/v4) propAMM (Ethereum L1) RFQ (Hashflow, 0x RFQ)
Where the price lives Matching engine’s book Pool reserves (curve) Contract state, rewritten by the maker Off-chain signed quote
Who moves it Maker, at will Only trades Maker, streamed to the builder Maker, on request
Who orders Matching engine, price-time Builder, for its own profit Builder, update-before-take rule Taker carries the quote in its tx
Age of the price at fill µs Up to 12 s (last trade) ≥ 50 ms newer than the take Up to quote expiry
Time to fill ~1 ms Next slot (12 s) or later Next slot (12 s) or later Next slot (12 s) or later
Maker learns of the fill Milliseconds Not applicable (passive LP) ~1.2 s after its quote (median) When the block is visible
Maker’s adverse selection Cancel race LVR to the arbitrageur Window between update and take Quote validity window
Custody The exchange On-chain, taker On-chain, taker On-chain, taker
Settlement Internal ledger, immediate Atomic on-chain Atomic on-chain Atomic on-chain
Trust assumption Exchange solvency None on ordering Builder honours the rule None on ordering

Sources