Knotsday

Bitaxe Solo Mining Guide

The Winged Hussars

Why Solo Mine Through Your Node?

The Winged Hussars did not charge through intermediaries. When you solo mine through your own node, your blocks are built by your software, enforcing your rules. The block template comes from your Bitcoin Knots node, which means:

A new proof of work may be coming. After the BIP110 chain stalled at block 961,632, its backers began work on a proof-of-work change that would end dependence on SHA-256 mining entirely. If that activates on a successor chain, today's SHA-256 hardware (Bitaxe included) will not mine it. No algorithm has been chosen yet — so for now, a Bitaxe or dedicated ASIC pointed at your own node remains the way to participate. See the road ahead.

Prerequisites: You need a running, fully synced Bitcoin Knots node. If you have not set one up yet, follow the Node Setup Guide first.

What You Need

Architecture

The Bitaxe speaks the Stratum mining protocol, but bitcoind does not. You need a Stratum proxy in between. We use ckpool — a lightweight, C-based solo mining proxy.

Diagram — Bitaxe / ckpool / Node Architecture 
  [Bitaxe] ---Stratum--> [ckpool :3333] ---RPC--> [Bitcoin Knots :8332]
     |                        |                          |
  Your miner            Mining proxy              Your full node
  (WiFi)              (your machine)            (validates blocks)

Step 1: Build and Install ckpool

1

Install build dependencies

sudo apt-get update
sudo apt-get install -y build-essential autoconf automake \
  libtool pkg-config libssl-dev
2

Clone and build

cd /tmp
git clone https://bitbucket.org/ckolivas/ckpool.git
cd ckpool
./autogen.sh
./configure
make -j$(nproc)

# Install
cp src/ckpool src/notifier ~/.local/bin/

# Verify
ckpool --help

Step 2: Configure ckpool

3

Create the configuration

mkdir -p ~/.local/etc ~/.local/var/log/ckpool

cat > ~/.local/etc/ckpool.conf <<'EOF'
{
    "btcd" : [
        {
            "url" : "localhost:8332",
            "auth" : "your_rpc_username",
            "pass" : "your_secure_rpc_password_here"
        }
    ],
    "btcaddress" : "YOUR_BITCOIN_ADDRESS_HERE",
    "btcsignet" : false,
    "serverurl" : [
        "0.0.0.0:3333"
    ],
    "mindiff" : 1,
    "startdiff" : 1000,
    "logdir" : "/home/YOUR_USER/.local/var/log/ckpool"
}
EOF

Replace your_rpc_username and your_secure_rpc_password_here with the credentials from your bitcoin.conf. Replace YOUR_BITCOIN_ADDRESS_HERE with your wallet address.

4

Test ckpool

# Start in the foreground to verify it connects
ckpool -B -c ~/.local/etc/ckpool.conf

You should see:

[...] Bound serverurl[0]: 0.0.0.0:3333 (SV1)
[...] Server alive: localhost:8332
[...] Connected to bitcoind: localhost:8332
[...] Mining solo to any incoming valid BTC address username

Press Ctrl+C to stop once verified.

5

Set up as a systemd service

mkdir -p ~/.config/systemd/user

cat > ~/.config/systemd/user/ckpool.service <<'EOF'
[Unit]
Description=CKPool Solo Mining Proxy
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=%h/.local/bin/ckpool -B -c %h/.local/etc/ckpool.conf
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
EOF

# Enable and start
systemctl --user daemon-reload
systemctl --user enable ckpool.service
systemctl --user start ckpool.service

# Enable linger so it runs at boot without login
loginctl enable-linger $USER

# Check status
systemctl --user status ckpool

Step 3: Connect Your Bitaxe

6

Find your computer's IP address

# Find your IP on the local network
ip addr show | grep "inet " | grep -v 127.0.0.1

Note the IP address on the same network as your Bitaxe (e.g. 192.168.1.100).

7

Connect to the Bitaxe

If your Bitaxe is new or unconfigured, it broadcasts a WiFi access point named Bitaxe_XXXX. Connect to it, then access the web interface: 

# Connect to the Bitaxe AP
# Open a browser to: http://192.168.4.1

Or if the Bitaxe is already on your network, find it:

# Scan your local network for the Bitaxe
nmap -sn 192.168.1.0/24 | grep -B2 "Bitaxe"

# Or use its API directly if you know the IP
curl http://BITAXE_IP/api/system/info | python3 -m json.tool
8

Configure via API

You can configure the Bitaxe entirely from the command line using its REST API: 

# Set WiFi (if Bitaxe is still in AP mode)
curl -X PATCH http://192.168.4.1/api/system \
  -H "Content-Type: application/json" \
  -d '{"ssid":"YOUR_WIFI_NAME","wifiPass":"YOUR_WIFI_PASSWORD"}'

# Set stratum to your ckpool
curl -X PATCH http://BITAXE_IP/api/system \
  -H "Content-Type: application/json" \
  -d '{
    "stratumURL":"YOUR_COMPUTER_IP",
    "stratumPort":3333,
    "stratumUser":"YOUR_BITCOIN_ADDRESS",
    "fallbackStratumURL":"solo.ckpool.org",
    "fallbackStratumPort":3333,
    "fallbackStratumUser":"YOUR_BITCOIN_ADDRESS"
  }'

# Restart to apply
curl -X POST http://BITAXE_IP/api/system/restart

The fallback stratum (solo.ckpool.org) is used if your node goes down. Your Bitaxe will still solo mine to your wallet address, but blocks will be built by ckpool.org's node rather than yours.

9

Verify it is working

# Check Bitaxe status
curl -s http://BITAXE_IP/api/system/info | python3 -c "
import sys, json
d = json.load(sys.stdin)
print(f'Hashrate: {d[\"hashRate\"]:.1f} GH/s')
print(f'Stratum: {d[\"stratumURL\"]}:{d[\"stratumPort\"]}')
print(f'Shares accepted: {d[\"sharesAccepted\"]}')
print(f'Shares rejected: {d[\"sharesRejected\"]}')
print(f'Using fallback: {\"Yes\" if d[\"isUsingFallbackStratum\"] else \"No\"}')
print(f'Temp: {d[\"temp\"]}C')
"

# Check ckpool logs
tail -20 ~/.local/var/log/ckpool/ckpool.log

You should see sharesAccepted increasing and Using fallback: No.

Network Considerations

Same WiFi network

The simplest setup: both your computer and Bitaxe on the same WiFi. The Bitaxe connects to your ckpool via your local IP.

Phone hotspot as bridge

If your main WiFi is 5 GHz only (the Bitaxe only supports 2.4 GHz), you can use a phone hotspot:

  1. Connect a USB WiFi adapter on your computer to the phone hotspot
  2. Connect the Bitaxe to the same phone hotspot
  3. Point the Bitaxe stratum to your computer's IP on the hotspot network
  4. Your computer keeps its main WiFi for internet

Prevent data leakage: If using a phone hotspot for the Bitaxe bridge, remove the default route on that interface so your node doesn't accidentally sync over mobile data: 

sudo ip route del default via HOTSPOT_GATEWAY dev HOTSPOT_INTERFACE

Important: 2.4 GHz only

The Bitaxe uses an ESP32 WiFi chip which only supports 2.4 GHz networks. Make sure your WiFi network broadcasts on 2.4 GHz, or use a phone hotspot as described above.

Monitoring

# Quick status check
curl -s http://BITAXE_IP/api/system/info | python3 -c "
import sys, json
d = json.load(sys.stdin)
up = d['uptimeSeconds']
print(f'Uptime: {up//3600}h {(up%3600)//60}m')
print(f'Hashrate: {d[\"hashRate\"]:.0f} GH/s (expected: {d[\"expectedHashrate\"]})')
print(f'Shares: {d[\"sharesAccepted\"]} accepted, {d[\"sharesRejected\"]} rejected')
print(f'Best diff: {d[\"bestDiff\"]} (session: {d[\"bestSessionDiff\"]})')
print(f'Temp: {d[\"temp\"]}C | Fan: {d[\"fanrpm\"]} RPM | Power: {d[\"power\"]:.1f}W')
"

# ckpool service status
systemctl --user status ckpool

# ckpool live stats
tail -f ~/.local/var/log/ckpool/ckpool.log

Odds of Finding a Block

Let's be honest about the maths. At current network difficulty (~127 trillion), a Bitaxe BM1370 at 1.2 TH/s would take on average: 

Time = (Difficulty * 2^32) / Hashrate
     = (127,000,000,000,000 * 4,294,967,296) / 1,200,000,000,000
     ≈ 14,500 years

This is a lottery, not an investment. But every lottery ticket also casts a vote. Your block template signals for the protocol rules you believe in. That signal has value beyond the block reward.

"It is not the size of the army, but the courage of the soldiers."