Blockchain Fundamentals, Part 1: What Actually Is a “Block”? — From Ledgers to Nodes

Series: A Python Developer’s Deep Dive into Blockchain
Written for developers who know how to code but are new to blockchain. Code snippets included — but following along is enough even if you skip them.

Breaking Down the Word “Blockchain”

“Blockchain” is a compound of two words:

• Block: A bundle of transaction data
• Chain: Those bundles cryptographically linked in sequence

Put simply, it’s a distributed ledger maintained collectively by nodes around the world — with no central server. The reason it can’t be tampered with lies entirely in this structure.

---

The Actual Structure of a Block

Pop open a single block and you’ll find two main sections:

┌──────────────────────────────────┐
│           Block Header            │
│  - prevHash (previous block hash) │  ← The key to the chain
│  - timestamp                      │
│  - Merkle Root (of transactions)  │
│  - difficulty / nonce             │
├──────────────────────────────────┤
│         Transaction List          │
│  TX1: Alice → Bob   10 ETH        │
│  TX2: Charlie → Dave  5 ETH       │
│  TX3: ...                         │
└──────────────────────────────────┘

The prevHash field is what makes everything work. Every block holds the hash of the entire previous block — so if you tamper with any block in the middle, every subsequent block’s prevHash no longer matches. To forge history, you’d have to recompute every block from that point forward.

What’s a Merkle Tree?

Transactions inside a block are organized into a Merkle Tree for efficient verification:

        [Root Hash]
       /            \
  [Hash AB]       [Hash CD]
  /       \       /       \
[Hash A][Hash B][Hash C][Hash D]
   |       |       |       |
  TX_A   TX_B   TX_C   TX_D

If even a single transaction is altered, the root hash changes. This lets light nodes verify a specific transaction without downloading the full block — using a Merkle Proof.

---

How Many Blocks Actually Exist?

Let’s use ARK as an example. It launched in March 2017.

As of June 2026, ARK has approximately 36.2 million blocks.

block_time       = 8           # seconds
seconds_per_day  = 86_400
daily_blocks     = seconds_per_day / block_time  # 10,800
years            = 9
total            = daily_blocks * 365 * years    # ≈ 35.5M  ✓

For comparison:

Blockchain	Block Time	Approx. Block Count
Bitcoin	10 min	~850,000
Ethereum	12 sec	~20 million
ARK	8 sec	~36.2 million

---

Full Nodes vs. Light Nodes

Full Node

Downloads and stores every block from genesis to present, independently verifying every transaction.

Storage: Tens of gigabytes (ARK)
Role: Trustless — verifies everything itself
Cost: Server + electricity (~$2–$30/month)

Light Node (SPV)

Stores only block headers. For transaction verification, it requests a Merkle Proof from a full node.

Storage: A tiny fraction of a full node
Verification: Merkle Proof confirms specific transactions
Tradeoff: Must trust the full node it queries

Wallet App Users

Apps like MetaMask or ARK mobile wallets store nothing locally. They query full node servers via RPC (Remote Procedure Call):

App → RPC request → Full node server → Response
"What's the balance of this address?"
"Has this transaction confirmed?"

---

Who Creates New Blocks? — ARK’s Delegate System

ARK uses DPoS (Delegated Proof of Stake):

ARK token holders vote
        ↓
Top 51 vote-getters → elected as Active Delegates
        ↓
One delegate creates a block every 8 seconds
(order shuffled randomly each round)

If a delegate misses their slot, a missed block is recorded — hurting their credibility and potentially costing them votes.

The Structural Weakness of DPoS

51 is a small number. It needs to be said plainly:

Majority control requires: 26 delegates
Attack method: accumulate ARK → dominate votes → install loyal delegates

ARK market cap: ~$24 million
Elon Musk's net worth: ~$300 billion

ARK's entire market cap = 0.000008% of Musk's wealth

This isn’t hypothetical — similar events actually happened on EOS (2019) and Steem (2020). Ethereum’s PoS, by contrast, has over 1 million validators — making such an attack practically impossible.

---

Key Concepts

Concept	Explanation
Block	Transaction bundle + hash of previous block
Merkle Tree	Efficient structure for verifying transactions
Full Node	Stores all blocks, verifies independently
Light Node	Stores headers only, uses Merkle Proofs
DPoS	A small set of elected representatives create blocks

---

What’s Next

Part 2 digs into Ethereum’s mining algorithm — specifically Ethash. We’ll trace the full pipeline: Cache → DAG → Hashimoto, and see exactly why VRAM was non-negotiable.

---

Questions? Drop them in the comments. Happy to go deeper on anything.