Struct Config 

pub struct Config { /* private fields */ }

Implementations

impl Config

pub fn new(fault_tolerance: u64) -> Self

Create a config with the given fault tolerance f. The system tolerates up to f byzantine nodes. Requires at least 3f + 1 total nodes.

Examples found in repository

examples/single_round.rs (line 4)

fn main() {
    let config = Config::new(1); // f=1, needs 4 nodes
    let mut engine = ConsensusEngine::new(config);

    for i in 1..=4 {
        let node = Node::new(i, 1000).expect("failed to create node");
        engine.add_node(node);
    }

    println!("Running VRF-PBFT with 4 nodes (f=1)...\n");

    // VRF selection is probabilistic, so retry until a round succeeds
    loop {
        match engine.run_round() {
            Ok(block) => {
                println!("Consensus reached on round {}!", engine.round());
                println!("  Proposer:  node {}", block.proposer);
                println!("  Seed:      {}", block.seed);
                println!("  Prev hash: {}...", &hex(&block.prev_hash)[..16]);
                println!("  Hash:      {}...", &hex(&block.hash())[..16]);
                println!("\nMessages exchanged: {}", engine.messages().len());
                break;
            }
            Err(vrf_pbft::Error::NoProposer(r)) => {
                println!("Round {}: no proposer elected, retrying...", r);
            }
            Err(vrf_pbft::Error::InsufficientVotes { needed, got }) => {
                println!(
                    "Round {}: not enough votes ({}/{}), retrying...",
                    engine.round(),
                    got,
                    needed
                );
            }
            Err(e) => {
                eprintln!("Fatal error: {}", e);
                std::process::exit(1);
            }
        }
    }
}

examples/byzantine.rs (line 5)

fn main() {
    // f=2: can tolerate 2 byzantine nodes, needs 7 total
    let config = Config::new(2);
    let mut engine = ConsensusEngine::new(config);

    for i in 1..=7 {
        let mut node = Node::new(i, 1000).expect("failed to create node");
        // Mark first 2 nodes as byzantine (they vote against valid blocks)
        if i <= 2 {
            node.set_byzantine(true);
        }
        engine.add_node(node);
    }

    println!("Byzantine fault tolerance demo");
    println!("  Nodes:     7 (5 honest, 2 byzantine)");
    println!("  f=2:       system tolerates up to 2 faults");
    println!("  Threshold: 2f+1 = {}\n", 2 * 2 + 1);

    let total_rounds = 100;
    let blocks = engine.run(total_rounds).expect("simulation failed");

    println!("After {} round attempts:", engine.round());
    println!("  Blocks committed: {}", blocks.len());

    if !blocks.is_empty() {
        println!("\n  Byzantine nodes voted AGAINST every block,");
        println!("  but consensus still passed because 5 honest");
        println!("  nodes exceed the threshold of 5 (2f+1).\n");

        // Verify ledger consistency
        let first_len = engine.nodes()[0].ledger().len();
        let consistent = engine.nodes().iter().all(|n| n.ledger().len() == first_len);
        println!(
            "  Ledger consistency: {} ({} blocks per node)",
            if consistent { "PASS" } else { "FAIL" },
            first_len
        );
    } else {
        println!("\n  No blocks committed (VRF didn't elect enough validators).");
        println!("  Try running again -- VRF selection is probabilistic.");
    }
}

examples/simulation.rs (line 5)

fn main() {
    let config = Config::new(3); // f=3, needs 10 nodes
    let mut engine = ConsensusEngine::new(config);

    // 10 nodes with varying weights (simulating different stakes)
    let weights = [500, 300, 200, 150, 100, 100, 80, 60, 40, 20];
    for (i, &w) in weights.iter().enumerate() {
        let node = Node::new((i + 1) as u64, w).expect("failed to create node");
        engine.add_node(node);
    }

    let total_rounds = 100;
    println!(
        "Simulating {} rounds with {} nodes (f=3)\n",
        total_rounds,
        weights.len()
    );
    println!(
        "Node weights: {:?}",
        weights
    );
    println!("Total weight: {}\n", weights.iter().sum::<u64>());

    let blocks = engine.run(total_rounds).expect("simulation failed");

    // Proposer distribution
    let mut proposer_count: HashMap<u64, u32> = HashMap::new();
    for block in &blocks {
        *proposer_count.entry(block.proposer).or_default() += 1;
    }

    println!("Results:");
    println!("  Rounds attempted: {}", engine.round());
    println!("  Blocks committed:  {}", blocks.len());
    println!(
        "  Success rate:      {:.1}%",
        blocks.len() as f64 / engine.round() as f64 * 100.0
    );

    println!("\nProposer distribution:");
    let mut sorted: Vec<_> = proposer_count.iter().collect();
    sorted.sort_by_key(|(id, _)| *id);
    for (id, count) in sorted {
        let w = weights[(*id - 1) as usize];
        println!("  Node {} (weight {:>3}): {} blocks", id, w, count);
    }

    // Verify all nodes have the same ledger length
    let ledger_lens: Vec<usize> = engine.nodes().iter().map(|n| n.ledger().len()).collect();
    let all_same = ledger_lens.windows(2).all(|w| w[0] == w[1]);
    println!(
        "\nLedger consistency: {} (all nodes have {} blocks)",
        if all_same { "PASS" } else { "FAIL" },
        ledger_lens[0]
    );
}

pub fn with_expected_committee(self, n: u64) -> Self

pub fn threshold(&self) -> u64

Minimum votes needed for quorum: 2f + 1

pub fn min_nodes(&self) -> u64

Minimum nodes needed: 3f + 1