DEV Community: Yelyzaveta Dymchenko

Everything you want to know about Ethereum Stateless

Yelyzaveta Dymchenko — Wed, 14 Jan 2026 20:57:25 +0000

The Ethereum State is becoming unmanageable.

To verify blocks today, running a node requires a 2TB+ NVMe SSD and significant bandwidth. This hardware barrier forces centralization, pushing users to rely on trusted third parties like Infura or Alchemy instead of verifying the chain themselves.

The solution is Stateless Consensus - a fundamental shift in how nodes communicate. This article explores the mechanics of Verkle Trees, the engineering constraints of the network, and why solving the "Concurrency Trap" is critical for Ethereum's roadmap.

The Constraints: Latency & Bandwidth

Why can't we just send the data needed to verify a block?

To verify a block statelessly, a node needs specific account values (balances, nonces, code) along with a cryptographic proof that these values are correct. This package is called The Witness.

The problem is network propagation. Blocks must propagate across the global P2P network in seconds. If we used today's math, the Witness would be 10-20 MB per block. At that size, propagation slows down, stale block rates increase, and only massive data centers can keep up.

To make statelessness viable, we need to shrink that proof from 20 MB to <100 KB.

The Architecture of Statelessness

Statelessness splits the network into two distinct classes of nodes:

Proposers (Heavy): These nodes store the full 2TB state. They build the blocks and generate the Witness.
Validators (Light): These nodes store nothing. They receive the (Block, Witness) tuple and verify it mathematically.

The Bottleneck: Merkle Patricia Tries

Ethereum currently uses Merkle Patricia Tries (Radix-16). In this structure, every node has 16 children. To prove that one specific child value exists, you must provide the hashes of all 15 siblings at every level of the tree's depth.

The Math:

Size ≈ 15 × Depth × 32 bytes

This scales linearly. As the state grows, the tree gets deeper, and the proof gets bigger. Currently, this results in roughly 3-4 KB per account. In a busy block consuming 30M gas, the total witness data exceeds the bandwidth budget of the P2P network.

The Fix: Verkle Trees & Vector Commitments

To solve this, Ethereum is moving to Verkle Trees.

In a Verkle Tree, we make the structure much wider. Each node has 256 children instead of 16. Normally, proving one child among 256 would require sending 255 sibling hashes—a massive amount of data.

The Solution: Polynomials

Instead of hashing the siblings, we treat the 256 children as coefficients (v) of a polynomial P(x). It looks like this:

P(x) = v₀ + v₁x + v₂x² + ... + v₂₅₅x²⁵⁵

We then "commit" to this entire polynomial using KZG Commitments.

The KZG Magic Formula 🔮

The commitment C is a single curve point, derived from a secret value s. It is calculated by multiplying the Generator point G by the polynomial's value at s:

C = G • P(s)

To prove a specific child value y at index z, the prover calculates a Quotient Polynomial Q(x):

Q(x) = (P(x) - y) / (x - z)

Why this formula works:
The logic relies on polynomial divisibility. If the value at index z is truly y, then subtracting y from the polynomial makes it perfectly divisible by (x - z). If the value were anything else, there would be a "remainder" left over, and Q(x) would not be a valid polynomial. By providing the commitment to Q(x), the prover demonstrates that the division was clean and the data is correct.

The "Proof" is simply the commitment to this quotient polynomial Q(x). This proof is a constant 48 bytes, regardless of whether the tree is wide or narrow.

The Impact: Bandwidth Saved

Merkle Proof: ~3,000 bytes per account (Linear complexity).
Verkle Proof: ~150 bytes per account (Constant complexity). This reduces the stateless block witness from 10 MB down to 200 KB.

The Engineering Challenges

1. The Trade-off: Trusted Setup

KZG Commitments require a "Structured Reference String" (SRS)—a set of parameters generated using a secret value $s$.

The Risk: If an attacker knows s, they can fake proofs P'(s) = P(s) and trick the network into accepting bad data.
The Defense: The "Powers of Tau" Ceremony. Over 140,000 participants contributed entropy to generate these parameters. As long as one single person in that chain deleted their "toxic waste" (secret randomness), the system is mathematically secure.

2. The Concurrency Trap (Race Condition)

Who should generate these proofs? There are two approaches:

Strong Statelessness: Users generate proofs for their own transactions.
Weak Statelessness: Block Builders generate proofs for everyone.

Ethereum has chosen Weak Statelessness because of a fundamental distributed systems problem: The Race Condition.

If users had to make these proofs themselves, their transactions would often fail when the network is busy. Therefore, the burden is placed on the Block Builders (Proposers), who have the server capacity to regenerate proofs instantly.

Future Proofing: State Expiry

Another piece of the puzzle is State Expiry (EIP-7736). Statelessness solves the verification problem, but the underlying database (stored by Proposers) still grows endlessly.

Mechanism: Epoch-based tree rotation.
Logic: If a "leaf" (account) is not accessed for ~1 year, it is dropped from the active tree.
Restoration: To use that account again, the user must provide a proof from the "Archive" to reactivate it.

Conclusion: The "Verge" Vision

All of this math serves one singular vision in Vitalik’s roadmap, known as "The Verge." The goal is to make the chain so lightweight that verifying Ethereum no longer requires trusting centralized providers like Alchemy or Infura.

Today: We trust.
Tomorrow: We verify.

Summary & Specs

Feature	Description
Tech	KZG Polynomials compress 256 siblings into 48 bytes.
Network	Reduces bandwidth overhead by ~99%.
UX	"Weak" statelessness prevents transaction failures.
Target	The "Hegota" Upgrade (H2 2026).

Related EIPs:

Top Resources

Vitalik Buterin: "Verkle Trees"
- Link
Dankrad Feist: "Verkle Trie for Eth1 State"
- Link

Polygon’s AggLayer Explained: Aggregating Liquidity Across Chains

Yelyzaveta Dymchenko — Tue, 16 Sep 2025 08:20:14 +0000

Introduction – Why Liquidity Matters

In crypto, liquidity means how easily you can buy, sell, or move assets without delays or high costs. In DeFi, liquidity is oxygen: without it, apps struggle, trades become expensive, and users leave.

But Ethereum’s rollups, while solving scalability, split liquidity into dozens of separate networks. Imagine every neighborhood in a city printing its own currency — trade inside each one works, but moving money across town is messy. Worse, bridges connecting those neighborhoods have been some of crypto’s weakest points. In 2025 alone, crypto theft has already topped $2.17B by mid-year, driven by the $1.5B Bybit incident, which was the largest single hack on record.

In my previous article on ZK Rollup Superchains, I wrote about the race to unify Ethereum’s fragmented rollups. Now let’s look at how Polygon is approaching this challenge with its new interoperability layer: AggLayer.

This is the problem AggLayer is trying to fix.

What is Polygon’s AggLayer?

AggLayer is Polygon’s interoperability and liquidity aggregation layer, part of the broader Polygon 2.0 roadmap. Instead of being just another rollup, it connects:

Polygon PoS
Polygon zkEVM
New chains launched with Polygon’s Chain Development Kit (CDK)
And potentially non-Polygon chains in the future

into one unified ecosystem.

Normally, every pair of chains needs its own custom bridge — a messy and risky approach. AggLayer replaces that with one shared highway - the Unified Bridge. Apps and users interact across chains without juggling multiple wrapped tokens or bridges.

👉 Think of it as many small ponds merging into one giant lake of liquidity.

Quick note on CDK*:* Polygon’s Chain Development Kit is an open-source toolkit to launch custom zk-powered chains. Developers can spin up new appchains with different configurations, and AggLayer ensures they’re automatically plugged into the shared liquidity pool.

Even more ambitious: AggLayer is not limited to Polygon chains. It’s designed to be chain-neutral, potentially aggregating liquidity across all of Web3, not just Ethereum rollups.

Liquidity-First Design

Most rollups focus first on performance (faster, cheaper transactions) and then patch liquidity with bridges. Polygon flipped the script with a liquidity-first design:

All tokens and assets across Polygon chains are treated as if they’re in one pool.
Instead of many small ponds, AggLayer gathers liquidity into one giant lake.
Traders, DeFi apps, and NFT marketplaces all benefit because assets flow freely.

👉 Analogy: Instead of needing different logins for every bank branch, AggLayer makes it feel like you’re banking from one app, with one balance, everywhere.

Under the Hood: How AggLayer Actually Works

AggLayer’s architecture relies on three core systems that keep cross-chain transactions secure, efficient, and trustworthy:

1. Unified Bridge – The Shared Highway

The Unified Bridge is the central mechanism that moves tokens and messages between chains.

No more wrapped tokens: AggLayer treats assets natively across chains. A token on one AggLayer chain is equivalent everywhere — liquidity isn’t fractured into multiple versions.
Message passing: Smart contracts across chains can talk to each other, enabling cross-chain dApps without custom bridges.
Ethereum settlement: Bridge smart contracts on Ethereum track deposits, exits, and global chain states, providing a secure anchor.

👉 Analogy: The Unified Bridge is like a highway system that connects multiple cities. Each city keeps local toll records, but there’s also a central authority verifying the entire network.

2. Pessimistic Proof – The Security Guard

The Pessimistic Proof acts as AggLayer’s safety net. Before any withdrawal is approved, it double-checks that the assets exist and haven’t been claimed already.

Deposits must match withdrawals. No one can claim more than they put in.
Three Merkle Trees per chain:
- Exit Tree – logs what each chain sends out
- Balance Tree – tracks token balances
- Nullifier Tree – prevents replay attacks
Prevents “double dipping.” Once a withdrawal is claimed, it’s nullified.

👉 Analogy: Think of it as a strict accountant cross-checking both the books of each chain and the global ledger. If the numbers don’t add up, no transaction goes through.

3. State Transition Proof – The Auditor

The State Transition Proof (often called the AggChain Proof) ensures every transaction and every cross-chain operation is valid.

Internal verification: Confirms transactions inside each chain are correct.
Cross-chain verification: Confirms that bridge operations (deposits, exits, balances) are consistent with the global record.
Flexible proofs: Some chains use full ZK proofs, others lighter proofs like sequencer signatures.

👉 Analogy: This is like a forensic auditor who not only checks each company’s (chain’s) books but also compares them against the master ledger (AggLayer).

Most importantly: AggLayer enables atomic cross-chain transactions. That means multi-chain actions either all succeed or all fail together — no more risk of getting debited on one chain and failing on another.

Simplified architecture: AggLayer nodes coordinate proofs, Ethereum provides settlement, and the Unified Bridge ties everything together.

Why This Matters for DeFi

By combining these systems, AggLayer delivers on its liquidity-first promise:

Unified Liquidity: One pool of assets across chains → deeper markets, less slippage.
Atomic Swaps: Cross-chain trades that settle instantly or not at all.
Better UX: Users don’t care what chain they’re on — apps just work.
Lower Risk: One robust Ethereum-secured bridge instead of dozens of risky ones.

👉 Example: A DEX on one chain can tap liquidity from another instantly. A lending protocol can pool collateral from all chains. An NFT marketplace can let buyers and sellers trade seamlessly across chains.

Challenges Ahead

AggLayer is ambitious, but questions remain:

Attracting non-Polygon chains: Will independent ecosystems trust a Polygon-led framework? Its neutrality could help, but adoption will take time.
Sequencer decentralization: Polygon plans to use POL staking to decentralize sequencers and provers, but it’s not fully live yet.
Ecosystem fragmentation: Optimism’s Superchain, zkSync’s Elastic Chain, and AggLayer may unify liquidity within their own networks — but will they interconnect, or remain competing “mega-lakes”?

Conclusion – One Big Lake Instead of Many Small Ponds

Polygon’s AggLayer is a bold attempt to solve Ethereum’s liquidity fragmentation. With a shared bridge, strict proofs, and a liquidity-first design, it makes Polygon chains feel like one seamless ecosystem.

Instead of dozens of small, disconnected ponds, AggLayer promises one vast, thriving lake of liquidity — the kind DeFi needs to grow.