docs/advanced/cross-compile-hush-full-node-to-aarch64-with-docker.md

Cross compiling a Hush full node daemon from AMD64 to ARM64(aarch64) CPU architecture with Docker

Requirements: Docker-Engine & arm64(aarch64) architecture with Debian operating system, such as a Raspberry Pi 400

Summary

These are instructions for cross compiling a Hush full node daemon on a regular AMD64 PC (also known as x86 architecture) to ARM64(aarch64) CPU architecture with Docker. The following instructions enables a smoother transition between your desktop/laptop to the raspberry pi device.

These instructions were created as a result of (no. 1) issues with glibc versions differing on the two different machine architectures and (no. 2) no gcc and g++ multilib packages existing natively on the arm64(aarch64) architecture. Currently there are open issues with Debian to include these packages for this architecture.

Note: This should work on all types of arm64(aarch64) devices. By cross compiling (building) on a different system for another machine type, we are able to bypass the ARMv7 requirements. Cross compiling is useful for machines that don't have lots of hardware resources to compile on or, in this case, G++-multilib isn't available on ARM64(aarch64) devices and hushd requires it to compile binaries.

1. Let's Begin!

• Install & setup Docker-Engine. Most users will install this via their operating system's package manager, but also refer to Docker-Engine Installation for additional information.

sudo docker run -it --rm -v /tmp:/tmp debian:bullseye

This creates a container with the latest version of Debian. A bind mount is created mapping the /tmp directory on the host machine to the /tmp directory on the container. The additional options mean the container will run in interactive mode with a terminal, and the container will be destroyed when you stop(exit) it.

2. Upgrade the Docker OS image packages

Make sure we have the latest versions of everything in the base OS image. apt-get -y update && apt-get -y upgrade

3. Install Hush build dependencies

Note: the dependencies for arm64(aarch64) are slightly different

apt-get -y install build-essential pkg-config libc6-dev m4 autoconf libtool libncurses-dev unzip git python3 python-is-python3 zlib1g-dev wget bsdmainutils \
 automake nano curl unzip libsodium-dev libboost-dev libdb++-dev libwolfssl-dev g++-aarch64-linux-gnu g++ cmake \
build-essential vim gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu

4. Pull or clone latest hush3 from git.hush.is

git clone https://git.hush.is/hush/hush3.git && cd hush3

5. Build and compile for aarch64-linux-gnu device

HOST=aarch64-linux-gnu ./util/build-arm-xcompile.sh -j$(nproc)

Relax and let the code flow. It normally takes 15-30 minutes to compile successfully, but may take longer on some systems.

6. Prepare binaries for our ARM64(aarch64) device

On success of building the Hush binaries, we first want to "prepare" them. We do this so we don't end up with a 311 MB hushd binary and instead get the correct size, which is much smaller.

The following commands are used in the Docker container terminal:

aarch64-linux-gnu-strip src/hushd
aarch64-linux-gnu-strip src/hush-cli
aarch64-linux-gnu-strip src/hush-tx

7. Copy binaries from Docker container to our desktop

Next we will copy these new binaries from our Docker container to our desktop and exit the Docker container.

The following cp command used in the Docker container terminal copies from the docker container to actual desktop machine environment into the /tmp/hush-arm64 directory.

mkdir /tmp/hush-arm64
cp src/hushd /tmp/hush-arm64/
cp src/hush-cli /tmp/hush-arm64/
cp src/hush-tx /tmp/hush-arm64/
cp src/hush-smart-chain /tmp/hush-arm64/
cp asmap.dat /tmp/hush-arm64/
cp sapling-output.params /tmp/hush-arm64/
cp sapling-spend.params /tmp/hush-arm64/

Then you can type exit in the docker container when you are done. exit Note: on exit, the docker container will be completely destroyed!.

8. Copy binaries to ARM64(aarch64) device

Next we will copy these new binaries to our ARM64(aarch64) device. Now that these are on our actual desktop machine, we will next copy them to our raspberry pi (or other ARM device).

The installation location is up to you, but for this example we will use /home/username/hush3-folder, which has to already exist on the raspberry pi end, and we assume that your raspberry pi is already running a server. If you want to mount the media on your desktop system, then please do a web search for those instructions, but most people will be scp'ing the files to their raspberry pi.

Substitute your username and server name or IP below in the commands below:

cd /tmp/hush-arm64
scp * username@YOUR-SERVER-NAME-OR-IP:/home/username/hush3-folder/

9. Launch a fresh hush daemon(node) puppy on ARM64(aarch64)

./hushd --version

We have successfully cross-compiled a hushd for a arm64(aarch64) device from the amd64 architecture. Note: this has only been tested from amd64 architecture; we will update this list later for other tested hardware; the process will almost be identical, but other dependencies may be needed

Happy Hacking! [Hooray!]

Creating debian ARM64 package

1. Be on a Debian computer and place the hush binaries in the hush3/src directory.
2. Run ./util/build-debian-package.sh aarch64 and it will create a Debian installable package from your hush binaries.

Automation with Docker

Note: this has not been recently tested... may not work with recent code I will update the steps required to automatically build and run hushd with a Dockerfile. This is useful for testing and also aids in other hush puppies who don't need to deep dive into developer chores and maintainance. Required dep is Docker-Engine.

Create Hush docker image

0. git clone https://git.hush.is/hush/hush3.git && cd hush3/
1. docker build -t hush:3.8.0 .

List docker images & run Hush docker image

2. docker images
3. Look for the docker image ID for hush:3.x.x
4. docker run imageID
5. hushd --version

Support, Socials and Licensing

Support, Socials and Licensing

Credits

Odinzu originally created this documentation (along with testing) after about ~34 hours of tedious focus and work. This documentation has continued to be updated by the Hush devs, so that it will still work, as it has changed from its original form.