Back to Articles

Running Reth on Hoodi: The Chillest Ethereum Testnet Setup Guide 🦀

August 15, 2025
Ethereum Reth Hoodi Testnet Rust Node Tutorial

Warning: This guide contains an excessive amount of chill vibes, crab emojis, and dad jokes about blockchain. Proceed with caution (and maybe some snacks). 🍿

Introduction: Welcome to the Hoodi Hood 🎭

So you want to run your own Ethereum node, huh? Tired of trusting other people’s RPC endpoints? Want to feel the raw power of being your own bank AND your own infrastructure? Well, my friend, you’ve come to the right place!

Meet Hoodi - Ethereum’s newest testnet that’s so chill, it makes Holesky look stressed out. And we’re going to run it with Reth (pronounced “wreath” 🎄), the Rust-based Ethereum client that’s faster than your ex running away from commitment.

Hoodi Vibes When someone asks why you’re running a testnet node

Why Hoodi? Why Reth? Why Not Just Use Metamask Like Everyone Else? 🤔

Great questions! Let me break it down for you:

Hoodi Testnet:

  • 🆕 Brand new (launched March 17, 2025)
  • 🔗 Chain ID: 560048 (easy to remember… if you’re a computer)
  • 🎯 Built for staking and infrastructure testing
  • 💰 Free ETH (it’s testnet, don’t get too excited)

Reth Client:

  • 🦀 Written in Rust (because we’re not masochists)
  • ⚡ Fast as lightning ⚡
  • 🔥 Burns less CPU than your laptop running Chrome with 47 tabs
  • 🛠️ Built by the same folks who brought you Foundry

“But why not just use Infura?” - Person who clearly doesn’t understand the beauty of decentralization

Because, dear reader, running your own node is like growing your own vegetables. Sure, you can buy them from the store, but there’s something magical about saying “I BUILT THIS” while pointing at your terminal showing block numbers incrementing.

Prerequisites: What You Need (Besides Patience) 📋

Before we dive into this blockchain adventure, make sure you have:

  • A Linux machine (Windows users, WSL is your friend)
  • At least 16GB RAM (32GB if you want to multitask like a pro)
  • 2TB+ SSD storage (HDDs are for storing family photos, not blockchains)
  • Decent internet (dial-up users from 1999, this isn’t for you)
  • Basic command line skills (if sudo rm -rf / scares you, you’re ready)
  • A sense of humor (absolutely essential for blockchain development)

System Requirements Meme Your computer when you tell it to sync an Ethereum node

Step 1: Installing Reth (The Rust-y Way) 🦀

First, let’s get Reth installed. Think of this as adopting a very smart, very hungry digital pet that eats blocks for breakfast.

 1# Download the latest Reth binary (because compiling Rust takes forever)
 2RETH_VERSION="v1.6.0"  # Check GitHub for the latest version
 3curl -LO "https://github.com/paradigmxyz/reth/releases/download/${RETH_VERSION}/reth-${RETH_VERSION}-x86_64-unknown-linux-gnu.tar.gz"
 4
 5# Extract it (like unwrapping a blockchain Christmas present)
 6tar -xzf reth-${RETH_VERSION}-x86_64-unknown-linux-gnu.tar.gz
 7
 8# Move it to a place where your system can find it
 9sudo mv reth /usr/local/bin/
10
11# Check if it worked (fingers crossed!)
12/usr/local/bin/reth --version

If you see a version number, congratulations! You’re now the proud owner of a Rust-based Ethereum client. If you see an error, welcome to software development - grab some coffee and check the GitHub issues. ☕

Pro Tip: If you have a shell alias conflict (like I did), use the full path /usr/local/bin/reth instead of just reth. Future you will thank past you.

Step 2: Setting Up the Fortress (User & Permissions) 🏰

We’re going to create a dedicated user for Reth because security is sexy, and nobody wants their node running as root like it’s 1995.

1# Create a system user named 'rethm' (short for "Reth Master")
2sudo useradd --no-create-home --shell /bin/false rethm
3
4# Create the data directory (Reth's new home)
5sudo mkdir -p /var/lib/reth
6
7# Give our user ownership (it's like a blockchain house deed)
8sudo chown -R rethm:rethm /var/lib/reth
9sudo chmod -R 755 /var/lib/reth

Security Meme When you properly configure user permissions

Step 3: The Secret Sauce (JWT Token) 🔐

Every good blockchain setup needs a secret handshake. In our case, it’s a JWT token that lets the execution layer (Reth) talk to the consensus layer. Think of it as a VIP pass to the blockchain club.

1# Generate a super secret JWT token (shhh! 🤫)
2sudo openssl rand -hex 32 | sudo tee /var/lib/reth/jwt.hex > /dev/null
3
4# Make it super secure (more secure than your password123)
5sudo chmod 600 /var/lib/reth/jwt.hex
6sudo chown rethm:rethm /var/lib/reth/jwt.hex

This JWT token is what we call “cryptographically secure” - which is fancy talk for “even your hacker neighbor Kyle can’t guess it.”

Step 4: Systemd Configuration (Making It Professional) 🎩

Now we’re going to set up Reth as a proper system service. This means it’ll start automatically, restart if it crashes, and generally behave like a responsible adult (unlike most crypto projects).

Create the service file:

1sudo nano /etc/systemd/system/reth.service

And paste this configuration (it’s like a recipe, but for blockchain):

 1[Unit]
 2Description=Reth Ethereum Execution Client
 3After=network.target
 4
 5[Service]
 6User=rethm
 7Group=rethm
 8Type=simple
 9Restart=always
10RestartSec=5
11WorkingDirectory=/var/lib/reth
12ExecStart=/usr/local/bin/reth node \
13  --chain hoodi \
14  --datadir /var/lib/reth \
15  --http \
16  --http.addr 127.0.0.1 \
17  --http.port 8545 \
18  --http.api eth,net,web3,admin,debug,txpool \
19  --authrpc.jwtsecret /var/lib/reth/jwt.hex \
20  --authrpc.addr 127.0.0.1 \
21  --authrpc.port 8551 \
22  --metrics 127.0.0.1:9000 \
23  --log.file.directory /var/lib/reth/logs
24
25# Security Enhancements (because we're not animals)
26LimitNOFILE=1048576
27LimitNPROC=1048576
28PrivateTmp=true
29ProtectHome=true
30NoNewPrivileges=true
31ReadWritePaths=/var/lib/reth
32
33[Install]
34WantedBy=multi-user.target

What all this magic means:

  • --chain hoodi: We’re joining the cool kids’ Hoodi testnet
  • --http.port 8545: Your personal RPC endpoint (like having your own Infura)
  • --authrpc.port 8551: The secret door for consensus clients
  • --metrics 127.0.0.1:9000: Because who doesn’t love graphs? 📊

Configuration Meme When your systemd configuration works on the first try

Step 5: Launch Time! (The Moment of Truth) 🚀

Time to fire up this bad boy and see if we’ve successfully assembled our blockchain IKEA furniture without any leftover screws:

 1# Create the logs directory (Reth is chatty and needs somewhere to vent)
 2sudo mkdir -p /var/lib/reth/logs
 3
 4# Enable the service (tell systemd this is important)
 5sudo systemctl daemon-reload
 6sudo systemctl enable reth
 7
 8# Start the engines! 🚀
 9sudo systemctl start reth
10
11# Check if it's alive and kicking
12sudo systemctl status reth

If you see active (running), pop the champagne! 🍾 If you see failed, don’t panic - debugging is just problem-solving with more cursing.

Step 6: Health Check (Is This Thing On?) 🩺

Let’s make sure your node is actually doing node things:

 1# Check if we're connected to the right network
 2curl -X POST -H "Content-Type: application/json" \
 3     --data '{"jsonrpc":"2.0","method":"net_version","params":[],"id":1}' \
 4     http://127.0.0.1:8545
 5# Should return "560048" (Hoodi's network ID)
 6
 7# Check peer count (friends are important)
 8curl -X POST -H "Content-Type: application/json" \
 9     --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' \
10     http://127.0.0.1:8545
11
12# Check sync status
13curl -X POST -H "Content-Type: application/json" \
14     --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' \
15     http://127.0.0.1:8545

Health Check Meme When all your RPC calls return successfully

Step 7: Monitoring Your Node (Keeping Tabs on Your Digital Baby) 👶

Your node is like a Tamagotchi - it needs constant attention and occasional feeding (of blocks).

Watch the Logs (Node TV)

1# Live logs (better than Netflix)
2sudo journalctl -f -u reth.service
3
4# Recent logs (the highlight reel)
5sudo journalctl -u reth.service -n 50

Quick Status Checks

1# Service status
2sudo systemctl status reth
3
4# Peer count check
5curl -s -X POST -H "Content-Type: application/json" \
6     --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' \
7     http://127.0.0.1:8545 | jq -r '.result'

Metrics Dashboard (For the Data Nerds)

Visit http://127.0.0.1:9000/metrics in your browser for Prometheus metrics. It’s like a health dashboard for your node, but with more numbers and less dramatic music.

Common Issues (When Things Go Wrong) 🔧

Because let’s be real - something always goes wrong in blockchain land.

“Permission Denied” Errors

1# Fix ownership (the universal blockchain solution)
2sudo chown -R rethm:rethm /var/lib/reth
3sudo chmod -R 755 /var/lib/reth
4sudo chmod 600 /var/lib/reth/jwt.hex

“No Peers” Problem

  • Check your firewall (port 30303 needs to be open)
  • Wait patiently (P2P networks are social, they need time to make friends)
  • Make sure your internet isn’t powered by hamsters

“Sync is Slow”

  • Get a faster SSD (your HDD is not helping)
  • More RAM = more happy
  • Patience, young Padawan

Debugging Meme When you finally fix that one bug that’s been haunting you

Advanced Testing (For the Overachievers) 🎓

Want to really flex your node? Here are some advanced tests:

Create a Test Script

Save this as test_node.sh and make it executable:

 1#!/bin/bash
 2echo "🧪 Testing Your Reth Node Like a Pro"
 3echo "=================================="
 4
 5# Test basic functionality
 6echo "📊 Node Version: $(curl -s -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":1}' http://127.0.0.1:8545 | jq -r '.result')"
 7
 8# Check network
 9PEERS=$(curl -s -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' http://127.0.0.1:8545 | jq -r '.result')
10echo "🌐 Connected Peers: $((16#${PEERS#0x}))"
11
12# Storage usage
13echo "💾 Data Directory Size: $(du -sh /var/lib/reth | cut -f1)"
14
15echo "🎉 Node test complete! You're officially running Hoodi!"

Performance Testing

1# Stress test your RPC (because why not?)
2for i in {1..100}; do
3    curl -s -X POST -H "Content-Type: application/json" \
4         --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
5         http://127.0.0.1:8545 >/dev/null
6    echo "Request $i complete"
7done

What’s Next? (Your Blockchain Journey Continues) 🛣️

Congratulations! You’re now running your own piece of the Ethereum ecosystem. But wait, there’s more!

Add a Consensus Client

Your Reth node is lonely. It needs a consensus client friend (like Lighthouse, Teku, or Prysm) to be a complete Ethereum node. Think of it as blockchain dating - they need each other to be happy.

Connect Your Wallet

Add your node to MetaMask:

  • Network Name: Hoodi Testnet
  • RPC URL: http://127.0.0.1:8545
  • Chain ID: 560048
  • Symbol: ETH

Build Something Cool

Now that you have your own RPC endpoint, build a dApp! Or just flex on Twitter that you’re running your own infrastructure. Both are valid life choices.

Success Meme When you successfully run your own Ethereum node

Conclusion: You Did It! 🎉

You’ve successfully set up a Reth node on the Hoodi testnet. You’re now part of the decentralized infrastructure that powers Ethereum. You’re basically a blockchain hero - cape not included, but definitely earned.

Key Takeaways:

  • ✅ Reth is fast and efficient (like a blockchain sports car)
  • ✅ Hoodi is the chill testnet we all needed
  • ✅ Running your own node is empowering (and slightly addictive)
  • ✅ Systemd makes everything professional
  • ✅ JWT tokens are the blockchain equivalent of a secret handshake

Commands to Remember:

 1# Check service status
 2sudo systemctl status reth
 3
 4# Watch logs (node entertainment)
 5sudo journalctl -f -u reth.service
 6
 7# Test RPC
 8curl -X POST -H "Content-Type: application/json" \
 9     --data '{"jsonrpc":"2.0","method":"net_version","params":[],"id":1}' \
10     http://127.0.0.1:8545

Remember: Running infrastructure is a journey, not a destination. Your node will have good days and bad days, just like the rest of us. When in doubt, check the logs, restart the service, and remember that every blockchain veteran has been where you are now.

Now go forth and decentralize! The Hoodi testnet awaits your contributions. 🚀

P.S. If this guide helped you, consider starring the Reth repository and maybe buying the devs a coffee. They’re doing the hard work so we can have nice things.

P.P.S. If you broke something while following this guide, it’s definitely not your fault. Blockchain is hard, computers are weird, and sometimes Mercury is in retrograde. Try turning it off and on again. 🌙

Final Meme You, after successfully running your own Ethereum infrastructure

Ready for more blockchain adventures? Check out my other articles on portfolio or connect with me on LinkedIn for more hot takes on decentralized infrastructure, Rust development, and why running your own node is basically like having a pet that eats electricity and poops transaction receipts.