Struct beefy_primitives::witness::SignedCommitmentWitness[−][src]

pub struct SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> {
    pub commitment: Commitment<TBlockNumber, TPayload>,
    pub signed_by: Vec<bool>,
    pub signatures_merkle_root: TMerkleRoot,
}

Expand description

A light form of SignedCommitment.

This is a light (“witness”) form of the signed commitment. Instead of containing full list of signatures, which might be heavy and expensive to verify, it only contains a bit vector of validators which signed the original SignedCommitment and a merkle root of all signatures.

This can be used by light clients for 2-phase interactive verification (for instance for Ethereum Mainnet), in a commit-reveal like scheme, where first we submit only the signed commitment witness and later on, the client picks only some signatures to verify at random.

Fields

commitment: Commitment<TBlockNumber, TPayload>

The full content of the commitment.

signed_by: Vec<bool>

The bit vector of validators who signed the commitment.

signatures_merkle_root: TMerkleRoot

A merkle root of signatures in the original signed commitment.

Struct beefy_primitives::witness::SignedCommitmentWitness[−][src]

Fields

Implementations

impl<TBlockNumber, TPayload, TMerkleRoot> SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

pub fn from_signed<TMerkelize>( signed: SignedCommitment<TBlockNumber, TPayload>, merkelize: TMerkelize) -> (Self, Vec<Option<Signature>>) where TMerkelize: FnOnce(&[Option<Signature>]) -> TMerkleRoot,

Trait Implementations

impl<TBlockNumber: Debug, TPayload: Debug, TMerkleRoot: Debug> Debug for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

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

impl<TBlockNumber, TPayload, TMerkleRoot> Decode for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where Commitment<TBlockNumber, TPayload>: Decode, Commitment<TBlockNumber, TPayload>: Decode, TMerkleRoot: Decode, TMerkleRoot: 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, TMerkleRoot> Encode for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where Commitment<TBlockNumber, TPayload>: Encode, Commitment<TBlockNumber, TPayload>: Encode, TMerkleRoot: Encode, TMerkleRoot: 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: PartialEq, TPayload: PartialEq, TMerkleRoot: PartialEq> PartialEq<SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>> for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

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

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

impl<TBlockNumber: Eq, TPayload: Eq, TMerkleRoot: Eq> Eq for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

impl<TBlockNumber, TPayload, TMerkleRoot> StructuralEq for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

impl<TBlockNumber, TPayload, TMerkleRoot> StructuralPartialEq for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot>

Auto Trait Implementations

impl<TBlockNumber, TPayload, TMerkleRoot> RefUnwindSafe for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where TBlockNumber: RefUnwindSafe, TMerkleRoot: RefUnwindSafe, TPayload: RefUnwindSafe,

impl<TBlockNumber, TPayload, TMerkleRoot> Send for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where TBlockNumber: Send, TMerkleRoot: Send, TPayload: Send,

impl<TBlockNumber, TPayload, TMerkleRoot> Sync for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where TBlockNumber: Sync, TMerkleRoot: Sync, TPayload: Sync,

impl<TBlockNumber, TPayload, TMerkleRoot> Unpin for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where TBlockNumber: Unpin, TMerkleRoot: Unpin, TPayload: Unpin,

impl<TBlockNumber, TPayload, TMerkleRoot> UnwindSafe for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where TBlockNumber: UnwindSafe, TMerkleRoot: 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<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,

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

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

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

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

pub fn into(self) -> U

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

pub fn from_ref(outer: &Outer) -> &T

pub fn from_mut(outer: &mut Outer) -> &mut T

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

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

pub fn from_signed<TMerkelize>(
signed: SignedCommitment<TBlockNumber, TPayload>,
merkelize: TMerkelize
) -> (Self, Vec<Option<Signature>>) where
TMerkelize: FnOnce(&[Option<Signature>]) -> TMerkleRoot,

impl<TBlockNumber, TPayload, TMerkleRoot> Decode for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
Commitment<TBlockNumber, TPayload>: Decode,
Commitment<TBlockNumber, TPayload>: Decode,
TMerkleRoot: Decode,
TMerkleRoot: 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, TMerkleRoot> Encode for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
Commitment<TBlockNumber, TPayload>: Encode,
Commitment<TBlockNumber, TPayload>: Encode,
TMerkleRoot: Encode,
TMerkleRoot: 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,

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

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

impl<TBlockNumber, TPayload, TMerkleRoot> RefUnwindSafe for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
TBlockNumber: RefUnwindSafe,
TMerkleRoot: RefUnwindSafe,
TPayload: RefUnwindSafe,

impl<TBlockNumber, TPayload, TMerkleRoot> Send for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
TBlockNumber: Send,
TMerkleRoot: Send,
TPayload: Send,

impl<TBlockNumber, TPayload, TMerkleRoot> Sync for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
TBlockNumber: Sync,
TMerkleRoot: Sync,
TPayload: Sync,

impl<TBlockNumber, TPayload, TMerkleRoot> Unpin for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
TBlockNumber: Unpin,
TMerkleRoot: Unpin,
TPayload: Unpin,

impl<TBlockNumber, TPayload, TMerkleRoot> UnwindSafe for SignedCommitmentWitness<TBlockNumber, TPayload, TMerkleRoot> where
TBlockNumber: UnwindSafe,
TMerkleRoot: 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<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,

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

impl<T, U> TapAsRef<U> for T where
U: ?Sized,

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

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