Struct polkadot_runtime_parachains::configuration::HostConfiguration[−][src]

pub struct HostConfiguration<BlockNumber> {Show 40 fields
    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: BlockNumber,
    pub validation_upgrade_delay: BlockNumber,
    pub max_pov_size: u32,
    pub max_downward_message_size: u32,
    pub ump_service_total_weight: Weight,
    pub hrmp_max_parachain_outbound_channels: u32,
    pub hrmp_max_parathread_outbound_channels: u32,
    pub hrmp_sender_deposit: Balance,
    pub hrmp_recipient_deposit: Balance,
    pub hrmp_channel_max_capacity: u32,
    pub hrmp_channel_max_total_size: u32,
    pub hrmp_max_parachain_inbound_channels: u32,
    pub hrmp_max_parathread_inbound_channels: u32,
    pub hrmp_channel_max_message_size: u32,
    pub code_retention_period: BlockNumber,
    pub parathread_cores: u32,
    pub parathread_retries: u32,
    pub group_rotation_frequency: BlockNumber,
    pub chain_availability_period: BlockNumber,
    pub thread_availability_period: BlockNumber,
    pub scheduling_lookahead: u32,
    pub max_validators_per_core: Option<u32>,
    pub max_validators: Option<u32>,
    pub dispute_period: SessionIndex,
    pub dispute_post_conclusion_acceptance_period: BlockNumber,
    pub dispute_max_spam_slots: u32,
    pub dispute_conclusion_by_time_out_period: BlockNumber,
    pub no_show_slots: u32,
    pub n_delay_tranches: u32,
    pub zeroth_delay_tranche_width: u32,
    pub needed_approvals: u32,
    pub relay_vrf_modulo_samples: u32,
    pub ump_max_individual_weight: Weight,
}

Expand description

All configuration of the runtime with respect to parachains and parathreads.

Fields

max_code_size: u32

The parameters that are required for the parachains. 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: BlockNumber

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

validation_upgrade_delay: BlockNumber

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

max_pov_size: u32

The parameters that are not essential, but still may be of interest for parachains. The maximum POV block size, in bytes.

max_downward_message_size: u32

The maximum size of a message that can be put in a downward message queue.

Since we require receiving at least one DMP message the obvious upper bound of the size is the PoV size. Of course, there is a lot of other different things that a parachain may decide to do with its PoV so this value in practice will be picked as a fraction of the PoV size.

ump_service_total_weight: Weight

The amount of weight we wish to devote to the processing the dispatchable upward messages stage.

NOTE that this is a soft limit and could be exceeded.

hrmp_max_parachain_outbound_channels: u32

The maximum number of outbound HRMP channels a parachain is allowed to open.

hrmp_max_parathread_outbound_channels: u32

The maximum number of outbound HRMP channels a parathread is allowed to open.

hrmp_sender_deposit: Balance

The deposit that the sender should provide for opening an HRMP channel.

hrmp_recipient_deposit: Balance

The deposit that the recipient should provide for accepting opening an HRMP channel.

hrmp_channel_max_capacity: u32

The maximum number of messages allowed in an HRMP channel at once.

hrmp_channel_max_total_size: u32

The maximum total size of messages in bytes allowed in an HRMP channel at once.

hrmp_max_parachain_inbound_channels: u32

The maximum number of inbound HRMP channels a parachain is allowed to accept.

hrmp_max_parathread_inbound_channels: u32

The maximum number of inbound HRMP channels a parathread is allowed to accept.

hrmp_channel_max_message_size: u32

The maximum size of a message that could ever be put into an HRMP channel.

This parameter affects the upper bound of size of CandidateCommitments.

code_retention_period: BlockNumber

Parameters that will unlikely be needed by parachains. How long to keep code on-chain, in blocks. This should be sufficiently long that disputes have concluded.

parathread_cores: u32

The amount of execution cores to dedicate to parathread execution.

parathread_retries: u32

The number of retries that a parathread author has to submit their block.

group_rotation_frequency: BlockNumber

How often parachain groups should be rotated across parachains.

Must be non-zero.

chain_availability_period: BlockNumber

The availability period, in blocks, for parachains. This is the amount of blocks after inclusion that validators have to make the block available and signal its availability to the chain.

Must be at least 1.

thread_availability_period: BlockNumber

The availability period, in blocks, for parathreads. Same as the chain_availability_period, but a differing timeout due to differing requirements.

Must be at least 1.

scheduling_lookahead: u32

The amount of blocks ahead to schedule parachains and parathreads.

max_validators_per_core: Option<u32>

The maximum number of validators to have per core.

None means no maximum.

max_validators: Option<u32>

The maximum number of validators to use for parachain consensus, period.

None means no maximum.

dispute_period: SessionIndex

The amount of sessions to keep for disputes.

dispute_post_conclusion_acceptance_period: BlockNumber

How long after dispute conclusion to accept statements.

dispute_max_spam_slots: u32

The maximum number of dispute spam slots

dispute_conclusion_by_time_out_period: BlockNumber

How long it takes for a dispute to conclude by time-out, if no supermajority is reached.

no_show_slots: u32

The amount of consensus slots that must pass between submitting an assignment and submitting an approval vote before a validator is considered a no-show.

Must be at least 1.

n_delay_tranches: u32

The number of delay tranches in total.

zeroth_delay_tranche_width: u32

The width of the zeroth delay tranche for approval assignments. This many delay tranches beyond 0 are all consolidated to form a wide 0 tranche.

needed_approvals: u32

The number of validators needed to approve a block.

relay_vrf_modulo_samples: u32

The number of samples to do of the RelayVRFModulo approval assignment criterion.

ump_max_individual_weight: Weight

The maximum amount of weight any individual upward message may consume. Messages above this weight go into the overweight queue and may only be serviced explicitly.

Struct polkadot_runtime_parachains::configuration::HostConfiguration[−][src]

Fields

Implementations

impl<BlockNumber: Zero> HostConfiguration<BlockNumber>

pub fn check_consistency(&self)

Panic

Trait Implementations

impl<BlockNumber: Clone> Clone for HostConfiguration<BlockNumber>

fn clone(&self) -> HostConfiguration<BlockNumber>

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

impl<BlockNumber> Debug for HostConfiguration<BlockNumber> where BlockNumber: Debug,

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

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<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber>

fn default() -> Self

impl<'de, BlockNumber> Deserialize<'de> for HostConfiguration<BlockNumber> where BlockNumber: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where __D: Deserializer<'de>,

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<BlockNumber: PartialEq> PartialEq<HostConfiguration<BlockNumber>> for HostConfiguration<BlockNumber>

fn eq(&self, other: &HostConfiguration<BlockNumber>) -> bool

fn ne(&self, other: &HostConfiguration<BlockNumber>) -> bool

impl<BlockNumber> Serialize for HostConfiguration<BlockNumber> where BlockNumber: Serialize,

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

type Identity = Self

fn type_info() -> Type

impl<BlockNumber> StructuralPartialEq for HostConfiguration<BlockNumber>

Auto Trait Implementations

impl<BlockNumber> RefUnwindSafe for HostConfiguration<BlockNumber> where BlockNumber: RefUnwindSafe,

impl<BlockNumber> Send for HostConfiguration<BlockNumber> where BlockNumber: Send,

impl<BlockNumber> Sync for HostConfiguration<BlockNumber> where BlockNumber: Sync,

impl<BlockNumber> Unpin for HostConfiguration<BlockNumber> where BlockNumber: Unpin,

impl<BlockNumber> UnwindSafe for HostConfiguration<BlockNumber> where BlockNumber: 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<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<BlockNumber> Debug for HostConfiguration<BlockNumber> where
BlockNumber: Debug,

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

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

impl<'de, BlockNumber> Deserialize<'de> for HostConfiguration<BlockNumber> where
BlockNumber: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
__D: Deserializer<'de>,

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<BlockNumber> Serialize for HostConfiguration<BlockNumber> where
BlockNumber: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,

impl<BlockNumber> RefUnwindSafe for HostConfiguration<BlockNumber> where
BlockNumber: RefUnwindSafe,

impl<BlockNumber> Send for HostConfiguration<BlockNumber> where
BlockNumber: Send,

impl<BlockNumber> Sync for HostConfiguration<BlockNumber> where
BlockNumber: Sync,

impl<BlockNumber> Unpin for HostConfiguration<BlockNumber> where
BlockNumber: Unpin,

impl<BlockNumber> UnwindSafe for HostConfiguration<BlockNumber> where
BlockNumber: 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<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>,

impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,