Struct State 

pub struct State<C>
where
    C: Context,
{ /* private fields */ }

A passive instance of the Highway protocol, containing its local state.

Both observers and active validators must instantiate this, pass in all incoming vertices from peers, and use a FinalityDetector to determine the outcome of the consensus process.

Implementations

impl<C: Context> State<C>

pub fn params(&self) -> &Params

Returns the fixed parameters.

pub fn validator_count(&self) -> usize

Returns the number of validators.

pub fn weight(&self, idx: ValidatorIndex) -> Weight

Returns the idxth validator’s voting weight.

pub fn weights(&self) -> &ValidatorMap<Weight>

Returns the map of validator weights.

pub fn faulty_weight_in(&self, panorama: &Panorama<C>) -> Weight

Returns the total weight of all validators marked faulty in this panorama.

pub fn faulty_weight(&self) -> Weight

Returns the total weight of all known-faulty validators.

pub fn total_weight(&self) -> Weight

Returns the sum of all validators’ voting weights.

pub fn maybe_evidence(&self, idx: ValidatorIndex) -> Option<&Evidence<C>>

Returns evidence against validator nr. idx, if present.

pub fn maybe_endorsements(&self, unit: &C::Hash) -> Option<Endorsements<C>>

Returns endorsements for unit, if any.

pub fn has_evidence(&self, idx: ValidatorIndex) -> bool

Returns whether evidence against validator nr. idx is known.

pub fn has_all_endorsements<I: IntoIterator<Item = ValidatorIndex>>( &self, unit: &C::Hash, v_ids: I, ) -> bool

Returns whether we have all endorsements for unit.

pub fn is_endorsed(&self, hash: &C::Hash) -> bool

Returns whether we have seen enough endorsements for the unit. Unit is endorsed when it has endorsements from more than 50% of the validators (by weight).

pub fn needs_endorsements(&self, unit: &SignedWireUnit<C>) -> Option<C::Hash>

Returns hash of unit that needs to be endorsed.

pub fn last_seen(&self, idx: ValidatorIndex) -> Timestamp

Returns the timestamp of the last ping or unit received from the validator, or the start timestamp if we haven’t received anything yet.

pub fn mark_faulty(&mut self, idx: ValidatorIndex)

Marks the given validator as faulty, unless it is already banned or we have direct evidence.

pub fn maybe_fault(&self, idx: ValidatorIndex) -> Option<&Fault<C>>

Returns the fault type of validator nr. idx, if it is known to be faulty.

pub fn is_faulty(&self, idx: ValidatorIndex) -> bool

Returns whether validator nr. idx is known to be faulty.

pub fn faulty_validators(&self) -> impl Iterator<Item = ValidatorIndex> + '_

Returns an iterator over all faulty validators.

pub fn iter_correct_hashes(&self) -> impl Iterator<Item = &C::Hash>

Returns an iterator over latest unit hashes from honest validators.

pub fn maybe_unit(&self, hash: &C::Hash) -> Option<&Unit<C>>

Returns the unit with the given hash, if present.

pub fn has_unit(&self, hash: &C::Hash) -> bool

Returns whether the unit with the given hash is known.

pub fn unit(&self, hash: &C::Hash) -> &Unit<C>

Returns the unit with the given hash. Panics if not found.

pub fn maybe_block(&self, hash: &C::Hash) -> Option<&Block<C>>

Returns the block contained in the unit with the given hash, if present.

pub fn block(&self, hash: &C::Hash) -> &Block<C>

Returns the block contained in the unit with the given hash. Panics if not found.

pub fn panorama(&self) -> &Panorama<C>

Returns the complete protocol state’s latest panorama.

pub fn leader(&self, timestamp: Timestamp) -> ValidatorIndex

Returns the leader in the specified time slot.

First the assignment is computed ignoring the can_propose flags. Only if the selected leader’s entry is false, the computation is repeated, this time with the flagged validators excluded. This ensures that once the validator set has been decided, correct validators’ slots never get reassigned to someone else, even if after the fact someone is excluded as a leader.

pub fn has_endorsement(&self, uhash: &C::Hash, vidx: ValidatorIndex) -> bool

Returns whether this state already includes an endorsement of uhash by vidx.

pub fn has_ping(&self, creator: ValidatorIndex, timestamp: Timestamp) -> bool

Returns true if the latest timestamp we have is older than the given timestamp.

pub fn find_conflicting_endorsements( &self, endorsements: &Endorsements<C>, instance_id: &C::InstanceId, ) -> Vec<Evidence<C>>

Creates new Evidence if the new endorsements contain any that conflict with existing ones.

Endorsements must be validated before calling this: The endorsers must exist, the signatures must be valid and the endorsed unit must be present in self.units.

pub fn wire_unit( &self, hash: &C::Hash, instance_id: C::InstanceId, ) -> Option<SignedWireUnit<C>>

Returns the SignedWireUnit with the given hash, if it is present in the state.

pub fn fork_choice<'a>(&'a self, pan: &Panorama<C>) -> Option<&'a C::Hash>

Returns the fork choice from pan’s view, or None if there are no blocks yet.

The correct validators’ latest units count as votes for the block they point to, as well as all of its ancestors. At each level the block with the highest score is selected from the children of the previously selected block (or from all blocks at height 0), until a block is reached that has no children with any votes.

pub fn find_ancestor_proposal<'a>( &'a self, hash: &'a C::Hash, height: u64, ) -> Option<&'a C::Hash>

Returns the ancestor of the block with the given hash, on the specified height, or None if the block’s height is lower than that. NOTE: Panics if used on non-proposal hashes.

pub fn find_in_swimlane<'a>( &'a self, hash: &'a C::Hash, seq_number: u64, ) -> Option<&'a C::Hash>

Returns the hash of the message with the given sequence number from the creator of hash, or None if the sequence number is higher than that of the unit with hash.

pub fn swimlane<'a>( &'a self, uhash: &'a C::Hash, ) -> impl Iterator<Item = (&'a C::Hash, &'a Unit<C>)>

Returns an iterator over units (with hashes) by the same creator, in reverse chronological order, starting with the specified unit. Panics if no unit with uhash exists.

pub fn ancestor_hashes<'a>( &'a self, bhash: &'a C::Hash, ) -> impl Iterator<Item = &'a C::Hash>

Returns an iterator over all hashes of ancestors of the block bhash, excluding bhash itself. Panics if bhash is not the hash of a known block.

pub fn seen_endorsed(&self, pan: &Panorama<C>) -> BTreeSet<C::Hash>

Returns the set of units (by hash) that are endorsed and seen from the panorama.

pub fn sees_correct(&self, hash0: &C::Hash, hash1: &C::Hash) -> bool

Returns whether the unit with hash0 sees the one with hash1 (i.e. hash0 ≥ hash1), and sees hash1’s creator as correct.

pub fn sees(&self, hash0: &C::Hash, hash1: &C::Hash) -> bool

Returns whether the unit with hash0 sees the one with hash1 (i.e. hash0 ≥ hash1).

pub fn confirmation_panorama( &self, creator: ValidatorIndex, uhash: &C::Hash, ) -> Panorama<C>

Returns the panorama of the confirmation for the leader unit uhash.

pub fn valid_panorama( &self, creator: ValidatorIndex, pan: Panorama<C>, ) -> Panorama<C>

Creates a panorama that is valid for use in creator’s next unit, and as close as possible to the given one. It is only modified if necessary for validity:

• Cite creator’s previous unit, i.e. don’t equivocate.
• Satisfy the LNC, i.e. don’t add new naively cited forks.

pub fn inclusive_panorama(&self, uhash: &C::Hash) -> Panorama<C>

Returns panorama of a unit where latest entry of the creator is that unit’s hash.

Trait Implementations

impl<C> Clone for State<C>

where C: Context + Clone, C::Hash: Clone, C::Signature: Clone,

fn clone(&self) -> State<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> DataSize for State<C>

where HashMap<ValidatorIndex, Fault<C>>: DataSize, Panorama<C>: DataSize, C: Context,

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

fn estimate_detailed_heap_size(&self) -> MemUsageNode

Create a tree of memory estimations.

impl<C> Debug for State<C>

where C: Context + Debug, C::Hash: Debug, C::Signature: Debug,

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for State<C>

where C: Context + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Serialize for State<C>

where C: Context + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.