Ephemeral Rollups (ERs) Overview

• Ephemeral Rollups (ERs) are session-limited, horizontally scalable runtimes on Solana that enable real-time, gasless, fully on-chain applications with strong composability.
• They leverage configurable tick intervals, delegated account execution, and ZK-validity proofs to ensure rapid settlement and trust minimization on the Solana base layer.
• The ER model maintains atomic composability by preserving state integrity on L1 while integrating off-chain execution with rigorous economic and security guarantees.

Ephemeral Rollups (ERs) are horizontally-scalable, session-limited runtimes built atop the Solana Virtual Machine (SVM), enabling high-frequency fully on-chain (FOC) applications—particularly games—with zero-fee transactions, configurable ticking logic, and strong composability guarantees. Unlike traditional L2s or app-chains that fragment state, ERs preserve the integrity of the Solana base layer, executing only against temporarily delegated accounts while enforcing provable validity and fast settlement back to L1. By combining configurable runtimes, state delegation, and ZK-verifiable execution traces, ERs deliver scalable application throughput without sacrificing atomic composability or trust minimization (Picco et al., 2023).

1. Formal Structure and Session Definition

An Ephemeral Rollup is formally defined as a session $\mathcal{E}$ on Solana, parameterized by:

• $P$: the on-chain program (game logic),
• $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$: subset of accounts delegated to the session,
• $\mathrm{ID} \in \{0,1\}^*$: session identifier,
• $\tau > 0$: tick interval (ms),
• $f_{\mathrm{settle}}$: max settlement frequency (Hz),
• $g_{\max}$: optional session gas budget.

The tuple is

$$\mathcal{E} = (\mathrm{ID}, P, \mathcal{A}_{\mathrm{del}}, \tau, f_{\mathrm{settle}}, g_{\max}).$$

Within $\mathcal{E}$, only transactions exclusively writing to $\mathcal{A}_{\mathrm{del}}$ are permitted; state updates proceed at block time $P$0; at each $P$1 interval (or on demand), the sequencer posts a state diff to L1. If cumulative session gas exceeds $P$2, the session is force-closed and all updates revert (Picco et al., 2023).

2. Architecture, Lifecycle, and Workflow

Key ER lifecycle steps:

1. Program $P$3 invokes $P$4 to request a new session via a delegation program (DLP), specifying session parameters.
2. An off-chain Provisioner spins up a customized SVM runtime instance with tick rate $P$5 and budget $P$6.
3. $P$7 delegates control of $P$8 to the ER sequencer.
4. Client transactions are routed by an RPC router: if their writable set $P$9, they reach the ER; otherwise, they are forwarded to L1 Solana.
5. At each settlement interval, the ER sequencer submits a batched L1 transaction to update $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$0.
6. On session expiry or closure, runtime shuts down and account control returns to $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$1.

ERs employ SVM "forks" with custom schedulers and fee rules. Accounts correspond to ECS (Entity-Component-System) components; programs are ECS systems. ER SVM instances retain bytecode and execution semantics identical to the base-layer, including parallel execution and PDA addressing (Picco et al., 2023).

3. Scalability, Tick Management, and Composability

ERs can drastically reduce per-instance block time, e.g., $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$2 ms, matching or exceeding Solana's base throughput $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$3 TPS with block time $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$4 ms. Running $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$5 ERs in parallel yields aggregate throughput

$\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$6

Each ER's tick interval $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$7 is fully configurable, supporting fine-grained event scheduling without per-tick gas fees. For applications such as real-time games, this facilitates millisecond-level updates for delegated state. Importantly, ERs maintain atomic composability: delegated accounts $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$8 are always readable L1-side, and any on-chain program can be invoked from either ER or base-layer context as long as non-delegated accounts are unaffected—contrasting sharply with composability loss typical in sharded or bridged L2s (Picco et al., 2023).

4. Security Guarantees and Settlement

Upon session closure, the ER sequencer generates a validity proof $\mathcal{A}_{\mathrm{del}} \subseteq \mathcal{A}$9 (using frameworks such as RISC0), which a single L1 transaction verifies before finalizing diffs. Two execution guarantees are provided: a "fast path" (optimistic, minimal delay) and a "proof path" (ZK-validity at L1). Rollback safety is enforced via timeout $\mathrm{ID} \in \{0,1\}^*$0, after which any user can force undelegation and revert state. This trust-minimized model sharply reduces the risk associated with off-chain execution compared to many L2s, while ensuring that the ER's impact remains strictly limited to delegated accounts (Picco et al., 2023).

5. Fee Model, Gasless Transactions, and Economic Structure

All writes within $\mathrm{ID} \in \{0,1\}^*$1 during an ER session are zero-fee: Solana L1 fees are paid solely by the sequencer when posting state diffs. Each session requires a deposit $\mathrm{ID} \in \{0,1\}^*$2 staked in the DLP: every batch settlement $\mathrm{ID} \in \{0,1\}^*$3 deducts from $\mathrm{ID} \in \{0,1\}^*$4, and violation of $\mathrm{ID} \in \{0,1\}^*$5 closes the session. This structure enables gasless user experience within the ER scope, while still ensuring L1 fee coverage and economic accountability (Picco et al., 2023).

6. Comparison to L2 Solutions and State Fragmentation

App-chains and L3s incur state fragmentation, with atomic cross-app composability lost and only bridge-mediated coordination possible; ERs instead preserve all programs/assets on Solana L1, achieving throughput comparable to app-chains yet maintaining composability at full fidelity:

• App-chain throughput $\mathrm{ID} \in \{0,1\}^*$6 ER throughput
• App-chain composability $\mathrm{ID} \in \{0,1\}^*$7; ER composability $\mathrm{ID} \in \{0,1\}^*$8

This compositional integrity is a distinguishing structural property, critical for use cases—such as open gaming or DeFi protocols—relying on atomic multi-program interactions (Picco et al., 2023).

7. Concrete Example, Session Programming, and EIP-4844 Context

A representative use case is a multiplayer game with per-player positions delegated as PDAs, session-tick $\mathrm{ID} \in \{0,1\}^*$9 ms, and position updates handled every tick. Movement transactions occur gasless and off-chain until L1 settlement; cross-cutting actions (e.g., NFT claims) pass via the RPC router to L1 if target accounts are not delegated. Example pseudocode provided in (Picco et al., 2023) illustrates tick-based logic. In the EIP-4844 setting, an explicit rollup cost model quantifies blob-posting trade-offs, determining a threshold $\tau > 0$0 transaction rate above which ephemeral blobs are optimal and formalizing cost-sharing via Nash bargaining for shared blob usage (Crapis et al., 2023).

Feature	ERs	App-chains
Composability	$\tau > 0$1 (L1-preserved)	$\tau > 0$2 (fragmented)
Execution environment	SVM fork, identical bytecode	Isolated VM
Fee model	Gasless for delegated accounts	App-specific
Security	L1 enforcement, ZK session proofs	Bridge/layer-specific

The ER model enforces explicit, delay-bounded, and verifiable settlement with public cost/performance tradeoffs, supporting rigorous throughput, latency, and economic guarantees, and offers a paradigm for scalable FOC applications without the drawbacks of fragmentation or trust dilution (Picco et al., 2023, Crapis et al., 2023).