Struct Block 

pub struct Block {
    pub round: u64,
    pub prev_hash: Hash,
    pub proposer: NodeId,
    pub seed: u64,
    pub data_hashes: Vec<Hash>,
}

Fields

round: u64

prev_hash: Hash

proposer: NodeId

seed: u64

data_hashes: Vec<Hash>

Implementations

impl Block

pub fn new(round: u64, prev_hash: Hash, proposer: NodeId, seed: u64) -> Self

pub fn hash(&self) -> Hash

Examples found in repository

examples/single_round.rs (line 22)

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);
            }
        }
    }
}

pub fn genesis() -> Self

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Block

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Block

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.