Research
Empirical Analysis of TEE-Enabled Rollup Designs
Head-to-head measurement of TEE-based proposer-builder-separation sequencer designs, giving engineers concrete throughput and trust trade-offs before committing to one.

- arXiv
- 2610.24284
- Published
- 2026-10-16
- Authors
- Claudiu-Nicu Bărbieru, Corentin Libert, Peterson Yuhala, Andrei Arusoaie, Matthieu Bettinger, Oana-Otilia Captarencu, Pascal Felber, Emanuel Onica, Etienne Rivière, Valerio Schiavoni
AI summary
Overview
Research area: Computer security and blockchain systems — specifically Layer-2 (L2) Ethereum rollups, proposer–builder separation (PBS), and hardware trusted execution environments (TEEs).
Technical level: Intermediate. Readers should know roughly what an Ethereum rollup and a sequencer are; the paper explains TEEs and PBS from the ground up, but the evaluation details assume familiarity with blockchain benchmarking and systems metrics.
Scope (one sentence): The paper is an empirical measurement study comparing four rollup sequencer configurations — monolithic vs. PBS-based, each with and without a VM-level TEE — on transaction time to inclusion, CPU usage, and RAM usage.
What This Paper Is About
Rollups are Ethereum's main scaling solution, but most are run by a single centralized sequencer that could censor transactions or reorder them to extract MEV. Deployed systems such as Rollup Boost have started splitting the sequencer into a proposer and a separate block builder, and the builder can run inside a TEE so that clients can cryptographically verify it follows the stated ordering rules. The paper's goal is to measure, rather than theorize, what these TEE and PBS choices actually cost in performance and how they affect resource consumption.
Key Contributions
-
First experimental comparison of TEE-enabled rollup designs with and without PBS. The authors state that prior work proposed theoretical frameworks and TEE-based sequencer designs, but no thorough experimental evaluation of VM-level TEEs integrated into production-style PBS rollups existed.
-
A reproducible evaluation environment spanning four designs plus two builder implementations. They adapt Flashbots' Builder Playground for Kubernetes and measure
noPBS-noTEE,noPBS-TEE,PBS-noTEE, andPBS-TEE, each evaluated with bothop-gethand (for PBS)op-rbuilderas the builder. -
Separated attribution of overhead to TEEs versus PBS. Rather than reporting one combined number, the study isolates how much CPU cost comes from TEE cryptography and how much comes from the extra network communication PBS introduces.
-
A practical discussion of TEE integration issues — choice of TEE type, trusted computing base (TCB) reduction via unikernels or LibOS designs such as Gramine-TDX, and application-level attestation using the Linux Integrity Measurement Architecture (IMA), which boot-time TDX attestation alone does not cover.
Main Findings
-
TEEs barely affect time to inclusion (TTI). With the same builder implementation, the distribution of transaction time to inclusion was near-identical across non-PBS and PBS variants, with or without TEEs, for both ERC-20 and Uniswap workloads. The authors attribute this to block building being predominantly CPU-intensive, so the TEE's context-switch and I/O overheads rarely apply.
-
PBS unlocks faster builders, and that matters more than TEEs. When
op-rbuilderwas the external builder, TTI was twice as fast as PBS setups usingop-geth. The authors credit implementation differences:op-rbuilderis a lightweight Rust builder of roughly 14K lines of code, whereasop-gethis a Go system of roughly 352K lines of code that also performs block validation. -
TEEs cost roughly 17% and 25% more CPU. At 210 TPS with ERC-20 load,
noPBS-TEEused about 16.7% more CPU thannoPBS-noTEE, andPBS-TEEused approximately 25.3% more thanPBS-noTEE. The cause is hardware-based cryptography, such as memory page encryption and decryption between CPU and main memory in Intel TDX. -
PBS itself adds CPU overhead from networking. At 210 TPS,
PBS-noTEEused 10.9% more CPU thannoPBS-noTEE, attributed to forwarding transactions to an external builder. This overhead plateaus once processing stabilizes; briefly at test start, non-PBS CPU usage is higher because all logic is concentrated in one place. -
RAM is governed by the builder, not by PBS or TEEs. For a given builder implementation, RAM usage showed no clear variation between PBS and non-PBS, TEE or no TEE.
op-rbuilderused about 1.927× and 1.597× more RAM on average thanop-gethin the PBS setting at 30 TPS and 210 TPS respectively. TDX's extra cryptographic metadata lives outside guest VM memory, and its AES-XTS memory encryption does not expand ciphertext relative to plaintext size. -
Higher load raises both CPU and RAM. All setups used more RAM at 210 and 270 TPS than at 30 and 90 TPS, with RAM also creeping upward over each run as new blocks and state changes accumulate in memory.
Methodology in Plain English
The team built a complete Optimism rollup network on top of an emulated Ethereum node that plays the role of Layer 1, using Flashbots' Builder Playground, which they adapted to run on Kubernetes. They ran this on a cluster of four VMs on one host with a 16-core Intel Xeon Gold 5515+ at 2.70GHz supporting Intel TDX, using KVM; each VM had 4 vCPUs, 4GB of memory, and Ubuntu 24.04 LTS, with one VM TDX-enabled. Work was pinned to nodes via affinity rules: one node for metrics collection and load injection, one for sequencer components, and one for the external builder.
Load was generated with Flashbots' Contender tool, which fires high volumes of transactions at the rollup's RPC endpoint and records metrics such as TTI. The workload was repeated ERC-20 transfers from pre-funded accounts to random recipients, with Uniswap transactions also observed. Input rates were 30 and 90 TPS for the low setting and 210 and 270 TPS for the high setting — well above the 20 to 30 TPS daily average the authors cite for real rollups such as Optimism. Each ERC-20 run lasted 10 minutes.
Four configurations were compared, and PBS variants were additionally tested with the op-rbuilder builder (marked with the -rb suffix) versus op-geth. All PBS designs used a single external builder, which the authors describe as common practice for Rollup Boost deployments at the time of writing. Beyond chain-level metrics, system-level CPU and RAM usage of the block builders were collected with Prometheus.
Why This Matters
Impact on research: The paper fills a measurement gap. Prior TEE-in-rollup proposals reported large penalties — TEE Rollup reported 15.74% lower throughput and 20.17% higher latency, and Cristiano et al. reported Intel SGX increasing confirmation time by roughly 614%–740% — but those involved multiple heterogeneous sequencers, quorum coordination, or process-level SGX. This study shows that a VM-level TEE integrated into a PBS rollup imposes a small cost, reframing the trade-off for future designs.
Real-world applications:
- Rollups already running Rollup Boost, such as those integrated with OP Stack, can use these CPU and RAM figures to size builder infrastructure and decide whether TEE overhead is acceptable.
- Teams choosing between
op-gethand a specialized builder likeop-rbuilderget direct evidence that the builder implementation, not the TEE, dominates both latency and memory footprint. - Deployers can anticipate that TEE CPU overhead compounds with PBS networking overhead (roughly 25% in combination versus roughly 17% for TEE alone), which matters for capacity planning.
- Application domains beyond finance that the paper flags as harmed by censorship — e-government voting, supply chain shipment registration, and financial exchanges — stand to benefit from verifiable ordering guarantees.
Industry relevance: The paper is explicitly a practical experience report grounded in the designs actually deployed rather than proposed ones, making its findings directly actionable for rollup operators and infrastructure providers.
Future Directions
-
Benchmark finer-grained externalization. The authors name this explicitly as future work: measuring what happens when other sequencer responsibilities, such as batching and state computation, are also moved out of the TEE or out of the sequencer.
-
Reduce the trusted computing base of VM-based TEEs. The paper calls TCB reduction "a fundamental requirement" and points to unikernel-based designs and LibOS architectures such as Gramine-TDX as promising but unresolved directions.
-
Solve application-level attestation. Boot-time TDX attestation covers kernel and firmware but not the builder or sequencer binary, unlike SGX. IMA-based measurement is proposed as a fix, but the paper does not evaluate it.
-
Test geographically distributed builders. The evaluation placed the builder on a VM on the same host, so network latency was small; the authors expect TTI to rise when the external builder sits on a separate node, and that remains unmeasured. Detailed memory profiling to explain
op-rbuilder's higher RAM use is also left open.
Target Audience
Rollup operators and infrastructure engineers deciding whether to adopt TEE-backed builders; blockchain protocol researchers studying PBS, MEV, and censorship resistance; confidential-computing practitioners evaluating Intel TDX for blockchain workloads; and systems researchers who want a concrete, reproducible methodology for benchmarking TEE overhead in latency-sensitive distributed applications.
Authors’ abstract
Layer 2 (L2) rollups have become the dominant scaling solution in Ethereum. At the core of these systems lies the rollup sequencer, a component that orders, executes, and submits L2 transaction blocks to the main Ethereum blockchain. The centralization of this sequencer introduces security risks, including censorship and malicious manipulation of transactions to extract maximum extractable value (MEV). Trusted execution environments (TEEs) provide strong hardware-enforced…
The full abstract on arXiv