Struct cumulus_primitives_core::AbridgedHostConfiguration[−][src]

pub struct AbridgedHostConfiguration {
    pub max_code_size: u32,
    pub max_head_data_size: u32,
    pub max_upward_queue_count: u32,
    pub max_upward_queue_size: u32,
    pub max_upward_message_size: u32,
    pub max_upward_message_num_per_candidate: u32,
    pub hrmp_max_message_num_per_candidate: u32,
    pub validation_upgrade_frequency: u32,
    pub validation_upgrade_delay: u32,
}

Expand description

Abridged version of HostConfiguration (from the Configuration parachains host runtime module) meant to be used by a parachain or PDK such as cumulus.

Fields

max_code_size: u32

The maximum validation code size, in bytes.

max_head_data_size: u32

The maximum head-data size, in bytes.

max_upward_queue_count: u32

Total number of individual messages allowed in the parachain -> relay-chain message queue.

max_upward_queue_size: u32

Total size of messages allowed in the parachain -> relay-chain message queue before which no further messages may be added to it. If it exceeds this then the queue may contain only a single message.

max_upward_message_size: u32

The maximum size of an upward message that can be sent by a candidate.

This parameter affects the size upper bound of the CandidateCommitments.

max_upward_message_num_per_candidate: u32

The maximum number of messages that a candidate can contain.

This parameter affects the size upper bound of the CandidateCommitments.

hrmp_max_message_num_per_candidate: u32

The maximum number of outbound HRMP messages can be sent by a candidate.

This parameter affects the upper bound of size of CandidateCommitments.

validation_upgrade_frequency: u32

The minimum frequency at which parachains can update their validation code.

validation_upgrade_delay: u32

The delay, in blocks, before a validation upgrade is applied.

Struct cumulus_primitives_core::AbridgedHostConfiguration[−][src]

Fields

Trait Implementations

impl Clone for AbridgedHostConfiguration

pub fn clone(&self) -> AbridgedHostConfiguration

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

impl Debug for AbridgedHostConfiguration

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

impl Decode for AbridgedHostConfiguration

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

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

fn encoded_fixed_size() -> Option<usize>

impl Encode for AbridgedHostConfiguration

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 PartialEq<AbridgedHostConfiguration> for AbridgedHostConfiguration

pub fn eq(&self, other: &AbridgedHostConfiguration) -> bool

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

impl TypeInfo for AbridgedHostConfiguration

type Identity = AbridgedHostConfiguration

pub fn type_info() -> Type<MetaForm>

impl EncodeLike<AbridgedHostConfiguration> for AbridgedHostConfiguration

impl StructuralPartialEq for AbridgedHostConfiguration

Auto Trait Implementations

impl RefUnwindSafe for AbridgedHostConfiguration

impl Send for AbridgedHostConfiguration

impl Sync for AbridgedHostConfiguration

impl Unpin for AbridgedHostConfiguration

impl UnwindSafe for AbridgedHostConfiguration

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<T> EncodeAs<T> for T where T: Encode,

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

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

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

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

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

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

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

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

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

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<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<T> EncodeAs<T> for T where
T: Encode,

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