Parallel Relay-and-Execution Distributed Architecture designed to scale out smart contracts [email protected]

Deterministic Parallel VM
Joined January 2023
New benchmark report for Crystality-REVM — Deterministic State Parallelism now LIVE for REVM users @base, @OPLabsPBC, & @Scroll_ZKP. ⚡️Higher concurrency, near-linear scaling. Six representative Solidity contracts tested on 1–64 cores, compared against high-performance chains like Sui , Aptos , & Sei. Full report + test suites: github.com/preda-devteam/tes… — download and reproduce the benchmarks. A 🧵👇
Crystality's now live for Reth/REVM The PREDA parallel execution runtime evolves with each expansion
1
1
1
1,335
Crystality & PREDA | Parallel EVM Runtime retweeted
Parallel execution is coming to Ethereum with the next upgrade, Glamsterdam among many benefits, Block-level Acess Lists (BALs) can enable lighter-weight client experiments like below!
I started writing smart contracts in 2018, and one thing always bothered me: why did running my own RPC mean running a full node, or an archive node if I wanted historical state? My app only cared about my contracts, a few dependencies and some ERC20s. Why did I need to keep up with everything everyone else was doing on Ethereum just to serve those reads? The annoying part was keeping that smaller set of state up to date. Reading a value at one block was doable, but knowing what changed in the next block meant executing it or asking a node that had. A transaction could reach my contract through several other contracts, so just filtering transactions by their destination wasn’t enough. I mostly forgot about it. RPC providers got reliable enough for what I needed, and I had other things to build. I still didn’t love the setup, but it stopped being something I spent time thinking about. Then over the weekend, I was looking through Glamsterdam’s EIPs and realized block-level access lists might make this practical. BALs include the state changes made during a block, including the new values, and the block commits to that list. So once you have the initial state you care about, you can follow its changes without re-executing every transaction. So I started vibe coding it. It’s called skim. You tell it which accounts and storage slots you care about, or let it discover the state your simulations read. It fetches the initial values from Ethereum’s P2P network through SNAP, checks their Merkle proofs, and keeps them updated using BALs. Your eth_calls then run locally. If a call needs something it hasn’t fetched, it gets that from peers too, just with more latency. No upstream RPC provider for those reads. It can also keep historical versions of the state you’re tracking. That was another thing I wanted: being able to query my app’s past state without keeping everyone else’s history. It exposes a JSON-RPC interface, so existing tools can use it for the methods it supports. It still receives full payloads and BALs. The state it maintains is selective, not everything it downloads. There’s also a consensus light-client implementation now, but that path isn’t active on Sepolia yet because the required Gloas light-client data isn’t being served by the peers tested so far. For now, the head is still trusted. It’s still an experiment, and I’m working through correctness bugs and longer-running tests. I’m not presenting it as a production node replacement. But it’s pretty satisfying to finally build something around a complaint I’ve had since 2018. I wanted a small client that knows the parts of Ethereum my app actually uses, and that’s what I’m trying to make. github.com/leekt/skim
5
10
84
2,510
Frontier talent gathers at Frontiers. We bring RETH++, our take on the next frontier of Reth to the show xitter.cf/PREDALang/status/21085…
19
Meet RETH++ (took my cofounder 2 hrs to explain the name). Built on Reth, it brings Parallel execution within a single HOTSPOT contract Parallel state-root computation Partitioned state storage to EVM's EL
🤖 Made with AI
1
1
1
38
Using txns from the Crystality-adapted contracts, RETH++ achieves up to 8.09× block-building speedup over Reth.
🤖 Made with AI
1
5
Existing Solidity contracts run without modification alongside Crystality-adapted contracts, preserving the same transaction status, gas usage, logs, receipts, final state and state root as sequential Reth execution for the same block and initial state.
🤖 Made with AI
2
Crystality & PREDA | Parallel EVM Runtime retweeted
Glamsterdam will bring Ethereum’s biggest throughput increase since launch.
9
26
5
226
17,476
Crystality & PREDA | Parallel EVM Runtime retweeted
Gm folks it's @token2049 week and we'll be holding the following @base events at the Spago Bar and Lounge: Base Builder Meetup (8 Oct, 12pm-2pm) - luma.com/1zd3973i - connect with Global Builder Lead @saxenasaheb and his team, and learn about our global builder support programs Base Alpha (8 Oct, 3pm-6pm) - luma.com/base-nnz4 - Connect with @Nibel_eth and traders on Base, and learn about some of the initiatives and products planned for rollout in Q4 Also guest starring @jessepollak and @XenBH and other base team members! See y'all there!
32
14
4
123
15,748
Team burned through the usage limits of 5 pro accounts, shipping multiple key features in the last 2 weeks. We don’t have to spread every key feature across a few iterations, which is one of the few benefits of staying small. But we still want to be the key building blocks of infra today. Call me when the dream is over.
2
22
Crystality & PREDA | Parallel EVM Runtime retweeted
A malicious hook doesn't need a UI to scam you. 👉 It just needs to look like the best quote. After analyzing over 84,000 v4 hooks, we determined only 19% of hooks to be safe. It's time to get real about hooks.
104
117
201
903
629,312
Frontiers hey, here we come Crystality’s heading to Frontiers @paradigm for our recent work on parallelization at the block building stage with Reth. Reth, Tempo, blockchain, open source and beyond. we’re coming for them all @gakonst.
1
41
Crystality & PREDA | Parallel EVM Runtime retweeted
I don’t think base nor anyone from their internal team has endorsed this coin at all, and it’s unfair to attack them just because someone chose to launch there. May surprise many BD-slop chains, but you don’t always have to pay for activity.
Replying to @R89Capital
Base isn’t “launching the memecoin” / you don’t need CB permission or endorsement to launch a coin, there is no partnership or whatever ppl are implying AFAIK. Obviously lots of real things to criticise CB about but not sure what we did wrong here
11
13
114
9,260
Crystality & PREDA | Parallel EVM Runtime retweeted
One positive consequence of all the recent detailed thinking about transaction formats - not just 8141, also "future of state" discussions eg. UTXOs, PBT, keyed nonces, and also recursive STARK mempool - is that we have a much more explicit understanding of how transactions have "actions" and "dependencies", and we can engineer around optimizing the two separately. An action is an effect that a transaction has. A dependency is a fact about the transaction and/or the state that must be true for the transaction to be valid. eg. a signature is a dependency, a Merkle proof of a UTXO is a dependency, a ZK-SNARK (or STARK) is a dependency, a call that sends ETH is an action Dependencies can be processed in parallel. Dependencies that involve state can be reasoned about by a mempool, especially if the specific state accessed is statically declared. Dependencies that are pure (no state calling allowed) can be processed once at the mempool layer and never need to be processed again - and potentially even replaced with a STARK verifying them, allowing not just execution but also data to be elided. In principle, dependencies and actions can all be expressed as calls (if needed, calls to precompiles). This would make the transaction format itself very bare-bones and minimalist (a list of calls, flags for the type of each call eg. dependencies would be static or pure calls, and origin, nonce, etc) and allows maximum cross-compatibility even if different EVM chains have different features. In 2015-era Ethereum, thinking explicitly about these differences was not very important: execution was execution, there were few enough transactions that we could process them all serially, and single-key ECDSA accounts were good enough for everyone. Ethereum's current scaling strategy, however, requires moving beyond that paradigm. Ethereum is beloved by many developers because the execution and state model is so dynamic and flexible. But dynamic and flexible is not friendly to scaling. Fortunately, >90% of Ethereum's activity by volume does not require anything dynamic and flexible. So, we require contracts, accounts and transactions to more explicitly specify what is dynamic and flexible and what is more statically-analyzable but more restrictive, and more statically-analyzable things get the lowest gas cost and thus scale the most. Effectively, learning from the best of both the 2015-era Ethereum model and a more Bitcoin-like model (reminder: Bitcoin has had what I call account abstraction since the beginning), and making a mixture of both (really, the full spectrum between both) available, with gas costs appropriate for the level of scale involved. New state types, the recursive STARK mempool, keyed nonces, etc all go in this direction. This all relates to transaction types, because a general-purpose transaction type is a very natural interface layer on top of which all of this can be implemented, and the current thinking around the EIP-8141 transaction type is going in this exact direction that is friendly to these kinds of future generalizations. So in that sense, 8141 done well is not just a culmination of 10 years of account abstraction work, it's also preparation for the next few years of responsible decentralization-friendly hyper-scaling.
291
309
58
1,742
326,015
Robinhood is a little bit too good for Arbitrum.
1
35
Crystality extends Reth with deterministic Waves for parallel execution, delivering 3.2×–9.03× the gas throughput of standard Reth execution while remaining fully Ethereum-compatible , and, requiring no BAL. It works with no BAL today and can take full advantage of BAL when Glamsterdam drops. Crystality is built for block builders Preliminary benchmark results 👇
32
Crystality & PREDA | Parallel EVM Runtime retweeted
We also created an explorer so you can search, filter and sort the EIPs and our positions more easily. Our positions on Hegotá are our best assessments as of today, but we will update our thinking whenever new evidence from discussions or implementation work changes our view. ethlabs.org/hegota-explorer
1
3
35
2,648
Wish we work alongside you guys!
New blog post about our contribution to the core of Ethereum is out! Go check out the development status of @ethrex_client, @ethlambda_lean, and Lambda VM.
40
Latest piece on Ethereum block building brought me back to this. Killer apps drive adoption → value follows the app. App-level auctions + in-app ordering is how that value flows back to users. Insightful piece by@greenfield_cap link 👇
tldr even if ethereum becomes giga successful -- priority fees will probably not rise and may even go down a lot, and that is a good thing. if ethereum scales in both tech and adoption, base fees (i.e. the fixed fee paid by the marginal transaction for inclusion in the block) can certainly increase a lot, and there isn't really a ceiling for that. 1M txns/s paid $0.1 cent each? that's $315b in run rate revenue per year. something like that is probably Ethereum's bull case for me. but there is simply no such case for prio fees to increase a lot, and one big reason to believe they will actually continue to fall over time. for a primer, searchers and retail traders pay prio fees price to access a *specific* piece of state before other transactors. a block can have a base fee of 1 gwei, with someone paying 1m gwei to access the first slot in the block. even though ethereum's adoption and txn activity increased, prio fees have stayed relatively constant at 500-600m/year for the last 4 years. many mev experts, including me, have predicted that priority fees would likely decrease even as activity increases a lot, and the reason is that most of these conflicts should never "trickle down" to the validator to begin with. they are like free dollar bills that someone drops on the street, and if they are smart, they will simply stop dropping it. and if they are not smart, someone who is will replace their app over time. when you zoom in on what conflicts searchers are paying for priority in, its primarily two things: arbitrage and liquidations (which are itself a form of arbitrage of buying an underpriced lending market position and selling it for a profit). in both cases, the conflict used to reach the chain even though there sits someone upstream who could resolve this conflict already: e.g. a wallets running backrunning auctions on their user's orderflow (metamask, rabby, everyone), DEXs selling the first right to arbitrage (angstrom), DEXs paying to update their quotes before the first order can hit per block (propAMMs), lending markets selling the right to liquidate a position (chainlink svr + aave) - the list goes on. even though I predicted this trend of "apps taking control of their own ordering" for years, 2026 is the year when it finally reached not just wallets but DEXs and lending markets as well, at scale, and Defi is becoming much better for it. this has several consequences for ethereum: if you think that Defi is ethereum's main usecase and will be responsible for much of its future growth, this trend is amazing. it will make Defi spreads tighter and fees lower, making it ultimately more competitive against cefi and tradfi markets. second, prio fees will likely never matter again for stakers, and should not be a big part of the discussion for issuance reduction. another update that comes up occasionally is mev-burn - on the face of it, probably not worth the complexity. if you take away one thing from the thread, its that "95% of priority fees belong the apps or wallets who create them, and will flow there over time". ethereum has been benefiting from the inefficiency of the apps built on top of it for so much value to trickle down, but this trend is now in full reversal. and a future when apps make trillions of trading and lending volume per day, while paying hardly any priority fees - that future is actually very good, because it means the apps are well designed and competitive with tradfi, in spite of running on a blockchain. if Ethereum wins, it will be on the back of a small base fee that millions of actors pay, that can still accumulate to a whole lot of revenue per year.
1
36