Firo

Firo formerly known as Zcoin, is a privacy focused cryptocurrency that utilizes the Lelantus Spark protocol which supports high anonymity sets without requiring trusted setup and relying on standard cryptographic assumptions.

The Lelantus Spark cryptographic library and implementation was audited by HashCloak. The Lelantus Spark cryptography paper has undergone two separate audits by HashCloak and Daniel (Linfeng) Zhao.

Firo also utilises Dandelion++ to obscure the originating IP of transactions without relying on any external services such as Tor/i2P.

Firo uses a hybrid PoW and LLMQ Chainlocks system combining fair distribution of supply with protection against 51% attacks and quick finality of blocks and transactions. FiroPOW (a ProgPOW variant) is used as its Proof-of-Work algorithm which targets GPUs and is FPGA/ASIC resistant.

Running with Docker

If you are already familiar with Docker, then running Firo with Docker might be the the easier method for you. To run Firo using this method, first install Docker. After this you may continue with the following instructions.

Please note that we currently don't support the GUI when running with Docker. Therefore, you can only use RPC (via HTTP or the firo-cli utility) to interact with Firo via this method.

Local Dockerfile

This repository contains a Dockerfile that you can build and run locally.

To build it, run from the root of this repository:

docker build . -t firo-local

After the process is completed, run a container based on the firo-local image you built:

docker run -d --name firod -v "${HOME}/.firo:/home/firod/.firo" firo-local

This will start a detached docker container, which you can interact with using docker exec. See the section "Interact with the container" for a list of useful commands you can use to manage your node. Make sure to change firod with firo-local, if you have built the local Docker image.

Docker image on DockerHub

If it doesn't already exist, create a .firo folder in your home (this is a workaround until #1241 is resolved):

mkdir -p ${HOME}/.firo

Pull our latest official Docker image:

docker pull firoorg/firod

Start Firo daemon:

docker run -d --name firod -v "${HOME}/.firo:/home/firod/.firo" firoorg/firod

Interact with the container

View current block count (this might take a while since the daemon needs to find other nodes and download blocks first):

docker exec firod firo-cli getblockcount

View connected nodes:

docker exec firod firo-cli getpeerinfo

Stop daemon:

docker stop firod

Backup wallet:

docker cp firod:/home/firod/.firo/wallet.dat .

Start daemon again:

docker start firod

Linux Build Instructions and Notes

Firo contains build scripts for its dependencies to ensure all component versions are compatible. For additional options such as cross compilation, read the depends instructions

Alternatively, you can build dependencies manually. See the full unix build instructions.

Bootstrappable builds can be achieved with Guix.

Development Dependencies (compiler and build tools)

• Debian/Ubuntu/Mint (minimum Ubuntu 18.04):

sudo apt-get update
sudo apt-get install python; sudo apt-get install git curl build-essential libtool automake pkg-config cmake
# Also needed for GUI wallet only:
sudo apt-get install qttools5-dev qttools5-dev-tools libxcb-xkb-dev bison

If you use a later version of Ubuntu, you may need to replace python with python3.

• Redhat/Fedora:

sudo dnf update
sudo dnf install bzip2 perl-lib perl-FindBin gcc-c++ libtool make autoconf automake cmake patch which
# Also needed for GUI wallet only:
sudo dnf install qt5-qttools-devel qt5-qtbase-devel xz bison
sudo ln /usr/bin/bison /usr/bin/yacc

• Arch:

sudo pacman -Sy
sudo pacman -S git base-devel python cmake

Build Firo with autotools

1. Download the source:

git clone https://github.com/firoorg/firo
cd firo

2. Build dependencies and firo:

Headless (command-line only for servers etc.):

cd depends
NO_QT=true make -j`nproc`
cd ..
./autogen.sh
./configure --prefix=`pwd`/depends/`depends/config.guess` --without-gui
make -j`nproc`

Or with GUI wallet as well:

cd depends
make -j`nproc`
cd ..
./autogen.sh
./configure --prefix=`pwd`/depends/`depends/config.guess`
make -j`nproc`

3. (optional) It is recommended to build and run the unit tests:

./configure --prefix=`pwd`/depends/`depends/config.guess` --enable-tests
make check

If the build succeeded, two binaries will be generated in /src: firod and firo-cli. If you chose to build the GUI, firo-qt will be also generated in the qt folder.

Build Firo with CMake

This document provides instructions for building Firo using the new CMake-based build system.

Prerequisites (macOS Specific)

Ensure Homebrew is installed as per the macOS build guide.

---

Build Instructions

1. Build Dependencies

cd depends
make -j$(nproc)
cd ..

2. Configure and Build

mkdir build && cd build
cmake .. \
  -DCMAKE_TOOLCHAIN_FILE=$(pwd)/../depends/x86_64-pc-linux-gnu/toolchain.cmake \
  -DBUILD_CLI=ON \
  -DBUILD_GUI=ON \
  -DBUILD_TESTS=ON
make -j$(nproc)

3. Run GUI Client

./bin/firo-qt

CMake Options Reference

Flag	Description	Default
BUILD_DAEMON	Build firod executable	ON
BUILD_GUI	Build firo-qt GUI client	ON
BUILD_CLI	Build firo-tx and other command-line tools	ON
ENABLE_WALLET	Enable wallet functionality	ON
BUILD_TESTS	Build test suite	OFF
BUILD_TX	Build firo-tx transaction tool	Subset of BUILD_CLI
ENABLE_CRASH_HOOKS	Enable crash reporting/stack traces	OFF
WITH_ZMQ	Enable ZeroMQ notifications	ON

Supported Cross-Compilation Targets

Host Target	Platform
x86_64-w64-mingw32	Windows 64-bit
aarch64-apple-darwin	macOS
arm-linux-gnueabihf	Linux ARM 32-bit
aarch64-linux-gnu	Linux ARM 64-bit

Usage Example:

# Build dependencies for Windows 64-bit
cd depends
make HOST=x86_64-w64-mingw32 -j$(nproc)
cd ..

Cross-Compilation

To build for other platforms, specify HOST variable.

mkdir build && cd build
cmake .. \
  -DCMAKE_TOOLCHAIN_FILE=$(pwd)/../depends/x86_64-w64-mingw32/toolchain.cmake \
  -DBUILD_CLI=ON \
  -DBUILD_GUI=ON \
  -DBUILD_TESTS=ON
make -j$(nproc)

Notes

• The toolchain path in CMAKE_TOOLCHAIN_FILEmust match your target architecture.
• BUILD_TX is automatically enabled if BUILD_CLI=ON is enabled.

macOS Build Instructions and Notes

See doc/build-macos.md for instructions on building on macOS.

Note: these instructions are inherited from Bitcoin and might not work as expected

Windows (64/32 bit) Build Instructions and Notes

See doc/build-windows.md for instructions on building on Windows 64/32 bit.

Note: these instructions are inherited from Bitcoin and might not work as expected

Run Firo

Now that you have your self-built or precompiled binaries, it's time to run Firo! Depending by your skill level and/or setup, you might want to use the command line tool or the graphic user interface. If you have problems or need support, contact the community.

Install Firo

After building with CMake, generate .sh file with make package. Once you run make package you should have ./FiroCore-VERSION_MAJOR.VERSION_MINOR.VERSION_REVISION-Linux.sh in your build directory.

For example, you can install Firo on your /usr/bin with:

./FiroCore-0.14.14-Linux.sh --prefix=/usr/bin --exclude-subdir

Contributors

Code Contributors

This project exists thanks to all the people who contribute. Would you like to help Firo and contribute? See the [CONTRIBUTING] file.

Financial Contributors

Become a financial contributor and help us sustain our community. [Contribute]

You can also donate to the MAGIC Firo Fund which allows some US entities to claim a charitable deduction.

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [Contribute]