Node implementation for the Avalanche network –
a blockchains platform with high throughput, and blazing fast transactions.
Avalanche is an incredibly lightweight protocol, so the minimum computer requirements are quite modest.
Note that as network usage increases, hardware requirements may change.
The minimum recommended hardware specification for nodes connected to Mainnet is:
- CPU: Equivalent of 8 AWS vCPU
- RAM: 16 GiB
- Storage: 512 GiB
- OS: Ubuntu 18.04/20.04 or macOS >= 10.15 (Catalina)
- Network: Reliable IPv4 or IPv6 network connection, with an open public port.
If you plan to build AvalancheGo from source, you will also need the following software:
Clone the AvalancheGo repository:
git clone [email protected]:ava-labs/avalanchego.git cd avalanchego
This will clone and checkout to
Building the Avalanche Executable
Build Avalanche using the build script:
The Avalanche binary, named
avalanchego, is in the
Install AvalancheGo using an
Adding the APT Repository
If you have already added the APT repository, you do not need to add it again.
To add the repository on Ubuntu 18.04 (Bionic), run:
sudo su - wget -O - https://downloads.avax.network/avalanchego.gpg.key | apt-key add - echo "deb https://downloads.avax.network/apt bionic main" > /etc/apt/sources.list.d/avalanche.list exit
To add the repository on Ubuntu 20.04 (Focal), run:
sudo su - wget -O - https://downloads.avax.network/avalanchego.gpg.key | apt-key add - echo "deb https://downloads.avax.network/apt focal main" > /etc/apt/sources.list.d/avalanche.list exit
Installing the Latest Version
After adding the APT repository, install avalanchego by running:
sudo apt update sudo apt install avalanchego
Download the latest build for your operating system and architecture.
The Avalanche binary to be executed is named
Make sure docker is installed on the machine – so commands like
docker run etc. are available.
Building the docker image of latest avalanchego branch can be done by running:
To check the built image, run:
docker image ls
The image should be tagged as
xxxxxxxx is the shortened commit of the Avalanche source it was built from. To run the avalanche node, run:
docker run -ti -p 9650:9650 -p 9651:9651 avaplatform/avalanchego:xxxxxxxx /avalanchego/build/avalanchego
Connecting to Mainnet
To connect to the Avalanche Mainnet, run:
You should see some pretty ASCII art and log messages.
You can use
Ctrl+C to kill the node.
Connecting to Fuji
To connect to the Fuji Testnet, run:
Creating a Local Testnet
See this tutorial.
A node needs to catch up to the latest network state before it can participate in consensus and serve API calls. This process, called bootstrapping, currently takes several days for a new node connected to Mainnet.
A node will not report healthy until it is done bootstrapping.
Improvements that reduce the amount of time it takes to bootstrap are under development.
The bottleneck during bootstrapping is typically database IO. Using a more powerful CPU or increasing the database IOPS on the computer running a node will decrease the amount of time bootstrapping takes.
Avalanchego uses multiple tools to generate efficient and boilerplate code.
Running protobuf codegen
To regenerate the protobuf go code, run
scripts/protobuf_codegen.sh from the root of the repo.
This should only be necessary when upgrading protobuf versions or modifying .proto definition files.
To use this script, you must have protoc (v3.17.3), protoc-gen-go (v1.26.0) and protoc-gen-go-grpc (v1.1.0) installed. protoc must be on your $PATH.
To install the protoc dependencies:
go install google.golang.org/protobuf/cmd/[email protected] go install google.golang.org/grpc/cmd/[email protected]
If you have not already, you may need to add
$GOPATH/bin to your
export PATH="$PATH:$(go env GOPATH)/bin"
If you extract protoc to ~/software/protobuf/, the following should work:
export PATH=$PATH:~/software/protobuf/bin/:~/go/bin go get google.golang.org/protobuf/cmd/protoc-gen-go go get google.golang.org/protobuf/cmd/protoc-gen-go-grpc scripts/protobuf_codegen.sh
For more information, refer to the GRPC Golang Quick Start Guide.
Running protobuf codegen from docker
docker build -t avalanche:protobuf_codegen -f Dockerfile.protoc . docker run -t -i -v $(pwd):/opt/avalanche -w/opt/avalanche avalanche:protobuf_codegen bash -c "scripts/protobuf_codegen.sh"
AvalancheGo can run on different platforms, with different support tiers:
- Tier 1: Fully supported by the maintainers, guaranteed to pass all tests including e2e and stress tests.
- Tier 2: Passes all unit and integration tests but not necessarily e2e tests.
- Tier 3: Builds but lightly tested (or not), considered experimental.
- Not supported: May not build and not tested, considered unsafe. To be supported in the future.
The following table lists currently supported platforms and their corresponding
AvalancheGo support tiers:
|Architecture||Operating system||Support tier|
To officially support a new platform, one must satisfy the following requirements:
|AvalancheGo continuous integration||Tier 1||Tier 2||Tier 3|
|Unit and integration tests pass||✓||✓|
|End-to-end and stress tests pass||✓|
We and our community welcome responsible disclosures.
If you’ve discovered a security vulnerability, please report it via our bug bounty program. Valid reports will be eligible for a reward (terms and conditions apply).