consensus

Lux Consensus

Lux Quasar: Post Quantum Consensus Engine with Photonic Selection

Quasar upgrades traditional consensus mechanisms with a Quantum Finality engine. Quasar combines traditional BLS signature aggregation with parallel lattice encryption to deliver 2-round finality with both classical and quantum security. Every chain in the Lux primary network - Q, C, X - run Quasar, reaching Quantum Finality, in < 1 second.

Why Quasar?

Traditional consensus engines have limitations:

• Different engines for different chain types
• No native post-quantum security
• Complex multi-layer architecture

Quasar solves all these with "One engine to rule them all":

• Unified Protocol: Same engine for DAG, linear, EVM, MPC chains
• Quantum Finality: Every block requires post quantum certificates
• 2-Round Total: BLS Signatures (1 round) + Lattice Signatures (2 phases) = quantum finality
• Zero Leaders: Fully decentralized, leaderless, highly secure
• Sub-Second Performance: <1s finality with quantum security

🚀 Recent Updates (v1.22.0 - January 2025)

Simplified Single-Import API 🚀

• NEW: Complete package restructure with shallow, obvious paths
• NEW: Single-import convenience for all SDKs (Go, Python, Rust)
• NEW: Unified consensus.Chain API replacing complex factory patterns
• NEW: Type aliases for zero-friction development
• BREAKING: Migrated from deep nested paths to clean root exports

Multi-Language SDK with 100% Test Parity 🎉

• NEW: Complete C implementation with optimized hash tables (9M+ blocks/sec)
• NEW: Rust FFI bindings with safe wrappers and Criterion benchmarks
• NEW: Python SDK via Cython with Pythonic API (6.7M blocks/sec)
• NEW: Go CGO integration for seamless C/Go switching
• NEW: Quantum-resistant OP Stack integration example
• 100% test parity across all 4 language implementations
• 15 comprehensive test categories with full coverage
• Performance benchmarks exceeding all targets

Previous: Photon/Emitter Refactoring ✅

• Replaced Sampler/Sample pattern with light-themed Emitter/Emit
• Implemented luminance tracking (10-1000 lux range) for node selection
• Performance-based weighting adjusts selection probability
• 96%+ test coverage maintained
• CI fully green with all lint checks passing

Quick Start

Installation

Go (Default)

go get github.com/luxfi/consensus@v1.22.0

C Library (High Performance)

cd consensus/c
make && sudo make install
# Enable with: CGO_ENABLED=1 USE_C_CONSENSUS=1

Rust

# Add to Cargo.toml
[dependencies]
lux-consensus = "1.22.0"

Python

cd consensus/python
python3 setup.py install
# Or: pip install lux-consensus

Basic Usage

import "github.com/luxfi/consensus" // Single clean import!

// Create chain with default config
chain := consensus.NewChain(consensus.DefaultConfig())

// Start the chain
ctx := context.Background()
if err := chain.Start(ctx); err != nil {
    panic(err)
}
defer chain.Stop()

// Add a block
block := &consensus.Block{
    ID:       consensus.NewID(),
    ParentID: consensus.GenesisID,
    Height:   1,
    Payload:  []byte("Hello, Lux!"),
}
if err := chain.Add(ctx, block); err != nil {
    panic(err)
}

Running Tests

# Run all tests
go test ./...

# Run with coverage
go test -cover ./...

# Run benchmarks
go test -bench=. ./...

Architecture

Core Consensus Components

consensus/
├── photon/                # 🌟 K-of-N committee selection (NEW)
│   ├── emitter.go        # Light emission-based peer selection
│   └── luminance.go      # Node brightness tracking (lux units)
│
├── core/
│   ├── wave/             # 🌊 Wave consensus mechanism
│   │   └── engine.go     # Threshold voting (α, β parameters)
│   ├── dag/              # 📊 DAG structure & ordering
│   │   ├── flare/        # Certificate generation
│   │   └── horizon/      # Frontier management
│   └── focus/            # 🎯 Confidence tracking
│
├── protocol/
│   ├── quasar/          # ⚛️ Post-quantum security
│   │   └── ringtail.go  # Quantum-resistant signatures
│   ├── nebula/          # ☁️ State sync protocol
│   └── nova/            # ⭐ Parallel chain support
│
├── qzmq/                # 🔐 Post-quantum transport
│   ├── session.go       # Hybrid key exchange
│   └── messages.go      # Wire protocol
│
└── engine/              # 🎮 Consensus engines
    ├── chain/          # Linear blockchain
    └── dag/            # DAG-based chains

Framework for Quasar Consensus

Quasar is built on two core components that provide both classical and quantum finality:

1. Nova DAG (Classical Finality)

• Sampling: k-peer sampling for vote collection
• Confidence: Build confidence d(T) through repeated sampling
• Thresholds: β₁ for early preference, β₂ for decision
• Time: ~600-700ms to classical finality

2. Quasar (Quantum Finality)

• Phase I - Propose: Sample DAG frontier, propose highest confidence
• Phase II - Commit: Aggregate threshold signatures if > α𝚌 agree
• Certificates: Lattice-based post-quantum certificates
• Time: ~200-300ms additional for quantum finality

Quantum Finality

Every block header now contains:

type CertBundle struct {
    BLSAgg  []byte  // 96B BLS aggregate signature
    PQCert  []byte  // ~3KB lattice certificate
}

// Block is only final when BOTH certificates are valid
isFinal := verifyBLS(blsAgg, quorum) && verifyPQ(pqCert, quorum)

Key Hierarchy

The same rt.key registered on Q-Chain is reused by all chains - no extra onboarding.

Quick Start

package main

import (
  "context"
  "log"

  "github.com/luxfi/consensus/config"
  "github.com/luxfi/consensus/engine/quasar"
  "github.com/luxfi/ids"
)

func main() {
  // 1. Configure Quasar parameters
  cfg := config.Parameters{
    K:               21,  // Validators to sample
    AlphaPreference: 15,  // Preference threshold
    AlphaConfidence: 18,  // Confidence threshold
    Beta:            8,   // Finalization rounds
    QRounds:         2,   // Quantum rounds
  }

  // 2. Create Quasar engine
  nodeID := ids.GenerateNodeID()
  engine := quasar.NewQuasar(cfg, nodeID)

  // 3. Initialize with both BLS and PQ keys
  engine.Initialize(ctx, blsKey, pqKey)

  // 4. Process vertices/blocks
  engine.AddVertex(ctx, vertex)

  // 5. Dual-certificate finality
  engine.SetFinalizedCallback(func(qBlock QBlock) {
    log.Printf("Q-block %d finalized with quantum certificates\n", qBlock.Height)
  })
}

Performance Metrics

Consensus Performance

Benchmark Results (Apple M1 Max)

Both BLS and post-quantum certificates complete within one consensus slot.

Security Model

1. Pre-quantum: Attacker must corrupt ≥⅓ stake to fork
2. Q-day (BLS broken): Attacker can forge BLS but not lattice
   • Block fails quantum check
   • Consensus halts rather than accepting unsafe fork
3. Post-quantum: Security rests on lattice SVP (2¹⁶⁰ ops)

Attack window ≤ PQ round time (≤50ms mainnet).

Chain Integration

Account-Level PQ Options

EVM (C-Chain)

• Lamport-XMSS multisig contracts
• Gas: ~300k for VERIFY_LAMPORT
• EIP-4337 AA wrapper available

X-Chain

• New LatticeOutput type with PQ pubkey
• Spend verifies single RT signature (~1.8KB)
• CLI: lux-wallet generate --pq

Research Tools

# Interactive parameter tuning
consensus params tune

# Distributed benchmark with Quasar
consensus bench --engine quasar

# Simulate quantum state progression
consensus sim --quantum

# Analyze quantum-certificate safety
consensus check --quantum-cert

Implementation Roadmap

Testing

# Unit tests with quantum scenarios
go test ./engine/quasar/...

# Benchmark dual-certificate performance
go test -bench=QuantumCert ./lattice/

# Fuzz test certificate aggregation
go test -fuzz=Certificate ./testing/

Summary

Quasar is not an add-on or extra layer - it IS the consensus engine for Lux. By combining Nova DAG with Quasar PQ in a unified protocol, Quasar delivers:

• 2-round finality with both classical and quantum security
• Dual certificates required for every block
• One engine for all chain types
• Sub-second performance even with PQ security

Welcome to the quantum era of consensus.

License

BSD 3-Clause — free for academic & commercial use. See LICENSE.