Struct hbbft::honey_badger::HoneyBadger

pub struct HoneyBadger<C, N> { /* fields omitted */ }

An instance of the Honey Badger Byzantine fault tolerant consensus algorithm.

Methods

impl<C, N> HoneyBadger<C, N> where
    C: Contribution + Serialize + DeserializeOwned,
    N: NodeIdT, 

pub fn builder(netinfo: Arc<NetworkInfo<N>>) -> HoneyBadgerBuilder<C, N>

Returns a new HoneyBadgerBuilder configured to use the node IDs and cryptographic keys specified by netinfo.

pub fn propose<R: Rng>(
    &mut self,
    proposal: &C,
    rng: &mut R
) -> Result<Step<C, N>>

Proposes a contribution in the current epoch.

Returns an error if we already made a proposal in this epoch.

If we are the only validator, this will immediately output a batch, containing our proposal.

pub fn handle_message(
    &mut self,
    sender_id: &N,
    message: Message<N>
) -> Result<Step<C, N>>

Handles a message received from sender_id.

This must be called with every message we receive from another node.

pub fn has_input(&self) -> bool

Returns true if input for the current epoch has already been provided.

pub fn get_encryption_schedule(&self) -> EncryptionSchedule

Returns the current encryption schedule that determines in which epochs contributions are encrypted.

pub fn next_epoch(&self) -> u64

Returns the epoch of the next batch that will be output.

pub fn received_proposals(&self) -> usize

Returns the number of validators from which we have already received a proposal for the current epoch.

This can be used to find out whether our node is stalling progress. Depending on the application logic, nodes may e.g. only propose when they have any pending transactions. In that case, they should repeatedly call this method: if it returns f + 1 or more, that means at least one correct node has proposed a contribution. In that case, we might want to propose one, too, even if it's empty, to avoid unnecessarily delaying the next batch.

pub fn max_future_epochs(&self) -> u64

Returns the maximum future epochs of the Honey Badger algorithm instance.

pub fn params(&self) -> &Params

Returns the parameters controlling Honey Badger's behavior and performance.

Trait Implementations

impl<C, N> Epoched for HoneyBadger<C, N> where
    C: Contribution + Serialize + DeserializeOwned,
    N: NodeIdT, 

type Epoch = u64

Type of epoch.

fn epoch(&self) -> u64

Returns the object's epoch number.

impl<C, N> ConsensusProtocol for HoneyBadger<C, N> where
    C: Contribution + Serialize + DeserializeOwned,
    N: NodeIdT, 

type NodeId = N

Unique node identifier.

type Input = C

The input provided by the user.

type Output = Batch<C, N>

The output type. Some algorithms return an output exactly once, others return multiple times.

type Message = Message<N>

The messages that need to be exchanged between the instances in the participating nodes.

type Error = Error

The errors that can occur during execution.

type FaultKind = FaultKind

The kinds of message faults that can be detected during execution.

fn handle_input<R: Rng>(
    &mut self,
    input: Self::Input,
    rng: &mut R
) -> Result<Step<C, N>>

Handles an input provided by the user, and returns

fn handle_message<R: Rng>(
    &mut self,
    sender_id: &Self::NodeId,
    message: Self::Message,
    _rng: &mut R
) -> Result<Step<C, N>>

Handles a message received from node sender_id.

fn terminated(&self) -> bool

Returns true if execution has completed and this instance can be dropped.

fn our_id(&self) -> &N

Returns this node's own ID.

impl<C, N> SenderQueueableConsensusProtocol for HoneyBadger<C, N> where
    C: Contribution + Serialize + DeserializeOwned,
    N: NodeIdT, 

fn max_future_epochs(&self) -> u64

The maximum number of subsequent future epochs that the ConsensusProtocol is allowed to handle messages for.

impl<C, N> Debug for HoneyBadger<C, N> where
    C: Debug,
    N: Debug, 

fn fmt(&self, __f: &mut Formatter) -> Result

Formats the value using the given formatter.