How EIP-4844 Transformed Ethereum L2 Rollups—and Made Fees Ultra-Low

\n

Blockchain’s Bottleneck Was Data, Not Computation

What happens on Ethereum when countless users send tokens, mint NFTs, and execute swaps on DeFi at the same time? Transaction queues grow longer, and users offer higher gas fees to have their transactions processed sooner. Eventually, network fees surge, making small transactions economically unviable.

At first glance, the problem may appear to be a lack of “computing power.” But the more fundamental bottleneck to Blockchain scalability is not simply the amount of computation involved. The real issue is the cost of propagating, storing, and reproducing transaction data so that anyone can verify it.

A Structure Where Every Node Keeps the Same Record

A traditional public blockchain is a distributed ledger in which numerous nodes, rather than a central server, share the same transaction history. When a new transaction occurs, the network generally goes through the following process:

1. The user sends the transaction to the network.
2. Multiple nodes verify the transaction’s signature, balance, and smart contract execution conditions.
3. The verified transaction is included in a block.
4. The block goes through consensus and is connected to the canonical chain.
5. Nodes receive and store the data, then reproduce the same state change.

This structure is powerful. Users do not need to trust a specific company or administrator, and anyone can independently verify the transaction history. If someone secretly attempts to alter past data, the problem is immediately exposed through the hash links between blocks and the network’s verification process.

But that trust comes at a high cost. As the number of users grows, it is not only the number of transactions that increases. The data burden required to make those transactions verifiable to every participant grows as well.

Blockchain is not only a system that “processes” transactions; it is also a system that “publishes, propagates, and preserves” them so anyone can verify them.

Why Doesn’t Throughput Increase Easily?

Conventional web services can scale by adding more servers as the number of users grows. For example, when an online retailer receives more orders, it can add more database or application servers. Because there is a single operator, no consensus is required over which servers should be trusted.

Public Blockchains such as Ethereum are different. If block size or throughput is increased without restraint, more data must be propagated across the entire network, requiring each node to have faster internet connections, more storage capacity, and higher-performance hardware.

This, in turn, raises the barrier to participation.

• Only a small number of participants with high-performance equipment may be able to operate nodes.
• As the number of validators decreases, decentralization may weaken.
• Slower block propagation may reduce network stability and consensus efficiency.
• If the amount of data that must be stored explodes, independent verification by ordinary users may become more difficult.

In other words, increasing throughput is not simply a matter of “using bigger servers.” It is a question of balancing speed, security, decentralization, and data accessibility.

The Real Background Behind Surging Gas Fees: Competition for Block Space

On Ethereum, users pay gas fees to have their transactions included in blocks. The amount of block space the network can process at one time is limited, but there is no fixed limit on the number of transactions users can submit.

When demand exceeds supply, users offer higher fees to have their transactions processed first. This competition drives gas fees upward.

Smart contract calls, in particular, may require more computation and state changes than simple transfers. But from a scalability perspective, the more important point is that the network must handle the relevant transaction and state-change information in a verifiable form to make the execution results trustworthy.

For example, when a swap is executed on a decentralized exchange, the network does not store only the result—“the exchange was completed.” It must be possible to verify who sent how much, how the state of the relevant liquidity pool changed, and whether the calculations were carried out according to the rules.

For this reason, block space is not merely storage space. It becomes a scarce public resource used by validators around the world to collectively establish trust.

Data Availability: Simply Being Recorded Isn’t Enough

In Blockchain, data is not finished merely because it has been included in a block. Network participants must actually be able to download and inspect that data. This is known as Data Availability.

When data availability is not guaranteed, serious problems arise. Even if someone claims that “a valid state change occurred,” independent verification becomes impossible if other participants cannot access the original data used in the computation.

Therefore, scaling technologies must solve two problems at the same time:

• Process more transactions quickly and cheaply
• Make the data required to verify the results accessible to everyone

These two conditions often conflict. Publishing more data increases verifiability, but also raises costs. Conversely, reducing the amount of data may lower costs, but make it more difficult for users to reverify the results.

The Question of Scalability Is Not “How Much Can We Compute?”

Discussions about Ethereum scalability are often summarized by TPS, or transactions per second. It is certainly an important metric. But the more fundamental question is this:

How much transaction data can be made available—how cheaply, and in a way that can be verified by how many people?

This question matters because Blockchain’s trust comes not from the performance of a central server, but from verifiable data. Computation can be performed quickly in a specific environment. But providing the data that allows anyone to confirm that the computation was performed correctly is far more expensive and difficult.

This is where Layer 2 Rollups come in. Rollups process large volumes of execution on a separate layer and distribute the burden by posting compressed results, along with the data required for verification, to Ethereum. Proto-Danksharding, or EIP-4844, is a change designed to reduce this data cost.

Ultimately, the starting point for ultra-low-cost scaling is not to force more computation into L1. It is to publish data more efficiently and make it verifiable at a lower cost.

Rollups Compress Thousands of Transactions into a Single Proof: Inheriting Blockchain Security

User transactions are processed outside the Ethereum mainnet. So why can L2 Rollups still leverage Ethereum’s security?

The core idea is simple: execute transactions quickly on L2, while leaving the data and proofs needed to verify those execution results on Ethereum. In other words, Rollups do not abandon Blockchain’s security foundation. Instead, they separate out and process the most expensive execution work elsewhere.

User Transactions Begin on L2

When a user transfers tokens from an L2-based wallet or executes a DeFi swap, the transaction is first sent to the relevant Rollup network. Rather than being immediately executed by every node on Ethereum L1, the transaction is processed within the L2 environment.

The central actor here is the Sequencer.

A Sequencer typically performs the following tasks:

1. Collects user transactions.
2. Determines the order of the transactions.
3. Executes smart contracts.
4. Updates the L2 state, including balances, NFT ownership, and DeFi positions.
5. Groups thousands of transactions into a single batch.

From the user’s perspective, the transaction appears to be confirmed quickly. Since the L2 executes the transaction directly, it is far faster and cheaper than waiting for each transaction to be processed on the Ethereum mainnet.

However, an important question remains:

What happens if the Sequencer creates an incorrect transaction order or arbitrarily manipulates balances?

The Rollup trust model is not “trust the Sequencer.” The Sequencer is closer to an operator that organizes and submits transactions, while the final standard for accepting the result resides on Ethereum L1.

---

State Roots: How Thousands of Results Are Summarized into a Single Value

Rollups do not store the final result of every individual transaction on Ethereum. If they did, the cost-saving benefits would disappear. Instead, they record a state root representing the entire L2 state.

A state root is a hash value that summarizes vast amounts of data on L2—such as account balances, contract storage values, and NFT ownership information—using a Merkle tree structure.

Put simply:

• L2 state before the transactions: Previous state root
• Execution of thousands of transactions: Batch processing
• L2 state after the transactions: New state root

Even a difference of just 1 won in a balance will produce a completely different state root. A state root is therefore a cryptographic fingerprint that compactly represents “what the L2 state is after this batch has been executed.”

The Sequencer submits the following information to Ethereum:

• The state roots before and after the batch
• The transaction data included in the batch, or data that can be used to reconstruct it
• A proof that the state transition is valid, or information needed to verify it

Thanks to this structure, Ethereum does not need to execute every L2 transaction itself to obtain a basis for determining whether the state change claimed by the L2 is legitimate.

---

Why Batch Data Matters: The Conditions for “Verifiable Compression”

If only the state root were posted to Ethereum, costs could be extremely low. But if no one could reverify whether the result was correct, it would not be a secure Rollup.

Suppose, for example, that a Sequencer makes the following claim:

“In this batch, A’s balance decreased by 1 ETH, while B’s balance increased by 1 ETH.”

To determine whether this claim is correct, one must at least know which transactions were included and in what order they were processed. That is why genuine Rollups place enormous importance on Data Availability.

Data availability means that the transaction data required for verification is publicly accessible to everyone and can be downloaded and re-executed whenever necessary.

By publishing this data on Ethereum L1, Ethereum-based Rollups make the following possible:

• Anyone can download the L2 transaction data.
• Independent participants can reconstruct the L2 state.
• Even if the Sequencer stops operating, users can attempt escape or recovery procedures.
• If an invalid state transition occurs, it can be proven or invalidated.

This is the decisive difference between a simple “off-chain server” and a Rollup. If a server operator hides the data, users have no way to verify it. Rollups, by contrast, leave the key verification data on Blockchain’s public ledger.

---

Optimistic Rollups: Accept First, Challenge if Wrong

As the name suggests, Optimistic Rollups initially accept batch results optimistically. When the Sequencer submits a new state root and batch data to Ethereum, the system does not immediately re-execute every calculation for verification.

Instead, it establishes a challenge period.

During this period, anyone can review the batch. If they discover an incorrect transaction execution or an invalid state change, they can submit a Fraud Proof to demonstrate that the batch is wrong.

The process works as follows:

1. The Sequencer executes L2 transactions and creates a batch.
2. The batch data and state root are submitted to Ethereum.
3. A verifier or watcher independently re-executes the batch.
4. If an error is discovered, a Fraud Proof is submitted.
5. An Ethereum smart contract verifies the proof.
6. The invalid state transition is rejected, and the party responsible for the misconduct may suffer an economic penalty.

The crucial point is that this system is designed so that a single honest watcher can detect fraudulent behavior. Of course, actual security depends on the data being publicly available and on the challenge system and withdrawal procedures functioning properly.

---

ZK Rollups: Submit a Mathematical Answer Key with the Result

ZK Rollups take a different approach. When submitting a batch, they also submit a Validity Proof, or zero-knowledge proof, cryptographically demonstrating that “this state transition was calculated correctly.”

Instead of re-executing thousands of transactions itself, Ethereum verifies a relatively small proof. Generating the proof may require significant computation, but verifying it can be performed far more efficiently.

The process is as follows:

1. The L2 executes a large number of transactions.
2. The proof system demonstrates that the transaction execution followed the rules.
3. The Sequencer or Prover submits the state root, batch data, and Validity Proof to Ethereum.
4. An Ethereum smart contract verifies the proof.
5. The new L2 state is approved only when the proof is valid.

If Optimistic Rollups follow a model of “challenge it if it is wrong,” ZK Rollups are closer to a model of “submit proof that it is correct first.”

| Category | Optimistic Rollup | ZK Rollup | |---|---|---| | Basic assumption | Accept the batch first | Accept the state after verifying the proof | | Core verification method | Fraud Proof | Validity Proof | | Withdrawal finality | Affected by the challenge period | Can be finalized quickly after validity proof verification | | Main challenge | Watcher participation and challenge design | Proof-generation costs and technical complexity |

Both approaches share the same goal: process large-scale transactions on L2 while keeping Ethereum as the ultimate source of trust.

---

The Change Brought by EIP-4844: Posting Batch Data More Cheaply

The cost of a Rollup ultimately depends heavily on how expensive it is to post batch data to Ethereum. Even if transactions are executed quickly on L2, user fees will remain difficult to reduce sufficiently if recording transaction data on L1 is expensive.

Proto-Danksharding, or EIP-4844, was designed to address this problem. Rollups can now use blob space intended for large volumes of batch data instead of relying solely on conventional Ethereum call data.

Blobs are a separate data area designed for Rollup data availability. Because they use a cost structure different from ordinary EVM execution data, they help significantly reduce the cost of posting Rollup transaction data to Ethereum.

As a result, users may experience changes such as:

• Lower transfer and swap fees
• Greater practicality for micropayments and on-chain gaming transactions
• More frequent on-chain recording of social and community activity
• Improved UX for DApps handling large volumes of user traffic

---

What It Precisely Means for a Rollup to Inherit Ethereum’s Security

The phrase “L2 inherits Ethereum’s security as is” is convenient, but the conditions behind it must also be understood.

A Rollup’s security is not automatically complete simply because it exists on top of Ethereum. In general, the following elements must be in place:

• The data required for L2 state changes must be available on Ethereum.
• Fraud Proof or Validity Proof verification must function correctly.
• Users must have a way to recover their assets even if the Sequencer fails.
• Bridges and smart contracts must be designed securely.

In other words, the Sequencer provides a fast user experience, but it is not the entity that determines the final truth. The legitimacy of the final state is judged by the data and proofs posted to Ethereum, along with the smart contract rules that execute them.

A Rollup is not simply a technology that moves transactions “outside.” It processes large-scale execution on L2 while anchoring verifiable facts and final settlement to Ethereum. This compressed architecture is precisely how Blockchain pursues scalability and trust at the same time.

EIP-4844 and Blobs: Separating Blockchain Data Costs

If a Rollup processes thousands of transactions in a single batch but fees still haven’t fallen as much as expected, where does the bottleneck remain?

The answer is the cost of recording data on L1—more precisely, the price of securing data availability (DA). Rollups move transaction execution to Layer 2, but they still need to publish the relevant data to Ethereum L1 so that anyone can verify the transaction results and recover the state if necessary. Previously, this data had to be included in the calldata of regular transactions, and that cost set a floor for L2 fees.

EIP-4844, also known as Proto-Danksharding, addresses this problem by separating how Blockchain data is processed. At its core are Blobs and an independent blob gas market.

Rollup’s Hidden Cost: Data Publication, Not Execution

Rollups execute users’ transactions quickly on L2. The sequencer then compresses thousands of transactions into a single batch and submits the result to Ethereum.

What needs to be uploaded to L1 is not merely the final balance.

• Which transactions were processed
• In what order they were executed
• Whether anyone can recalculate the results or challenge them
• Whether users can recover their assets if the Rollup operator withholds the data

To preserve this verifiability, Rollups must make sufficient transaction data publicly available. This is known as data availability.

The problem was the old method. Rollups recorded data in the calldata of Ethereum transactions, and calldata uses the same space as regular Ethereum blocks. As a result, when L1 became congested due to NFT minting, DeFi liquidations, memecoin trading, and other activity, the cost of publishing Rollup data also increased.

In other words, even if Rollups dramatically reduced execution costs, the following structure remained:

L2 fees = L2 execution costs + L1 data publication costs + operating and proving costs

For many Rollups, the largest component was precisely the cost of publishing data on L1.

What Is a Blob?

Instead of placing Rollup data in regular calldata, EIP-4844 introduced a new transaction format called a blob-carrying transaction.

Blob is short for “Binary Large Object.” It is a separate data container designed to allow Rollups to publish large amounts of batch data to Ethereum. A single Blob can hold approximately 128 KiB of data, and Rollups can attach multiple Blobs to a single transaction when necessary.

The important point is that a Blob is not ordinary smart contract storage.

| Category | Existing calldata | EIP-4844 Blob | |---|---|---| | Primary use | Contract call data and Rollup data publication | Securing data availability for large-scale data, including Rollups | | Direct EVM access | Possible | Impossible | | Data retention | Effectively recorded permanently in the chain’s history | Stored by the network for a limited period | | Fee market | General Ethereum gas market | Separate blob gas market | | Best suited for | Inputs required for execution | Large amounts of data needed for verification after execution |

Blobs cannot be read directly by the EVM. This means smart contracts cannot use data inside Blobs as if it were storage. That limitation is intentional.

The purpose of Blobs is not to turn Ethereum into an unlimited database, but to allow Rollups to publish the data they need cheaply and keep it verifiable for a certain period.

Why Are Blobs Cheaper? Separating Execution Space from Data Space

The price of existing calldata is determined by Ethereum’s general gas market. In this market, various activities—including simple transfers, DEX swaps, NFT transactions, and smart contract execution—compete for the same resources.

EIP-4844, by contrast, gives Blobs their own pricing system.

• Execution gas applies to regular transaction execution
• Blob gas applies to Blob data publication

Under this structure, even if execution gas becomes expensive because of heavy DeFi activity, Rollup data publication costs can remain relatively low in a separate market if demand for Blobs is modest. Conversely, if Rollup usage surges and competition for Blob space intensifies, only blob gas rises independently.

This separation creates several important economic effects.

1. Rollup data costs become more predictable.
   Demand for regular L1 execution and demand for Rollup data no longer compete under exactly the same pricing mechanism.

2. Ethereum block space can be used more purposefully.
   Activities that require EVM execution and activities that publish large amounts of data are less likely to crowd each other out excessively.

3. A structural decline in L2 fees becomes possible.
   Rollups can reduce their dependence on calldata—their most expensive component—and make use of Blob space instead.

Blob fees also adjust according to demand. However, because they use a target capacity and price-adjustment mechanism separate from the general gas market, they create a market tailored to the data availability resources Rollups require.

KZG Commitments: Verifying Data Without Executing It All On-Chain

The fact that Blobs are inexpensive does not mean verifiability has been sacrificed. Ethereum uses a cryptographic technique called KZG commitments (Kate-Zaverucha-Goldberg commitments) to verify the integrity of Blob data.

Put simply, instead of processing the entire large Blob directly during transaction execution, the Rollup submits a short cryptographic commitment to that data.

This allows the network to verify:

• Whether a particular Blob matches the data submitted at the time
• Whether any part of the Blob has been tampered with
• Whether the data referenced by the Rollup was actually published

The Blob provides the large volume of data, while the KZG commitment efficiently proves that the data has not been altered. This is the key mechanism that allows Ethereum to handle large-scale Blockchain data availability without charging the full cost of processing all that data as EVM execution.

Not Permanent Storage, but “Verifiable Temporary Publication”

Blobs are different from conventional on-chain storage. Blob data is not intended to be preserved indefinitely; after nodes retain it for a certain period, it may be pruned.

This actually fits the purpose of Rollups well.

Rollups do not need to store the original text of every transaction permanently in the L1 execution layer for years. What matters is that anyone can download and verify the data—or reconstruct the state when necessary—during the following periods:

• Immediately after a batch is submitted
• During the period when challenges or proof verification may be required
• During the period when users may need to prepare forced withdrawals or recover their state

Data that requires long-term preservation can be handled by Rollup operators, archive nodes, distributed storage, or separate indexing services. Ethereum L1 becomes less like a warehouse that stores all data permanently and more like a benchmark for verifiable data availability.

How Will User Fees Change?

After EIP-4844, Rollups can use Blobs instead of traditional calldata to publish batch data. As a result, L1 data costs can fall, potentially leading to lower fees for L2 users.

The effects are especially significant for activities such as:

• Small token transfers
• DEX swaps and repetitive transactions
• State updates in on-chain games
• Posts and reactions on social applications
• Airdrops and point settlements for large user bases
• High-frequency payment and micropayment services

Of course, the introduction of Blobs does not mean that “every L2 transaction will always be nearly free.” Actual fees depend on Blob demand, the Rollup’s own execution costs, sequencer policies, proving costs, token prices, and network congestion.

Even so, EIP-4844 has created a major shift. By separating data publication costs—the greatest barrier to Rollup scalability—from general execution costs, it laid the foundation for Ethereum to evolve into a data availability and settlement layer capable of supporting a large number of L2s.

Ethereum Blockchain Evolves from an Execution Chain into Settlement and Security Infrastructure

What if Ethereum could remain at the center of the ecosystem without directly processing every application transaction?

The combination of Rollups and Blobs offers a practical answer to this question. The role of the Ethereum Blockchain is no longer limited to being a single chain that directly executes every smart contract. Instead, it is evolving into infrastructure that provides the foundation for settlement, consensus, data availability, and security, enabling countless Layer 2s to operate safely.

Execution on L2, Final Trust on Ethereum

Under the traditional structure, the Ethereum mainnet directly executed user transactions, stored the results, and handled network consensus. While its security was strong, all activity had to share a single block space, leading to congestion and high fees.

In a Rollup-centered structure, these roles are divided.

• Layer 2 Rollup: Executes transactions quickly and handles the user experience and application functionality.
• Sequencer: Collects L2 transactions, determines their order, and organizes them into batches.
• Ethereum L1: Settles Rollup results, provides a foundation where data can be publicly verified, and guarantees finality.
• Blob data space: Allows Rollups to publish the large amounts of data required for verification more efficiently than in the standard execution space.

In other words, users transact on L2, but the foundation that gives the L2 its credibility lies with Ethereum. Even if an L2 attempts to manipulate its state arbitrarily, problems can be exposed through the fraud-proof process of an Optimistic Rollup or the validity-proof process of a ZK Rollup. This is the core of the Rollup paradigm: “execution elsewhere, trust on Ethereum.”

Blobs Turn Ethereum into a Data Availability Layer

For a Rollup to be secure, recording only the final balances on L1 is not enough. Everyone must be able to obtain the Rollup’s transaction data and, if necessary, reconstruct its state or challenge an invalid result. This is known as Data Availability.

EIP-4844, or Proto-Danksharding, introduced Blobs to address this issue.

Blobs are a separate data space designed to allow Rollups to publish large volumes of transaction data to Ethereum. Unlike conventional smart contract storage, Blob data is not intended to be directly read or executed by the EVM. Instead, it is focused on making the data required for Rollup verification publicly available at a relatively low cost.

This change has two major implications.

1. Lower L2 Fees
   As the cost of publishing data to L1—once one of the major expenses for Rollups—declines, user transaction fees can also fall significantly.

2. Redefining Ethereum’s Role
   Rather than functioning as a giant computer that directly executes every transaction, Ethereum is becoming more like a shared public infrastructure that provides reliable data and final settlement for multiple execution environments.

In this structure, the Ethereum Blockchain functions not merely as an application platform, but as a shared security and settlement layer for a wide range of Rollups.

New Competition Created by a Modular Structure

Blockchain networks are now moving away from the model of placing every function on a single chain. This is commonly referred to as a modular blockchain architecture.

Each layer focuses on a different role.

| Role | Area of Responsibility | Core Value | |---|---|---| | Execution | Rollups, appchains | Fast processing, low fees, customized UX | | Data Availability | Ethereum Blobs, DA networks | Providing transaction data that anyone can verify | | Settlement | Ethereum L1 | Finalizing Rollup states and providing the basis for asset withdrawals | | Consensus and Security | Ethereum validator network | Ensuring network trust and finality |

This division of labor gives developers more choices. Games can choose L2s optimized for fast processing and low costs, while DeFi applications can select Rollups that prioritize security and connectivity to liquidity. Social services can design separate execution environments capable of handling countless small-value activities.

Ethereum, meanwhile, can focus less on competing over the features of individual applications and more on becoming a reliable common foundation for all these environments.

Why the Sequencer Is Becoming a New Center of Power

One actor that deserves particular attention in this structure is the Sequencer. A Sequencer gathers transactions submitted by L2 users, determines their order, creates Rollup batches, and submits them to L1.

At first glance, it may appear to be a simple operational component. But deciding the order of transactions represents enormous power. In DeFi especially, the order of transactions can affect prices, whether liquidations occur, and the availability of arbitrage opportunities.

The value generated in this process is known as MEV (Maximal Extractable Value). MEV refers to the economic gains that a block producer or transaction-ordering entity can obtain by arranging transactions before or after one another, or by adjusting whether they are included at all.

For example, when a large token-buying transaction enters the system, a participant who detects it in advance could buy first and then sell after the user’s transaction, capturing the price difference as profit. This behavior can cause unfavorable slippage or transaction failures for users.

As Rollup usage grows, Sequencers will gain significant authority over:

• Whether transactions are included or delayed
• The order of transactions
• The creation of L2 blocks
• The distribution of MEV opportunities
• User experience and censorship resistance

Therefore, ultra-low fees and fast processing alone are not enough. If Sequencer power becomes concentrated among a small number of operators, Rollups may gain performance while taking on the risk of centralization.

The Next Battleground: Shared Sequencing and Fair MEV

To address this issue, the industry is exploring ways to reduce dependence on a single Sequencer. Key approaches under discussion include Shared Sequencing, in which multiple Rollups use common infrastructure; decentralized models that increase the number of Sequencer participants; and auctions and cryptographic ordering mechanisms designed to improve the fairness of transaction ordering.

The central question is clear:

While building a faster and cheaper Blockchain, who will control the order of transactions—and who will capture the economic value that follows?

Rollups and Blobs have technically eased Ethereum’s scalability challenges. But the next stage of competition is unlikely to be limited to a simple TPS race. The trustworthiness of the modular ecosystem will be determined by how transparently and fairly it designs transaction ordering, MEV, censorship resistance, and interoperability between Rollups.

The Next Test for Ultra-Low-Cost Blockchain: Better Trust, Not More Transactions

The near-disappearance of fees will not automatically bring Blockchain into the mainstream. Once transaction costs fall below one cent, services such as micropayments, on-chain social platforms, in-game assets, and real-time settlement clearly become more viable. But users do not want merely “cheap transactions.”

They want to know whether their assets are being held securely, whether transactions can be arbitrarily blocked, whether they can move assets to other chains and services without complications, and whether they can recover when failures occur. The central question in Blockchain scaling is no longer a race for TPS. It is increasingly about how trust can be scaled through infrastructure.

New Use Cases Unlocked by Lower Fees

Rollups and EIP-4844’s blob data structure have dramatically reduced the cost of posting L2 data to L1. This change does more than make existing DeFi transactions cheaper. It brings service models into view that were previously difficult to sustain because of high fees.

• Micropayments and Streaming Payments
  Costs can be settled in extremely small units: one piece of content viewed, one API call, one minute of in-game item usage, or one minute of music played. Instead of monthly subscriptions, models based on “paying instantly for exactly what you use” become possible.

• On-Chain Social
  Recording posts, follows, comments, recommendations, and community rewards on-chain becomes more realistic from a cost perspective. However, whether it is desirable to permanently record every activity remains a separate question involving privacy and storage.

• Fully On-Chain Games
  It becomes easier to process movement, combat, item creation, and economic activity through smart contract state rather than a server database. One advantage is that game operators have greater difficulty arbitrarily changing rules or asset data. At the same time, high throughput, bot prevention, user experience, and data preservation remain unresolved challenges.

• Real-Time Financial Settlement
  Payments for freelance work, supply-chain transactions, advertising revenue, and global remittances can be settled automatically at short intervals. This is particularly promising for cross-border payments, where it could reduce the number of intermediaries.

What these use cases have in common is a high volume of transactions, small amounts per transaction, and a direct connection between the transparency of records and the value of the service. In other words, ultra-low-cost Blockchain can expand the market not through “more expensive financial transactions,” but through “digital activities that occur far more frequently.”

The Next Stage Is Full Danksharding: A Major Expansion of Data Space

Proto-Danksharding is the first step toward introducing a blob data market for Rollups. But if L2 usage continues to grow, blob space could once again become a competitive bottleneck. This is where Full Danksharding becomes important.

The goal of Full Danksharding is to enable Ethereum to process far more data-availability data efficiently. The key is to reduce the burden of requiring every node to download and verify all data in full, while still allowing the network to trust that the data exists and remains accessible.

This generally involves the following technical approaches:

1. Greater Data-Availability Capacity
   As the amount of data Rollups can publish increases, more L2 transactions can share the same L1 costs.

2. Data-Availability Sampling
   Rather than requiring every node to download an entire blob, this approach checks random samples to verify the likelihood that the data has actually been made available. It is important for network scalability, but its implementation and verification model must be highly sophisticated.

3. Separation of Long-Term Storage Systems
   Blobs are not intended to be stored permanently. As a result, it becomes crucial to determine who will preserve older transaction data, how users can restore historical states, and what incentives will support archive services.

Ultimately, Full Danksharding is both a technology for “fitting more transactions” and a test of how reliably the data foundation required by a large-scale Rollup ecosystem can be provided.

ZK Proofs as a Tool for Reducing the Cost of Trust

The development of ZK-Rollups and zkEVMs represents another major pillar of Blockchain scaling. Zero-knowledge proofs make it possible to verify that a complex computation was performed correctly without re-executing the entire process.

The advantage is clear. After executing countless transactions on L2, L1 can verify the validity of the results by checking a compressed proof. In other words, validators can confirm the legitimacy of a state transition without bearing the enormous cost of executing it themselves.

However, ZK technology still faces many challenges:

• Proof-generation Costs and Latency: Verification can be fast, but generating the proof still requires significant computational resources.
• Complexity of Circuits and Implementations: As the proof system itself becomes more complex, the difficulty of identifying bugs and conducting audits increases.
• Compatibility Issues: Full compatibility with the EVM, developer-tool support, and the debugging experience will have a major impact on real-world developer adoption.
• Balancing Privacy and Verification: ZK can also be used for privacy, but regulatory compliance and user-protection requirements must be considered at the same time.

ZK proofs, therefore, are not merely a performance technology. They are trust infrastructure that expands the range of situations in which users do not need to trust anyone and reduces the cost of verification itself.

The Centralization Problem Shared Sequencing Must Solve

As fees fall and transaction volume rises, the influence of L2 sequencers grows. Sequencers determine transaction order, assemble batches, and show users the results of their transactions first. Many Rollups rely on a single sequencer or a limited group of operators because this enables fast processing and simpler operations.

However, this structure leaves several risks:

• The possibility of censorship, in which certain transactions are delayed or excluded
• Service interruptions when a sequencer fails
• MEV concentration resulting from changes to transaction order
• Excessive dependence on trust in the operating entity

Shared sequencing is an approach in which multiple Rollups use common sequencing infrastructure or in which distributed participants determine transaction order. Ideally, it can reduce the exclusive control of individual L2 operators, improve the consistency of cross-Rollup transactions, and distribute MEV more transparently.

Shared sequencing, however, is not a universal solution. If multiple chains depend on a single sequencing layer, a new point of concentration may emerge. The design must simultaneously provide fast finality, decentralization, fair transaction ordering, and failure recovery.

The Growth of the DA Market: Data Is the Invisible Core Asset

The economics of ultra-low-cost Rollups ultimately depend heavily on data-availability costs. Ethereum’s blob space provides a powerful security foundation, but not every project requires the same level of cost and security. This is why separate DA layers and storage infrastructure are emerging.

The questions projects must consider in the DA market are far from simple:

• How can the fact that data has actually been made available be verified?
• If data disappears, can users recover the state of the Rollup?
• Could a cheaper DA option weaken the security model of bridges, withdrawals, or proof verification?
• Who will bear the cost of long-term storage?

The crucial point is that cheap data and secure data do not mean the same thing. The DA layer a Rollup chooses determines not only its fees, but also the recoverability of user assets, resistance to censorship, and risk of operational failure. Going forward, competition in Blockchain infrastructure may become more clearly defined by differences in DA trust models than by execution speed.

Conclusion: Mass Adoption Requires Affordability and Recoverability

Rollups and Proto-Danksharding mark an important turning point by lowering Blockchain fees and expanding the range of on-chain activity. But ultra-low-cost transactions are only the starting point. For users to rely on Blockchain services in everyday life, the following conditions must also be met:

• Transactions must be fast and inexpensive.
• Operators must find it difficult to arbitrarily block users.
• Assets and state must remain recoverable even when failures occur.
• Users must be able to connect safely with other Rollups and services.
• Data and transaction ordering must be transparently verifiable.

Full Danksharding will be tested on data throughput, ZK proofs on verification efficiency, shared sequencing on trust in transaction ordering, and the DA market on data accessibility and recoverability.

Ultimately, the final challenge for ultra-low-cost blockchains is not to create more transactions. It is to build a better trust structure—one that allows anyone to participate at low cost without becoming excessively dependent on a specific operator or opaque infrastructure.