Struct cumulus_primitives_core::PersistedValidationData[−][src]

pub struct PersistedValidationData<H = H256, N = u32> {
    pub parent_head: HeadData,
    pub relay_parent_number: N,
    pub relay_parent_storage_root: H,
    pub max_pov_size: u32,
}

Expand description

The validation data provides information about how to create the inputs for validation of a candidate. This information is derived from the chain state and will vary from para to para, although some fields may be the same for every para.

Since this data is used to form inputs to the validation function, it needs to be persisted by the availability system to avoid dependence on availability of the relay-chain state.

Furthermore, the validation data acts as a way to authorize the additional data the collator needs to pass to the validation function. For example, the validation function can check whether the incoming messages (e.g. downward messages) were actually sent by using the data provided in the validation data using so called MQC heads.

Since the commitments of the validation function are checked by the relay-chain, secondary checkers can rely on the invariant that the relay-chain only includes para-blocks for which these checks have already been done. As such, there is no need for the validation data used to inform validators and collators about the checks the relay-chain will perform to be persisted by the availability system.

The PersistedValidationData should be relatively lightweight primarily because it is constructed during inclusion for each candidate and therefore lies on the critical path of inclusion.

Fields

parent_head: HeadData

The parent head-data.

relay_parent_number: N

The relay-chain block number this is in the context of.

relay_parent_storage_root: H

The relay-chain block storage root this is in the context of.

max_pov_size: u32

The maximum legal size of a POV block, in bytes.

Struct cumulus_primitives_core::PersistedValidationData[−][src]

Fields

Implementations

impl<H, N> PersistedValidationData<H, N> where H: Encode, N: Encode,

pub fn hash(&self) -> H256

Trait Implementations

impl<H, N> Clone for PersistedValidationData<H, N> where H: Clone, N: Clone,

pub fn clone(&self) -> PersistedValidationData<H, N>

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

impl<H, N> Debug for PersistedValidationData<H, N> where H: Debug, N: Debug,

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

impl<H, N> Decode for PersistedValidationData<H, N> where N: Decode, H: Decode,

pub fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<PersistedValidationData<H, N>, Error> where __CodecInputEdqy: Input,

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

fn encoded_fixed_size() -> Option<usize>

impl<H, N> Default for PersistedValidationData<H, N> where H: Default, N: Default,

pub fn default() -> PersistedValidationData<H, N>

impl<H, N> Encode for PersistedValidationData<H, N> where N: Encode, H: Encode,

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

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<H, N> MallocSizeOf for PersistedValidationData<H, N> where H: MallocSizeOf, N: MallocSizeOf,

pub fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

fn constant_size() -> Option<usize>

impl<H, N> PartialEq<PersistedValidationData<H, N>> for PersistedValidationData<H, N> where H: PartialEq<H>, N: PartialEq<N>,

pub fn eq(&self, other: &PersistedValidationData<H, N>) -> bool

pub fn ne(&self, other: &PersistedValidationData<H, N>) -> bool

impl<H, N> TypeInfo for PersistedValidationData<H, N> where N: 'static + TypeInfo, H: 'static + TypeInfo,

type Identity = PersistedValidationData<H, N>

pub fn type_info() -> Type<MetaForm>

impl<H, N> EncodeLike<PersistedValidationData<H, N>> for PersistedValidationData<H, N> where N: Encode, H: Encode,

impl<H, N> Eq for PersistedValidationData<H, N> where H: Eq, N: Eq,

impl<H, N> StructuralEq for PersistedValidationData<H, N>

impl<H, N> StructuralPartialEq for PersistedValidationData<H, N>

Auto Trait Implementations

impl<H, N> RefUnwindSafe for PersistedValidationData<H, N> where H: RefUnwindSafe, N: RefUnwindSafe,

impl<H, N> Send for PersistedValidationData<H, N> where H: Send, N: Send,

impl<H, N> Sync for PersistedValidationData<H, N> where H: Sync, N: Sync,

impl<H, N> Unpin for PersistedValidationData<H, N> where H: Unpin, N: Unpin,

impl<H, N> UnwindSafe for PersistedValidationData<H, N> where H: UnwindSafe, N: 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> Clear for T where T: Default + Eq + PartialEq<T>,

pub fn is_clear(&self) -> bool

pub fn clear() -> 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<T> EncodeAs<T> for T where T: Encode,

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

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,

impl<H, N> PersistedValidationData<H, N> where
H: Encode,
N: Encode,

impl<H, N> Clone for PersistedValidationData<H, N> where
H: Clone,
N: Clone,

impl<H, N> Debug for PersistedValidationData<H, N> where
H: Debug,
N: Debug,

impl<H, N> Decode for PersistedValidationData<H, N> where
N: Decode,
H: Decode,

pub fn decode<CodecInputEdqy>(
codec_input_edqy: &mut CodecInputEdqy
) -> Result<PersistedValidationData<H, N>, Error> where
CodecInputEdqy: Input,

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

impl<H, N> Default for PersistedValidationData<H, N> where
H: Default,
N: Default,

impl<H, N> Encode for PersistedValidationData<H, N> where
N: Encode,
H: Encode,

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

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

impl<H, N> MallocSizeOf for PersistedValidationData<H, N> where
H: MallocSizeOf,
N: MallocSizeOf,

impl<H, N> PartialEq<PersistedValidationData<H, N>> for PersistedValidationData<H, N> where
H: PartialEq<H>,
N: PartialEq<N>,

impl<H, N> TypeInfo for PersistedValidationData<H, N> where
N: 'static + TypeInfo,
H: 'static + TypeInfo,

impl<H, N> EncodeLike<PersistedValidationData<H, N>> for PersistedValidationData<H, N> where
N: Encode,
H: Encode,

impl<H, N> Eq for PersistedValidationData<H, N> where
H: Eq,
N: Eq,

impl<H, N> RefUnwindSafe for PersistedValidationData<H, N> where
H: RefUnwindSafe,
N: RefUnwindSafe,

impl<H, N> Send for PersistedValidationData<H, N> where
H: Send,
N: Send,

impl<H, N> Sync for PersistedValidationData<H, N> where
H: Sync,
N: Sync,

impl<H, N> Unpin for PersistedValidationData<H, N> where
H: Unpin,
N: Unpin,

impl<H, N> UnwindSafe for PersistedValidationData<H, N> where
H: UnwindSafe,
N: 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>,

impl<T> Clear for T where
T: Default + Eq + PartialEq<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<T> EncodeAs<T> for T where
T: Encode,

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> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

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> MallocSizeOfExt for T where
T: MallocSizeOf,

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>,