┌─────────────────────────────────────────────────────────────┐
│                    PHOTON CONSENSUS                          │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Round 1: Propose                                            │
│  ┌─────────┐                                                 │
│  │ Leader  │ ──broadcast──> All validators                   │
│  │ Block   │                                                 │
│  └─────────┘                                                 │
│                                                               │
│  Round 2: Pre-Vote                                           │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐                      │
│  │ Vote 1  │  │ Vote 2  │  │ Vote N  │ ──> 2/3 threshold    │
│  └─────────┘  └─────────┘  └─────────┘                      │
│                                                               │
│  Round 3: Pre-Commit                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐                      │
│  │Commit 1 │  │Commit 2 │  │Commit N │ ──> 2/3 threshold    │
│  └─────────┘  └─────────┘  └─────────┘                      │
│                                                               │
│  Round 4: Finalize                                           │
│  Block committed to chain with 2/3+ signatures               │
│                                                               │
└─────────────────────────────────────────────────────────────┘

// Validator stake-weighted selection
type ValidatorSet struct {
    Validators []Validator
    TotalStake uint64
}

func (vs *ValidatorSet) SelectProposer(round uint64) Validator {
    // Deterministic selection based on stake weight
    seed := hash(round)
    target := seed % vs.TotalStake

    cumulative := uint64(0)
    for _, v := range vs.Validators {
        cumulative += v.Stake
        if cumulative > target {
            return v
        }
    }
    return vs.Validators[0]
}

import "github.com/luxfi/consensus/engine/chain"

// Create consensus engine
engine := chain.NewEngine(&chain.Config{
    Validators:    validatorSet,
    BlockTime:     500 * time.Millisecond,
    TimeoutPropose: 3 * time.Second,
    TimeoutPrevote: 1 * time.Second,
    TimeoutPrecommit: 1 * time.Second,
})

// Start consensus
engine.Start(ctx)

        ┌───┐
        │ G │  Genesis
        └─┬─┘
          │
    ┌─────┼─────┐
    │     │     │
  ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
  │B1 │ │B2 │ │B3 │  Epoch 1 (parallel)
  └─┬─┘ └─┬─┘ └─┬─┘
    │     │     │
    └──┬──┴──┬──┘
       │     │
     ┌─┴─┐ ┌─┴─┐
     │B4 │ │B5 │      Epoch 2 (parallel)
     └─┬─┘ └─┬─┘
       │     │
       └──┬──┘
          │
        ┌─┴─┐
        │B6 │          Merge block
        └───┘

type ConflictResolver interface {
    // Detect conflicts between parallel blocks
    DetectConflicts(blocks []*Block) []Conflict

    // Resolve conflicts using deterministic ordering
    Resolve(conflicts []Conflict) (*Block, error)
}

// Resolution rules:
// 1. Earlier timestamp wins
// 2. Tie: Lower block hash wins
// 3. Merge blocks consolidate state

INITIALIZE:
    opinion = initial_value  // 0 or 1
    confidence = 0

FOR round IN 1..MAX_ROUNDS:
    // Sample K random validators
    sample = RandomSample(validators, K)

    // Query opinions
    votes = QueryOpinions(sample)

    // Count votes
    yes_count = Count(votes, 1)
    no_count = Count(votes, 0)

    // Update opinion based on threshold
    IF yes_count >= THRESHOLD:
        opinion = 1
        confidence++
    ELSE IF no_count >= THRESHOLD:
        opinion = 0
        confidence++
    ELSE:
        confidence = 0  // Reset on tie

    // Check for finality
    IF confidence >= FINALITY_THRESHOLD:
        RETURN opinion  // Finalized!

RETURN UNDECIDED

type FPCConfig struct {
    K                 int           // Sample size (default: 3)
    Threshold         float64       // Agreement threshold (default: 0.67)
    MaxRounds         int           // Maximum rounds (default: 100)
    FinalityThreshold int           // Consecutive agreements (default: 3)
    QueryTimeout      time.Duration // Per-query timeout (default: 100ms)
}

// Hybrid BLS + Ringtail for transition period
type HybridSignature struct {
    BLSSignature      [96]byte   // Classical (aggregate)
    RingtailSignature []byte     // Post-quantum
    PublicKeys        [][]byte   // RT public keys
}

func (h *HybridSignature) Verify(msg []byte, validators []Validator) error {
    // Both must verify for hybrid mode
    if err := h.verifyBLS(msg, validators); err != nil {
        return err
    }
    if err := h.verifyRingtail(msg, validators); err != nil {
        return err
    }
    return nil
}

Phase 1 (Current):  BLS-only signatures
                    ↓
Phase 2 (Hybrid):   BLS + Ringtail dual signatures
                    ↓
Phase 3 (Future):   Ringtail-only (full PQ)