Technical Summary: Not All Reads Are Conflicts: A Write-Only Analysis of the Sui Blockchain

Problem Statement

Sui blockchain utilizes an object-centric data model to enable parallel transaction execution, theoretically allowing transactions touching disjoint state sets to run concurrently. However, realized performance is bounded by workload contention. Prior empirical analyses of Sui, such as Biton & Friedman [7], relied on a "read+write" (R+W) conflict graph model inherited from account-based blockchains (e.g., Ethereum). In the R+W model, a conflict edge exists between two transactions if they access the same object and at least one modifies it.

The authors argue that the R+W model is fundamentally misaligned with Sui's execution semantics. Because Sui's engine serializes only on mutable shared access (not shared reads), the R+W model introduces "spurious edges." A primary example is the system clock (object 0x6): in an R+W model, every user transaction reading the clock for a timestamp creates a conflict edge with the system transaction writing the clock. This artificially inflates contention metrics, creating "hub-and-spoke" topologies that suggest severe sequential bottlenecks where none exist. Consequently, R+W provides an upper bound on contention that may significantly overestimate sequential dependencies and underestimate achievable parallelism.

Methodology

To address these limitations, the authors propose and apply a complementary "write-only" (W-only) conflict model to Sui mainnet data through the end of 2025.

Data Acquisition and Processing

• Dataset: Transaction data was collected from Sui mainnet checkpoints using a custom Rust/Diesel indexer. The authors deterministically sampled every 3,455th checkpoint (approx. 100/day post-Mysticeti upgrade) to create a representative long-term dataset.
• Graph Construction: For each checkpoint, undirected conflict graphs were constructed where nodes represent transactions and edges represent conflicts.
  • R+W Model: Edge exists if $write(T_1) \cap (read(T_2) \cup write(T_2)) \neq \emptyset$.
  • W-only Model: Edge exists only if $write(T_1) \cap write(T_2) \neq \emptyset$.
• Metrics: The study employs standard graph metrics adapted from prior Ethereum research [8, 15]:
  • Density, Assortativity, Clique Number, Largest Connected Component (LCC).
  • LSP/χ Ratio: The ratio of the Longest Simple Path (LSP) to the Chromatic Number (χ). This bounds achievable parallelism (LSP is the lower bound of sequential chains; χ is the theoretical minimum rounds).
  • Gas-Weighted Analysis: Parallelism potential is also weighted by gas usage to account for computational cost, distinguishing between many cheap transactions and few expensive ones.

Analytical Techniques

1. Union-Find Grouping: Objects are grouped based on write co-occurrence to isolate specific application ecosystems (e.g., DeepBook) from the broader network.
2. Economic Mapping: Balance changes are anchored to historical CoinMarketCap prices to quantify the USD-denominated value flowing through sequential vs. parallel paths.
3. Counterfactual Probes: The authors simulate the removal of specific conflict edges (e.g., within the DeepBook ecosystem) to test if specific applications act as inherent bottlenecks.

Key Findings

1. Structural Topology Shift: From Stars to Cliques

The transition from R+W to W-only fundamentally alters the perceived network topology.

• R+W: Exhibits highly disassortative, "hub-and-spoke" structures driven by the system clock. Almost every user transaction connects to the clock writer, creating a massive artificial star.
• W-only: The artificial star collapses. The remaining topology is highly assortative and clique-dominated. Conflicts occur in dense, small groups of transactions modifying the same objects, rather than a central hub.
• Quantitative Shift: The median degree-assortativity flips from $-0.500$ (R+W) to $\approx +1$ (W-only). The median clique number drops from 5.5 to 4, and the Largest Connected Component (LCC) drops from 8.5 to 4.

2. Tighter Bounds on Parallelism

The W-only model provides a lower bound on contention (and thus a tighter upper bound on parallelism).

• Routine Load: The estimated optimal parallelism headroom drops from $\approx 1.2\text{--}1.4\times$ (R+W) to $\approx 1\times$ (W-only).
• High Load: The ceiling drops from $\approx 5\times$ to $\approx 3\times$.
• Conclusion: Stripping read-side dependencies shaves 30–40% off the optimal parallelism estimate at routine loads. The bottleneck on routine Sui load is identified as workload composition (specifically, write-hot objects) rather than the parallel engine's inability to schedule.

3. Application-Level Contention: The DeepBook Ecosystem

Using union-find grouping, the authors isolated the DeepBook ecosystem (Sui's native central limit order book).

• Volume vs. Logic: DeepBook accounts for 87.3% of all application-level conflicts by volume. However, counterfactual probes (removing DeepBook's internal edges) show that its contribution to sequential bottlenecks is strictly proportional to its transaction volume.
• Sharding Effect: Unlike traditional account-based CLOBs which force serialization on a single contract, DeepBook shards state across per-pool and per-balance-manager objects. This allows transactions touching disjoint pools to execute in parallel.
• Result: DeepBook does not impose disproportionate sequential bottlenecks relative to other high-volume applications; its contention is a function of volume, not unique logic.

4. Economic Cost of Sequentiality

Mapping graph structures to USD value reveals the economic exposure to ordering effects.

• Sequential Burden: 10–50% of the network's USD-denominated value flows through sequentially constrained execution paths (the LCC).
• Parallel Flow: The remaining 50–90% flows through parallel paths.
• MEV Implications: The sequential portion is potentially exposed to reordering-based Maximal Extractable Value (MEV) strategies, while the parallel portion is not. The authors note this is a snapshot of current workload exposure, not a universal ceiling.

Significance and Claims

The paper claims to provide a semantic re-evaluation of conflict modeling in Sui. By aligning the conflict model with Sui's actual execution semantics (mutable shared-object serialization), the W-only model eliminates "non-execution dependencies" introduced by read-only accesses.

• Methodological Contribution: The authors propose the W-only model as a necessary complement to R+W, arguing that R+W systematically overestimates contention in object-centric systems.
• Architectural Insight: The study demonstrates that Sui's object model successfully converts what would be a sequential bottleneck in account-based chains (a CLOB) into a workload where contention scales with volume but not with inherent logic constraints.
• Practical Impact: The findings suggest that operators should size infrastructure for "tail behavior" (viral events like the Sui 8192 game which showed $\approx 175\times$ speedup) rather than average behavior, as routine loads often have little residual parallelism to exploit due to workload composition.

The authors conclude that the W-only methodology offers a cross-platform vocabulary for comparing application-driven contention in modern blockchains (e.g., Aptos, Solana) without the "read-side noise" that dominates account-centric analyses.