# At a glance

Factoring, a fundamental concept acquired in primary school, involves the decomposition of numbers into prime factors. While the basic understanding of factoring is instilled early on, its complexity escalates with the size of numbers. Various algorithms, each exhibiting efficacy within specific integer ranges, have been devised for this purpose.

The foremost algorithm for handling large numbers is the General Number Field Sieve (NFS), followed closely by the Elliptic Curve Method (ECM). While ECM's acronym signifies something else, for our current context, this explanation suffices. Factoring large numbers is an arduous task, serving a crucial role in safeguarding critical systems such as those employed by banks and government websites. The RSA cryptographic system, for instance, heavily relies on the formidable challenge posed by factoring for its security.

Interestingly, there exists a community of enthusiasts who derive enjoyment from factoring as a hobby. Engaging in projects aimed at discovering prime numbers or factoring numbers with distinctive patterns, these individuals contribute to a collective exploration of mathematical intricacies. Notably, the RSA factoring challenge gained prominence as a notable event, enticing participants with cash prizes for successfully factoring specific numbers. Originating from RSA Labs, a company still in existence, it made headlines when Dell sold it in 2020 for a staggering $2.1 billion. In the contemporary landscape, the FACT0RN blockchain emerges as a modern iteration of the RSA challenge. Enabling widespread participation in factoring, it offers the potential for participants to earn coins through their factoring endeavors.


# Quick links

This page is intended to help you find your way around the FACT0RN knowledge database

Introduction

* [The Concept](/introduction/concept-of-fact0rn)
* [The Mathematic](/introduction/why-use-integer-factorization-to-secure-fact0rn)
* [The Tokenomics](/introduction/usdfact-tokenomics)
* [The Vision](/introduction/fact0rn-the-future-of-proof-of-work-and-you)

Node

* [Running a node](/node/running-a-node)

Mining

* [Factoring (Docker Mining)](/mining/factoring-docker-mining)
* [IntegerDispersion](/mining/integerdispersion)
* [GPUDispersion](/mining/gpudispersion)

Wallet

* [Command Line Wallet](/wallet/command-line-wallet)
* [Graphical User Interface - FactWallet](/wallet/graphical-user-interface-wallet-factwallet)

{% hint style="info" %}
**Want to join our team? Be part on** [**Github**](https://github.com/FACT0RN)**!**
{% endhint %}


# Concept of FACT0RN!

In 2009, Satoshi Nakamoto introduced Bitcoin as the first blockchain technology governed by three principles: security, transparency and immutability (unable to change once finalized). The Bitcoin blockchain secures the network and adheres to these principles through the process of hashing, which takes the transaction data to generate a unique 256-bit hash value.

Hashing is not an easy process; a miner attempted nearly 2.9 billion hash combinations to secure Bitcoin block number 775,771. The process of generating the hash acceptable by the network is an extremely energy intensive endeavor, and as such, the network is secured by the Proof of Work (PoW).

High energy costs of maintaining the Bitcoin network means that it faces scalability issues, which has given rise to hundreds of newer blockchains — known as Layer 1 blockchains — that aim to solve the scalability issue. Additionally, the hashing of input data on the Bitcoin network is not applicable for many other real life applications. The energy use in generating these blocks have raised legitimate questions about the cost benefits of using hashing as the “Work” to secure blockchains.

### Enter FACT0RN <a href="#bcfd" id="bcfd"></a>

None of the research that has resulted in the advancement of these Layer 1 architectures have much practical application other than just securing the ledger for their respective blockchains.

This has led to the development of the FACT0RN blockchain.

FACT0RN aims to be the blockchain that adheres to the fundamental principles of Bitcoin, but also provide advancements in real-world applications. Like Bitcoin, transactions in the FACT0RN blockchain are secured by the Proof of Work consensus. However, unlike Bitcoin’s hashing as the means of work, FACT0RN uses integer factoring, which is of great importance to areas of security, cryptography and mathematics research.

> **FACT0RN uses integer factoring to secure the network through Proof of Work, unlike Bitcoin, which uses hashing of block data.**

The FACT0RN blockchain’s development is funded in its entirety by the Coinbase Crypto Community Fund, and the recipient of the fund: Escanor Liones. FACT0RN also has a group of volunteer developers and support staff to help support the project.

### The FACT0RN challenge <a href="#id-9504" id="id-9504"></a>

Factoring small integers is easy. In fact, school children all around the world learn about factorization and factor small integers with relative ease; however, it gets exponentially more difficult to factor large integers. This is why there are now several communities, mathematical enthusiasts, research and security programs dedicated to factoring integers. One such program, the Cunningham Project, dedicated to factoring integers has been running for nearly a century, and still going strong!

These research programs are continuously developing new, powerful algorithms to factor large bit integers. These communities also run bounties to factor large integers with substantial cash prizes for those that crack the factorization challenge. An RSA factoring challenge that ran over 15 years starting from 1991 awarded regular cash prizes on integers being factored. During that time, the largest prize of $20,000 went to an individual who factored an RSA-640 number, which is 193-digit number.

In comparison, blockchains use RSA-2048 numbers (617 decimal digits) whose encryption would take an ordinary computer 300 trillion years to break. With rapid advancement in technology, the encryption will be broken sooner, but not so soon that we would likely see it in our lifetime.

The FACT0RN blockchain aims to keep alive the long tradition of factoring by allowing communities to submit integers to be solved by factoring, and offering financial incentives to miners who would not normally care about factoring. The project brings communities from cryptography, mathematics, blockchain and finance to create the 21st century version of the RSA Challenge. In doing so, FACT0RN has the noble ambition of attracting investments into mathematical research.


# Why use integer factorization to secure FACT0RN?

As it turns out, integer factoring is of immense interest to mathematicians and cryptography research. There are academics, professional societies and intelligence programs dedicated to factoring integers. Factorization is the process of breaking down a positive integer into smaller positive integers that are eventually broken down into their smallest factor, which are prime factors.

As an example, let’s use the number 60.

Factors of this number include 2, 3, 4, 5, 6, 10, 12, 15, 20 and 30.

2 x 30 = 60

3 x 20 = 60

4 x 15 = 60

5 x 12 = 60

6 x 10 = 60

While these numbers are all factors, not all are prime factors (prime numbers are only divisible by 1 or the number itself). The prime factors for the integer 60 only consist of the prime factors 2, 3 and 5.

2 x 2 x 3 x 5 = 60

22 x 3 x 5 = 60

It sounds simple, boring, and useless but that is far from the truth!

It is easy to generate a large bit number (hundreds of digits) by multiplying two long prime integers, but it is more difficult to work backwards and know the prime factors that created our number. In fact, the privacy and security of top intelligence agencies, government and banks hinges on the difficulty of integer factoring. Security encryption provided by these large bit numbers is almost impossible to break using the currently available technology, including some of the world’s most powerful supercomputers.

Rights to privacy and secure communications are fundamental to the pillars of modern society, including intelligence work, finance and the digital world. The internet achieves secure, private messaging through various encryption methods. With the internet’s initial design, protocols such as HTTP did not consider security, which led to encrypted versions like HTTPS that allow us to browse online more securely. Protocols like HTTPS are often secured by RSA encryption that is actually based on prime factorisation.

Users can only access the public encrypted messages with private decryption keys. We have seen the devastating consequences that may occur with the breach of intelligence information or financial services. For example, DeFi protocols with weak encryption have lost billions of dollars in compromised security. Therefore, a strong encryption system is vital to prevent hacking. Put simply, strong encryption methods based on prime factorization helps to keep our vital information secure.

The FACT0RN blockchain aims to be the PoW blockchain that requires better mathematical theory, and by doing so, it can help to advance knowledge in mathematics, cryptography and security in a way that we can all benefit.


# $FACT tokenomics

Miners that secure a block in the FACT0RN blockchain are rewarded with FACT0RN coins, $FACT, which can be traded as a cryptocurrency. As one would expect, miners who factor larger integers correctly receive better rewards than those factoring smaller integers.

There is no automatic vesting of $FACT coins or any allocation reserved for the team. All $FACT coins that enter into the circulation must be mined through factorization as the PoW. There is also no supply cap when it comes to $FACT. This is intentionally designed to incentivise factoring larger, more difficult integers. Making it more difficult to mine rewards controls the inflation of $FACT coins and protects against negative impact on the coin’s value. The larger the integer factored, the larger the reward, and the more $FACT that will enter circulation.

Additionally, FACT0RN is also introducing a “deadpool” concept, which will tap into the enthusiasm of factoring communities. Any user can pay a fee in $FACT and submit an integer to be factored to the deadpool. In addition, anyone else can add more $FACT coins to any integer of deadpools.

Below is a quick summary of $FACT emission:

* No pre-mining
* No pre-sale
* No team allocation
* No emission schedule (mining only)
* Unlimited supply, but low reward for block discovery
* 1.5 years and less than 260K coins in Supply
* Circulating Supply = Total Supply at all times


# FACT0RN, the future of Proof of Work, and you!

Until now, the work in PoW has not gone to benefit any other enterprise but itself. FACT0RN is the first PoW blockchain that seeks to drastically change this situation by replacing hashing by work that is of interest to the private sector, as well as to the academic communities and those whose success will propel significant funding for universities and mathematical research in general.

We strongly believe Satoshi’s vision of immutable and transparent ledger secured by PoW. We also believe that the high energy use in PoW can be used in something that should benefit the whole society. The FACT0RN blockchain achieves both.

FACT0RN is an initiative led by Escanor Liones, and a core team of volunteers who oversee its development. It has not received any investment and will not accept any investments, other than voluntary donations. We also welcome any proposals and ideas to improve the blockchain.

If you would like to support the project, we also have a Tip Jar wallet whose funds are used for the following purposes:

* Fund the technical development of the FACT0RN blockchain
* Fund mathematical research
* Fund development of related projects: e.g. factoring software and factoring hardware

**Tip Jar Address**: fact1qln3xayyyuhwww5jl6c4xtf8e3aqzym6wl45rrv


# Running a node

In this guide you learn how to run a node in two methods

Running a node can be done for two purposes: relaying transactions and/or mining. For relaying transactions all you need to do is run the executable and you are good to go. If you want to mine then you need to set a username and password so that your miner is able to connect to it.

There are two ways to do this: set them in your config file or pass them in using parameters.

#### Method 1: config file

The advantage of this method is that you don't have to enter it anywhere. You can run your node and use the cli tools wihtout passing in the rpcuser and rpcpassword flags all the time.

Create the file `~/.factorn/factorn.conf` if it does not exist. Add the following to it:

```
rpcuser=<Type a username of your choice>
rpcpassword=<Type in any password of your choosing>
```

That's it. You can start your node or use the cli tools and it will use that username and password automafically.

#### Method 2: Command line RPC flags

From the directory where you untar-ed your binaries from the release page do the following:

```
./factornd -rpcuser=<set your username here> -rpcpassword=<set your password here>
```

Your miner will need these to connect to your node and ask for the next block to mine. If you are mining locally your port are the standard ports: mainnet -> 8332 and testnet -> 18332. By default `factornd` runs on mainnet. To run testnet do:

```
./factornd -rpcuser=<set your username here> -rpcpassword=<set your password here> -testnet
```

You will need to know this ro run FACTOR.py from the mining code at `https://github.com/FACT0RN/factoring`.


# Factoring (Docker Mining)

Mining code for the FACT0RN blockchain. For the binaries and instructions on how to run a node see [FACT0RN](https://github.com/FACT0RN/FACT0RN). To run the miner you will need Docker.

You will need the scriptPubKey from an address in your wallet. For instructions on how to get a wallet, an address in your wallet and get the scriptPubKey for that address see the instructions on [FACT0RN](https://github.com/FACT0RN/FACT0RN).

These instructions are for the case where you are mining on the same machine where you have a node running:

1. From the parent folder of this repo, build the image:

```
docker build -t factorn_mining .
```

2. Now, to run a container do this:

```
docker run -ti -e SCRIPTPUBKEY="ValidScriptPubKey" -e RPC_USER="Your node's rpc username" -e RPC_PASS="Your node rpc's password" -e YAFU_THREADS=max_core_count_minus_one -e YAFU_LATHREADS=max_core_count_minus_one -e MSIEVE_BIN="/tmp/ggnfs-bin/" --network host factorn_mining  bash -c "python3.10 FACTOR.py"
```

I'd recommend to run one container. Use as many threads as you have cores, minus one so the OS has on core to do normal system stuff. If you run htop you will see how many cores you have.

Note: There are a few sophiscated software implemntations for factoring. Currently, we use YAFU by default. For advanced users, you can look into YAFU, ECM-GMP and CADO-NFS. A setup using CADO-NFS is welcomed. If you create one, please let us know.


# IntegerDispersion

Bare metal mining for FACT0RN. Meaning, no Docker containers.

### How to use

First, we need to create primorials containing all primes of a fixed bitsize. So all primes of bitsize 10, for example, would be the product of all primes between 512 and 1024....so we would call that the primorial at level 10, denoted P#\_10.

For simplicity, we say P#\_1 = 2\*3 = 6 is the Level 1 primorial and start from there....so the above example would be primorial level 9 or P#\_9. In my testing, the optimal number of levels to have to sieve candidates for mining is somewhere between 23 - 28. After 28 the degradation is significant, ecm sieves faster; depending on many parameters the optimal point changes at lower levels; 23 is the clearly-this-is-better level and 28 is the clearly-this-is-not-optimal.

To get the files containing these levels do the following:

```
cd work/yafu0/yafu/isieve
./sieverb 28
```

The siever can be built from soruce, just run the `build.sh` file in the isieve folder. Python is extremely slow generating this leveled primorials so generating them using C++ and loading them into memory is significantly faster.

If you are not running Ubuntu 20.04 on x86 you will need to build yafu, ecm from source and place them in the right directories. I strongly recommend to compile for your architecture with `-march=native` or the equivalent for clang when you build; I also strongly recommend to build GMP from source and optimize it, this process may take half an hour, and requires that you build GMP, run a benchmark that runs long, replace a header file, and rebuild again, but it is worth it.

To run the miner, do:

```
cd work/yafu0/yafu
python FACTOR.py <number of cores to use> <core offset> <scriptPubKey>
```

It is best to turn off Hyper-Threadind(Intel)/SMT(AMD) and dedicate a full physical core per thread. The terminology above assumes one thread per core, that is, HT/SMT is turned off. Because FACTOR.py uses taskset to pin threads to cores, the \<core offset> parameters helps you assign the next miner to different cores than the previous one. Note that to turn off HT/SMT it is not necessary to go to the BIOS, you can do it from the terminal...though your computer might freeze or slow down for several seconds while it does this. Use `echo off | sudo tee /sys/devices/system/cpu/smt/control` or the equivalent if you running on Intel CPUs.

To further increase performance, you may want to run the `renice_mining.py` python script as this will further reduce core migrations, context switches and give you even better time slices on the linux scheduler. The way to run it is to execute every second or two with the watch command:

```
watch -n 1 python renice_mining.py
```

You only need to have one instance of `renice_mining.py` regardless of how many miners you have running. It will do the right thing.

I would recommend at this point in time to use all cores per miner...minus one core, leave one core out for the OS to be responsive. Note, the log files generated by mining get into the GB range over time...so you need to check them and delete them every so often.

So, you will have something likthis:

```
------------------------
Terminal 0
------------------------
cd /word/yafu0/yafu
python FACTOR.py <core_count_minus_one> 0 <scriptPubKey>
------------------------

------------------------
Terminal 4
------------------------
watch -n 1 renice_python.py
------------------------

```

Remember to update lines 73 and 74 in `FACTOR.py` with the rpc credentials to your FACT0RN daemon.

There probably is a much better way of doing this and much better way to organize this entire process....feel free to contribute to make this better. I will merge improvements as they show up on the PR list.


# GPUDispersion

This version uses GPU to help eliminate candidates at scale much faster.

Roughly speaking, the situation is this: we get an interval of about 12,000 integers to sieve per nonce. Multiples of 2,3,5 and 7 reduces this amount of 12K candidates to by 79% to 2500 candidates. Next we sieve by multiples of 11, 13, and so on. We remove candidates by checking if they are a multiple of ever larger primes.

In all previous testing of ECM on GPUs we did not see any advantage over CPU for this task of sieving until recently when someone in the team investigating this stumble upon the fact that, if we remove phase 2 from ECM, then we get a huge speed up and can sieve by much larger primes in the same amount of time we perviously had available.

In practice, when before we tested and reduced 12000 candidates to \~350 now, in that same amount of time, we hav left \~100 or so candidates. If we add three GPUs of the same type this number comes down to \~60 or so candidates. We tested with 14 RTX 4090 GPUs and this number comes down to \~20 candidates.

Where now we can perform GNFS using CUDA-NFS on the remaining 100 or 20 survivors of this proccess -- depending on how much GPU power your system has available.

This miner automagically uses ALL gpus available on the system -- though, only nvidia GPUs. The ECM GPU implementation we use is here\[<https://github.com/FACT0RN/ecmongpu>]. Feel free to improve it.

## Installation

You will need the following python modules:

`pip install numpy base58 nvidia-ml-py3`

To build ecmongpu you will the cuda toolkit. We will publish a release built for x86 and ubuntu.

## Running

Once you have CUDA-NFS and ecmongpu ready to go -- run the `build.sh` script. You will need to set the `RPC_USER` and `RPC_PASS` in the environment so the miner can talk to the daemon.

```
export RPC_USER=youruserforfactornd
export RPC_PASS=yourpasswordforfactornd
```

Exctremely important, run:

```
python sitter.py
```

This script checks for new blocks and tells the miner to start over from the new block.

Then you will need your ScriptPubKey and the ecm level to run the miner. For example:

```
python blockchain.py 00scriptpubkeygoeshereff 4
```

The ECM levels are as follows:

```
Usage: python blockchain.py <ScriptPubKey> <ECM Level>")
       ScriptPubKey is a hexadecimal string and ECM Level is an integer from 1 to 5.
         ECM Levels
         Level 1:    Remove factors with up to 20 decimal digits.
         Level 2:    Remove factors with up to 25 decimal digits.
         Level 3:    Remove factors with up to 30 decimal digits.
         Level 4:    Remove factors with up to 35 decimal digits.
         Level 5:    Remove factors with up to 40 decimal digits.
        Level 5:    Remove factors with up to 45 decimal digits.
 Choose the appropiate one for the computational power in GPU you have
```

The higher the level the more you sieve but the longer it takes. The number of CUDA cores you have the higher you can for a fixed amount of time.

So, for example if CUDA-NFS takes 4 minutes to factor a block solver candidate and the average block time is 10 minutes...you should now take more than 6 minuets on GPU sieving -- choose a level that takes less than that to leave yourselve some buffer room for running CADO-NFS.

## Improvements

Please report any bugs or funny behaviour, in terms of timing or not sieving as much as expected given a number of GPus, and we will take a look at it. Scaling should be linear in terms of GPUs


# Command Line Wallet

First, we need a node running. See the installation section. Once you have your node running here's how to create a wallet, generate an address and extract the scriptPubKey value that will allow you to earn mining rewards.

From the project's root folder:

```
src/factorn-wallet  -wallet=<wallet name>  -descriptors create
src/factorn-cli    loadwallet <wallet name>
src/factorn-cli    getnewaddress
src/factorn-cli    getaddressinfo <address from previous command>
```

For example, from the get `getaddresinfo` command above you should get something similar to:

```
{
  "address": "fact1q4zjycg88kyk72szmhpjvm82mu0zm6p26g7zeh8",
  "scriptPubKey": "0014a8a44c20e7b12de5405bb864cd9d5be3c5bd055a",
  "ismine": true,
  "solvable": true,
  "desc": "wpkh([67f532c6/84'/0'/0'/0/0]02de55517a22dc5a66d4a193cb877a3658b1c456827c1404d18e79dec82d5d937a)#0hcn4tny",
  "parent_desc": "wpkh([67f532c6/84'/0'/0']xpub6D7gQbDdRjuiMN9EqbEzWY4owSUfNNcRdA4E5aaYCX4VoRPMzgeaF4C15D6hSCUpvUkZvjKJTLktDVvjZ3beL8sfW1ATsNQ6qCsAkV6STtr/0/*)#zylutadk",
  "iswatchonly": false,
  "isscript": false,
  "iswitness": true,
  "witness_version": 0,
  "witness_program": "a8a44c20e7b12de5405bb864cd9d5be3c5bd055a",
  "pubkey": "02de55517a22dc5a66d4a193cb877a3658b1c456827c1404d18e79dec82d5d937a",
  "ischange": false,
  "timestamp": 1650416082,
  "hdkeypath": "m/84'/0'/0'/0/0",
  "hdseedid": "0000000000000000000000000000000000000000",
  "hdmasterfingerprint": "67f532c6",
  "labels": [
    ""
  ]
}
```

You will need the value from "scriptPubKey" to mine. In this example, this person would use the value "0014a8a44c20e7b12de5405bb864cd9d5be3c5bd055a" to pass to the python mining script. This would credit the rewards of the block to their address.

To send a transaction, the FACT0RN node must be running. You can then submit a transaction using the following command:

```
./factorn-cli -named sendtoaddress address="receiving_address" amount="amount_to_be_sent" fee_rate=10 subtractfeefromamount=true avoid_reuse=true replaceable=true verbose=true
```


# Graphical User Interface Wallet - FACTWallet

Lightweight FactWallet

```
Licence: MIT Licence
Language: Python (>= 3.8)
Homepage: https://www.fact0rn.io
```

The binaries for the FACTWallet can be found here: <https://github.com/FACT0RN/FactWallet/releases>

FACTWallet can also be built from source.

### Getting started

Based on the Bitcoin Electrum Lightweight wallet. See the Contributing section below. There is still a lot of work that needs to be done.

Electrum itself is pure Python, and so are most of the required dependencies, but not everything. The following sections describe how to run from source, but here is a TL;DR:

```
$ sudo apt-get install libsecp256k1-dev
$ python3 -m pip install --user ".[gui,crypto]"
```

#### Not pure-python dependencies

If you want to use the Qt interface, install the Qt dependencies:

```
$ sudo apt-get install python3-pyqt5
```

For elliptic curve operations, [libsecp256k1](https://github.com/bitcoin-core/secp256k1) is a required dependency:

```
$ sudo apt-get install libsecp256k1-dev
```

Alternatively, when running from a cloned repository, a script is provided to build libsecp256k1 yourself:

```
$ sudo apt-get install automake libtool
$ ./contrib/make_libsecp256k1.sh
```

Due to the need for fast symmetric ciphers, [cryptography](https://github.com/pyca/cryptography) is required. Install from your package manager (or from pip):

```
$ sudo apt-get install python3-cryptography
```

If you would like hardware wallet support, [see this](https://github.com/spesmilo/electrum-docs/blob/master/hardware-linux.rst).

#### Running from tar.gz

If you downloaded the official package (tar.gz), you can run Electrum from its root directory without installing it on your system; all the pure python dependencies are included in the 'packages' directory. To run Electrum from its root directory, just do:

```
$ ./run_electrum
```

You can also install Electrum on your system, by running this command:

```
$ sudo apt-get install python3-setuptools python3-pip
$ python3 -m pip install --user .
```

This will download and install the Python dependencies used by Electrum instead of using the 'packages' directory. It will also place an executable named `electrum` in `~/.local/bin`, so make sure that is on your `PATH` variable.

#### Development version (git clone)

*(For OS-specific instructions, see* [*here for Windows*](https://github.com/FACT0RN/FactWallet/blob/master/contrib/build-wine/README_windows.md)*, and* [*for macOS*](https://github.com/FACT0RN/FactWallet/blob/master/contrib/osx/README_macos.md)*)*

Check out the code from GitHub:

```
$ git clone https://github.com/spesmilo/electrum.git
$ cd electrum
$ git submodule update --init
```

Run install (this should install dependencies):

```
$ python3 -m pip install --user -e .
```

Create translations (optional):

```
$ sudo apt-get install python3-requests gettext qttools5-dev-tools
$ ./contrib/pull_locale
```

Finally, to start Electrum:

```
$ ./run_electrum
```

#### Run tests

TODO: tests need to be redone for the Fact0rn blockchain.

Run unit tests with `pytest`:

```
$ pytest electrum/tests -v
```

To run a single file, specify it directly like this:

```
$ pytest electrum/tests/test_bitcoin.py -v
```

### Creating Binaries

* [Linux (tarball)](https://github.com/FACT0RN/FactWallet/blob/master/contrib/build-linux/sdist/README.md)
* [Linux (AppImage)](https://github.com/FACT0RN/FactWallet/blob/master/contrib/build-linux/appimage/README.md)
* [macOS](https://github.com/FACT0RN/FactWallet/blob/master/contrib/osx/README.md)
* [Windows](https://github.com/FACT0RN/FactWallet/blob/master/contrib/build-wine/README.md)
* [Android](https://github.com/FACT0RN/FactWallet/blob/master/contrib/android/Readme.md)

### Contributing

Any help testing the software, reporting or fixing bugs, reviewing pull requests and recent changes, writing tests, or helping with outstanding issues is very welcome. Implementing new features, or improving/refactoring the codebase, is of course also welcome, but to avoid wasted effort, especially for larger changes, we encourage discussing these on the issue tracker or Discord first.

Besides [GitHub](https://github.com/FACT0RN/FactWallet), most communication about Electrum development happens on Discord, in the `Fact0rn` [server](https://discord.gg/Mfzp2QtmQG).