Ethereum is often described as a world computer. But how does that computer keep track of everything—balances, smart contracts, token holdings, etc.?

The answer lies in the World State.

In this blog, we’ll break down:

• What the World State actually is

• Ethereum as a State Machine

• Types of accounts (EOAs vs Contract Accounts)

• How storage works (hint: Merkle Patricia Tries)

• A simple example of a token transfer

And yes—we’ll explain it like you’re 12.

🌐 So... What is the World State?

Imagine Ethereum as a giant notebook. The World State is the current page showing everyone's account balance, contract code, and storage.

It’s a snapshot of the entire Ethereum network at a given moment.

Every time a transaction happens, Ethereum updates this notebook and turns to the next page.

• ✅ Your ETH balance changed? World State updates.

• 📜 A contract runs? World State updates.

In Ethereum, the World State is the source of truth—it stores everything.

🧮 Ethereum as a State Machine

Ethereum works like a state machine. That means:

• It starts with a known state

• Executes a transaction

• Transforms into a new state

Like this:

Old World State + Transaction → New World State

Each block includes many transactions, which together create a new version of the World State.

So Ethereum isn't just storing data—it's transforming over time.

👥 Account Types in Ethereum

There are two types of accounts in Ethereum:

1. Externally Owned Accounts (EOAs)

• Controlled by a private key

• No code inside

• Used by people (like your wallet)

• Can send and receive ETH and call contracts

2. Contract Accounts

• Controlled by code (smart contracts)

• Cannot initiate transactions (they only respond)

• Have logic and storage

What Does an Ethereum Account Store?

Every account (EOA or contract) has:

1. Nonce – Number of transactions sent

2. ETH Balance – How much ETH it owns

3. Storage Root – Link to data it stores

4. Code Hash – The contract code (only for contracts)

Think of each account as a folder. Inside:

• A balance sheet

• Notes on past transactions

• Code and internal variables (for contracts)

Ethereum Uses Merkle Patricia Tries (Say What?)

To store the World State, Ethereum uses a data structure called a Merkle Patricia Trie (MPT).

Sounds scary, but here's the idea:

🧒 Explained Like a Kid:

Imagine a huge filing cabinet with folders (accounts). Each folder has subfolders (storage). The MPT helps Ethereum:

• 📦 Find data quickly

• 🔐 Prove data hasn’t been tampered with

• 🧬 Compress large datasets into a single hash (called the State Root)

Each block in Ethereum contains this State Root—a fingerprint of the entire World State.

So instead of storing everything, Ethereum just stores this tiny hash. If the hash matches, we know the data is valid!

Example: Sending ETH from Elon to Trump

Let’s say Elon sends 2 ETH to Trump.

1. Elon (EOA) creates and signs a transaction

2. It goes into a block

3. Ethereum runs the transaction:

   • Elon’s balance goes down by 2 ETH

   • Trump’s goes up by 2 ETH

4. A new World State is created

This transaction changes two folders (accounts) in the filing cabinet. The trie is updated, and a new State Root is recorded.

Example: A Smart Contract Call

Let’s say Elon calls a contract to swap ETH for tokens.

1. Elon sends a transaction to the contract

2. The EVM runs the contract code

3. Contract updates its internal storage (token balances, logs, etc.)

4. World State is updated again

Here, code runs, and storage values change.

🧠 Why This Matters

Understanding the World State helps you grasp:

• How Ethereum remembers everything

• Why blockchain apps can’t fake data

• What happens behind the scenes of Metamask, Uniswap, or Etherscan

If you’re a developer, you’ll interact with accounts, balances, and storage all the time. Knowing how Ethereum stores this helps debug and optimize your dApps.

📦 Summary: Ethereum's Living Ledger

• The World State is Ethereum’s current memory of all accounts and contracts

• Ethereum is a state machine that evolves over time

• There are two types of accounts: EOA and Contract

• Storage is handled using Merkle Patricia Tries for integrity and efficiency

• Every transaction = a new state

Ethereum isn’t just money—it’s a living, breathing database that updates with every action.

If you're just stepping into the world of crypto and DeFi, you're in the right place.

There are hundreds of blog posts explaining liquidity and AMMs—but this one stands out because:

• It’s built for beginners, using real-life examples, playful analogies, and visuals.

• It simplifies DeFi concepts without watering them down.

• It doesn't assume you're an expert—it meets you where you are.

By the end, you’ll not only understand what liquidity pools and LPs are—you’ll know why they matter, how they work together, and how to spot opportunities and risks in DeFi.

So why should you choose this blog over others?

Because it turns confusing crypto buzzwords into clear, relatable stories—even your 12-year-old cousin could follow.

Let’s break it down.

You’ve probably heard crypto terms like:

• Liquidity pools

• LP tokens

• AMMs

• Impermanent loss

• Slippage

• Order books

But what do they really mean? And how do they fit into the world of decentralized finance (DeFi)?

This post walks you through it all—clearly, visually, and with fun metaphors—so you walk away confident, not confused.

What Is Liquidity in Crypto?

Explained Like to a Kid:

Imagine you're at school with a pocket full of candy, and you want to trade a lollipop for a chocolate bar.

• If lots of your classmates also want to trade, it’s super easy to swap—this is high liquidity.

• But if no one wants lollipops or has chocolate, you're stuck—this is low liquidity.

In crypto, liquidity means how quickly and easily you can trade your tokens without getting a bad deal.

In grown-up terms:
Liquidity is how easily an asset can be bought or sold without causing big price changes.

• High liquidity = fast, smooth trades

• Low liquidity = price slippage, delays, or failed transactions

In DeFi, liquidity is the lifeblood of any token or protocol.

What Is a Liquidity Pool?

Explained Like a Kid:

Think of a liquidity pool like a candy bucket in the middle of the playground. Kids (users) put two types of candy in it—say, gummies and chocolates.

Any kid can walk up and swap one candy for the other. No need to find a trade partner. The candy bucket is always open.

A liquidity pool works the same way. It’s a smart contract that holds two tokens (like ETH and USDC), and lets anyone swap between them.

Instead of relying on a buyer and seller to match orders, the pool and some math handle everything instantly—like a crypto vending machine.

What Are AMMs (Automated Market Makers)?

Explained Like a Kid:

An AMM is like a smart robot watching the candy bucket.

If kids are grabbing all the chocolates and leaving gummies, the robot says: "Chocolates are rare now—they cost more gummies."

That’s what an AMM does: it uses math to adjust token prices automatically based on supply and demand.

In crypto terms: An AMM is an algorithm that replaces order books. It automatically calculates prices based on how much of each token is in the pool (often using x * y = k).

Popular AMMs include:

• Uniswap (Ethereum)

• Raydium (Solana)

• Trader Joe (Avalanche)

Order Books vs AMMs

Explained Like a Kid:

Order books are like a chalkboard in class:

• One kid writes: "I’ll trade 1 chocolate for 2 lollipops."

• Another writes: "I’ll buy 1 chocolate for 1 lollipop."

You wait until two kids agree.

But with AMMs, there’s no waiting. The candy bucket and math robot let you swap instantly, anytime.

Real-World View:

Traditional markets (and centralized exchanges) use order books:

• Buyers place bids

• Sellers place asks

• The spread is the difference between best bid and ask

In contrast, AMMs don’t match people—they let you trade against the pool.

What Is a Swap?

A swap is just a token trade. You give one token (like USDC) and get another (like ETH) using a liquidity pool.

No matching needed. The AMM and the pool do the work.

Swaps in DeFi are:

• Trustless

• Fast

• Available 24/7

Quote Price vs Executed Price

When you preview a trade, you get a quote price—what you should get.

But if the pool changes before your trade goes through (like others trading before you), you might get a different amount. This is where slippage comes in.

What Is Slippage?

Explained Like a Kid:

You see a sticker that says "1 chocolate = 2 gummies." You run to swap... but someone just traded and now the sticker says "1 chocolate = 1.9 gummies."

That tiny change is slippage.

Slippage is the difference between expected price and final executed price.

It’s common in:

• Low liquidity pools

• Large trades

• Volatile markets

What Is Slippage Tolerance?

Slippage tolerance is how much slippage you’re okay with.

If slippage goes beyond your limit, the trade fails.

• Too low = failed trades

• Too high = bad price

Most platforms let you set it (e.g., 0.1%, 0.5%, 1%).

Who Provides Liquidity? (And Why?)

People called Liquidity Providers (LPs) deposit equal values of two tokens into pools.

In return, they get LP tokens (like a receipt), and they earn:

• A share of trading fees

• Bonus rewards (like farming yields)

Example:

You add ETH and USDC to a Uniswap pool. Every time someone swaps, you earn a % of that fee.

What Is Impermanent Loss?

When token prices change too much, LPs might earn less than if they had just held their tokens.

This is called impermanent loss—and it’s real. It only becomes permanent if you withdraw when the price difference is large.

What Are LP Tokens?

When you provide liquidity, you receive LP tokens.

• They represent your share of the pool

• You can stake them for extra rewards

• Losing them = losing access to your funds

Pools, Farms, Vaults: What’s the Difference?

Real Ecosystem Examples

• 

  Uniswap V3 (Ethereum): Advanced fee strategies

• PancakeSwap (BNB Chain): High-yield farming

• Curve Finance: Stablecoin swapping with minimal slippage

• Raydium (Solana): DEX + order routing hybrid

Summary: Liquidity Is the Lifeblood of DeFi

Let’s recap:

• Liquidity = smooth trading

• Liquidity pools = shared token buckets for instant swaps

• AMMs = robots that set prices using math

• Order books = slower, person-to-person trading method

• Slippage = trade price difference due to market movement

• Slippage tolerance = your safety setting for that difference

• LPs = the heroes who keep the pools alive

DeFi wouldn’t run without liquidity pools. They're the silent engines behind every swap you make.

Follow me for more beginner-friendly guides on Web3, DeFi, and token economics.

Follow me on X

“Why do we need tokens? Isn’t Ethereum or Solana enough to do transactions?”

This is one of the most asked questions by crypto beginners—and it’s totally valid.

In this blog post, we’ll explore:

• What tokens are (in simple terms)

• Why they’re essential in the crypto world

• Real-world examples of tokens

• Why tokens empower decentralized applications (dApps)

What Is a Token?

A token is a digital asset that is built on top of an existing blockchain like Ethereum or Solana.

It is not the native currency of the blockchain (like ETH or SOL), but it runs on top of them using smart contracts.

📌 Think of it this way:

• Ethereum/Solana = Operating System (like Windows or Android)

• Token = App running on top of it (like Instagram or WhatsApp)

Just like apps use the power of your phone without building new hardware, tokens use the power of existing blockchains without creating a new one.

Why Tokens Instead of Just Using ETH or SOL?

1. Custom Use-Cases & In-App Economies

Projects need their own economy or utility system.

Example:
A game built on Ethereum wants to reward players → it creates its own token, say GAME.
Players earn, trade, and stake GAME tokens.
This keeps the economy self-contained, flexible, and not dependent on ETH's price.

2. Tokens Are Easy to Create, Blockchains Are Not

Creating a new blockchain (like Ethereum) takes:

• Years of development

• Massive infrastructure

• Security testing

Creating a token using Ethereum's ERC-20 standard or Solana's SPL standard takes a few lines of code:

// Ethereum example
contract MyToken is ERC20 {
    constructor() ERC20("My Token", "MTK") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
}

3. Governance & Voting Rights

Tokens can act like voting power in a decentralized organization.

Example:

• Uniswap has a token called UNI

• If you hold UNI, you can vote on:

  • Protocol upgrades

  • Fee structure

  • Treasury spending

This is how DAOs (Decentralized Autonomous Organizations) work.

4. Brand Identity & Incentives

Having a unique token:

• Builds brand value (like $SAND for The Sandbox, $MANA for Decentraland)

• Attracts users with rewards

• Helps raise funding via token sales (ICOs, IDOs)

Tokens act as both a currency and a marketing tool

Real-World Examples of Tokens

Bonus: Tokens ≠ Coins

Summary

Tokens are not just alternatives to ETH or SOL—they’re the fuel that powers thousands of apps, games, DeFi protocols, DAOs, and NFT platforms.

They allow developers to:

• Customize economies

• Enable voting rights

• Distribute rewards

• Build without launching a full blockchain

Ethereum or Solana is the playground. Tokens are the toys, tools, and currency you use to play.

Final Thoughts

Next time someone asks, “Why tokens?”, you’ll know the answer:
Tokens give apps the power to build, grow, and govern their own economies — all while standing on the shoulders of giants like Ethereum and Solana.

Want More?

• Follow me on Twitter

• Or reach out if you want help creating your first token!