An Introduction to Geth and Running Ethereum Nodes

In this article, we’ll look at what Ethereum nodes are, and explore one of the most popular ones, called Geth.

In order to communicate with the blockchain, we must use a blockchain client. The client is a piece of software capable of establishing a p2p communication channel with other clients, signing and broadcasting transactions, mining, deploying and interacting with smart contracts, etc. The client is often referred to as a node.

The formal definition of the functionality an Ethereum node must follow is defined in the ethereum yellow paper. The yellow paper defines the required functions of nodes on the network, the mining algorithm, private/public key ECDSA parameters. It defines the entirety of features which make nodes fully compatible Ethereum clients.

--ADVERTISEMENT--

Based on the yellow paper, anyone is able to create their own implementation of an Ethereum node in whatever language they see fit.

A full list of clients can be seen here.

The most popular clients so far are Geth and Parity. The implementations differ mostly by the programming language of choice — where Geth uses Golang and Parity uses Rust.

Since Geth is the most popular client implementation currently available, we’ll focus on it for now.

Types of Nodes

When you’re joining the Ethereum network, you have an option of running
various types of nodes. The options currently are:

  • Light node
  • Full node
  • Archive node

An archive node is a special case of a full node, so we won’t go into detail on it. One of the best summaries on the types of nodes I’ve found is on Stack Exchange:

In general, we can divide node software into two types: full nodes and light(weight) nodes. Full nodes verify block that is broadcast onto the network. That is, they ensure that the transactions contained in the blocks (and the blocks themselves) follow the rules defined in the Ethereum specifications. They maintain the current state of the network (as defined according to the Ethereum specifications).

Transactions and blocks that do not follow the rules are not used to determine the current state of the Ethereum network. For example, if A tries to send 100 ether to B but A has 0 ethers and a block includes this transaction, the full nodes will realize this does not follow the rules of Ethereum and reject that block as invalid. In particular, the execution of smart contracts is an example of a transaction. Whenever a smart contract is used in a transaction (e.g., sending ERC-20 tokens), all full nodes will have to run all the instructions to ensure that they arrive at the correct, agreed-upon next state of the blockchain.

There are multiple ways of arriving at the same state. For example, if A had 101 ether and gave a hundred of them to B in one transaction paying 1 ether for gas, the end result would be the same as if A sent 100 transactions of 1 ether each to B paying 0.01 ether per transaction (ignoring who received the transaction fees). To know if B is now allowed to send 100 ether, it is sufficient to know what B’s current balance is. Full nodes that preserve the entire history of transactions are known as full archiving nodes. These must exist on the network for it to be healthy.

Nodes may also opt to discard old data; if B wants to send 100 ether to C, it doesn’t matter how the ether was obtained, only that B’s account contains 100 ether. Light nodes, in contrast, do not verify every block or transaction and may not have a copy of the current blockchain state. They rely on full nodes to provide them with missing details (or simply lack particular functionality). The advantage of light nodes is that they can get up and running much more quickly, can run on more computationally/memory constrained devices, and don’t eat up nearly as much storage. On the downside, there is an element of trust in other nodes (it varies based on client and probabilistic methods/heuristics can be used to reduce risk). Some full clients include features to have faster syncs (e.g., Parity’s warp sync).

Installing Geth

The installation instructions for Geth on various platforms (Windows, macOS, Linux) can be found here. The list is quite comprehensive and kept up to date, so I won’t go over it in the article.

Running Geth

In order to spin up a Geth node, the only thing you need to do is go to your terminal window and run geth. When you do it, you should get an output similar to this:

➜  ~ geth
INFO [06-03|11:03:13] Maximum peer count                       ETH=25 LES=0 total=25
INFO [06-03|11:03:13] Starting peer-to-peer node               instance=Geth/v1.8.10-stable/darwin-amd64/go1.10.2
INFO [06-03|11:03:13] Allocated cache and file handles         database=/Users/mjvr/Library/Ethereum/geth/chaindata cache=768 handles=128
INFO [06-03|11:03:13] Writing default main-net genesis block
INFO [06-03|11:03:14] Persisted trie from memory database      nodes=12356 size=2.34mB time=48.31016ms gcnodes=0 gcsize=0.00B gctime=0s livenodes=1 livesize=0.00B
INFO [06-03|11:03:14] Initialised chain configuration          config="{ChainID: 1 Homestead: 1150000 DAO: 1920000 DAOSupport: true EIP150: 2463000 EIP155: 2675000 EIP158: 2675000 Byzantium: 4370000 Constantinople: <nil> Engine: ethash}"
INFO [06-03|11:03:14] Disk storage enabled for ethash caches   dir=/Users/mjvr/Library/Ethereum/geth/ethash count=3
INFO [06-03|11:03:14] Disk storage enabled for ethash DAGs     dir=/Users/mjvr/.ethash                      count=2
INFO [06-03|11:03:14] Initialising Ethereum protocol           versions="[63 62]" network=1
INFO [06-03|11:03:14] Loaded most recent local header          number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Loaded most recent local full block      number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Loaded most recent local fast block      number=0 hash=d4e567…cb8fa3 td=17179869184
INFO [06-03|11:03:14] Regenerated local transaction journal    transactions=0 accounts=0
INFO [06-03|11:03:14] Starting P2P networking
INFO [06-03|11:03:16] UDP listener up                          self=enode://a4cb08519bc2bceecb8ad421871c624d5212888653bbaee309fda960f3c87ca7aa9855ee14684d521836ae88ad1986b8ca944348e976760d2bd1247ed3ca7628@[::]:30303
INFO [06-03|11:03:16] RLPx listener up                         self=enode://a4cb08519bc2bceecb8ad421871c624d5212888653bbaee309fda960f3c87ca7aa9855ee14684d521836ae88ad1986b8ca944348e976760d2bd1247ed3ca7628@[::]:30303
INFO [06-03|11:03:16] IPC endpoint opened                      url=/Users/mjvr/Library/Ethereum/geth.ipc

After this, you should see new lines appear periodically, where Geth says “Importing new state” or “Importing new block headers” or “Importing new receipts”. The state, block headers and transactions are part of Ethereum’s tree tries: they must be downloaded in order to synchronize your node with the Ethereum blockchain.

This is a process which can take a really long time, so one of the options you have is to run a light node like this;

geth --light

What Geth needs to do now is only pull the latest block headers and rely on other full nodes to validate transactions through the usage of merkle proofs.

Accessing a Geth Console

Now that you’ve created a node, you can access it by opening up a new tab in your terminal and running the following:

geth attach

This will connect a Geth console — which is a Javascript environment for communicating with the blockchain — to your running node. This can be done in both the full client mode and the light mode.

After you’ve opened the console, type this:

web3.eth.blockNumber

You should get an output as a number (e.g. 5631487) which represents the current block number of the Ethereum network.

Creating a New Account

In order to use the blockchain, you need to have an account. With Geth, you can do it by running the following in your terminal:

geth account new

After you’ve done that, it will ask you for the password, which you’ll need to protect your account. Make sure to use a secure password and to store it safely.

What Geth does when you run geth account new is update a file in the Geth data directory (a directory where Geth stores all the necessary data, including blocks and headers). The locations are (per platform):

  • macOS: ~/Library/Ethereum
  • Linux: ~/.ethereum
  • Windows: %APPDATA%\Ethereum

Accessing Geth from Other Clients

When you start Geth, the client automatically starts an RPC server at port 8545. You can access the RPC server and its methods on this port by connecting to localhost:8545 with a library like web3js or web3j or call it manually with curl or wget.

To learn about connecting with external tools like those to a running Geth instance (either private when launching your own blockchain, or public as in the instructions above) see this post.

Conclusion

In this short introduction we covered Geth, the types of Ethereum nodes, and their purpose. You can now run a Geth node of your own, and enhance it with third-party tools. In future articles, we’ll cover running private networks (your own Ethereum blockchain with Geth) and much more.