Skip to main content

⚡ Aztec Prover Node

Node briefing

Aztec Prover

Generate zero-knowledge proofs for the Aztec network and earn rewards. Unlike sequencers, provers don't publish to L1, meaning zero gas costs - it's purely computational work.

NetworkMainnet
Setup time30-45 minutes
Difficulty🟡 Medium

System checklist

CPU
8 cores / 16 vCPU (AVX2 support recommended)
RAM
22 GB minimum (32 GB recommended)
Storage
200-300 GB SSD
Network
Stable internet connection
GPU
Optional - CUDA-capable for acceleration

Launch prerequisites

  • Docker and Docker Compose installed
  • Connection to Aztec network (RPC endpoint)
  • Basic command line knowledge

Key features

  • Zero L1 gas costs - purely compute-based
  • Earn rewards for proof generation
  • No staking requirement
  • GPU optional but recommended for performance
Best for Compute-Focused Operators

If you have a VPS with good CPU but don't want to deal with L1 gas costs, the prover role is ideal. Your existing 8 CPU / 22 GB RAM setup is sufficient.

🎯 What Does a Prover Do?​

Aztec uses zero-knowledge proofs to ensure privacy and correctness. Provers are responsible for:

  1. Receiving proof requests from the network
  2. Generating ZK proofs for transactions and blocks
  3. Submitting proofs back to the network
  4. Earning rewards for valid proof generation

Prover vs Sequencer​

AspectProverSequencer
L1 Gas CostsNone20-60$/month
StakingNone required200k AZTEC
HardwareCPU/GPU focusedFull node + L1
ComplexityMediumAdvanced
RewardsPer proofBlock rewards

🏗️ Architecture​

┌─────────────────────────────────────────────┐
│              Aztec Network                   │
│                                              │
│  Sequencer ──► Proof Request ──► Prover     │
│                                    │         │
│                                    ▼         │
│                              Generate Proof  │
│                                    │         │
│                                    ▼         │
│  Network ◄── Submit Proof ◄── Prover        │
│                                              │
│              ✓ Reward Distributed            │
└─────────────────────────────────────────────┘

🛠️ Step 1: Prepare Your Server​

System Requirements Check​

# Check CPU cores (need 8+)
nproc

# Check for AVX2 support (improves proof performance)
grep -o 'avx2' /proc/cpuinfo | head -1

# Check RAM (need 22GB+)
free -h

# Check disk space (need 200GB+)
df -h /

Install Docker​

# Update system
sudo apt update && sudo apt upgrade -y

# Install Docker
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

# Verify
docker --version

Log out and back in for group changes.

Optional: GPU Setup (NVIDIA)​

For faster proof generation:

# Install NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
    sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo systemctl restart docker

# Verify GPU access
docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi

⚙️ Step 2: Configure the Prover​

Create Working Directory​

mkdir -p ~/aztec-prover
cd ~/aztec-prover

Create Environment File​

nano .env
# === Prover Configuration ===
PROVER_ID=my-prover-001

# === Network Connection ===
# Connect to Aztec network
AZTEC_NODE_URL=http://YOUR_AZTEC_NODE:8080
# Or use public endpoint if available

# === Performance Tuning ===
# Number of parallel proof jobs
PROVER_JOBS=4

# Memory per job (in GB)
PROVER_MEMORY_PER_JOB=4

# === GPU Settings (if available) ===
# Set to true if you have NVIDIA GPU
USE_GPU=false

# === Logging ===
LOG_LEVEL=info

Create Docker Compose File​

nano docker-compose.yml
services:
  aztec-prover:
    container_name: aztec-prover
    image: aztecprotocol/aztec:latest
    restart: unless-stopped
    env_file: .env
    volumes:
      - ./data:/data
      - ./proofs:/proofs
    command: >
      start --prover
      --prover.jobs ${PROVER_JOBS:-4}
      --node-url ${AZTEC_NODE_URL}
    # Uncomment for GPU support:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"

🚀 Step 3: Start the Prover​

# Start prover
docker compose up -d

# Check status
docker ps

# View logs
docker compose logs -f aztec-prover

Verify It's Working​

Look for log messages like:

[INFO] Prover connected to network
[INFO] Waiting for proof requests...
[INFO] Received proof request #12345
[INFO] Generating proof...
[INFO] Proof submitted successfully

📊 Step 4: Monitor Performance​

Check Prover Stats​

# Container resource usage
docker stats aztec-prover --no-stream

# View recent proofs
docker logs aztec-prover 2>&1 | grep -i "proof" | tail -20

Create Monitoring Script​

nano ~/prover-stats.sh
#!/bin/bash
echo "=== Aztec Prover Stats ==="
echo ""
echo "Container Status:"
docker ps | grep aztec-prover
echo ""
echo "Resource Usage:"
docker stats aztec-prover --no-stream
echo ""
echo "Recent Proof Activity:"
docker logs aztec-prover 2>&1 | grep -i "proof\|reward" | tail -10
echo ""
echo "Disk Usage:"
du -sh ~/aztec-prover/data ~/aztec-prover/proofs 2>/dev/null
chmod +x ~/prover-stats.sh

🔧 Performance Optimization​

CPU Optimization​

# Set CPU governor to performance mode
echo 'performance' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

# Verify
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

Memory Settings​

Adjust PROVER_JOBS based on your RAM:

  • 22 GB RAM: 4 jobs × 4 GB = 16 GB (safe margin)
  • 32 GB RAM: 6 jobs × 4 GB = 24 GB
  • 64 GB RAM: 12 jobs × 4 GB = 48 GB

GPU Acceleration​

If using GPU, uncomment the GPU section in docker-compose.yml and set:

USE_GPU=true

GPU can provide 2-5x speedup for certain proof types.

💰 Rewards​

How Rewards Work​

  1. Network assigns proof requests based on prover capacity
  2. You generate and submit proofs
  3. Rewards distributed per valid proof
  4. Higher capacity = more proof requests = more rewards

Maximize Earnings​

  • More CPU cores = More parallel jobs
  • GPU acceleration = Faster proof generation
  • High uptime = More proof assignments
  • Low latency = Priority for time-sensitive proofs

🔧 Troubleshooting​

Common Issues​

"Connection refused" errors:

# Check if Aztec node is reachable
curl -s http://YOUR_AZTEC_NODE:8080/status

Out of memory:

# Reduce parallel jobs
# In .env, change:
PROVER_JOBS=2
PROVER_MEMORY_PER_JOB=8

Slow proof generation:

  • Check CPU isn't thermal throttling
  • Consider adding GPU
  • Ensure no other heavy processes running

Container keeps restarting:

# Check logs for errors
docker logs aztec-prover --tail 50

# Check available disk space
df -h

🔗 Useful Resources​

Official Documentation​

⚠️ Important Notes​

  • No staking required - Lower barrier than sequencer
  • No L1 gas costs - Purely computational
  • Rewards vary - Based on network demand and your capacity
  • Stay updated - Proof algorithms may change with upgrades

🎯 Next Steps​

  1. Monitor your prover - Track proof success rate
  2. Optimize performance - Tune jobs based on resource usage
  3. Consider GPU - For significant performance boost
  4. Run Slasher too - Combine roles for extra rewards

Your prover is now generating ZK proofs and earning rewards! ⚡

This guide is maintained by TokioStack - Always verify on official sources.

© 2026 TokioStack. All rights reserved.
DMCA.com Protection Status