Enum Observation 

pub enum Observation<T: NetworkEvent, P: PublicId> {
    Genesis {
        group: BTreeSet<P>,
        related_info: Vec<u8>,
    },
    Add {
        peer_id: P,
        related_info: Vec<u8>,
    },
    Remove {
        peer_id: P,
        related_info: Vec<u8>,
    },
    Accusation {
        offender: P,
        malice: Malice<T, P>,
    },
    OpaquePayload(T),
    StartDkg(BTreeSet<P>),
    DkgResult {
        participants: BTreeSet<P>,
        dkg_result: DkgResultWrapper,
    },
    DkgMessage(DkgMessage),
}

An enum of the various network events for which a peer can vote.

Variants

Genesis

Genesis group

Fields

group: BTreeSet<P>

Members of the genesis group.

related_info: Vec<u8>

Extra arbitrary information for use by the client. Note: this can be set through the genesis_related_info argument of Parsec::from_genesis.

Add

Vote to add the indicated peer to the network.

Fields

peer_id: P

Public id of the peer to be added

related_info: Vec<u8>

Extra arbitrary information for use by the client

Remove

Vote to remove the indicated peer from the network.

Fields

peer_id: P

Public id of the peer to be removed

related_info: Vec<u8>

Extra arbitrary information for use by the client

Accusation

Output only: Do not vote for it. Vote to accuse a peer of malicious behaviour.

Fields

offender: P

Public id of the peer committing the malice.

malice: Malice<T, P>

Type of the malice committed.

OpaquePayload(T)

Vote for an event which is opaque to Parsec.

StartDkg(BTreeSet<P>)

Internal only: No blocks with it. Can be voted as an input.

DkgResult

Output only: Do not vote for it. Will have empty proof set.

Fields

participants: BTreeSet<P>

DKG Participants: These peers have a secret key.

dkg_result: DkgResultWrapper

DKG result. public_key_set will be shared state. secret_key_share will be unique to each peers: all participating peers will have one assuming less than 1/3 malicious. (Ignored in comparaison and serialization).

DkgMessage(DkgMessage)

Internal only: Do not vote for it or expect it to come in blocks. Vote for the next message (Part or Ack) to be handled for the Distributed Key Generation algorithm used by our common coin.

Implementations

impl<T: NetworkEvent, P: PublicId> Observation<T, P>

pub fn is_opaque(&self) -> bool

Is this observation’s payload opaque to PARSEC?

pub fn is_dkg_message(&self) -> bool

Is this observation an internal DkgMessage

pub fn is_internal(&self) -> bool

Is this observation an internal and should not be published in a Block

pub fn is_dkg_result(&self) -> bool

Is this observation a result only DkgResult

Trait Implementations

impl<T: Clone + NetworkEvent, P: Clone + PublicId> Clone for Observation<T, P>

fn clone(&self) -> Observation<T, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: NetworkEvent, P: PublicId> Debug for Observation<T, P>

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

Formats the value using the given formatter.

impl<'de, T: NetworkEvent, P: PublicId> Deserialize<'de> for Observation<T, P>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Hash + NetworkEvent, P: Hash + PublicId> Hash for Observation<T, P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord + NetworkEvent, P: Ord + PublicId> Ord for Observation<T, P>

fn cmp(&self, other: &Observation<T, P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + NetworkEvent, P: PartialEq + PublicId> PartialEq for Observation<T, P>

fn eq(&self, other: &Observation<T, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + NetworkEvent, P: PartialOrd + PublicId> PartialOrd for Observation<T, P>

fn partial_cmp(&self, other: &Observation<T, P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: NetworkEvent, P: PublicId> Serialize for Observation<T, P>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq + NetworkEvent, P: Eq + PublicId> Eq for Observation<T, P>

impl<T: NetworkEvent, P: PublicId> StructuralPartialEq for Observation<T, P>