repricing state access looks clean on a slide. @grok i'm more stuck on the contracts that already shipped and can't be upgraded if a path starts running out of gas.
one thing i think deserves more attention in ethereum’s next upgrade is the risk of changing the rules underneath applications that are already live.
@ethereum’s upcoming @GLAMSTERDAM_ETH upgrade is meant to improve how the network handles state growth and execution costs. two proposals, EIP-8037 and EIP-8038, are particularly important because they change how gas is charged for state creation and state access.
the reasoning makes sense.
as ethereum grows, storing and accessing data becomes increasingly expensive for the nodes maintaining the network. gas pricing needs to reflect those real costs if ethereum wants to increase capacity without making the network harder to operate.
but there’s another side to this.
@chain_security identified that some existing smart contracts rely on gas-related assumptions that these changes could invalidate.
the Ethereum Foundation subsequently reported four submissions identifying deployed contracts that could break under the proposed changes.
this is where things get interesting for DeFi.
→ a smart contract doesn’t need to be rewritten to become incompatible with a network upgrade.
→ protocols can have failure-handling logic, gas limits and execution assumptions that were perfectly reasonable under the old rules but behave differently under new ones.
→ for immutable contracts, fixing the problem may not even be straightforward. some developers could be forced to consider migration, while others may need changes to the protocol specifications themselves.
there’s also a bigger economic implication here.
ethereum is trying to make state growth more sustainable so it can support greater capacity over time. but that capacity is only valuable if the applications, liquidity and infrastructure built on top of it can continue operating safely.
this is why protocol upgrades should be evaluated beyond transaction throughput and cheaper execution.
developer confidence, backward compatibility and the cost of maintaining deployed applications matter just as much.
the Hoodi testnet rollout has been put on hold while the findings are reviewed. the November 16 developer meeting is expected to examine the audit reports, with further discussion scheduled for November 19.
my take:
i actually think delaying an upgrade over compatibility concerns is a positive signal, not necessarily a setback.
ethereum’s value isn’t just in being able to process more transactions. it’s also in the reliability of the financial applications people have already built around it.
scaling the network while preserving that trust is the harder problem.
and honestly, that’s the part worth watching.
do you think protocol upgrades should prioritize backward compatibility even when it means sacrificing some progress on scalability?
On Base and OP I don't treat latest like the real chain anymore. Arbitrum too.
latest there is the sequencer head. It moves constantly, which is fine if I'm just watching or checking whether a hash showed up at all. It gets messy once you already acted on that block. A receipt can come back from eth_getTransactionReceipt, logs from eth_getLogs, the balance can even look right — and then that head gets reorged. The block you stored isn't canonical anymore.
I use safe and finalized for that. safe is the head that's already been confirmed back through L1, so you're not sitting on a sequencer-only fork. finalized waits for L1 finality. I still use latest when I only care if a tx landed. If I'm about to reuse a nonce, move funds, or write a position into a database, I pin the read to safe, or I keep the block hash and check it again.
Another thing: not every public endpoint treats these tags the same. Some nodes error if they don't support them. If the call fails and you retry with latest without looking, you think you asked for safe.
I also don't mix tags in the same decision. eth_getLogs at latest and eth_getBalance at safe will give you a state that never existed on either block.
the old cancel-all coming back before the orders are actually gone would drive me crazy. I'll take the 3ms that means it's really done. @grok 412x is a fun headline, that early-return thing is what got me.
At the end of August, I said our Polymarket DeFi CLOB couldn't be saved, and we were rewriting it from scratch in Rust 🦀
Today I'm excited to announce Nex, our new exchange built from the ground up.
We've been sprinting on it since August. A Nex instance has been running in shadow mode on production traffic for the last week, side by side with the current exchange. It mirrors every order the current exchange gets, so we can measure latency, stability under load, and validate matching correctness against live production flow.
The numbers below are internal exchange timings, not e2e (those are coming soon), but we wanted to show how big the difference is.
p99 current CLOB → Nex:
- Place order: 1.55s → 3.76ms (412x faster)
- Cancel orders: 627.92ms → 3.20ms (196x faster)
- Cancel market orders: 810.16ms → 5.14ms (158x faster)
- Cancel all*:
↳ Response (current CLOB) vs complete (Nex): 35.70ms → 3.14ms (11x faster)
↳ Full cancel all: ~636ms-2.04s → 3.14ms (~200-650x faster)
p95 current CLOB → Nex:
- Place order: 341.84ms → 1.59ms (215x faster)
- Cancel orders: 78.22ms → 1.58ms (50x faster)
- Cancel market orders: 84.89ms → 2.27ms (37x faster)
- Cancel all*:
↳ Response (current CLOB) vs complete (Nex): 6.20ms → 1.58ms (4x faster)
↳ Full cancel all: ~606ms-2.01s → 1.58ms (~380-1,270x faster)
*Cancel all: the current CLOB responds immediately and cancels in the background, so when you get the response, your orders aren't cancelled yet. Nex responds only after everything is actually cancelled. Full cancel all on the current CLOB depends on how many orders you have, but it usually adds another 600ms-2s.
We also rewrote our WebSockets in Rust. This is the feed you see the market through: book changes, price moves, your fills. Fall behind it, and you're trading on old prices, and your quotes get picked off.
- Write latency p99: 44.5-88.1ms → 0.099ms (~449-889x faster)
- Slow readers/sec: 48.7-75.6 → 0.01 (~4,870-7,560x fewer, basically 0)
Scale: The current CLOB in stable state can handle 10k commands/s with 15k bursts → Nex can handle 100k commands/s with 150k bursts. 10x more, and with a few optimisations we can get to 200k commands/s with 250k bursts; with more low-level core changes, we can get to 1M commands/s over the next year. Not needed yet, but the headroom is there.
Startup time: 5 mins → 15s (20x faster)
The old CLOB had many race conditions and wasn't deterministic. Nex is deterministic by design and removes the race conditions in the old CLOB.
We also skipped some easy wins for launch to get this out faster that could make p95 and p99 another 5x faster, and we'll start work on that in Q1 next year to keep pushing these numbers down.
We wanted to build this without any breaking changes for MMs or builders; Nex has no breaking changes to requests or responses, so we just need to swap out the binary on our side and it will go live.
We want everyone to be on this journey with us, with the ability to relay feedback and test it against the existing CLOB, so we've opened a Nex Sandbox. Fill out the form and test it yourself: docs.polymarket.com/nex
We'll run 4 weeks of shadow mode on production traffic to make sure everything is perfect, then if everything is good, we will go live mid-December. We can roll out WebSocket improvements without the full exchange, so we may do that sooner.
We've been rebuilding every system around the exchange for months, and we've seen huge benefits, but the exchange is the heart of Polymarket DeFi. Nex fixes most of the pain traders have had.
Really proud of the team on this one.
Make Polymarket fast, finally. It's coming.
A security patch changes the risk for everyone who has not installed it yet
The distinction in this research is important: recovering a vulnerability from a binary is not the same as building a working exploit. The strongest tested agent did both on a subset of the benchmark, and standard hardening reduced success in a follow up test. Those results do not tell us how often production systems will be compromised
For DeFi infrastructure, the useful question is how long critical dependencies remain exposed after a fix becomes public. RPC providers, validator clients, wallet backends and bridge operators all have different deployment constraints
A practical response is to inventory those dependencies, rehearse emergency updates and prepare temporary controls for components that cannot be patched immediately. Faster analysis must be matched by faster, verifiable rollout
Ethereum RPC pricing in 2026 — packs vs CU vs credits, archive + WSS called out.
Unlike some L2s there's no single official public endpoint; you pick a provider when you need history or subscriptions. @grokblockreq.com/blog/en/best-et…