Layer 1 Storage

The state trie (Merkle Patricia Trie) is a core data structure that stores the entire global state of an account-based blockchain like Ethereum. It maps account addresses to their balance, nonce, storage root, and code hash. This cryptographic trie allows for efficient verification of any account's state without needing the entire dataset.

These are separate tries that permanently record all network activity.

• Transaction Trie: Stores the details of every transaction included in a block.
• Receipt Trie: Stores the outcomes (logs, gas used, status) of those transactions. Together, they provide an immutable, verifiable history and are essential for light clients and indexers.

Each block header contains cryptographic commitments (hashes) to the underlying storage tries. The stateRoot, transactionsRoot, and receiptsRoot are 32-byte hashes stored in the header, allowing anyone to cryptographically prove that a specific piece of data (e.g., an account balance) was part of the canonical chain state at that block height.

Writing data to Layer 1 storage is expensive and consumes gas. Key operations:

• SSTORE: Writes data to a smart contract's persistent storage, with costs varying based on whether the slot is zeroed or not.
• Expensive Reads: While reading from storage (SLOAD) also costs gas, it is significantly cheaper than writes. This economic model prevents state bloat.

In smart contract execution, it's critical to distinguish between data locations:

• Storage: Persistent, on-chain, and costly. Survives between transactions.
• Memory: Temporary, mutable data scoped to a single transaction execution.
• Calldata: Immutable, temporary data containing the transaction's input arguments. Understanding these is fundamental for gas optimization.

A major challenge of L1 storage is state bloat—the continuous growth of the state trie. Solutions include:

• State Expiry: Proposals to make old, unused state data inactive.
• Verkle Trees: A more efficient cryptographic structure proposed for Ethereum to replace Merkle Patricia Tries, enabling stateless clients and better pruning.
• Archive Nodes: Full nodes that retain all historical state, unlike pruned nodes.

The primary use case is storing the persistent state of smart contracts. This includes variables, mappings, and structs that define the contract's current condition, such as token balances in an ERC-20 contract, ownership records for NFTs, or governance parameters in a DAO. This state is immutable, transparent, and accessible to all network participants, forming the backbone of decentralized applications (dApps).

Layer 1s permanently record all transaction data in the blockchain's ledger. This includes sender/receiver addresses, amounts transferred, smart contract function calls with their input data, and transaction fees. This immutable history enables full auditability, allows nodes to synchronize and verify the chain's state, and is essential for explorers and analytics tools.

Storing governance proposals, voting records, and protocol parameters directly on-chain. This creates a transparent and verifiable record of decentralized decision-making. Key data stored includes:

• Proposal metadata and executable code
• Vote tallies per address (often using token-weighted voting)
• Final execution status and updated protocol constants (e.g., fee changes, validator sets)

Storing verifiable credentials, attestations, and user reputation data. Systems like Decentralized Identifiers (DIDs) and Soulbound Tokens (SBTs) use Layer 1 storage to create tamper-proof records of identity attributes, achievements, or social graphs. This data can be permissionlessly verified by any application without relying on a central database.

Maintaining the canonical ledger for the blockchain's native assets, such as BTC on Bitcoin or ETH on Ethereum. This includes the Unspent Transaction Output (UTXO) set or account balances. For L1s that support native tokens (e.g., Cosmos SDK chains), the storage also manages the issuance, minting, and burning parameters for these assets at the protocol level.

Storing data critical to the network's consensus mechanism. For Proof-of-Stake chains, this includes the validator set, their staked amounts, and slashing records. For Proof-of-Work, it includes the difficulty adjustment and block headers. This state is continuously updated by the protocol itself to ensure network security and liveness.

Data stored on a Layer 1 is immutable and secured by the network's full consensus mechanism (e.g., Proof of Work, Proof of Stake). This provides the highest level of cryptographic security and data availability, as the integrity of the data is guaranteed by the same trust model as the chain's native assets. There is no reliance on external data providers or committees.

Smart contracts can read and write to Layer 1 storage directly and synchronously. This enables complex, trustless applications where contract logic and state are atomically updated. Key use cases include:

• Decentralized Autonomous Organizations (DAOs) storing governance parameters.
• Non-Fungible Tokens (NFTs) with on-chain metadata.
• DeFi protocols managing user balances and loan terms.

Clients and light nodes can cryptographically verify the state of the entire network, including stored data, using Merkle proofs (e.g., Merkle Patricia Tries in Ethereum). This allows for trust-minimized interactions without needing to store the full blockchain history, as any piece of data can be proven to be part of the canonical chain.

Once data is included in a block and confirmed, it becomes part of the canonical chain history and cannot be selectively removed or altered by any single entity. This property is critical for applications requiring permanent, tamper-proof records, such as land registries, academic credentials, or audit trails, where the guarantee of persistence is paramount.

The cost and security of storage are directly tied to the blockchain's native token economics. Storage rent or state bloat management (e.g., Ethereum's EIP-4444) are handled within the protocol's incentive layer. This aligns the cost of long-term data persistence with the security budget provided by validators/stakers, creating a cohesive economic model.

Data stored on the base layer is universally accessible to all protocols and applications built on that chain. This enables composability—the ability for different smart contracts to seamlessly interact with and build upon the same state. It removes fragmentation and integration overhead compared to siloed off-chain or Layer 2 storage systems.

Storing data on a Layer 1 is the most expensive operation in terms of gas fees. Every byte of data must be processed and replicated by every node, leading to substantial costs. For example, storing 1KB of data on Ethereum can cost over $100 during peak network congestion, making it impractical for large files or frequent updates.

The block size and block time of a Layer 1 create a hard limit on storage throughput. Each block can only contain a finite amount of data, creating a bottleneck. This limits the rate at which new data can be committed to the chain, which is a core scalability challenge for applications requiring high-frequency data logging.

Permanent, on-chain storage leads to blockchain bloat, where the historical state grows indefinitely. This increases hardware requirements for running a full node, potentially leading to centralization as fewer participants can afford the storage and bandwidth costs. This trade-off challenges the decentralized ethos of the network.

Layer 1 storage is immutable by design. Once data is written, it cannot be altered or deleted. While this provides auditability and censorship resistance, it is a severe limitation for applications that require data updates, corrections for errors, or compliance with regulations like the Right to be Forgotten (GDPR).

Native Layer 1 storage is typically limited to simple key-value stores or small data chunks within smart contract state. Storing and querying complex, relational data structures is inefficient and costly. Developers often must implement custom logic and indexing on-chain, which further increases gas costs and contract complexity.

The primary advantage of Layer 1 storage—cryptographic verifiability—comes at the cost of everything else. Off-chain or Layer 2 storage solutions (like IPFS, Arweave, or rollups) offer cheaper, scalable storage but introduce a verifiability trade-off, requiring additional trust assumptions or consensus mechanisms to prove data availability and integrity.

A Merkle Patricia Trie is the primary data structure used by Ethereum and similar blockchains to store the global state, which includes all account balances, smart contract code, and storage. It cryptographically commits to the entire state in the block header, enabling efficient and verifiable proofs of state via Merkle proofs.

The phenomenon where a blockchain's historical data grows indefinitely, increasing the hardware requirements for running a full node. This is a direct consequence of full on-chain storage and poses a challenge to network decentralization. Solutions include state expiry, stateless clients, and moving data to Layer 2 or off-chain storage.

A major Ethereum upgrade introducing blob-carrying transactions. Blobs are large packets of data attached to blocks that are cheap to post and are automatically deleted after ~18 days. This provides a dedicated, low-cost data availability layer for Layer 2 rollups, separating data cost from execution gas fees.

A critical property guaranteeing that the data behind a new block is published to the network and is accessible for download. It is essential for verifying transactions and preventing fraud, especially in optimistic rollups and zk-rollups. Data Availability Committees (DACs) and Data Availability Sampling (DAS) are key solutions.