Validator

Minimum requirements:

• 1 Gbps+ stable internet connection, working IPv4
• Modern CPU with AVX2 — AVX-512 for self solving^?
• UDP port 36969 open to the world
• Modest NVMe^* — 2 TB+ for archival nodes

The 2 TB is for archival nodes only: indexers, RPC providers, select exchanges. Those set ARCHIVALNODE=true. Everyone else leaves it off (window tunable via HISTORY_KEEP_EPOCHS, default 10).

Grab the latest release and run it:

wget https://github.com/amadeusprotocol/node/releases/latest/download/amadeusd
chmod +x amadeusd
./amadeusd

Chain data lands in ~/.cache/amadeusd/. Everything is configured with env vars — the ones you'll actually touch:

# transport — consensus traffic (always UDP 36969, hardcoded)
UDP_IPV4=192.168.1.10    # interface IP — bind a specific interface if the
                         # system has several
PUBLIC_UDP_IPV4=5.6.7.8  # optional: hardcode the public IP if STUN can't resolve

# RPC — HTTP API
HTTP_IPV4=127.0.0.1     # bind address for RPC (default 0.0.0.0)
HTTP_PORT=80            # RPC port

# storage
WORKFOLDER=~/.cache/amadeusd/   # chain data location
ARCHIVALNODE=false              # true only for indexers / rpc / exchanges
HISTORY_KEEP_EPOCHS=10          # non-archival prune window

# identity shown on explorers (optional)
ANR_NAME=my-validator
ANR_DESC="ops contact: [email protected]"

Example — RPC kept private on a custom port:

HTTP_IPV4=127.0.0.1 HTTP_PORT=8080 ./amadeusd

A node that just follows the chain produces no blocks. Set COMPUTOR=true to compute tiles — the node solves tiles with its own key and builds score toward the validator set:

# compute tiles with this node's own key
COMPUTOR=true ./amadeusd

# cap solver threads (default: half your cores minus two)
COMPUTOR=true COMPUTOR_UPOW_THREADS=8 ./amadeusd

Your validator identity lives in seeds inside the workfolder (default ~/.cache/amadeusd/seeds):

• If the file is empty or missing, the node generates a fresh key on first boot.
• One 64-byte private key in Base58 per line.
• Every key in the file is picked up and tracked as a potential validator, and any of them can be used as a signing key. The first line is the primary identity — how the node is identified on the network.

cat ~/.cache/amadeusd/seeds
<base58 64-byte private key>   <- primary identity (and potential validator)
<base58 64-byte private key>   <- also tracked as a potential validator

The keys are BLS12-381 with short keys and long signatures (48-byte public keys, 96-byte signatures) — all signatures use them. Network messages are encrypted with AES-256-GCM using a shared secret derived against the peer's identity.

Tune the UDP stack:

cat <<EOT >> /etc/sysctl.conf
# buff up the UDP stack for 1gbps
net.core.wmem_max = 268435456
net.core.rmem_default = 212992
net.core.rmem_max = 268435456
net.core.netdev_max_backlog = 300000
net.core.optmem_max = 16777216
net.ipv4.udp_mem = 3060432 4080578 6120864

# block spoofed UDP packets
net.ipv4.conf.all.rp_filter=1
net.ipv4.conf.default.rp_filter=1
EOT
sysctl -p

Raise the limits:

cat <<EOT >> /etc/security/limits.conf
* hard nofile 1048576
* soft nofile 1048576
* hard nproc unlimited
* soft nproc unlimited
* hard memlock unlimited
* soft memlock unlimited
EOT

Install jemalloc and run the node under it as a service — the config below returns dirty pages immediately instead of letting memory creep:

apt install libjemalloc2

cat <<EOT > /etc/systemd/system/amadeusd.service
[Unit]
Description=AmadeusD
After=network-online.target

[Service]
Type=forking
LimitNOFILE=1048576
KillMode=control-group
Restart=always
RestartSec=3
User=root
WorkingDirectory=/root/
Environment="AUTOUPDATE=true"
Environment="COMPUTOR=false"
Environment="LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2"
Environment="MALLOC_CONF=background_thread:true,narenas:4,dirty_decay_ms:0,muzzy_decay_ms:0"
ExecStart=/usr/bin/screen -UdmS amadeusd bash -c './amadeusd'

[Install]
WantedBy=default.target
EOT

systemctl daemon-reload
systemctl enable amadeusd
systemctl start amadeusd

# attach to the running node
screen -rd amadeusd

• AUTOUPDATE=true keeps the binary current on its own.
• Non-root: change User and WorkingDirectory.

Set AUTOUPDATE=true and the node keeps itself current. Every 30–60 minutes it checks the latest tagged release on GitHub; when a newer version ships it downloads, verifies, swaps the binary and restarts. Every step fails closed:

• SSL cert pinning — downloads verify against the CA bundle compiled into the binary, never the host's CA store, with the chain pinned and hostname checks on every redirect hop.
• Signed releases — a release ships amadeusd plus amadeusd.sig: a <version> <sha256> manifest signed by a release key pinned inside the binary. No valid signature, no install — TLS proves who we talked to, the signature proves the author signed the bytes.
• Hash + anti-rollback — the downloaded binary must match the signed sha256, and the version must be newer than anything previously accepted.
• Validator-safe restart — a validator finishes its production slot before exiting; a follower restarts immediately.

After swapping the binary, autoupdate kills the process — it does not restart itself. You're responsible for running it under systemd (previous section) or another process supervisor that brings it back up.

A replica group is several machines carrying the same seed pack — only one may act at a time:

• Members heartbeat every 500 ms; signing requires majority ack as leader.
• No member ever re-signs a height another already signed — the high-water mark survives restarts.
• Lose a machine: the group fails over. Lose quorum: it goes safely silent.

Three machines, same variables on each — only REPLICA_ID differs:

# the group: id@ip:port, comma-separated — identical on every member
[email protected]:36969,[email protected]:36969,[email protected]:36969

# this machine's id — must appear in REPLICAS. doubles as leader
# priority: the lowest id online becomes leader
REPLICA_ID=1

# shared secret: 32 random bytes, Base58 — generate once, same on every member
REPLICA_PSK=<32-bytes-base58>

Signing needs a majority online, so useful group sizes are odd — an even member adds no tolerance:

• Group of 3 — survives 1 failure (the standard shape)
• Group of 5 — survives 2
• Group of 7 — survives 3