🟢ACTIVE(2026)

Guide tested and maintained

🔮 Aztec Sequencer Node Installation

Node briefing

Aztec Network

Aztec Network is building the first privacy-first ZK-rollup on Ethereum. Sequencers order transactions, produce blocks, and maintain the network. Running a sequencer requires staking 200,000 AZTEC tokens and meeting hardware requirements.

NetworkMainnet

Setup time45-60 minutes

Difficulty🟡 Medium

System checklist

CPU: 8 cores / 16 vCPU (2015 or later)
RAM: 16 GB minimum
Storage: 1 TB NVMe SSD
Network: 25 Mbps stable connection
OS: Ubuntu 22.04+ (or any Linux with Docker)

Launch prerequisites

200,000 AZTEC tokens for staking
ETH for L1 gas fees (~0.1 ETH per attester)
Ethereum Mainnet RPC (execution + consensus)
Foundry installed (for status queries)

Key features

Privacy-first architecture using advanced zero-knowledge proofs
Mainnet live with staking rewards for validators
Docker-based deployment with official images
Multiple roles: Sequencer, Prover, Delegator, Slasher

Staking Required

Running an Aztec Sequencer requires 200,000 AZTEC tokens minimum stake. If you don't have tokens, consider the Delegator Guide (coming soon) to earn rewards without running infrastructure.

Version Check

Always verify the latest Docker image version on the official GitHub or Aztec Discord before installation.

🎯 Understanding Aztec Roles

Before starting, understand which role fits your situation:

Role	Stake Required	Hardware	Gas Costs	Best For
Sequencer	200k AZTEC	High	20-60$/month	Experienced operators
Delegator	Any amount	None	None	Passive income seekers
Prover	None	Medium-High	None	Compute-focused operators
Slasher	None	Minimal	None	Security-minded operators

This guide covers Sequencer setup. Other guides coming soon.

🛠️ Step 1: Prepare Your Server

System Requirements Verification

# Check CPU cores (need 8+)
nproc

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

# Check disk space (need 1TB+)
df -h /

# Check disk type (should be NVMe)
lsblk -d -o name,rota
# rota=0 means SSD/NVMe, rota=1 means HDD

Update System & Install Dependencies

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

# Install essential tools
sudo apt install -y curl wget git build-essential jq make gcc nano \
    htop nvme-cli pkg-config libssl-dev tar clang ncdu unzip ufw screen

Install Docker

# Remove old Docker versions
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do
    sudo apt-get remove $pkg 2>/dev/null
done

# Add Docker GPG key
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verify installation
sudo docker run hello-world

# Enable Docker service
sudo systemctl enable docker
sudo systemctl restart docker

# Add user to docker group
sudo usermod -aG docker $USER

Logout and login again for group changes to take effect.

Install Foundry (for status queries)

# Install Foundry
curl -L https://foundry.paradigm.xyz | bash
source ~/.bashrc
foundryup

# Verify
cast --version

🔥 Step 2: Configure Firewall

# Configure UFW firewall
sudo ufw allow ssh
sudo ufw allow 40400/tcp   # P2P TCP
sudo ufw allow 40400/udp   # P2P UDP
sudo ufw allow 8080/tcp    # RPC (public)
# Note: Port 8880 (Admin API) should NOT be exposed

sudo ufw enable
sudo ufw status

🔑 Step 3: Generate Keystores

Create a working directory and generate your validator keys.

# Create directory structure
mkdir -p ~/aztec-node/keys
cd ~/aztec-node

# Pull the latest Aztec image (check version on GitHub/Discord)
docker pull aztecprotocol/aztec:2.1.9

Generate Validator Keys

# Generate keys (creates keystore files)
docker run --rm -v $(pwd)/keys:/keys aztecprotocol/aztec:2.1.9 \
    aztec-cli generate-keys \
    --output /keys/key0.json \
    --output-staker /keys/key0_staker_output.json

This creates:

key0.json - Private keystore (keep secret!)
key0_staker_output.json - Public info for staking dashboard

Backup Your Keys

Immediately backup your keys/ directory and mnemonic phrase to a secure offline location. Loss of keys = loss of stake.

Multiple Validators (Optional)

For delegated staking providers managing multiple validators:

# Generate multiple keys
docker run --rm -v $(pwd)/keys:/keys aztecprotocol/aztec:2.1.9 \
    aztec-cli generate-keys \
    --count 3 \
    --output /keys/key \
    --output-staker /keys/key_staker_output

💰 Step 4: Fund Publisher Account

The publisher address submits blocks to L1 and needs ETH for gas.

# View your publisher address from keystore
cat ~/aztec-node/keys/key0.json | jq -r '.publisher.address'

Send at least 0.1 ETH per attester account to this address on Ethereum Mainnet.

Gas Estimation

Expect ~20-60$ per month in L1 gas costs for an active sequencer. Monitor and top up regularly.

⚙️ Step 5: Configure Environment

Create .env File

cd ~/aztec-node
nano .env

Add the following configuration:

# === Data Directory ===
DATA_DIRECTORY=/data

# === Keystores ===
VALIDATOR_KEYS=/keys

# === Logging ===
LOG_LEVEL=info

# === L1 Ethereum Connection ===
# Option A: External RPC (Alchemy/Infura)
ETHEREUM_HOSTS=https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY

# Option B: Self-hosted (recommended for reliability)
# ETHEREUM_HOSTS=http://YOUR_GETH_IP:8545

# L1 Consensus (Beacon Chain)
L1_CONSENSUS_HOST_URLS=https://ethereum-beacon-api.publicnode.com

# === P2P Configuration ===
P2P_IP=YOUR_PUBLIC_IP
P2P_TCP_PORT=40400
P2P_UDP_PORT=40400

# === RPC Ports ===
AZTEC_PORT=8080
ADMIN_PORT=8880

Replace:

YOUR_API_KEY - Your Alchemy/Infura API key
YOUR_PUBLIC_IP - Your server's public IP (curl -s ifconfig.me)

Get Your Public IP

export P2P_IP=$(curl -s ifconfig.me)
echo "Your IP: $P2P_IP"

🐳 Step 6: Create Docker Compose

nano docker-compose.yml

Add this configuration:

services:
  aztec-sequencer:
    container_name: aztec-sequencer
    image: aztecprotocol/aztec:2.1.9
    restart: unless-stopped
    network_mode: host
    env_file: .env
    volumes:
      - ./data:/data
      - ./keys:/keys:ro
    command: >
      start --node --archiver --sequencer
      --data-directory /data
      --validator-keys /keys
      --l1-rpc-urls ${ETHEREUM_HOSTS}
      --l1-consensus-host-urls ${L1_CONSENSUS_HOST_URLS}
      --p2p.p2pIp ${P2P_IP}
      --p2p.tcpPort ${P2P_TCP_PORT}
      --p2p.udpPort ${P2P_UDP_PORT}
      --port ${AZTEC_PORT}
      --admin-port ${ADMIN_PORT}
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "5"

🚀 Step 7: Start the Node

# Start in detached mode
docker compose up -d

# Verify container is running
docker ps

# View logs
docker compose logs -f aztec-sequencer

Initial Sync

The node will sync with the network. This may take several hours depending on network state.

# Check sync progress
curl -s -X POST -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","method":"node_getL2Tips","params":[],"id":67}' \
    http://localhost:8080 | jq -r ".result.proven.number"

# Compare with network (check AztecScan)
echo "Compare with: https://aztecscan.xyz/"

📝 Step 8: Register via Staking Dashboard

Once your node is synced:

Go to Staking Dashboard: https://staking.aztec.network
Connect your wallet with AZTEC tokens
Upload key0_staker_output.json (public staker info)
Stake 200,000 AZTEC tokens
Confirm transaction

Your sequencer is now registered on-chain!

📊 Step 9: Verify Sequencer Status

Use Foundry's cast to query your validator status on-chain:

# Query AttesterView struct
cast call STAKING_CONTRACT_ADDRESS \
    "getAttesterView(address)" YOUR_ATTESTER_ADDRESS \
    --rpc-url https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY

Status values:

NONE - Not registered
VALIDATING - Active and validating
ZOMBIE - Inactive but not exited
EXITING - Exit in progress

🔧 Troubleshooting

Common Issues

Container won't start:

# Check logs
docker compose logs aztec-sequencer --tail 100

# Verify .env values
cat .env

Sync stuck:

# Restart with fresh data
docker compose down
sudo rm -rf ./data
docker compose up -d

RPC connection issues:

# Test L1 RPC
curl -X POST -H "Content-Type: application/json" \
    --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
    $ETHEREUM_HOSTS

# Test Beacon RPC
curl -s "$L1_CONSENSUS_HOST_URLS/eth/v1/node/health"

Port conflicts:

sudo lsof -i :40400
sudo lsof -i :8080

🔗 Useful Resources

Official Documentation

Aztec Docs - Full documentation
Sequencer Management - Detailed setup
Node Operator Hub - Operator resources

Community

Explorers

AztecScan - Block explorer
Aztec Explorer - Nethermind explorer

GitHub

aztec-packages - Check latest versions

⚠️ Important Notes

Staking is required - 200,000 AZTEC minimum
Gas costs are ongoing - Budget 20-60$/month in ETH
Keep keys secure - Loss of keys = loss of stake
Monitor regularly - Check sync status and logs daily
Stay updated - Join Discord for version announcements

🎯 Next Steps

Monitor your node - See Monitoring Guide
Set up alerts - Aztec Ops Toolkit (coming soon)
Consider self-hosted L1 - RPC Nodes Guide (coming soon)
Join the community - Aztec Discord

Congratulations! You're now running an Aztec Sequencer Node and contributing to the first fully decentralized privacy-focused L2! 🔮🚀

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

Aztec Network

System checklist

Launch prerequisites

Key features

🎯 Understanding Aztec Roles​

🛠️ Step 1: Prepare Your Server​

System Requirements Verification​

Update System & Install Dependencies​

Install Docker​

Install Foundry (for status queries)​

🔥 Step 2: Configure Firewall​

🔑 Step 3: Generate Keystores​

Generate Validator Keys​

Multiple Validators (Optional)​

💰 Step 4: Fund Publisher Account​

⚙️ Step 5: Configure Environment​

Create .env File​

Get Your Public IP​

🐳 Step 6: Create Docker Compose​

🚀 Step 7: Start the Node​

Initial Sync​

📝 Step 8: Register via Staking Dashboard​

📊 Step 9: Verify Sequencer Status​

🔧 Troubleshooting​

Common Issues​

🔗 Useful Resources​

Official Documentation​

Community​

Explorers​

GitHub​

⚠️ Important Notes​

🎯 Next Steps​