Struct beefy_primitives::Commitment[−][src]

pub struct Commitment<TBlockNumber, TPayload> {
    pub payload: TPayload,
    pub block_number: TBlockNumber,
    pub validator_set_id: ValidatorSetId,
}

Expand description

A commitment signed by GRANDPA validators as part of BEEFY protocol.

The commitment contains a payload extracted from the finalized block at height block_number. GRANDPA validators collect signatures on commitments and a stream of such signed commitments (see SignedCommitment) forms the BEEFY protocol.

Fields

payload: TPayload

The payload being signed.

This should be some form of cumulative representation of the chain (think MMR root hash). The payload should also contain some details that allow the light client to verify next validator set. The protocol does not enforce any particular format of this data, nor how often it should be present in commitments, however the light client has to be provided with full validator set whenever it performs the transition (i.e. importing first block with validator_set_id incremented).

block_number: TBlockNumber

Finalized block number this commitment is for.

GRANDPA validators agree on a block they create a commitment for and start collecting signatures. This process is called a round. There might be multiple rounds in progress (depending on the block choice rule), however since the payload is supposed to be cumulative, it is not required to import all commitments. BEEFY light client is expected to import at least one commitment per epoch, but is free to import as many as it requires.

validator_set_id: ValidatorSetId

BEEFY validator set supposed to sign this commitment.

Validator set is changing once per epoch. The Light Client must be provided by details about the validator set whenever it’s importing first commitment with a new validator_set_id. Validator set data MUST be verifiable, for instance using payload information.

Struct beefy_primitives::Commitment[−][src]

Fields

Trait Implementations

impl<TBlockNumber: Clone, TPayload: Clone> Clone for Commitment<TBlockNumber, TPayload>

fn clone(&self) -> Commitment<TBlockNumber, TPayload>

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

impl<TBlockNumber: Debug, TPayload: Debug> Debug for Commitment<TBlockNumber, TPayload>

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

impl<TBlockNumber, TPayload> Decode for Commitment<TBlockNumber, TPayload> where TPayload: Decode, TPayload: Decode, TBlockNumber: Decode, TBlockNumber: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<Self, Error>

fn skip<I>(input: &mut I) -> Result<(), Error> where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl<TBlockNumber, TPayload> Encode for Commitment<TBlockNumber, TPayload> where TPayload: Encode, TPayload: Encode, TBlockNumber: Encode, TBlockNumber: Encode,

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy)

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8, Global>

fn using_encoded<R, F>(&self, f: F) -> R where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<TBlockNumber, TPayload> Ord for Commitment<TBlockNumber, TPayload> where TBlockNumber: Ord, TPayload: Eq,

fn cmp(&self, other: &Self) -> Ordering

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

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

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

impl<TBlockNumber: PartialEq, TPayload: PartialEq> PartialEq<Commitment<TBlockNumber, TPayload>> for Commitment<TBlockNumber, TPayload>

fn eq(&self, other: &Commitment<TBlockNumber, TPayload>) -> bool

fn ne(&self, other: &Commitment<TBlockNumber, TPayload>) -> bool

impl<TBlockNumber, TPayload> PartialOrd<Commitment<TBlockNumber, TPayload>> for Commitment<TBlockNumber, TPayload> where TBlockNumber: Ord, TPayload: Eq,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

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

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

impl<TBlockNumber, TPayload> EncodeLike<Commitment<TBlockNumber, TPayload>> for Commitment<TBlockNumber, TPayload> where TPayload: Encode, TPayload: Encode, TBlockNumber: Encode, TBlockNumber: Encode,

impl<TBlockNumber: Eq, TPayload: Eq> Eq for Commitment<TBlockNumber, TPayload>

impl<TBlockNumber, TPayload> StructuralEq for Commitment<TBlockNumber, TPayload>

impl<TBlockNumber, TPayload> StructuralPartialEq for Commitment<TBlockNumber, TPayload>

Auto Trait Implementations

impl<TBlockNumber, TPayload> RefUnwindSafe for Commitment<TBlockNumber, TPayload> where TBlockNumber: RefUnwindSafe, TPayload: RefUnwindSafe,

impl<TBlockNumber, TPayload> Send for Commitment<TBlockNumber, TPayload> where TBlockNumber: Send, TPayload: Send,

impl<TBlockNumber, TPayload> Sync for Commitment<TBlockNumber, TPayload> where TBlockNumber: Sync, TPayload: Sync,

impl<TBlockNumber, TPayload> Unpin for Commitment<TBlockNumber, TPayload> where TBlockNumber: Unpin, TPayload: Unpin,

impl<TBlockNumber, TPayload> UnwindSafe for Commitment<TBlockNumber, TPayload> where TBlockNumber: UnwindSafe, TPayload: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> DecodeAll for T where T: Decode,

pub fn decode_all(input: &[u8]) -> Result<T, Error>

impl<T> DecodeLimit for T where T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<Q, K> Equivalent<K> for Q where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

pub fn equivalent(&self, key: &K) -> bool

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

impl<TBlockNumber, TPayload> Decode for Commitment<TBlockNumber, TPayload> where
TPayload: Decode,
TPayload: Decode,
TBlockNumber: Decode,
TBlockNumber: Decode,

fn decode<CodecInputEdqy: Input>(
codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

fn skip<I>(input: &mut I) -> Result<(), Error> where
I: Input,

impl<TBlockNumber, TPayload> Encode for Commitment<TBlockNumber, TPayload> where
TPayload: Encode,
TPayload: Encode,
TBlockNumber: Encode,
TBlockNumber: Encode,

fn encode_to<CodecOutputEdqy: Output + ?Sized>(
&self,
codec_dest_edqy: &mut __CodecOutputEdqy
)

fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<TBlockNumber, TPayload> Ord for Commitment<TBlockNumber, TPayload> where
TBlockNumber: Ord,
TPayload: Eq,

impl<TBlockNumber, TPayload> PartialOrd<Commitment<TBlockNumber, TPayload>> for Commitment<TBlockNumber, TPayload> where
TBlockNumber: Ord,
TPayload: Eq,

impl<TBlockNumber, TPayload> EncodeLike<Commitment<TBlockNumber, TPayload>> for Commitment<TBlockNumber, TPayload> where
TPayload: Encode,
TPayload: Encode,
TBlockNumber: Encode,
TBlockNumber: Encode,

impl<TBlockNumber, TPayload> RefUnwindSafe for Commitment<TBlockNumber, TPayload> where
TBlockNumber: RefUnwindSafe,
TPayload: RefUnwindSafe,

impl<TBlockNumber, TPayload> Send for Commitment<TBlockNumber, TPayload> where
TBlockNumber: Send,
TPayload: Send,

impl<TBlockNumber, TPayload> Sync for Commitment<TBlockNumber, TPayload> where
TBlockNumber: Sync,
TPayload: Sync,

impl<TBlockNumber, TPayload> Unpin for Commitment<TBlockNumber, TPayload> where
TBlockNumber: Unpin,
TPayload: Unpin,

impl<TBlockNumber, TPayload> UnwindSafe for Commitment<TBlockNumber, TPayload> where
TBlockNumber: UnwindSafe,
TPayload: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,