WebsiteGithubDiscordJoin Ecosystems

Manual

Node Technical Requirements

Node Specifications

These are some recommended specs to a Engram Network node.

Node Type
CPU
Memory
Data Disk

Archive Node

2 CPUs

4 GB Memory

100+ GB Data Disk

Snap Node

4 CPUs

8 GB Memory

300+ GB Data Disk

Full Node

8 CPUs

16 GB Memory

500+ GB Data Disk

Operating System

Engram Network nodes have been developed and tested on x86_64 architecture. Our binary files have been compiled with Ubuntu 22.04 LTS x86_64 & 20.04 LTS x86_64. This guide assumes you are using Ubuntu 22.04 or 20.04 LTS. If you are using a different OS you may need to make some adjustments.

Getting Started

Set Limits on Open Files and Number of Processes

To better manage the resources of your nodes, we recommend setting some limits on the maximum number of open file descriptors (nofile) and maximum number of processes (nproc).

Edit /etc/security/limits.conf to include or modify the following parameters:

*       soft    nproc   262144 
*       hard    nproc   262144
*       soft    nofile  262144 
*       hard    nofile  262144

Edit /etc/sysctl.conf to include the following:

fs.file-max=262144

Steps to Run a Tokio Node

Install Necessary Dependencies:

Start by updating your system and installing required dependencies:

$ sudo apt update
$ sudo apt upgrade
$ sudo apt-get install gcc jq clang llvm g++ ccze -y

Installing Golang:

Clone the repository Engram Genesis Spec:

$ git clone https://github.com/engram-network/tokio-node
$ cd tokio-node
$ git checkout stable
$ mkdir -p data-geth data-beacon data-validator
$ geth --datadir=data-geth init /path/to/genesis.json 

// Replace /path/to/genesis.json with the actual directory path to Genesis file.

Install Geth Client: 

$ go install github.com/ethereum/go-ethereum/cmd/geth@latest
$ sudo mv $HOME/go/packages/bin/geth /usr/local/bin

Systemd

Create a Configuration Execution File:

Create a systemd service config file to configure the execution node service. Paste the following service configuration into the file. Exit and save once done (Ctrl + X, Y, Enter).

[Unit]
Description=Engram Execution Client - (Tokio)
After=network.target
Wants=network.target

[Service]
User=root
Group=root
Type=simple
Restart=always
RestartSec=5s
TimeoutStopSec=180
ExecStart=/usr/local/bin/geth \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> 

[Install]
WantedBy=default.target

Run the Execution Node:

Start the Execution node using the configuration file you created reload systemd to reflect the changes and start the service. Check status to make sure it’s running correctly.

$ sudo systemctl daemon-reload
$ sudo systemctl start geth.service
$ sudo systemctl status geth.service

You can watch the live messages from your Geth node logs using this command. Make sure nothing suspicious shows up in your logs.

$ sudo journalctl -f -u geth.service -o cat | ccze -A

Press Ctrl + C to stop showing those messages.

Adding Peer:

Access the Console: Open a terminal window and connect to your Engram node's console. You can usually do this by running:

$ geth attach http://localhost:8545
$ admin.addPeer("enode://<peer_enode_url>@<peer_ip>:<peer_port>")
$ admin.addTrustedPeer("enode://<peer_enode_url>@<peer_ip>:<peer_port>")

Please refer to all public Tokio Bootnodes Here

After you add public tokio bootnodes, you need to see your static peer whether it has connected and joined the engram network or is still in the queue. you can utilize the geth command as follows:

$ > admin.peers
[{
    caps: ["eth/66", "eth/67", "eth/68", "snap/1"],
    enode: "enode://1a7ee57bf5fc6b151c2a1d917a10db5fade2efd3bddf88bfa4830112cacb59ad3ca59147b48026d8b8cb5ae362e15b61e72974507c5a4de667112f133c3171c5@18.142.177.161:51850",
    id: "8dfca9b32dcdf3a1e3206bb1ad01859b32038240388a972f67ec577852a6a336",
    name: "Geth/Enterprise-Engram/v1.12.2-stable/linux-amd64/go1.21.1",
    network: {
      inbound: true,
      localAddress: "172.31.19.20:30303",
      remoteAddress: "18.142.177.161:51850",
      static: false,
      trusted: false
    },
    protocols: {
      eth: {
        version: 68
      },
      snap: {
        version: 1
      }
    }
}]

After you add peers to the engram node, the static peers in your geth will change from static=0 to static=1 which means that the public bootnodes of engram accept your node's request to join the network.

Configuring Beacon Node

Start by updating your system and installing required dependencies:

$ curl -LO https://github.com/sigp/lighthouse/releases/download/v4.5.0/lighthouse-v4.5.0-x86_64-unknown-linux-gnu-portable.tar.gz
$ tar -xvf lighthouse-v4.5.0-x86_64-unknown-linux-gnu-portable.tar.gz
$ sudo mv lighthouse /usr/local/bin
$ lighthouse --version

Lighthouse v4.5.0
BLS library: blst-portable
SHA256 hardware acceleration: false
Allocator: jemalloc
Profile: maxperf
Specs: mainnet (true), minimal (false), gnosis (true)

Create a Configuration Beacon File:

Create a systemd service config file to configure the execution node service. Paste the following service configuration into the file. Exit and save once done (Ctrl + X, Y, Enter).

[Unit]
Description=Lighthouse Ethereum Client Beacon Node - (Tokio)
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=lighthousebeacon
Group=lighthousebeacon
Restart=always
RestartSec=5
ExecStart=/usr/local/bin/lighthouse bn \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> \
  <YOUR COMMAND LINE HERE> 

[Install]
WantedBy=multi-user.target

Run the Beacon Node:

Start the Beacon node using the configuration file you created reload systemd to reflect the changes and start the service. Check status to make sure it’s running correctly.

$ sudo systemctl daemon-reload
$ sudo systemctl start beacon.service
$ sudo systemctl status beacon.service

You can watch the live messages from your beacon node logs using this command. Make sure nothing suspicious shows up in your logs.

$ sudo journalctl -f -u beacon.service -o cat | ccze -A

Press Ctrl + C to stop showing those messages.

After the execution network and consensus network have connected and joined the engram network, your node will automatically synchronize all the databases from the engram, wait until everything is synchronized and take the last block of events.

PreviousDockerNextEngram (Mainnet)

Last updated