---
# System prepended metadata

title: WEEK3 SOFTWARE ENGINEERING PROGRAM AT BLOCKFUSE LABS WEB3 COHORTIV

---

# WEEK4 SOFTWARE ENGINEERING BOOTCAMP AT BLOCKFUSE LABS WEB3 COHORTIV

## Ethereum Nodes.

We conitinued with the masteringetheruem book and we started with chapter3 and we learnt about the Etheruem node in which we were told to run an etheruem node either on Go and Rust. Before going further we have to know what is a node. An Ethereum node is a software application that implements the Ethereum specification and communicates over the P2P network with other Ethereum nodes. A node only had to run a single client to completely implement all the requirements to be part of the Ethereum ecosystem. But On September 15, 2022, The Merge hard fork happened, changing the consensus protocol from a PoW (Proof of Work) based scheme to Gasper, the new PoS (Proof of Stake) based consensus protocol. An Ethereum node must run two pieces of software at the same time to be compatible with the latest specification which are the consensus and execution client.

### Consensus Client
the consensus client software is now in charge of the consensus protocol that lets all nodes agree on a single history of the blockchain. these means that the work of the consensus client is that it let's all node agree on a single history of the blockchain.

### Execution Client
the execution client is responsisble for the focusing on receiving all the blocks and transactions happening on the network, executing them inside the EVM, and verifying their correctness. what these client does is that it executed all the transactions and the blocks on the etheruem network and then verifies if they are correct or not.

As of June 2025, there are five main implementations of the Ethereum execution protocol, written in four different languages, and five implementations of the Ethereum consensus protocol, written in five different languages:

* The execution clients are:
Geth, written in Go
Nethermind, written in C#
Besu, written in Java
Erigon, written in Go
Reth, written in Rust

* The consensus clients are:
Lighthouse, written in Rust
Lodestar, written in TypeScript
Nimbus, written in Nim
Prysm, written in Go
Teku, written in Java

#### RUNNING A FULL NODE.
Before you can be able to run a node you must have any of these languages installed on your laptop either Rust or Go or Java so you can use it to run both the consensus and the execution client so i used Rust which in installed lighthouse for the consensus client and then Reth for the execution client here are some few steps to follow to run a fullnode on your laptop.

##### Reth-Lighthouse
Let’s do the same thing but using two different clients: Reth as the execution client and Lighthouse as the consensus client.
First, you need to install Reth. Cloning the repository. The first step is to clone the Git repository to get a copy of the source code. Go back to your home directory and type the following commands:

##### Preparation Phase
Create a folder in your computer called ethereum-node2 and then two subfolders within it called execution and consensus these mkdir is short for makedirectory just like create a folder

```
mkdir ethereum-node2
cd ethereum-node2
mkdir execution
mkdir consensus
```

From the folder we created earlier on cd into that's go into the folder enter into that folder then enter into the execution folder onces you are there open your terminal and then clone the reth repository

```
cd ethereum-node2
cd execution
git clone https://github.com/paradigmxyz/reth
```

Building Reth from the source code we now enter into the reth folder once we have clone the repository

```
cd reth
cargo install --locked --path bin/reth --bin reth
```

check if Reth is correctly installed by running:

`reth --version`

you should see something like these:

```
reth Version: 0.2.0-beta.6-dev
Commit SHA: ac29b4b73
Build Timestamp: 2024-04-22T17:29:01.000000000Z
Build Features: jemallocBuild Profile: maxperf+
```

Now we would move to install Lighthouse.
we would now go into the consensus folder

` cd consensus `

you need to install some dependencies by running:

`brew install cmake`

then after that you would now clone the repository

`git clone https://github.com/sigp/lighthouse.git`
Building Lighthouse from source code. To build Lighthouse, you need to run the following command you would now enter into the lighthouse folder after you have cloned the repository

```
cd lighthouse
git checkout stable
make
```

Run the node
Note: you need to run the execution client, Reth, first before running the consensus client.

Running the execution client. Navigate back to the execution folder and run this command

here is the command to run to get your jwt please we would create it in the root folder of the ethereum-node2 where we see the execution and the consensus folder thats where we would create our jwt.

```
openssl rand -hex 32 > ethereum-node2/jwt.hex
cd ethereum-node2/jwt.hex ./jwt.hex # we use the same jwt.hex file we generated before
cd execution
reth node --full --http --http.api all --authrpc.jwtsecret=../jwt.hex
```

Running the consensus client. Now you should run the consensus client, Lighthouse. Don’t close the terminal tab in which the execution client lives. Just open a new terminal window or tab and navigate into the consensus folder

```
cd ethereum-node2
cd consensus
lighthouse bn \
    --network mainnet \
    --checkpoint-sync-url https://mainnet.checkpoint.sigp.io \
    --execution-endpoint http://localhost:8551 \
    --execution-jwt ../jwt.hex \
    --http
```

And you’re done! You should see both the execution and consensus client start logging lots of data on the terminal.

### The JSON-RPC Interface
Ethereum clients offer an API and a set of RPC commands, which are encoded as JSON. You will see this referred to as the JSON-RPC API. Essentially, the JSON-RPC API is an interface that allows us to write programs that use an Ethereum client as a gateway to an Ethereum network and blockchain. Usually, the RPC interface is offered as an HTTP service on port 8545. For security reasons, it is restricted by default to accept connections only from localhost (the IP address of your own computer, which is 127.0.0.1).

* Browser Wallets
these are wallets extensions of web browsers like Chrome and Firefox. These are remote clients that run inside your browser. Some of the more popular ones include:
1. MetaMask
2. Phantom
3. Rabby Wallet
4. Coinbase Wallet e.t.c,


* Hardware Wallets
The majority of mobile and browser wallets can be coupled with the higher security of hardware wallets: offline devices designed to never connect to the internet and built to resist tampering and other forms of physical attacks, providing a higher level of security. Several companies are building these kinds of devices, but two of the most widely used are Ledger and Trezor.