Skip to main content
This guide provides step-by-step instructions for setting up the configuration and monitoring options for op-challenger. The challenger is a critical fault proofs component that monitors dispute games and challenges invalid claims to protect your OP Stack chain. See the OP-Challenger Explainer for a general overview of this fault proofs feature. The challenger is responsible for:
  • Monitoring dispute games created by the fault proof system
  • Challenging invalid claims in dispute games
  • Defending valid state transitions
  • Resolving games when possible

Prerequisites

Essential requirements

Before configuring your challenger, complete the following steps:
1

Deploy OP Stack chain with fault proofs enabled

  • L1 contracts deployed with dispute game factory
  • Fault proof system active on your chain
  • Access to your chain’s contract addresses
  • Generate an absolute prestate for your network version - This is critical as the challenger will refuse to interact with games if it doesn’t have the matching prestate
2

Set up required infrastructure access

  • L1 RPC endpoint (Ethereum, Sepolia, etc.)
  • L1 Beacon node endpoint (for blob access)
  • L2 archive node with debug API enabled
  • Rollup node (op-node) with historical data
3

Prepare configuration files

  • rollup.json - Rollup configuration file
  • genesis-l2.json - L2 genesis file
  • prestate.json - The absolute prestate file generated in step 1

Software requirements

  • Git (for cloning repositories)
  • Go 1.21+ (if building from source)
  • Docker and Docker Compose (optional but recommended)
  • Access to a funded Ethereum account for challenger operations

Finding the current stable releases

To ensure you’re using the latest compatible versions of OP Stack components, always check the official releases page: OP Stack releases page Look for the latest op-challenger/v* release. The challenger version used in this guide (op-challenger/v1.5.0) is a verified stable version. Always check the release notes to ensure you’re using compatible versions with your chain’s deployment.

Software installation

For challenger deployment, you can either build from source (recommended for better control and debugging) or use Docker for a containerized setup.
  • Tab Title
  • Tab Title

Build and Configure

Building from source gives you full control over the binaries and is the preferred approach for production deployments.Clone and build op-challenger
# Clone the optimism monorepo
git clone https://github.com/ethereum-optimism/optimism.git
cd optimism

# Check out the latest release of op-challenger
git checkout op-challenger/v1.5.0

# Install dependencies and build
just op-challenger

# Binary will be available at ./op-challenger/bin/op-challenger

Verify installation

Check that you have properly installed the challenger component:
# Make sure you're in the optimism directory
./op-challenger/bin/op-challenger --help

# You should see the challenger help output with available commands and flags

Configuration setup

1

Organize your workspace

After building the binaries, create your challenger working directory:
# Create challenger directory (this should be at the same level as optimism directory)
mkdir challenger-node
cd challenger-node

# Create necessary subdirectories
mkdir scripts
mkdir challenger-data

# Verify the optimism directory is accessible
# Directory structure should look like:
# /optimism/                 (contains the built binaries)
# /challenger-node/          (your working directory)
2

Copy configuration files

# Copy configuration files to your challenger directory
# Adjust paths based on your deployment setup
cp /path/to/your/rollup.json .
cp /path/to/your/genesis-l2.json .
3

Set up environment variables

You’ll need to gather several pieces of information before creating your configuration. Here’s where to get each value:L1 network access:
  • L1 RPC URL: Your L1 node endpoint (Infura, Alchemy, or self-hosted)
  • L1 Beacon URL: Beacon chain API endpoint for blob access
L2 network access:
  • L2 RPC URL: Your op-geth archive node endpoint
  • Rollup RPC URL: Your op-node endpoint with historical data
Challenger wallet:
  • Private key for challenger operations (must be funded)
Network configuration:
  • Game factory address from your contract deployment
  • Network identifier (e.g., op-sepolia, op-mainnet, or custom)
Copy and paste in your terminal, to create your env file.
# Create .env file with your actual values
cat > .env << 'EOF'
# L1 Configuration - Replace with your actual RPC URLs
L1_RPC_URL=https://sepolia.infura.io/v3/YOUR_ACTUAL_INFURA_KEY

# L2 Configuration - Replace with your actual node endpoints  
L2_RPC_URL=http://localhost:8545
ROLLUP_RPC_URL=http://localhost:8547
L1_BEACON=http://sepolia-cl-1:5051

# Wallet configuration - Choose either mnemonic + HD path OR private key
MNEMONIC="test test test test test test test test test test test junk"
HD_PATH="m/44'/60'/0'/0/0"
# PRIVATE_KEY=0xYOUR_ACTUAL_PRIVATE_KEY  # Alternative to mnemonic

# Network configuration
NETWORK=op-sepolia
GAME_FACTORY_ADDRESS=0xYOUR_GAME_FACTORY_ADDRESS

# Trace configuration
TRACE_TYPE=permissioned,cannon

# Data directory
DATADIR=./challenger-data

# Cannon configuration
# Path to the cannon binary (built from optimism repo)
CANNON_BIN=<PATH_TO_OPTIMISM_REPO>/cannon/bin/cannon

# Configuration files
CANNON_ROLLUP_CONFIG=<PATH_TO_YOUR_ROLLUP_CONFIG>
CANNON_L2_GENESIS=<PATH_TO_YOUR_L2_GENESIS>
CANNON_SERVER=<PATH_TO_OPTIMISM_REPO>/op-program/bin/op-program
CANNON_PRESTATE=<PATH_TO_YOUR_PRESTATE_FILE>
EOF
Important: Replace ALL placeholder values (YOUR_ACTUAL_*) with your real configuration values.
4

Understanding key configuration flags

Create challenger startup script

Create scripts/start-challenger.sh:
#!/bin/bash
source .env

# Path to the challenger binary
../optimism/op-challenger/bin/op-challenger \
  --trace-type permissioned,cannon \
  --l1-eth-rpc=$L1_RPC_URL \
  --l2-eth-rpc=$L2_RPC_URL \
  --l1-beacon=$L1_BEACON \
  --rollup-rpc=$ROLLUP_RPC_URL \
  --game-factory-address $GAME_FACTORY_ADDRESS \
  --datadir=$DATADIR \
  --cannon-bin=$CANNON_BIN \
  --cannon-rollup-config=$CANNON_ROLLUP_CONFIG \
  --cannon-l2-genesis=$CANNON_L2_GENESIS \
  --cannon-server=$CANNON_SERVER \
  --cannon-prestate=$CANNON_PRESTATE \
  --mnemonic "$MNEMONIC" \
  --hd-path "$HD_PATH"

Initializing and starting the challenger

Start the challenger

# Make sure you're in the challenger-node directory
cd challenger-node

# Make script executable
chmod +x scripts/start-challenger.sh

# Start challenger
./scripts/start-challenger.sh

Verify challenger is running

Monitor challenger logs to ensure it’s operating correctly:
# Check challenger logs
tail -f challenger-data/challenger.log

# Or if running in foreground, monitor the output
The challenger should show logs indicating:
  • Successful connection to L1 and L2 nodes
  • Loading of prestates and configuration
  • Monitoring of dispute games

Monitoring with op-dispute-mon

Consider running op-dispute-mon for enhanced security monitoring:
  • Provides visibility into all game statuses for the last 28 days
  • Essential for production challenger deployments
  • Create Grafana dashboards using: Download the Dispute Monitor JSON

Next steps

I