One of the most important market sectors for Ethereum Classic has always been cybersecurity and Internet of Things (IoT). When you have a Turing-Complete blockchain that follows the pillars of immutability of transactions and noninterventionism, you have the perfect candidate for a network that can secure IoT devices.
Imagine IoT devices being secured by a network that doesn’t hardfork to include unusual state changes because it’s protected by a strong social layer as well. That’s the promise of ETC and IoT.
I wanted to get started exploring the possibilities of IoT with ETC by getting my hands dirty building my own project. This guide will be split into several parts and will document my explorations of IoT, ETC, and all things Raspberries.
For this first part, I wanted to cover setting up your Raspberry Pi and running a cross-compiled version of Parity on it with the Classic Network. Parity is a very popular Ethereum Virtual Machine (EVM) client that can run several networks like ETC and ETH.
The following is the hardware you’ll need for this project:
- Raspberry Pi 3 Model B
- Micro SD Card
- Micro SD Card Reader
- Ethernet Cable
- Micro USB Power Supply
This Raspberry Pi setup will be completely headless, so we won’t be needing USB keyboards, monitors or other gadgets. We will set it up so we can directly SSH into it when it’s starting up. You will need to be comfortable with the command line. If not, the directions and commands I give should be sufficient enough for you to explore around some more on your own if you’re curious.
This initial setup for the Raspberry Pi will happen using an OSX Machine. Other Operating Systems can find their own install setup guides from Raspberry Pi documentation.
Configuring the Raspberry Pi
- In the first step, we need to download the Raspberry Pi
Raspbianimage, which is the Operating System used for Raspberry Pi. The Lite version is fine for download. This guide will be using Mac OS X, but there are guides for Windows and Linux.
- Next, we need to erase and reformat our micro SD card. We need to plug it into our local machine for reformatting it, which I’ll be using my OSX machine for. We first insert our micro SD card into the reader as shown below, which is then plugged into our laptop.
- On a Mac, you reformat your SD card by using
Disk Utility. I open Disk Utility and try to locate my SD card, which is empty and named to RASPBERRYPI as shown below.
- Next, you select
Erasebutton and select the Format to be
MS-DOSas shown below. Then you confirm by clicking
- Great, you have now reformatted your microSD card. It’s time to mount your Raspbian Image on it. On all OS setups, it’s best to download Etcher for mounting the image onto the SD card.
- Now, unzip your
Raspbian Litefile that you downloaded earlier. Popular unzip tools are 7-Zip (Windows), The Unarchiver (Mac), and Unzip (Linux).
- Unzipping it will result in a Raspbian
.imgfile, which you’ll be mounting on to your micro SD card.
- On Etcher, after installation, you then select your image that you unzipped and then the micro SD card as shown below.
- Next, you click
Flash!to mount the image.
Great, we have written our Raspbian Image onto our micro SD card!
Now that we have our mounted image installed, it’s time to prepare it for our ssh configuration and wireless setup. On a Mac, I’ll be using the command line to communicate with the Raspberry Pi and will be using Vim for any code changes and implementations shown, but feel free to use any IDE that you like.
- In your terminal, try to locate your micro SD card
bootdirectory. For Mac, it’s located here:
This takes you to the
bootdirectory of your Raspbian image. Inside it, we need to make an empty file called
ssh. When Raspbian is first launched on your Raspberry Pi, it will look for this file called
ssh on your boot directory, and from there enable SSH. More information on this can be found here.
To write a file in that directory, run the following command:
This creates an empty file called
ssh inside your
boot directory which will be used by Raspbian upon start up.
Now, let’s get to the more fun part, installing Raspbian on our Raspberry Pi.
Safely unmount your micro SD card from your computer, and remove it from the micro SD card reader. Next, insert it inside the Raspberry Pi as shown below.
Next, we connect the Ethernet cable to the Raspberry Pi as shown below.
After that, connect the power supply by connecting the micro USB power to turn it on.
You’ll see an LED light blink, indicating it’s turning on.
While it installs, we will now try to find the IP address our Raspberry Pi is using.
Connecting to Raspberry Pi
In order to find out the IP address of our Raspberry Pi headlessly (without a monitor), we need to login into our Router IP address.
In OS X, to do that, you must first click on
System Preferences and then click on
Advanced as shown in the image below (network names and IP address blurred out).
After clicking on
Advanced, click on
TCP/IP which will then show you the
Router Address. You will need the
Router address to access your Router and it will probably ask you for a username and password. I usually find those on a sticker on my router machine itself.
After going to that IP address on your browser and logging in, you should be able to find a client list connected to your router, depending on your type of router. This is mine and it has the device Raspberry Pi along with its IP address. The address is local and will most likely always start in your case with
192.168.X.Y , so look out for that, you’ll need it to ssh in to your system.
Here, we find out Raspberry Pi address to be
192.168.0.6 . The default username for Raspbian is
pi and the default password is
raspberry which we will need to log in.
Inside terminal, run the following command in order to ssh into your Raspberry Pi:
$ ssh pi@IPADDRESS
IPADDRESS in my case is the
192.168.0.6 I shared above, but is different than the value you’ll get.
When prompted for a password, type in
raspberry. It should then ssh you into your Raspberry Pi because your shell will explicitly indicate it:
Notice the new shell name says
pi@raspberrypi, it means you’ve successfully SSHed into your Raspberry Pi!
Now, you can setup your configuration for your Raspberry Pi by running the following command:
This will provide you a command line menu where you can configure the settings. We will just focus on setting up Wireless Network since this is a Raspberry Pi 3 Model B. Not all devices would have a wireless network, so it may not apply to you.
Network Options and then select
Wifi. When you first run a new Raspbian OS install, it’ll ask you what country you’re in for regulatory purposes. After that, it asks for the SSID, which is your network name. The passphrase is the password to your WIFI network. After that, you should be good to go. More information on wireless found here.
Compiling Parity for Raspberry Pi
This step will require you do the compilation locally on your laptop instead of using resources on the Raspberry Pi. It’s easy to secure-copy the binary we compile for Parity after into the Raspberry Pi.
The source code can be found in this Github repository, which we will be going over together.
The Dockerfile is shown in the gist below.
This uses Debian as the OS environment needed to cross-compile Parity (Debian is the best OS ever made). If you notice, there are references to armv7 for the targets we set for Rust to compile and the gcc and g++ compilers. If you aren’t sure what most of the content in the gist are, it’s fine, it’s not required learning for cross-compiling, since Docker does it all for you and you are just left with a binary. I leave it more for the convenience of others who are interested.
First thing we need to do is install Docker, which is what we will be using to compile Parity. The reason we can’t compile Parity locally without Docker is because we want to target the ARM architecture (armv7) for Raspberry Pi which is where Parity will be running.
For example, a binary compiled to run on an AMD architecture which is X86 won’t be able to run on an ARM architecture. This is why cross-compiling is needed in this scenario. Usually, Parity would release ARM architecture binaries whenever they have a new version, but they’ve stopped supporting it a while back, so I built my own Docker file for as shown in Github link above.
Now that Docker is installed on our machine, let’s get started!
We run the following command to get the image:
$ git clone https://github.com/YazzyYaz/parity-arm.git
$ cd parity-arm
Ok, now we are in the
parity-arm directory which contains the Dockerfile that we will be compiling for parity.
We will start the build process for cross-compilation by running this following command:
$ docker build -t yazanator90:parity-arm .
This will build the image for it. It can take a while, so be you might want to go grab lunch or call a loved one while you wait for the build process to complete.
Once it’s done, you run the following commands:
$ docker run -d --name parity-arm yazanator90:parity-arm
This will run the image. After that, we enter the rest of the commands shown below in order to generate the binary that is resulted after compilation:
$ docker start parity-arm
$ docker ps
$ docker cp parity-arm:/parity-ethereum/target/armv7-unknown-linux-gnueabihf/release/parity parity-arm
$ docker stop parity-arm
$ docker rm parity-arm
This will delete the image we built but we will still have a compiled binary called
parity-arm in our current directory. To verify it, run the following command:
Notice the file produced called
parity-arm now. That’s the binary we will use to copy into our Raspberry Pi.
Running Parity in Raspberry Pi
Now, let’s run Parity!
We will first make sure we already have SSHed into our Raspberry Pi as we have discussed in our step above. Once SSHed in one terminal window, open a new terminal window which we will use to SCP. SCP is Secure-Copy which allows us to use SSH to copy files between machines.
Assuming you are in the
parity-arm directory which we compiled our binary in, run the following command to scp Parity into Raspberry Pi:
$ scp -r parity-arm pi@IPADDRESS:~/
This will copy the entire directory into Raspberry Pi’s $HOME folder, which is found on
Now, let’s go to our Raspberry Pi and run Parity.
Inside the Raspberry Pi window that you’ve SSHed into, type the following:
$ cd ~/
This shows the
parity-arm directory that we have copied over. Now, let’s run the Ethereum Classic chain on parity! Time to support our immutable network on this magnificent little piece of device.
Let’s cd into our
parity-arm directory now:
pi@raspberrypi:~ $ cd parity-arm/
Before we run parity, we need to find our current IP address. This will be used to inform Parity about which external IP to use so that it doesn’t use the local IP address given to it by our router. The local IP address given to us by the router won’t be discoverable outside our home network, so by providing the IP address of our system to connect to, Parity can communicate across the internet with other nodes.
We can get our IP address from this website. This IP will be referred to inside the following command as EXTIP. Replace EXTIP in the command below with your IP.
Inside, we will instantiate parity for the classic chain with the following command:
pi@raspberrypi:~/parity-arm $ ./parity-arm --chain=classic --light --nat extip:EXTIP
Here, we are setting Parity to the
classic chain so that we are running an ETC node. We also want it to be running the light client to go easy on disk space considering we are running it from Raspberry Pi. The
--nat command informs Parity that it’s enode connects to the
EXTIP we specified that we get from the website linked above.
Will you look at that! We now have Parity running ETC in Raspberry Pi. Now, it’s time to let it sync up. Keep it connected to power and let Parity do all the heavy lifting for now.
In the future guides, we will explore having smart contracts (maybe in Vyper) running on ETC and communicating with the Raspberry Pi and also maybe build an IoT device for Raspberry Pi and ETC. Hope you enjoyed this guide, please feel free to share any feedback you have.