Marketplace has launched, further enabling blockchain developers! Learn more

How to connect to Ethereum network using Go

September 23, 2022

Overview

Go helps you make faster scalable backends and this guide will show you how to connect your backend to Ethereum (and make it even faster, more reliable, and globally accessible, all thanks to QuickNode’s global infrastructure). 

What is GoLang?
Go is an open-source programming language launched by Google engineers in 2009. It was partially derived from C, adopting C’s syntax and features but with memory safety, garbage collection, structural typing, and concurrency. Go features super efficient concurrency mechanisms that take full advantage of modern multi-core hardware along with distributed networked infrastructures.

Go’s key features:
  1. Statically typed and fast compiled, produces binary executables - which are FAST
  2. Cross-platform with mobile support runs on most platforms and has native libraries 
  3. Strong support for concurrency with built-in primitives. Uses Goroutines which consume very little memory, featuring fast startup time, and can run multiple threads
  4. Simple and minimalist (full reference is only 50 pages)
  5. Strong standard library with lots of addons
  6. Pointers and parameters by reference - don’t you miss those?

Connecting to ethereum with Geth aka go-ethereum:
go-ethereum is the official implementation of Ethereum in Go, (also known as Geth), the ethclient package can be used for Ethereum RPC API.

Prerequisites
  • Go version 1.13 or above installed
  • A text editor
  • CLI

How to install Go and basic error handling

As mentioned, if we want to use the go-ethereum client, we will need to check if Go is installed on your system:

how to install go and basic error handling

Copy
$ go version

If Go is not installed, follow the official installation guide for your specific OS.

Make sure you have the gcc compiler installed as well.
For Ubuntu - use apt-get install build-essentials
For Windows - use https://jmeubank.github.io/tdm-gcc/download/
For Mac - using homebrew

how to install go and basic error handling

Copy
$ brew install gcc
another faster option is getting XCode Command Line Tools using 

how to install go and basic error handling

Copy
$ xcode-select --install

If you’re not familiar with Go, we recommend running their interactive tutorial that will cover the basic syntax, methods, and concurrency handling. There are some exercises you can run all without having to leave your environment. Simply type the command below into your command line / terminal to run the tutorial locally:

how to install go and basic error handling

Copy
$ go get golang.org/x/tour
Now type:

how to install go and basic error handling

Copy
$ tour

Booting our Ethereum node

Any Ethereum node may be used for the purpose of this guide - Geth or OpenEthereum (fka Parity). For the sake of simplicity, let’s grab a free endpoint from QuickNode, which makes everything much easier with less overhead. After you've created your free Ethereum node, copy your HTTP Provider endpoint, as you will need it later. QuickNode makes booting, running, and maintaining your own node a painless experience. Developers no longer need to wait days for full sync, sacrifice terabytes of storage space, and worry about security and maintenance.

A screenshot of the Getting Started page on QuickNode with HTTP and WSS links for the Ethereum endpoint


You'll need this later, so copy it and save it.

Connecting via Go

The following will show you how to initialize your Go project, connect to the Ethereum network and get the latest block number, quickly, easily, and headache-free, provided you have installed the latest version of Go on your environment. 

1. Create a file called quiknode.go 

connecting via go

Copy
package main

import (
	"fmt"
	"log"

	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {

	client, err := ethclient.Dial("ADD_YOUR_ETHEREUM_NODE_URL")

	if err != nil {
		log.Fatalf("Oops! There was a problem", err)
	} else {
		fmt.Println("Success! you are connected to the Ethereum Network")
	}
}

Replace `ADD_YOUR_ETHEREUM_NODE_URL` with the provider endpoint you saved earlier.

2. Create a module to track dependencies. If you’re not familiar with go, this is an essential step in setting up your project’s dependencies. With Go it’s quite easy

Simply type:

connecting via go

Copy
$ go mod init quiknode

This will ensure the ethclient that was included in your code is downloaded from GitHub and installed locally. It happens automatically and the latest version should be pulled into your environment along with built-in Go modules. 

3. Run your module with 

connecting via go

Copy
$ Go run quiknode.go

If everything goes well, you will see the following message:


That was easy! You are now running your own node that is connected and synced. Next, check if your node is working and pull some information from the blockchain.
  
4. Modify your code to obtain additional information from the ETH blockchain:
 

connecting via go

Copy
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("ADD_YOUR_ETHEREUM_NODE_URL")
   
    if err != nil {
		log.Fatalf("Oops! There was a problem", err)
    } 
    else {
		fmt.Println("Sucess! you are connected to the Ethereum Network")
	}
	header, err := client.HeaderByNumber(context.Background(), nil)
	if err != nil{
		log.Fatal(err)
	} 
	else {
		fmt.Println(header.Number.String())
	}
}

 A quick explanation of the code above:
Lines 1-9: Declaring the main package and adding dependencies necessary to connect to the blockchain.
Line 11: Invoking the main function.
Line 12: Setting up our client and connecting it to an Ethereum node hosted by QuickNode.
Line 14: Checking for connection errors.
Line 18: Displaying a message on the successful connection.
Line 20: Sending a request to our node to obtain the latest block number.
Lines 21-26: Checking for request error and outputting a success message if no errors, converting the hash number to a string and displaying it.

Don’t forget to replace `ADD_YOUR_ETHEREUM_NODE_URL` with the http endpoint address for your own node. 

Upon successful execution, you will see a similar message:


That’s it! You can now use your own QuickNode and build the next awesome dApp using Go.

Conclusion

This guide showed you how to connect to the Ethereum network using Go and a free QuikNode Ethereum Node. We encourage you to learn more about the various RPC methods of ethclient  in their docs and explore the go-ethereum's GitHub for other modules.

Also, learn how to spin up your own go-ethereum/geth node in our tutorial on 'How to install and run a Geth node.'

Subscribe to our newsletter for more articles and QuikNode guides on Ethereum. Share your feedback on Twitter, and ask us anything on Discord

Related articles 18

Pending and Queued Transactions Explained
Published: Mar 18, 2022
Updated: Sep 23, 2022

The Ethereum network processes over one million transactions a day. These transactions originate from users wanting to transfer Ether or interact with smart contracts. In this guide, we will...

Continue reading
What is Ethereum?
Published: Sep 23, 2022
Updated: Sep 26, 2022

Ethereum is a decentralized and open-sourced blockchain network that allows anyone in the world to participate and interact with it. In this guide, you will learn what Ethereum is, how it...

Continue reading
What are Ethereum Transactions?
Published: Mar 28, 2022
Updated: Sep 23, 2022

Transactions in Ethereum are cryptographically signed data messages that contain a set of instructions. These instructions can interpret to sending Ether from one Ethereum account to another...

Continue reading
How To Fork Ethereum Mainnet with Hardhat
Published: Jul 13, 2021
Updated: Oct 18, 2022

Forking the chain at an older block of the blockchain is helpful if you want to simulate the blockchain’s state at that block; Hardhat has this functionality built in. In this guide, let’s go...

Continue reading
How to Send an EIP-1559 Transaction
Published: Dec 3, 2021
Updated: Sep 23, 2022

While Ethereum has been trying to scale, it has encountered some gas price issues. Many layer 2 solutions and sidechains sprang into existence to solve this problem, but Ethereum is the main...

Continue reading