Ethereum 2.0 is around the corner (phase 0 is expected to launch in 2020). It is the best time to try the new tech if you are like me and don’t have the courage to test in production as you will need to burn your ETH.

In this practical guide, we will try to run a validator on the Ethereum 2.0 testnet. What we will be using:

• DigitalOcean droplet (the cheapest one at $5/month will do)
• DAppNode (it offers infrastructure as a service to run various services and control it from the web app, very useful)
• Medalla testnet (the latest ETH 2.0 test network that already served its purpose)
• Prysm client (it is one of the ETH 2.0 clients that DappNode supports)
• 32 GöETH (32 Ethers of Görli Testnet that you need to deposit to become a validator)

I know that running a validator in the cloud is not the best option but this tutorial is just for the sake of learning and testing in an isolated environment. And you don’t have to keep your PC online 24/7. In the future, you may want to run it on a physical machine, it’s all up to you.

Let’s get started:

1. Create a Docker droplet on DigitalOcean

I recommend using a Docker image as it allows running an application in a preconfigured isolated environment.

While the requirements of running an ETH 2.0 validator are a bit higher, I still managed to run it on the cheapest DigitalOcean droplet without any problems (tbh, the load on CPU is quite high but it still works). Of course, the resources are very minimal so I may decide to upgrade in the future. EDIT: I have upgraded my droplet to a $10/month plan, as apparently the cheapest one is not enough to catch up with the chain.

You can leave other settings as default or customize according to your needs. For instance, you might choose SSH keys authentication as it is a more secure way of authentication. If you have not generated your SSH keys before, you can follow the instructions by DigitalOcean.

2. Connect to your droplet

Copy your droplet IP address (you can see it in your dashboard). Open a terminal and enter the command:

ssh root@<YOUR_DROPLET_IP_ADDRESS>

3. Install DappNode

Follow the DappNode installation guide. Once the installation is complete, download the .ovpn file on your physical machine (either from the given link or QR code that you will see printed to the console).

4. Install OpenVPN

Follow the OpenVPN installation guide (do it on your physical machine, see specific instructions for your OS). Once installed you can import your .ovpn file and open the connection.

5. DAppNode’s dashboard

Now you should be able to open a DAppNode dashboard in your browser: http://my.dappnode/. Here you can manage and control your node.

6. Install Medalla Validator

In your dashboard, select DAppStore, search, and install Medalla Validator. Select to use Prysm client (if you want, you can try other supported clients, I think it won’t make much difference). If you go to packages you will see that it also installed the Medalla beacon chain. You can click on it, select logs and see that it already started syncing.

7. Get GöETH

32 is the minimum stake amount to become a validator. Probably the easiest way to get it is to request it from the faucet. Use your Eth1 address (from Metamask or whatever you use) to request some ethers. Alternatively, you can visit Prysmatic Labs discord and they will gladly send you some test eth.

8. Setup a validator

Visit Eth2 Launch Pad for Medalla testnet and follow the instructions to generate validator keystores and deposit your stake. Once finished, go to your DAppNode’s Medalla validator dashboard and import your validators.

After depositing you have to wait for it to be approved. Once the validator is approved it is expected to stay online and attest for the validity of incoming blocks or create a new block. If the validator is offline when required, it will be penalized. Being penalized is not so bad compared to what waits for those who try to misuse the network with malicious purposes (they get slashed!). There are several sites where you can view statistics of your validator or the whole network, for example, BeaconScan or eth2stats.

Bonus: get a unique POAP badge (valid if you propose a block between genesis and block 300'000)

You can get a badge (ERC721 token) that proves your participation in a multiclient testnet. All the instructions are provided here but basically you just input your Eth1 address, get a unique flag, and add it to your validator message. You can set that in a DAppNode, Medalla validator package config (alias field).

That’s it. Wish you a good experience and journey with Eth2, exciting times are ahead!

EDIT: I have not noticed that my beacon chain did not start syncing (msg=“Waiting for enough suitable peers before syncing”) and upon further investigation, I’ve found that you need to change the port numbers. If you are also experiencing this issue, go to your “Prysm Medalla Beacon Chain” package and set host port 12000 for the first TCP connection and 13000 for the second one.

Truffle is by far the most popular framework for developing DApps on the Ethereum blockchain. This article is intended to provide you with a comprehensive overview on how to configure your project so you can deploy your contracts to the main network, test networks (Ropsten, Rinkeby, Kovan) or private network faster and effortlessly without the need to run your own Ethereum node. I assume that you already have Truffle installed on your machine and know the basic commands (init, compile, migrate, etc). Without further ado let’s jump into the article.

Obtaining Infura API keys

Infura provides an access to the Ethereum network, so you don’t have to run your own node. Signup on Infura (enter your name, email and password) and you will receive an email message with your API keys. We will use them later.

Downloading Ganache

Ganache is a simulation of a private Ethereum blockchain. It is very useful to for testing your DApp at the early stage, as you can have instant transactions (no need to wait for the confirmations). Make sure to download it and get familiar with its interface.

Setting up Truffle project

If currently you don’t have your Truffle project, you can follow me and start with a fresh Pet Shop project.

Open a terminal and navigate to the directory where you want this project to be located. Then, run this command to initiate a new project with some boilerplate code:

truffle unbox pet-shop

Run the server:

npm run dev

You should be able to see your project running on localhost (if not, make sure that Ganache is running).

But what if you want to test your DApp on a more realistic simulation or even on the main Ethereum network? I hope you have heard about test networks like Ropsten, Rinkeby or Kovan. These are the simulations of the real Ethereum network, where you can test your smart contracts in a realistic environment without spending real Ether.

Adding different networks to the configuration

First, you will need a HD Wallet-enabled Web3 provider. Run the installation command:

npm install truffle-hdwallet-provider

Open truffle.js file on your favorite text editor. I am using (and highly recommending) Sublime Text (+ Solidity highlighting plugin for developing smart contracts).

First, include the required module:

var HDWalletProvider = require(“truffle-hdwallet-provider”);

Then, you need to declare your mnemonic phrases. You can use default Ganache phrases, but I would not recommend that, as everyone has access to these accounts and you can not use it for Ethereum mainnet (for obvious reason). What I would recommend is to add a Metamask extension to your browser and create an account there. Please make sure to backup your phrases somewhere safe and then add it to the configuration file:

var mnemonic = "candy maple cake sugar pudding cream honey rich smooth crumble sweet treat"; // replace with your own phrases

Note: it is not recommended to leave it as a plain text in the final production version, but we will cover that later.

Next, add a configuration for different networks. Add a comma in module.exports after the development network and declare a configuration for other networks (do not forget to replace your-api-key with the actual API keys from Infura):

ropsten: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://ropsten.infura.io/your-api-key");
      },
      network_id: 3
    },
    rinkeby: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/your-api-key");
      },
      network_id: 4
    },
    kovan: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://kovan.infura.io/your-api-key");
      },
      network_id: 42
    },
    main: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/your-api-key");
      },
      network_id: 1
    }

Also, for each network I like to explicitly declare gas limit and price (put it after network_id):

gasPrice: 20000000000, // 20 GWEI
gas: 3716887 // gas limit, set any number you want

This is optional, but it is very useful when you are deploying to the main network, as it makes sure you are not overpaying and the transaction will be provided with a reasonable amount of gas. To test how much gas the deployment costs, I use Remix IDE.

Here is the final truffle.js file:

var HDWalletProvider = require("truffle-hdwallet-provider");

var mnemonic = "candy maple cake sugar pudding cream honey rich smooth crumble sweet treat";

module.exports = {
  // See <http://truffleframework.com/docs/advanced/configuration>
  // for more about customizing your Truffle configuration!
  networks: {
    development: {
      host: "127.0.0.1",
      port: 7545,
      network_id: "*" // Match any network id
    },
 ropsten: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://ropsten.infura.io/your-api-key");
      },
      network_id: 3,
      gasPrice: 20000000000,
      gas: 3716887
    },
    rinkeby: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/your-api-key");
      },
      network_id: 4,
      gasPrice: 20000000000,
      gas: 3716887
    },
    kovan: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://kovan.infura.io/your-api-key");
      },
      network_id: 42,
      gasPrice: 20000000000,
      gas: 3716887
    },
    main: {
      provider: function() {
        return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/your-api-key");
      },
      network_id: 1,
      gasPrice: 20000000000, // 20 GWEI
      gas: 3716887    // gas limit, set any number you want
    }
  }
};

Now you are ready to deploy your DApp to any of these networks!

Deploying to different networks

To deploy your contracts on Ropsten, run:

truffle migrate --network ropsten

Rinkeby:

truffle migrate --network rinkeby

Kovan:

truffle migrate --network kovan

Main network:

truffle migrate --network main

Make sure you have some Ether on every network. If you get “Network up to date” message, add reset flag, for example:

truffle migrate --reset --network ropsten

If you get “exceeds block gas limit” message, try to adjust the gas limit (as I mentioned earlier, you can use Remix to see how much gas is needed for deployment).

If you do not specify a network, the default one is development. You can track your transactions on Etherscan.

Bonus: storing mnemonic in a separate place

Maybe you are working with a team using git and have your project uploaded online or at some point you are planning to open source it. Storing your mnemonic online is not the safest option, as if someone knows it, they have access to all your funds on these accounts.

A simple solution is to add mnemonic as an environment variable and replace hard-coded values:

var mnemonic = process.env.MNEMONIC;

Find a way to add environment variable to your OS (it may differ in Windows, Linux and Mac) and enjoy the safer way to access your mnemonic phrases.

That’s all! Hope you enjoyed this article (you can express your support by giving it a 👏) and if you have any questions, let me know in the 💬 section.