Capstok — learn by doing

Why this matters

The architectural leap isn't cryptographic — it's that there is no api.ethereum.com. Every full node holds the entire ledger, re-executes every transaction, and enforces identical rules. You don't ask a server 'is this transaction valid' — you run the rules yourself, or trust one of thousands of peers who does.

Demo

At this moment there are roughly 8,000 Ethereum execution-layer full nodes and 1M+ validators running consensus clients, plus tens of thousands of Bitcoin nodes. None of them is authoritative. If you run geth/reth/erigon locally and sync, your laptop is as canonical as Vitalik's — same rules, same state root. Contrast this with api.stripe.com, where Stripe's DB is the only truth.

Try it yourself

Run both curl commands within a second of each other. They should return the same block number in hex (off by at most 1).
Open ethernodes.org and look at the client diversity chart. Note how many independent implementations (geth, nethermind, reth, erigon, besu) are running — that's your trust diversity.
Find the hardware requirements for a full Ethereum node (~2TB NVMe, 16GB RAM). Compare to 'run a Stripe node' — a category that doesn't exist. Write one sentence on why that difference matters.

Prompt your AI

Use these three in order. Each builds on the one before.

1. Basics & terminology

Explain the difference between a full node, a light node, and an archive node on Ethereum. What does each store, roughly?

2. Why it works (the mechanism)

When my `eth_call` hits Infura, what does Infura's infrastructure actually do to answer it? Where does the ledger data live, and why is it replaceable with any other provider or my own node?

3. Advanced — application & what's next

If I'm building a DeFi app and I depend on Alchemy for RPC: what failure modes does that dependency reintroduce, and how would 'running your own node' actually help vs. multi-provider fallback? Be specific about latency, censorship, and data consistency.

References

// main.go — query eth_blockNumber from two public RPCs and compare
// Run: go run main.go   (stdlib only)
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
)

func blockNumber(rpc string) (int64, error) {
	body := []byte(`{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}`)
	resp, err := http.Post(rpc, "application/json", bytes.NewReader(body))
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()
	var out struct {
		Result string `json:"result"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return 0, err
	}
	return strconv.ParseInt(out.Result[2:], 16, 64)
}

func main() {
	for _, rpc := range []string{"https://cloudflare-eth.com", "https://eth.llamarpc.com"} {
		n, err := blockNumber(rpc)
		if err != nil {
			fmt.Println(rpc, "-> error:", err)
			continue
		}
		fmt.Println(rpc, "->", n)
	}
}

Run: go run main.go

Nodes, Not Servers