Guide to Running a Full Mainnet Node on the Celo Network

By Smoljanović | Smoljanovic | 1 Jun 2023

Guide to Running a Full Mainnet Node on the Celo Network

I became interested in the prospect of running my own node on the Celo Network shortly after my activity with Jumptoken on the Celo network using Jumptask while earning via Honeygain. The goal was to use a bridge from Celo network to BSC to transfer tokens to Binance. in my previous article Transferring JumpToken Between Celo and BSC Networks using PortalBridge.

The Celo network is an open platform that aims to make financial tools accessible to anyone with a mobile phone. It is built on blockchain technology and focuses on creating a more inclusive financial system. The interesting thing I found out about Celo is that it is a smart-phone-based DeFi ecosystem.

Although cost-effective, it appears Celo is currently lacking infrastructure, but I suspect Celo may advance into the banking sector in the near future.

Yeah, so anyway, to cut things short, running a full mainnet node on the Celo network allows you to contribute to the network's security and decentralization while enabling you to interact with the Celo ecosystem.

Prerequisites:

Before you begin, ensure that you have the following prerequisites:

Hardware requirements:

Running a full mainnet node on the Celo network requires a machine with sufficient computing power and storage capacity. As of now, the recommended specifications include a machine with at least 4 CPU cores, 16GB of RAM, and 500GB of available storage. I find that much less RAM is necessary for Linux and MacOS than for Windows. My desktop uses 64GB of RAM while my laptop only has 32GB. Using SSD is the best way to go and potentially reduces the amount of RAM required.

Operating system:

Celo supports various operating systems, including Linux, macOS, and Windows. Choose the one that best suits your needs and ensure that it meets the minimum requirements. My personal preference listed in order would be Linux, MacOS and then Windows but is your choice.

OS specific steps for setup are included below just before my conclusion, but I suggest using the instructions directly from the software repositories (repos), as I don't want to be responsible for coding errors.

Yeah, no, I may, or may not have tested anything beyond the realm of my imagination.

Internet connection:

A stable and reliable internet connection is essential for running a full mainnet node. Make sure you have a high-speed internet connection with sufficient bandwidth. Don't try this at home with a 2400 baud modem!

Celo software:

You will need to download and install the Celo software to run your mainnet node. Visit the Celo GitHub Celo Mono Repo and follow the instructions for installing the software based on your operating system.

General node setup guide:

Follow the upcoming steps to set up and run your full mainnet node on the Celo network.

Download the blockchain data:

To save time and bandwidth, you can download a recent snapshot of the Celo blockchain. Visit the Celo GitHub repository and download the latest snapshot file. This file contains the most recent state of the blockchain, which will significantly reduce the time required to sync your node.

Install and configure the Celo software:

Once you have downloaded the Celo software, follow the installation instructions provided in the repository. Make sure to configure the software according to your preferences, such as specifying the data directory and network settings.

Sync your node:

If you downloaded the snapshot in step 1, you could use it to bootstrap your node. Move the downloaded snapshot file to the appropriate data directory specified during the installation. Then, start the Celo software and let it sync with the network. This process may take several hours or even days, depending on your hardware and internet connection.

Keep your node up to date:

It is crucial to keep your mainnet node up to date with the latest software releases and security patches. Regularly check the Celo GitHub repository for updates and follow the instructions to update your node accordingly.

Configure network and security settings:

Ensure that you have properly configured your network and security settings. This includes setting up firewalls, opening the necessary ports, and implementing any additional security measures recommended by the Celo network.

Monitor and maintain your node:

Running a full mainnet node requires ongoing monitoring and maintenance. Keep an eye on your node's performance, check for any error messages or warnings, and take appropriate actions as needed. Regularly back up your node's data to prevent data loss.

Setup with Linux:

Step 1: Set Up the Environment

Ensure that you have a Linux machine with the necessary system requirements, including sufficient storage, memory, and processing power.
Install Docker on your Linux machine. Refer to the Docker documentation for instructions specific to your Linux distribution.

Step 2: Clone the Celo-Monsoon Repository

Open a terminal on your Linux machine.
Clone the Celo-Monsoon repository by running the following command:

git clone https://github.com/celo-org/celo-monorepo.git

Step 3: Build the Docker Image

Navigate to the cloned `celo-monorepo` directory:

cd celo-monorepo

Build the Docker image by running the following command:

docker build -f dockerfiles/fullnode.Dockerfile -t celo-fullnode.

Step 4: Configure the Node

Create a new directory to store the node configuration files:

mkdir celo-node

cd celo-node

Generate a new account key for your node by running the following command:

docker run --rm -v $PWD:/root/.celo celo-fullnode generate account

This will create a new key file named `keystore` in the `celo-node` directory.

Create a new file named `genesis.json` and copy the Celo Mainnet genesis block configuration into it. You can obtain the latest genesis block configuration from the Celo documentation or official sources.

Create a file named `config.toml` and configure the node parameters. Refer to the Celo documentation for the required configuration options.

Step 5: Start the Node

Start the node by running the following command:

docker run -d --name celo-node -v $PWD:/root/.celo -p 127.0.0.1:8545:8545 -p 127.0.0.1:30503:30503 -p 127.0.0.1:30504:30504 celo-fullnode --verbosity 3 --networkid 42220

Adjust the ports (`8545`, `30503`, `30504`) as needed.

Monitor the node's logs by running the following command:

docker logs -f celo-node

Setup with MacOS:

Install Prerequisites

- Homebrew: If you don't have Homebrew, install it by following the instructions at https://brew.sh/.

- Node.js: Install Node.js by running the following command in your terminal:

brew install node@14

Set Up the Environment

- Create a new directory for your Celo node and navigate to it:

mkdir celo-node

cd celo-node

Clone the Celo-Monorepo Repository

- Clone the Celo-Monorepo repository from GitHub by running the following command:

git clone https://github.com/celo-org/celo-monorepo.git

Install Dependencies and Build the Code

- Navigate to the cloned repository:

cd celo-monorepo

- Install the dependencies by running:

yarn install

- Build the code:

yarn build

Generate a Validator Key Pair

- Generate a new validator key pair using the `generate-account.sh` script:

./packages/celotool/scripts/generate-account.sh -n <NODE_NAME>

Replace `<NODE_NAME>` with a unique name for your node.

Set Up Configuration

- Create a new directory to hold your node configuration:

mkdir node-config

- Copy the generated key files to the `node-config` directory:

cp celo-monorepo/packages/celotool/scripts/tmp/fullnode-<NODE_NAME>/validator* node-config/

- Create a new file named `config.toml` in the `node-config` directory and add the following content:

toml

[network]

id = "mainnet"

[security]

signed-peer-objects = true

[ethereum]

rpc-url = "https://forno.celo.org"

Run the Celo Full Node

- Start the Celo full node by running the following command:

yarn run celotooljs run geth:mainnet -- \

--verbosity 3 \

--syncmode full \

--gcmode archive \

--datadir <ABSOLUTE_PATH_TO_NODE_CONFIG> \

--port 30303 \

--rpc \

--rpcaddr 127.0.0.1 \

--rpcport 8545 \

--rpcapi eth,net,web3,debug,admin,personal \

--nousb \

--nodekey <ABSOLUTE_PATH_TO_NODE_CONFIG>/validator.key

Replace `<ABSOLUTE_PATH_TO_NODE_CONFIG>` with the absolute path to your `node-config` directory.

Verify Node Synchronization

- Wait for the node to synchronize with the Celo mainnet. This process may take several hours or more, depending on your machine's resources and network connection.

- To check the synchronization progress, you can use the Celo Block Explorer (https://explorer.celo.org/) or query the Celo node's JSON-RPC API.

Setup Windows:

Set up the environment

- Install Git: Visit the official Git website and download the installer for Windows. Run the installer and follow the instructions to complete the installation.

- Install Node.js: Visit the official Node.js website and download the LTS version for Windows. Run the installer and follow the instructions to complete the installation.

- Install Yarn: Open a command prompt and run the following command to install Yarn globally:

npm install -g yarn

Clone the Celo repository

- Open a command prompt and navigate to the directory where you want to clone the Celo repository.

- Run the following command to clone the repository:

git clone https://github.com/celo-org/celo-monorepo.git

Install dependencies

- Navigate to the cloned Celo repository directory using the command prompt.

- Run the following command to install the dependencies:

yarn install

Build the project

- In the same command prompt, run the following command to build the Celo project:

yarn build

Configure the node

- Copy the sample configuration file to create your own configuration file:

cp .env.example .env

- Open the `.env` file in a text editor and configure the necessary parameters according to your preferences. For example, you may want to set the `CELO_VALIDATOR_GROUP_ADDRESS` and `CELO_VALIDATOR_ADDRESS` parameters.

Start the node

- In the command prompt, run the following command to start the Celo node:

yarn run celo:fullnode

- The node will start syncing with the Celo mainnet. This process may take some time depending on your internet connection speed and the current state of the network.

Conclusion

By generally following this simple guide, you can set up and run your own mainnet node, enabling you to participate in the consensus and validation process while supporting the network's goals of financial inclusivity. It would be wise to rely on the info provided on the REPOs containing the individual software to avoid setup pitfalls. Remember to stay updated with the latest patches and updates and read my other stuff.