---
# System prepended metadata

title: The Path to Stateless Ethereum

---



# The Path to Stateless Ethereum(Verkle Trees )

Ethereum needs a way to grow without becoming too hard or too expensive for people to run nodes. One of the biggest problems today is **state size**, the amount of data nodes must store to keep Ethereum running.
**Verkle trees** are a new data structure designed to fix this problem and make Ethereum more decentralized.

---

## What Is a Verkle Tree?

A **Verkle tree** is a smarter way to organize Ethereum’s data.

The name comes from:

* **Ver** => Vector commitment
* **Merkle** => Merkle trees (used in Ethereum today)


So, Verkle = Vector commitment + Merkle tree

The main goal of Verkle trees is simple:

> **Allow Ethereum nodes to stop storing huge amounts of data, while still being able to verify blocks correctly.**

---

## Why Is Ethereum’s State a Problem?

Ethereum keeps track of:

* Account balances
* Smart contract storage
* Contract code
* Nonces and other data

All of this is called **state**.

Right now, every full Ethereum node must store **almost all of this state** on disk. Over time, this state keeps growing, which means:

* More disk space is needed
* More powerful hardware is required
* Fewer people can afford to run nodes

This hurts decentralization.

---

## What Are Stateless Clients?

A **stateless client** is an Ethereum node that **does not store the full state**.

Instead of keeping all Ethereum data locally, it checks blocks using something called a **witness**, which comes with the block.

Think of it like this:

* Today: You store the whole textbook to answer exam questions
* Stateless: You receive only the exact pages needed for today’s exam, plus proof they’re real

Stateless clients are lighter, faster, and easier to run.

---

## What Is a Witness?

A **witness** is a small package of data that includes:

* Only the pieces of state needed to run the transactions in a block
* A cryptographic proof that this data is correct

Validators use the witness to:

1. Re-run the block’s transactions
2. Check the state changes
3. Confirm the block is valid

For this to work well:

* Witnesses must be **small**
* They must be shared across the network **within 12 seconds**

Big witnesses = slow network = fewer validators.

---

## Why Merkle Trees Don’t Work Well for Stateless Clients

Ethereum currently uses **Merkle Patricia Tries**.

The problem is:

* Merkle proofs need many hashes
* They include “sibling nodes” at every level
* The tree is deep, so proofs are large

This makes witnesses **too big**, sometimes several megabytes, which is not safe to send every 12 seconds.

Big witnesses push out users with slower internet and cheaper hardware.

---

## How Verkle Trees Fix This

Verkle trees make witnesses **much smaller** by:

### 1. Making the Tree Flatter

* Merkle trees are tall and narrow
* Verkle trees are wide and short

Fewer levels means fewer steps from data to the root.

### 2. Removing the Need for Sibling Hashes

Verkle trees use **vector commitments**, so proofs don’t need all sibling data.

### 3. Using Polynomial Commitments (Advanced but Powerful)

With polynomial commitments:

* Proof size stays almost the same no matter how much data is proven
* Witnesses become tiny and efficient

This is the key reason Verkle trees enable stateless clients.

---

## How Much Smaller Are Verkle Witnesses?

Let’s compare:

For a block needing proof of 1,000 state values:

* **Merkle tree witness:** ~3.5 MB
* **Verkle tree witness:** ~150 KB
  → about **23× smaller**

With polynomial commitments:

* Witness size can be as small as **0.1–1 KB**

That’s small enough to safely send with every block.

---

## What Does a Verkle Tree Look Like?

Verkle trees store **key–value pairs**.

* Each key is 32 bytes
* First 31 bytes = **stem**
* Last byte = **suffix**

Nodes in the tree:

* **Extension nodes**: one stem, up to 256 children
* **Inner nodes**: connect other nodes together

Because each node can hold many children, the tree stays flat and efficient.

---

## Why Verkle Trees Are Important for Ethereum

Verkle trees help Ethereum:

* Reduce storage requirements
* Support stateless clients
* Lower hardware costs
* Improve decentralization
* Make running nodes easier for everyone

They are one of the most important upgrades on Ethereum’s roadmap.

---

##  Summary

* Ethereum state is too big
* Stateless clients avoid storing full state
* Stateless clients need small witnesses
* Merkle trees create large witnesses
* **Verkle trees create small witnesses**
* Small witnesses = more decentralization
