Skip to content
Crypto.world

Research

Analyzing Solana's Blocks and Transactions

Solana's headline claim is that it can execute transactions in parallel, but the achievable parallelism inside a block is limited by how often transactions touch the same accounts with at least one…

Analyzing Solana's Blocks and Transactions
arXiv
2609.35171
Published
2026-09-28
Authors
Yaron Hay, Dvir David Biton, Roy Friedman

AI summary

Overview

Research area: Blockchain systems — empirical measurement of transaction workloads, conflict graphs, and parallel execution potential in Solana.

Technical level: Intermediate. The paper is an empirical measurement study; it assumes familiarity with accounts, read/write sets, and serializability, but its results are presented as distributions and ratios rather than formal proofs.

Scope (one sentence): The paper downloads and analyzes one million recent Solana blocks to characterize block sizes, compute costs, fees, program invocations, and the conflict graphs formed by transactions' declared read and write sets, in order to quantify how much parallelism Solana's blocks actually permit.

What This Paper Is About

Solana's headline claim is that it can execute transactions in parallel, but the achievable parallelism inside a block is limited by how often transactions touch the same accounts with at least one writer. Because Solana requires every transaction to pre-declare which accounts it reads and which it writes, these conflicts can be reconstructed after the fact from block data. The authors reconstruct conflict graphs for one million real blocks and measure both the graphs' structure and the transactions' execution costs, fees, and program usage, in order to see where the parallelism actually goes and which workloads create contention.

Key Contributions

  1. A large public dataset and toolchain. Transaction traces for 1,000,000 Solana blocks (block numbers between #390M and #391M, out of a total of 400 million blocks at the time of writing), collected from a rented Solana full node through the standard RPC interface using getBlock with transactionDetails="full". The data and code are released as open source, and the authors extended the ChainGrapher infrastructure to parse Solana traces (Python 3.12, networkx 3.4.2, httpx, HDF5 storage via h5py, plus pandas, numpy, matplotlib).

  2. Block- and transaction-level statistics. Distributions of transactions per block, per-transaction compute units (both runtime-only computeUnitsConsumed and total costUnits including signature verification, account loading, and write locks), transaction fees, and the rate of hard failures (transactions that executed but hit a logical error and were still recorded in the block).

  3. A structural analysis of conflict graphs. Density, mean and maximum degree, diameter, assortativity, clustering coefficient, largest connected component, clique number, an estimate of the chromatic number via the DSatur greedy coloring algorithm, and a Monte Carlo estimate of the longest simple path.

  4. A program-usage breakdown. Eighteen publicly known program addresses (core native programs, SPL programs, loader programs, and ecosystem programs) are labeled "standard," everything else "non-standard," and the paper counts transactions invoking non-standard programs, distinct non-standard programs per block, programs invoked per transaction, and pure read-only data accounts per transaction.

Main Findings

  • Block sizes cluster near 1,000 transactions. The block-size histogram is plotted on a log scale; most blocks hold around 1,000 transactions, with a long tail reaching 2,000 and more. The largest block observed contained 8,000 transactions. Blocks of size 0 occur rarely, and of the 1M blocks downloaded, only 1,498 were skipped due to consensus protocol failures.

  • Execution cost falls as blocks get bigger, but fees do not track block size. Average compute units per transaction (both the runtime-only and the total measure) appear inversely proportional to block size, which the authors read as consistent with targeting a roughly equal block execution time. Transaction fees do not correlate with block size. The authors infer that a block creator could earn more by packaging many short transactions than a few long ones, and that a smarter selection algorithm could improve block-producer profit given that Solana's fee is a base fee of 5,000 lamports per signature plus a priority fee unrelated to execution time.

  • Conflict graph density is low, with exceptions. Density is quite low, especially compared with what has been reported for Ethereum and Sui. Some graphs exceed 10% density, and one exceeded 35%. The authors attribute the low density to Solana's block construction: concurrency control delays some conflicting transactions, lowering the chance that conflicting transactions land in the same slot's block.

  • Conflicting transactions form near cliques. Assortativity and clustering coefficients are relatively high, and the mean degree is not far from the max degree even though many nodes are singletons — both consistent with conflicting transactions concentrating into near-clique structures (or being isolated singletons). Diameters are correspondingly low.

  • The greedy coloring appears near-minimal. The DSatur estimate of the chromatic number (an upper bound) and the clique number (a lower bound) produce almost identical graphs, which the authors take as evidence that DSatur finds near-minimal colorings on Solana conflict graphs. In denser and larger blocks the chromatic number is very large, suggesting a large share of the graph is one clique or near-clique — possibly a burst of interrelated activity.

  • Long conflict chains persist. The Monte Carlo longest-path estimate (a lower bound) and the largest connected component (an upper bound) are not far apart, and the relatively large values echo prior work reporting Solana serialization chains around 59% of block size versus around 18% in Ethereum.

  • Coloring-based ordering could give a meaningful speedup. The paper reports that ordering transactions by a minimal coloring, rather than by arbitrary block order, can improve block execution time. The summary of findings states a factor of 1.2–3 times, up to 10 in extreme cases; Section 6.3 reports a factor of 1.5–3 in most cases with extreme cases reaching 6–10; the Discussion states a reduction from 20% up to a factor of 10 in extreme cases (or where ordering is deliberately manipulated to form long chains).

  • User-defined programs are common and generate most conflicts. The number of transactions invoking at least one non-standard program is non-negligible, several non-standard programs are invoked by multiple transactions (so some user-defined contracts are fairly popular), and this count grows with the conflict rate — indicating most conflicts are generated by such programs. On average each transaction invokes more than one but less than three programs, and transactions in smaller blocks tend to invoke more programs. Each transaction accesses between 2 and 10 pure read-only data items, excluding program accounts. The most-used standard programs are the vote program and the compute budget program, which the authors describe as kernel-like rather than user-facing; the top three user-related programs are the system program (including transfers), the SPL Token program, and the associated token account program.

  • Solana's conflict structure differs qualitatively from Ethereum and Sui. In Solana there is a relatively high number of non-conflicting singleton transactions, and conflicts concentrate into near cliques; in Ethereum and Sui the authors observe more hub-and-spoke structures. Solana conflict chains are therefore longer.

  • A methodological caveat on conflict types. Because Solana treats writable=true as a request for an exclusive lock, the authors cannot distinguish true read-write conflicts from true write-write conflicts.

Methodology in Plain English

The authors rented time on a Solana full node and pulled full transaction detail for one million consecutive blocks. For each transaction they read off the account list, using the writable flag to split it into a write set (writable=true) and a read set (writable=false). Two transactions are counted as conflicting if they name at least one common account and at least one of them marks that account writable. Within each block they build an undirected conflict graph with one node per transaction and one edge per conflict, then compute standard graph metrics on it.

Two metrics need approximation because the exact versions are NP-hard: the chromatic number is estimated with the DSatur greedy coloring algorithm, and the longest simple path is estimated by a Monte Carlo procedure that repeatedly walks simple paths from random starting nodes, skipping connected components smaller than the current best. Because block size heavily influences every metric, blocks are bucketed by transaction count; each plotted line shows the median within a bucket, and the shaded band shows the top and bottom 5% of observed values.

Why This Matters

Impact on research. The paper supplies a large, open, real-world workload characterization for a major parallel blockchain, complementing smaller studies of Ethereum and Sui. Its central structural claim — Solana produces sparse graphs with near-clique conflict components and long chains, unlike the hub-and-spoke patterns seen elsewhere — argues against the idea that one synthetic workload can represent all blockchains, and supports the case for parameterized, TPC-like blockchain benchmarks.

Real-world applications:

  • Validator client scheduling. Coloring-based transaction ordering inside a block, rather than arbitrary block order, is reported as a route to 1.2–3× (up to 10× in extreme cases) faster block execution while preserving deterministic serializability.
  • Block producer / leader fee optimization. The finding that fees do not scale with block size suggests leaders leave revenue on the table by greedily taking high-fee long transactions under block compute and time limits; a smarter packing algorithm is a direct practical lever.
  • Smart contract design. Because a few popular non-standard programs generate most conflicts, developers of high-traffic contracts can target contention reduction (e.g., splitting hot accounts) where it has the largest effect.
  • Capacity planning and pre-warming. Knowing the distribution of programs invoked and of pure read accounts per transaction (2–10) informs prefetching of accounts before execution and resource provisioning at validator nodes.

Industry relevance. The results speak directly to the operators and designers of parallel-execution chains, to MEV/block-building infrastructure, and to teams deciding how much parallelism a Solana-style architecture actually delivers in production rather than in theory.

Future Directions

  1. A parameterized, TPC-like blockchain benchmark. The authors explicitly leave this as future work, motivated by the finding that Solana, Ethereum, and Sui produce structurally different conflict graphs, so no single synthetic workload is representative.

  2. Smarter block-packing algorithms for leaders. The fee-versus-block-size mismatch points to a scheduling/selection optimization problem — maximizing producer profit under block execution-time and compute limits.

  3. Deploying coloring-driven ordering in clients. Since DSatur appears to produce near-minimal colorings on these graphs, the natural next step is integrating color-ordered execution and measuring the realized speedup against real blocks, including adversarial or manipulated orderings that form long chains.

  4. Disambiguating conflict types and profiling hot programs. Because Solana's writable flag conflates read-write and write-write conflicts, finer instrumentation would sharpen contention analysis; pairing that with deeper profiling of the popular non-standard programs that dominate conflicts would identify concrete optimization targets.

Target Audience

Blockchain protocol and runtime engineers working on parallel execution and scheduling; validator and block-builder infrastructure teams; smart contract developers on Solana who want to understand which access patterns create contention; and academic researchers in distributed systems and databases who need realistic blockchain workloads to evaluate deterministic concurrency control, graph-coloring-based serialization, or benchmarking methodology. Beginners can read the findings, but the graph metrics and the serializability argument require some background.

Authors’ abstract

Solana is one of the most popular blockchains, and is arguably the most widely used blockchain for smart contracts, also known as dApps. Understanding the types of smart contracts that are being executed by Solana and their interplay is therefore highly beneficial both for designers of modern blockchains and developers of smart contracts. To that end, in this paper we analyze a million recent Solana blocks. We report statistics about the size of blocks (number of…

The full abstract on arXiv
Read the original paper