GoByte - With LCD display - FREE GUIDES FOR CRYPTOCURRENCY NODE BUILDERS

GoByte Full Node , Raspberry Pi3 With LCD Display
(For any Single board computer running an ARM Cortex-A53 processor - Full list of compatible hardware listed here)
Latest Update 9th June 2018

See the HARDWARE tab of this site for parts list and assembly/build information and tips.

3.5" LCD Display shown

Step (1) Preparing the Pi

Because all the preparation steps are the same for all nodes here, I have made a beginner friendly guide with images, step-by-step. "Getting started" Link opens a new window

Getting Started

Then continue below...

Step (2) Enabling WiFi

Wifi is available once the Pi is rebooted. Either reboot now using
sudo reboot
and remove the ethernet cable. Or continue, and reboot later as it is required after the next step.

With the Pi turned on, booted and you logged in with SSH we can start the setup.

First WiFi network connections are stored:

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Go to the bottom of the file and add the following text:

network={
ssid="YOUR WIFI ROUTER NAME"
psk="YOUR WIFI ROUTER PASSWORD"
}

**Note: Enter details between the quotes, leave the "" in
save and exit using

ctrl+O
Then 'enter'
ctrl+X

Step (3) Expand the file system, (making full use of the SD card) and changing the Password.

enter:
sudo raspi-config

The default password for obvious security reasons should be changed. That is done in this menu.

select "1 change user password", and follow the on-screen instructions. This will be the new password when using PUTTY to SSH into the Pi.

Because we installed a 2GB image onto the card, the Pi may think that the card is only 2GB in size. So we tell it to expand the file-system (returns it to it's full size allowed):

select "7 advanced options"

select "A1 expand filesystem"

select 'finish' and the system will reboot, (remove the Ethernet cable if you didn't at the previous step). And log back in with SSH and PUTTY once reboot is complete.

Step (4) Installing the LCD Display

The image we downloaded may have an update or two since they released it:

sudo apt-get update -y
sudo apt-get upgrade -y

sudo wget http://www.spotpear.com/download/diver24-5/LCD-show-170309.tar.gz
sudo tar xvf LCD-show-170309.tar.gz
cd LCD-show/

Then pick and type one command from the list below depending on your screen size/resolution.
**Note: This is for LCD Displays that use the GPIO header pins.

If your display is the Raspberry Pi 2.4inch, 2.8inch or Raspberry Pi 3.2inch

       sudo ./LCD32-show

If your display is the Raspberry Pi 3.5inch

       sudo ./LCD35-show

If your display is the Raspberry Pi 3.5 inch HDMI LCD

       LCD35-HDMI-480x320-show

OR

       LCD35-HDMI-800x480-show

If your display is the Raspberry Pi 4inch

       sudo ./LCD4-show

If your display is the Raspberry Pi 4.3inch

       sudo ./LCD43-show

If your display is the Raspberry Pi 5inch

      sudo ./LCD5-show

If your display is the Raspberry Pi 7inch (800x480)

       sudo ./LCD7-800x480-show

If your display is the Raspberry Pi 7inch (1024x600)

       sudo ./LCD7-1024x600-show

If your display is the Raspberry Pi 10.1inch (1024x600)

      sudo ./LCD101-1024x600-show

This command takes some time ("LCD configure 0" displayed for a while) and it reboots when it is complete but reboots in the background so it confuses PUTTY. The reboot causes PUTTY to crash and is normal. I recommend waiting until the activity indicator on the pi has been lazy for a minute or two (an indication it has finished) then press enter. PUTTY will bring up an error and close. (This has been updated and did this twice on a rebuild) This is fine. Log back in with SSH and PUTTY

Now we tell the Pi to boot using the new display:

     sudo nano /boot/config.txt

And at the bottom you will find, (as in the screenshot)

       # Enable audio (loads snd_bcm2835)
      dtparam=audio=on
      dtoverlay=waveshare35a
dtoverlay=ads7846,cs=1,penirq=17,penirq_pull=2,speed=1000000,keep_vref_on=1,sw$

sudo nano /boot/config.txt

Adding a # before a line make the Pi ignore it and is called a comment.
Comment out the dtoverlay=ads7846...line by adding a #.
The line that we want active is the dtoverlay=waveshare35a
The rotation value should be changed here from now on too, by adding :rotate=0 as in the image above
Choose your rotation value. 270 is the HDMI port at the top. Use 0,90,180,270 as needed.

It should look like this after, (depending on rotation preferences)

       # Enable audio (loads snd_bcm2835)
       dtparam=audio=on
      dtoverlay=waveshare35a:rotate=270
      #dtoverlay=ads7846,cs=1,penirq=17,penirq_pull=2,speed=1000000,keep_vref_on=1,sw$

then, Save the changes with Ctrl+O, then exit with Ctrl+X

     sudo reboot

And you will have your display working.
(If rotation is wrong, edit the config.txt again and change rotate=<figure>. A reboot required for changes to take affect)

Step (5) Adding the GUI (the desktop)
A very easy copy/paste step:

sudo apt-get install --no-install-recommends xserver-xorg
      sudo apt-get install --no-install-recommends xinit xserver-xorg-video-fbdev
       sudo apt-get install lxde-core lxappearance
       sudo apt-get install lightdm
       sudo apt-get install --no-install-recommends matchbox chromium-browser

don't reboot just yet...

Step (6) Force the output to the LCD, not HDMI

sudo nano /usr/share/X11/xorg.conf.d/99-fbdev.conf

should be blank, add the following text

       Section "Device"
       Identifier "touchscreen"
       Driver "fbdev"
       Option "fbdev" "/dev/fb1"
       EndSection

save, exit, ctrl+o ctrl+x

      sudo reboot

pi will reboot and after about 1 min for initial setup will load GUI onto the display giving a desktop

Step (7) - Installing GoByte Node/Wallet:

First, some dependencies are needed to compile GoByte on the Pi. I've kept it simple on one line to install them all:

sudo apt-get install git autoconf libevent-dev libtool libssl-dev libboost-all-dev libminiupnpc-dev -y

Downloading GoByte dependencies

Enlarge the Swapfile:

The Raspberry Pi has 1GB of RAM but this causes issues later. We can artificially enlarge that with a swap file.

sudo nano /etc/dphys-swapfile

And change the default size of 100(MB, to 1000 as shown to the right
**Optional, enlarge to 2000, (max)
save, exit, ctrl+o ctrl+x
Then, to build the new swap file...

sudo dphys-swapfile setup
sudo dphys-swapfile swapon

Install the BerkleyDB library, (for wallet functionality):

Not much to show here for screenshots, it's just another dependency that's needed. Copy/paste each one line by line.

mkdir db4.8
wget 'http://download.oracle.com/berkeley-db/db-4.8.30.NC.tar.gz'
tar -xzvf db-4.8.30.NC.tar.gz
cd db-4.8.30.NC/build_unix/
../dist/configure --enable-cxx --disable-shared --with-pic --prefix=/home/${USER}/db4.8/
make install
cd

Download GoByte:

We now have everything we need. Download with:

git clone -b v0.12.2.3 https://github.com/gobytecoin/gobyte.git

It's downloaded as a package and put in a folder called gobyte, navigate to this folder:

cd gobyte

And begin the setup:

./autogen.sh
./configure --enable-upnp-default LDFLAGS="-L/home/${USER}/db4.8/lib/" CPPFLAGS="-I/home/${USER}/db4.8/include/"

**The extra tags after configure 'universal plug and play'(upnp) for networking connections, and the 'LD' and 'CPP' flags show GoByte where to find the BerkleyDB files we installed earlier.

Finally, two slightly time consuming steps:

make
sudo make install

These steps can take several hours, be patient please.

Moving GoByte to the user folder:

For some reason in the build instructions, GoByte is compiled and sent to /usr/local/bin and can only be run as 'root'. This isn't ideal but is very simple to fix.

Copy the folder back to where our GoByte folder is:

sudo cp -r /usr/local/bin /home/$USER/gobyte

Then change the owner 'chown' to Pi so we can use it:

sudo chown pi:pi -R /home/$USER/gobyte/bin

Installation Complete!

Step (8) - Starting the GoByte Node for the first time:

All comands should be run from the /home/pi/gobyte/bin/ directory.
Navigate to there:

cd home/pi/gobyte/bin
To start the node use:

./gobyted -daemon

*-daemon tells the node to run in the background so we can perform other checks and functions.
**from the home command line (pi@raspberrypi:) use ./gobyte/bin/gobyted -daemon

Your Pi will do what's shown above. The green cursor will drop down a line and begin the node showing "GoByte Core server starting", it is now downloading and synchronizing the blockchain. (The initial sync took approx 2 hours)

We can now manage the running node

***Note: The Pi can also be used to run a masternode. The command

./gobyted -masternode=1 -daemon

is to be used, however the detailed configuration required for masternodes is to be considered out of the scope of this guide.

(9) Setup/Initial walllet Functions

./gobyte/bin/gobyte-cli -? | less

Will give a full list of available commands for future reference.
Scroll with the arrow keys, and tap "q" to quit.
I'll explain the key/common features for functionality below:

./gobyte/bin/gobyte-cli getinfo

This command shows some basic useful information about the running node.

Initially it is most useful to see if you are full sync'd by checking the value of "blocks" (your current block height) against the actual network block height.

Once it's within one or two blocks, it's sync'd and you'll be able to spend funds. It's worth noting that a complete sync takes a Raspberry Pi 3B approximately 2 hours on a fast conection.

This "getinfo" command will be most used to check balances and staking later.

./arm32/lore-cli getinfo

**Disclaimer** From here on in you must very very careful. I am not an official GoByte Dev nor do I have any affiliation with them. These commands and the software I have pointed you towards are all open source and you are free to interrogate them to check I have not done anything malicious. But as a rule you should not follow anyone in the crypto-world blindly, assess the risks. Yes, you are your own bank! But banks as a store of wealth are targets. Be smart, use firewalls, change default passwords and never share your Private Keys.... The punchline to this is that I accept no responsibility or liability for any funds you decide to store on this device. I've built these nodes purely as an educational project, and with previous builds there were no funds involved. However in this case, staking and loading the wallets now involves financial risk, and what you decide to do is 100% on you. Not me. Make backups of your wallet.dat and password you use to encrypt it. Typically the wallet.dat and password can be used to enact a recovery on another device should the Raspberry Pi/SD card/HDD fail.

With that said, if you wish, we'll proceed.

All these commands are run from the same folder so:
cd gobyte/bin
then:
./gobyte-cli getnewaddress

#This picks out an unused recieving address from the wallet.dat file in the .gobytecore directory.
This is your receiving address and will be used to fund your wallet for staking. Make a note of it.
It is currently not encrypted
In the earlier "getinfo" command the "keypoolsize" is referring to how many receiving addresses you have available in a pool to call upon each time you 'getnewaddress'. Once you have uses those 999 a new backup will need to be made of your wallet.dat file. Addresses you use after 999 won't be in your original backup. It's unlikely you'll hit this limit though.

./gobyte-cli dumpprivkey <copy/paste address from above>

#Displays the Private key of the address produced above. The account and any funds held within it can be recovered with this sequence of letters and numbers. It is case sensitive. Keep it safe. If someone else has this key, they have your funds.
This step could be useful to a user that intends to set up a master-node. Funds loaded to this single address can be recovered with this generated key. This backup method is okay as a second backup (Printed paper perhaps for secure storage).
I'll show you soon a few ways to backup all your addresses and keys in one go using the wallet.dat file, once we've encrypted it.

./gobyte-cli encryptwallet <Type a super secret mega complicated password here>

#Encrypts the wallet to prevent private keys being leaked.
**Very important** It's not obvious due to this website's text formatting but the above encryptwallet command has a space (_) before ./gobyte-cli. This is very important as it will prevent your password from being saved in the bash/command history.
This password you set should be remembered and backed up to gain access to with wallet and funds in future. It encrypts the wallet.dat file.

Once the encryption step is complete the node shuts down for security reasons.

Later, on restarting the node, you may notice that the "getinfo" command now has an extra line called "unlocked untill": 0
This shows the wallet is encrypted and '0' indicates it is locked.

Step (10) Moving everything to the USB drive

People have been making projects (not just nodes) on the raspberry pi for some time. A common failure point seems to be the SD cards. The constant read/write process 24/7 drastically shorten their life. We can reduce this by moving the entire file-system to the USB drive, and where possible using traditional platter HDDs. Check out the 'HARDWARE' section for cheap solutions available to the Raspberry Pi.

This is the ideal time to perform this step. Our Dash wallet has safely shut itself down, and has an encrypted wallet file and address ready to receive funds. When we perform this next step and copy the contents of the SD card to the HDD we are making a backup which remains on the SD card but is not used.
If at any point the USB HDD fails, this step can be performed again and our files are restored onto the new HDD, the node then continues to function, (after any required synchronization) with the same addresses and private keys.

So:

Insert the USB drive if you havn't already, then check it is mounted to the Pi.

sudo lsblk

99% of the time it will be mounted as /dev/sda with a partition called sda1. However if it has found sda1 it won't let us continue until it is unmounted. (It would be telling it to make changes to the filesystem whilst it's in use. It won't let us and doesn't like it). So we unmount with

umount /dev/sda1

We need to delete this partition to stop raspbian from automatically using the drive on boot, at this point. The helper in the next step will automatically create a new partition to do it's job of moving the files.

sudo fdisk /dev/sda

d

(deletes old partition)

w

(writes and commits the changes)

Now it's compatible with the helper script.

The folks at Adafruit have made a very useful helper to reduce the amount of commands you need. These next three lines create a new partition and move the entire file system onto the USB drive. It does warn you that any data currently written to /sda will be overwritten. If you are an advanced user and have called the partition something other than /sda, this is where it should be changed.

git clone https://github.com/adafruit/Adafruit-Pi-ExternalRoot-Helper.git
cd Adafruit-Pi-ExternalRoot-Helper
sudo ./adafruit-pi-externalroot-helper -d /dev/sda

It will ask you to check that you are writing to the correct partition, select y when you are sure. When I do this step it takes a little under 10mins. Please be patient.

So everything has been copied over and the drive configured. We just need to change the boot file so it starts from the USB drive from now on. The helper untility should have done this automatically. But recently this has not been the case. Do this just to check, it's simple and is just a copy/paste action.

sudo blkid -o export /dev/sda1

The numbers will be different but it brings up something like the image on the left.

This is our drives labels and addresses. We need to check that the PARTUUID long number (that's the USB), is entered into

sudo nano /boot/cmdline.txt

Enter:
sudo nano /boot/cmdline.txt
And ensure that the helper has changed
root=PARTUUID=
to match the one that was listed to you above. Yours will be different to mine. Then Save and exit using ctrl+o then ctrl+x.

Do another reboot with sudo reboot and when the Pi starts this time your USB activity light will blink like crazy, showing it's now getting it's data from there.

(11) Unlocking.
(a) Unlock wallet, (with mixing enabled:)

Log back into the Pi as before.

Then restart gobyted:

./gobyte/bin/gobyted -daemon

And we can now use our wallet securely. I'll explain the features listed below:
We need to gain access to our wallet. First we un-encrypt it:

./gobyte/bin/gobyte-cli walletpassphrase <yourpassword> 999999999 true

Broken down into parts so you understand:

walletpassphrase <yourpassword>
#Tells the node to unlock the wallet with whatever password you set in the encryption stage. Again be careful to include a space(_) before the command so your password isn't saved in the Pi's history.

999999999
#Tells the node how long to unlock the wallet for in seconds. I want it to unlock and stake indefinitely, and that's 31 years.

true
# This unlocks the wallet for mixing only. When you send funds they will be mixed with others to obscure their origin and destination.

It will display an error message only if you enter an incorrect password. If all goes well it will wait for another command.

(b) Add funds:

Earlier we made a receiving address and made a note of it.
Send funds to that address which you'd like to stake. There are many ways to do this but it is not within the scope of this guide. Most people send directly from and exchange and the process will differ depending on which exchange you use.

Once you have sent funds, they will appear under "balance" on the "getinfo" page:

(12) Basic Wallet Functions:

Sending GoByte:

First unlock your wallet for spending using:
./gobyte/bin/gobyte-cli walletpassphrase <youpassword> 999999999 true

The format is:
./gobyte/bin/gobyte-cli sendtoaddress <GoByteaddress> <amount>
So in my case I'm going to send 5 GoBytes to my exchange:

./gobyte/bin/gobyte-cli sendtoaddress GdvZW4XngVtfbfZwEYFcQw8M3Ux4c8p6gX 5

If the conditions of the network are followed, eg, If your wallet balance is sufficient, wallet unlocked etc a successful transaction will produce a transactio ID below your command.

**Note you will also be required to pay a transaction fee.

This tx ID can be followed in an online block-explorer.

Once you're done sending re-lock your wallet with:

./gobyte/bin/gobyte-cli walletlock

**Note the "true" or "false" on that command is for the option: "mixingonly"

Backing up wallets:

(1) In the event of HDD failure
The easiest method is to shutdown the Pi if you haven't already, and put the Micro SD card into a PC.
On the SD card, visible on a windows PC are two files of interest

cmdline (.txt)

and

cmdline.txt.bak

This was setup by the script that copied all our files to the HDD.
cmdline.txt.bak is the origional file the Pi used to boot from before we attached the HDD, and our wallet files are still held on the SD card as we set them up before copying them.

All that is required is for you to rename 'cmdline' to 'cmdline.txt.old' to disable it.
And rename 'cmdline.txt.bak' to 'cmdline.txt' to enable it.

Put the card back in the Pi and it will run as it did before the move to the HDD.

Simply complete 'Step (10) Moving everything to the USB drive' again with a new HDD and the node/wallet will perform as normal with the encrypted wallet.

Method 2: Import the Private key to a new node/rebuild.

There is a function of the wallet to import the private key we made and backed up
With gobyte -daemon running:

./gobyte/bin/gobyte-cli importprivkey "GoByteprivatekey"

**Where "GoByteprivatekey" is the clear text key generated when you did "dumpprivkey" on the build. (without "")

This will regenerate the un-encrypted wallet file again.

Follow the steps in this guide to re-encrypt the wallet and continue as normal.

Method 3: Copy the wallet.dat file

The GoByte wallet.dat file is held at /home/pi/.gobytecore/wallet.dat

Using a tool called WinSCP mentioned in the "Getting Started" section of this guide we can view this file:
WinSCP is a very useful tool, it shows the contents of the Pi structured like a windows file system which you may be more familiar with.

WinSCP works by displaying the file system on the Pi in the right window,
and the host PC file system in the left window.

Navigate to /home/pi/.gobytecore/ to find wallet.dat then drag and drop the file to the host PC in the left window. It brings up the dialogue window to "download". If your happy with the location click ok.

To restore the wallet.dat onto the Pi, reverse the process and Dash will find the wallet/addresses and keys on boot.

Step (13) Security

I've been made aware that there are some underlying defaults that can affect system security. One is to disable root login by ssh by editing

sudo nano /etc/ssh/sshd_config
and changing
PermitRootLogin without-password
to
PermitRootLogin no

and add the line below to only allow ssh access to user 'pi'

AllowUsers pi

Save, ctrl+o, enter, exit ctrl+x
then reboot just sshd by
sudo /etc/init.d/ssh restart

I will update any security recommendations as I become aware of them.
Enjoy

GoByte Full Node , Raspberry Pi3 With LCD Display(For any Single board computer running an ARM Cortex-A53 processor - Full list of compatible hardware listed here)Latest Update 9th June 2018

GoByte Full Node , Raspberry Pi3 With LCD Display
(For any Single board computer running an ARM Cortex-A53 processor - Full list of compatible hardware listed here)
Latest Update 9th June 2018