PropAMMs on Base: How Denim Changes Onchain Pricing
See how block times shape propAMM pricing on Ethereum and Base, and what Base’s Denim upgrade changes for quote freshness, execution and risk.

From Flashblocks to 200ms Blocks: What Denim Means for PropAMMs
A market moves continuously. An onchain quote doesn't. It shows up only after someone sends a transaction, the network orders it, and a block includes it. The slower that chain of events is, the longer a trader can act on a price that no longer matches the real market. For a professional automated market maker, that gap is a straight-up business risk: either you eat losses to faster traders, or you widen spreads so regular traders don't get picked off as easily.
Base's Denim upgrade changes that timing. It replaces the old two-second blocks and the flashblock preview system with full blocks every 200 milliseconds. That means propAMMs can update more often, but it also changes how makers think about quote freshness, transaction costs, and per-block protections. And the practical impact isn't just "faster blocks = better." Sequencer ordering, contract rules, and what trading services can actually observe all matter.
This article breaks down how block time affects propAMM pricing, why Ethereum makers lean on block builders to keep stale quotes under control, how Base's flashblocks worked, and what Denim changes for makers and traders.
Why block time matters for propAMM pricing
A propAMM, or proprietary automated market maker, posts a maker's trading prices onchain. Traders can take those prices directly or through aggregators and solvers, which look across routes and then submit a trade when the price they find is good. The maker isn't just updating a spreadsheet - it's publishing a quote via a transaction. That transaction has to land onchain before other participants can reliably use the new price.
A quote has an update path
First, the maker calculates a price based on its market view and risk limits. Then its systems build and submit an update transaction. The network orders it, includes it in a block, and the resulting state becomes visible to the services that route trades. In a well-tuned setup, the maker's own pricing and transaction building may take tens of milliseconds. After that, delay depends on the chain and on how the transaction gets ordered and observed.
Here's the catch: "fast pricing" doesn't automatically mean a fresh onchain quote, because the update may still be waiting to get included. And even once it's included, not every aggregator or solver sees the update at the same moment. Freshness is an end-to-end property, not something you can infer from a single "blocks per minute" number.
Stale quotes create a market-making trade-off
During the time a quote stays unchanged, the market can move. If the market moves against the maker, a faster trader can buy or sell at the old price before the maker's update takes effect. That's often called "toxic flow," because the trader is profiting off a price that's stale relative to what the market is doing - not because the maker intended to offer that price.
Makers track this with markouts: they compare what a trade filled for against the market price later, often after a minute or several minutes. If markouts are consistently negative, it can mean the maker is getting picked off - or that pricing and risk controls need adjustment.
That leads to two common approaches. A maker can widen spreads, reducing the odds of being adversely selected (at the cost of making the quote less attractive). Or it can work to improve update speed and control how much risk someone can take against an aging quote. Shorter blocks help with the second approach, but they don't stop market movement between updates.
The important distinction: block time affects how often the chain can finalize new state. It doesn't guarantee that the maker's update arrives immediately, or that every trading service learns about it instantly.
How Ethereum propAMMs manage 12-second blocks
Ethereum blocks roughly every 12 seconds. For market making, that can leave a long window where the "real" offchain market price and the onchain quote don't match. A maker could submit updates whenever its quote changes, but until a transaction is included, it doesn't protect the maker from trades against the old quote.
Builders can coordinate quote updates and trades
Ethereum's builder market gives some propAMMs another tool. Builders assemble blocks by picking and ordering transactions. A maker can send updated prices to a builder and arrange for the latest quote update to be placed before trades against that maker within the same block. As the builder constructs the block, it can keep checking for newer quote updates.
In other words, the maker is asking for sequencing guarantees inside a specific builder's block. If the builder follows through, a trade can use a fresh quote even though Ethereum's usual block interval is still long. Flashbots has proposed a shared standard for priority updates (ERC-8324), while actual implementation details still depend on individual systems and participants.
This can be useful because it reduces the pressure to put every quote update onchain as its own standalone transaction. The source material cites figures suggesting that Fermi - described there as Ethereum's largest propAMM - traded hundreds of millions of dollars in a single week using this general approach. Still, that's just an example of activity, not proof that every maker can rely on the exact same execution conditions.
The guarantee has limits
A builder arrangement isn't a network-wide rule. It only applies when the relevant builder is producing the block, and it depends on that builder honoring the setup. The source material notes that Titan - described there as Ethereum's largest builder - produced about half of builder blocks in the preceding week. So a maker relying on one builder can't assume the same ordering behavior will happen every time.
There's also an information trade-off. Builders see the maker's updates - and potentially the maker's trading flow. That might be acceptable if it buys better ordering, but it's something makers should evaluate rather than treat as "free infrastructure."
Gas also changes the math. Based on the prices cited for November 6, 2026, a typical price update cost on Ethereum was around two cents. Instead of forcing the maker to pay for every change, a builder can include an update onchain when a trade actually needs it. That can reduce update costs, but it trades some control and privacy for execution support.
How Base propAMMs used flashblocks before Denim
Base has a single sequencer (run by Base) that orders transactions by arrival time and priority fee from a private mempool. Unlike Ethereum's builder market, there isn't a comparable open builder environment where a maker can negotiate these ordering guarantees. Makers therefore had to get updates to the sequencer quickly and rely on contract-level rules to reduce risk when a quote goes stale.
Flashblocks provided earlier previews
Before Denim, Base produced a full block every two seconds and also streamed ten flashblock previews during that interval. Those previews arrived about 200 milliseconds apart. For propAMMs, that created a chance to get quote updates into the sequencer's view well before the full block was finalized.
Makers learned to time updates around those previews. For example, submitting a fresh quote near the start of a block could help position it ahead of swaps that come later in that same two-second window. The upside was faster confirmation for trades processed through the sequencer - no need to wait for the entire two-second block to finish.
But flashblocks introduced two separate "clocks." A quote confirmed in a flashblock could be usable by traders routed through the sequencer, while aggregators, solvers, or indexers that only read completed blocks might not see that quote until the full block closed. So makers effectively had to serve two audiences: the fast path that saw sequencer previews, and the broader set of services built on full-block data.
Speed and contract protections worked together
Running a propAMM on Base wasn't just about paying a bigger priority fee. A higher tip can move a transaction up in the sequencer's ordering, but it doesn't necessarily make the transaction arrive sooner. Getting the update into the sequencer early could matter more than aggressively bidding after the transaction is already sitting in the queue.
Without a builder that guarantees quote updates land ahead of trades, the smart contract had to carry some of the protection. That could mean rejecting a trade if the quote is too old, limiting how much can trade in one block, or effectively widening the spread as the quote ages. Those mechanisms don't make late updates harmless, but they can cap how much damage a stale quote causes and for how long.
The source team's experience running a Base propAMM from October - with a major market maker quoting on it - points to a practical lesson: execution speed and contract design are complementary. Updates typically landed in about a quarter of a second, while contract rules helped limit the fallout when updates were late. The takeaway is pretty simple: evaluate both parts, rather than treating "fast confirmation" as a full risk-control strategy.
What Denim changes for Base propAMMs
Base's Denim upgrade turns each 200-millisecond slot into a full block, which means five blocks per second. Flashblocks are retired, but transaction ordering stays the same. The key change is where the "fast path" quote becomes ordinary chain state: with Denim, it shows up in completed blocks at the 200-millisecond cadence, instead of only appearing as a preview.
One block cadence for trading services
Before Denim, a sequencer-confirmed flashblock and a completed block were different milestones for visibility. With Denim, the update confirmed in a 200-millisecond block is also part of the full-block data that aggregators, solvers, and indexers read. In practice, that means those services can see a maker's new price sooner than they could when they had to wait for the end of the two-second block.
That doesn't mean every service processes each block exactly 200 milliseconds after it happens. Indexing and routing delays still exist in each system. But the chain no longer forces those services to wait for the rest of a two-second interval before the update appears in completed data. The result is that the fast execution view and the full-block view align more closely.
For makers, that can improve the quality of quotes available to aggregators and solvers. If those services can observe fresher prices, they can route trades closer to the live market. That can make a propAMM more competitive without relying only on wider spreads to compensate for stale-quote risk.
More frequent blocks change risk controls
A per-block limit now applies over a 200-millisecond interval instead of a two-second interval. That gives makers a more fine-grained lever for capping how much a fast trader can take between update opportunities. The same idea holds for other per-block protections: when blocks are shorter, the system can respond to changing conditions more often.
One practical caveat: block timestamps still count whole seconds. With a 200-millisecond cadence, multiple blocks can share the same block.timestamp value. So if your contract needs to distinguish every 200-millisecond block, it can't safely treat the timestamp as a unique identifier. Makers and developers need to design quote-age checks and accounting around what the contract can actually observe - not around assumptions that timestamp precision matches block frequency.
Update cost still needs to be managed
Base transactions are cheaper than Ethereum, at least in the scenarios described by the source material. On the cited November 6, 2026 gas prices, a typical update was well under one-tenth of a cent. When updates are that cheap, it becomes practical to submit updates as market prices move, without needing a builder to coordinate every quote change.
But "cheap" doesn't mean "free." If a maker updates every block, it may pay for many updates that no one ends up trading against. Denim produces five times as many blocks per second as the old two-second cadence, so blindly updating every block could create extra activity without necessarily improving quote quality. A more sensible approach is to update when the market price or the maker's risk state changes enough to justify another transaction.
Key takeaways for makers:
- Measure quote freshness end to end: from the pricing decision to sequencer inclusion and then to what routing services actually see.
- Update when market movement or risk changes justify it, not automatically on every block.
- Use contract rules to bound exposure when a quote ages or an update gets delayed.
- Revisit per-block limits after the block interval changes; the same limit now covers a much shorter window.
- Test timestamp assumptions, since several 200-millisecond blocks can share one whole-second timestamp.
Denim doesn't turn Base into a builder-based system, and it doesn't guarantee that every update lands instantly. It changes the baseline: a maker's update can become part of a full block every 200 milliseconds, and services that read full blocks can access it sooner. Whether that translates into tighter spreads, more volume, or both depends on how makers behave, what the market is doing, how expensive transactions are in practice, and how well each integration is built.
Conclusion
Denim changes how Base propAMMs work by making 200-millisecond intervals into full blocks instead of flashblock previews. That shrinks the gap between what the sequencer confirms and what services reading completed blocks can observe. It also gives makers more frequent chances to update prices and apply per-block risk limits.
That said, it doesn't remove the need for careful execution design. Makers still have to get updates to the sequencer early, avoid paying for unnecessary transactions, handle timestamp granularity correctly, and enforce sensible limits in their contracts. The real question isn't just whether a chain has faster blocks - it's whether the full path from market price to an executable quote is fast, observable, and bounded when something goes wrong.
If you're building or evaluating a propAMM, start by measuring that path end to end. Then decide where faster updates actually improve execution enough to justify the cost - and where contract-level protections still have to do the heavy lifting.