Syntropy Stack + Ethereum 2.0: Blokchain Integration

Building and launching real, tangible use cases to drive long-term adoption of our technology and token.

Jonas Simanavicius
4 min readJul 22, 2021

Our new integration allows anyone to set up a secure Ethereum 2.0 node using Syntropy Stack. This integration will help exchanges, on-chain data analysts, node runners, and more set up a stable, fully monitored Ethereum 2.0 node with improved security.

Our Ethereum 2.0 integration is another example of how we’re building and launching real, tangible use cases to drive long-term adoption of our technology and token.

We will never achieve true decentralization until we decentralize connectivity itself. That’s what Syntropy provides to blockchain networks, applications, and users — a Layer Zero solution for our blockchain-powered future.

Learn why integrations matter
View full list of integrations on GitHub

How it works

This integration makes it simple to deploy our technology to improve and further decentralize blockchain applications and networks. An Ansible playbook configures the Ethereum 2.0 node and monitoring, while security and stability between all connections are facilitated over the Syntropy network.

Topology of a secure Ethereum 2.0 node using Syntropy Stack


The integration provides several immediate benefits:

  • Exchanges can now easily manage their multi-cloud node infrastructure without needing to worry about network connections and security between the instances.
  • Less technical node-runners can more easily set up a secure and observable Ethereum 2.0 node.
  • On-chain Ethereum 2.0 data analysts can manage Ethereum node clusters on multiple clouds with additional observability.

Following the launch of the Syntropy blockchain and the integration of DARP, everything running on our network also gains valuable performance advantages. Blockchain nodes can communicate faster with fewer outages, positioning Syntropy as the leading communication network for decentralized technologies.


For now, there are some prerequisites to get started.

  • An active Google Cloud Platform account with billing enabled
  • An active Linode Cloud account
  • Python >= 3.6
  • Terraform and Ansible >= 2.10 installed on your local machine
  • A Linux machine to run the Ansible playbook


In order for Terraform and Ansible to set up everything automatically, you will need to input a few variables in infra/terraform.tfvars and ansible/vars/main.yml. Examples for these can be found in their respective .example files.

Useful links for generating the variables:

  1. How to generate Linode Personal Access Token
  2. How to generate Google Cloud Platform service key
  3. How to generate a Syntropy Agent Token

Configuring an Ethereum node

Since Ethereum 2.0 nodes deploy on top of the Ethereum blockchain, you will need a functional Ethereum 1.0 node.

For this example, we will be using third-party eth1 providers. Instead of running our eth1 node, it is easier to use a third-party provider such as Infure, QuickNode, Chainstack or Alchemy. You can quickly sign up for free and get an APY key, which entitles you to use their respective eth1 endpoints.

Completing the onboarding process in the official eth2 launchpad

The Pyrmont testnet eth2 launchpad is the easiest way to go through a step-by-step process to deposit your 32 ETH to become a validator. You’ll be asked to generate new validator credentials using the official Ethereum deposit command-line-tool here throughout the process.

Make sure you use the pyrmont option when generating keys with the deposit CLI. During the process, you will have generated a validator_keys folder under the eth2.0-deposit-cli directory. You can import all of your validator accounts into Prysm from that folder in the next step.

Provisioning infrastructure

After you have filled in your Terraform and Ansible variables, you can start creating your virtual machines. This is a simple step and only requires two commands (in the infra directory):

terraform init
terraform apply

Deploying the Ethereum node and monitoring services using Ansible

After the virtual machines are done setting up, you can start provisioning the Ethereum 2.0 node and monitoring services (Grafana, Prometheus). In order to do this, only one command has to be run:

ANSIBLE_HOST_KEY_CHECKING=false ansible-playbook -i inventory.yml eth2.yaml

This can take a while, as a lot is done in this playbook. It usually takes about 15 to 20 minutes, so take your eyes off the screen.

Checkout the network setup on Syntropy Platform

If the script has executed completely, the endpoints will be visible on your Syntropy Stack UI.

Then you can connect your endpoints and activate services in order to achieve a properly working blockchain network.

Visiting the monitoring site

You can visit the Grafana instance with the link and by entering the credentials you entered in the vars/main.yml file.

After logging in, you should be able to visit your Grafana dashboard:

The validator needs to be recognized by the network. Therefore it may not present any data on Grafana immediately. After several hours your validator will be up and running.

Next steps

With this integration now live, anyone can begin to use it immediately. Getting closer to the network launch and integrating DARP into the rest of our software stack, performance advantages will follow security and monitoring benefits.