Concurrent Cairo Transactions: Storage Write Batching vs Memory Caching Trade-offs

Question

Assuming a recent Cairo compiler and StarkNet sequencer version, storage access to the same key under concurrent requests introduces latency that is absent in single-request execution because StarkNet orders transactions sequentially. The language specification does not define isolation levels for concurrent transactions, leaving unclear whether competing storage writes to the same key are serialized or resolved as last-write-wins.

Developers face a concrete design choice: batch multiple storage writes into a single transaction to reduce contention and preserve consistency, at the cost of higher gas per transaction; or cache critical reads in memory and defer storage writes to a later transaction, lowering immediate read latency but risking inconsistency if the deferred transaction fails. No standard Cairo pattern currently manages this trade-off.

Given that the specification does not state cross-transaction atomicity semantics for global state updates, which documented approach offers a safer default for high-throughput contracts under current StarkNet ordering rules, and what practical verification should precede relying on either batching or deferred writes?

Tasadduq Burney · Answer

The Safer Default: Storage Write Batching
For high-throughput Cairo contracts, storage write batching into a single transaction is the safer documented default. Because the StarkNet sequencer orders transactions sequentially, each transaction executes atomically against the global state. Batching ensures that multiple related updates are committed as a single atomic unit, eliminating the risk of state divergence between interdependent writes.

Analysis of Trade-offs
The choice between batching and deferred writes is a trade-off between atomicity and latency:

Batching: Preserves intra-transaction consistency. While it increases the gas cost per transaction and risks hitting execution limits, it guarantees that if the transaction succeeds, all updates are applied.
Deferred Writes (Memory Caching): Reduces immediate read latency and spreads gas costs across multiple transactions. However, it introduces a "divergence window" where the on-chain state is stale. Since there is no cross-transaction atomicity in the Cairo specification, a failure in the deferred transaction (due to nonce issues, gas exhaustion, or reordering) can lead to permanent data inconsistency.

Practical Verification Steps
Before relying on either pattern, perform the following validations in a test environment matching your production sequencer version:

Sequencer Order Test: Submit concurrent transactions to the same storage key from different accounts. Verify that the final state matches the transaction that was ordered last by the sequencer (confirming last-write-wins behavior).
Invariant Audit: Map every business invariant. If an invariant requires two different storage keys to be updated simultaneously to remain valid, these must be batched in one transaction.
Gas Profiling: Measure the gas ceiling for your batched transactions. Ensure the batch size does not exceed the maximum allowable gas or execution steps for a single Cairo transaction.
Failure Simulation: For deferred write patterns, simulate a failure of the second transaction to quantify the impact of the resulting stale state on the contract's logic.

Concurrent Cairo Transactions: Storage Write Batching vs Memory Caching Trade-offs

1 answer

The Safer Default: Storage Write Batching

Analysis of Trade-offs

Practical Verification Steps

Your perspective belongs here.

0 question comments