feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

pezkuwi/runtime/teyrchains/src/configuration/benchmarking.rs

@@ -0,0 +1,107 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::configuration::*;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+use pezkuwi_primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind};
+use sp_runtime::traits::One;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn set_config_with_block_number() {
+		#[extrinsic_call]
+		set_code_retention_period(RawOrigin::Root, One::one());
+	}
+
+	#[benchmark]
+	fn set_config_with_u32() {
+		#[extrinsic_call]
+		set_max_code_size(RawOrigin::Root, 100);
+	}
+
+	#[benchmark]
+	fn set_config_with_option_u32() {
+		#[extrinsic_call]
+		set_max_validators(RawOrigin::Root, Some(10));
+	}
+
+	#[benchmark]
+	fn set_hrmp_open_request_ttl() -> Result<(), BenchmarkError> {
+		#[block]
+		{
+			Err(BenchmarkError::Override(BenchmarkResult::from_weight(
+				T::BlockWeights::get().max_block,
+			)))?;
+		}
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_config_with_balance() {
+		#[extrinsic_call]
+		set_hrmp_sender_deposit(RawOrigin::Root, 100_000_000_000);
+	}
+
+	#[benchmark]
+	fn set_config_with_executor_params() {
+		#[extrinsic_call]
+		set_executor_params(
+			RawOrigin::Root,
+			ExecutorParams::from(
+				&[
+					ExecutorParam::MaxMemoryPages(2080),
+					ExecutorParam::StackLogicalMax(65536),
+					ExecutorParam::StackNativeMax(256 * 1024 * 1024),
+					ExecutorParam::WasmExtBulkMemory,
+					ExecutorParam::PrecheckingMaxMemory(2 * 1024 * 1024 * 1024),
+					ExecutorParam::PvfPrepTimeout(PvfPrepKind::Precheck, 60_000),
+					ExecutorParam::PvfPrepTimeout(PvfPrepKind::Prepare, 360_000),
+					ExecutorParam::PvfExecTimeout(PvfExecKind::Backing, 2_000),
+					ExecutorParam::PvfExecTimeout(PvfExecKind::Approval, 12_000),
+				][..],
+			),
+		);
+	}
+
+	#[benchmark]
+	fn set_config_with_perbill() {
+		#[extrinsic_call]
+		set_on_demand_fee_variability(RawOrigin::Root, Perbill::from_percent(100));
+	}
+
+	#[benchmark]
+	fn set_node_feature() {
+		#[extrinsic_call]
+		set_node_feature(RawOrigin::Root, 255, true);
+	}
+
+	#[benchmark]
+	fn set_config_with_scheduler_params() {
+		#[extrinsic_call]
+		set_scheduler_params(RawOrigin::Root, SchedulerParams::default());
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::mock::new_test_ext(Default::default()),
+		crate::mock::Test
+	);
+}

pezkuwi/runtime/teyrchains/src/configuration/migration.rs

@@ -0,0 +1,25 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+pub mod v10;
+pub mod v11;
+pub mod v12;
+pub mod v6;
+pub mod v7;
+pub mod v8;
+pub mod v9;

pezkuwi/runtime/teyrchains/src/configuration/migration/v10.rs

@@ -0,0 +1,384 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Defensive, UncheckedOnRuntimeUpgrade},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::{
+	AsyncBackingParams, Balance, ExecutorParams, NodeFeatures, SessionIndex,
+	LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+};
+use sp_runtime::Perbill;
+
+use super::v9::V9HostConfiguration;
+// All configuration of the runtime with respect to paras.
+#[derive(Clone, Encode, PartialEq, Decode, Debug)]
+pub struct V10HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	pub code_retention_period: BlockNumber,
+	pub on_demand_cores: u32,
+	pub on_demand_retries: u32,
+	pub on_demand_queue_max_size: u32,
+	pub on_demand_target_queue_utilization: Perbill,
+	pub on_demand_fee_variability: Perbill,
+	pub on_demand_base_fee: Balance,
+	pub on_demand_ttl: BlockNumber,
+	pub group_rotation_frequency: BlockNumber,
+	pub paras_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 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 pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+	pub minimum_backing_votes: u32,
+	pub node_features: NodeFeatures,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V10HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			paras_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			on_demand_cores: Default::default(),
+			on_demand_retries: Default::default(),
+			scheduling_lookahead: 1,
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+			on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+			on_demand_base_fee: 10_000_000u128,
+			on_demand_fee_variability: Perbill::from_percent(3),
+			on_demand_target_queue_utilization: Perbill::from_percent(25),
+			on_demand_ttl: 5u32.into(),
+			minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
+			node_features: NodeFeatures::EMPTY,
+		}
+	}
+}
+
+mod v9 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V9HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V9HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v10 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V10HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V10HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub struct VersionUncheckedMigrateToV10<T>(core::marker::PhantomData<T>);
+impl<T: Config> UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV10<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV10");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		migrate_to_v10::<T>()
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV10");
+		ensure!(
+			Pallet::<T>::on_chain_storage_version() >= StorageVersion::new(10),
+			"Storage version should be >= 10 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+pub type MigrateToV10<T> = frame_support::migrations::VersionedMigration<
+	9,
+	10,
+	VersionUncheckedMigrateToV10<T>,
+	Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
+
+// Unusual formatting is justified:
+// - make it easier to verify that fields assign what they supposed to assign.
+// - this code is transient and will be removed after all migrations are done.
+// - this code is important enough to optimize for legibility sacrificing consistency.
+#[rustfmt::skip]
+fn translate<T: Config>(pre: V9HostConfiguration<BlockNumberFor<T>>) -> V10HostConfiguration<BlockNumberFor<T>> {
+	V10HostConfiguration {
+		max_code_size                            : pre.max_code_size,
+		max_head_data_size                       : pre.max_head_data_size,
+		max_upward_queue_count                   : pre.max_upward_queue_count,
+		max_upward_queue_size                    : pre.max_upward_queue_size,
+		max_upward_message_size                  : pre.max_upward_message_size,
+		max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+		hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+		validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+		validation_upgrade_delay                 : pre.validation_upgrade_delay,
+		max_pov_size                             : pre.max_pov_size,
+		max_downward_message_size                : pre.max_downward_message_size,
+		hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+		hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+		hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+		hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+		hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+		hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+		hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+		code_retention_period                    : pre.code_retention_period,
+		on_demand_cores                          : pre.on_demand_cores,
+		on_demand_retries                        : pre.on_demand_retries,
+		group_rotation_frequency                 : pre.group_rotation_frequency,
+		paras_availability_period                : pre.paras_availability_period,
+		scheduling_lookahead                     : pre.scheduling_lookahead,
+		max_validators_per_core                  : pre.max_validators_per_core,
+		max_validators                           : pre.max_validators,
+		dispute_period                           : pre.dispute_period,
+		dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+		no_show_slots                            : pre.no_show_slots,
+		n_delay_tranches                         : pre.n_delay_tranches,
+		zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+		needed_approvals                         : pre.needed_approvals,
+		relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+		pvf_voting_ttl                           : pre.pvf_voting_ttl,
+		minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+		async_backing_params                     : pre.async_backing_params,
+		executor_params                          : pre.executor_params,
+		on_demand_queue_max_size                 : pre.on_demand_queue_max_size,
+		on_demand_base_fee                       : pre.on_demand_base_fee,
+		on_demand_fee_variability                : pre.on_demand_fee_variability,
+		on_demand_target_queue_utilization       : pre.on_demand_target_queue_utilization,
+		on_demand_ttl                            : pre.on_demand_ttl,
+		minimum_backing_votes                    : pre.minimum_backing_votes,
+		node_features                            : NodeFeatures::EMPTY
+	}
+}
+
+fn migrate_to_v10<T: Config>() -> Weight {
+	let v9 = v9::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v10 = translate::<T>(v9);
+	v10::ActiveConfig::<T>::set(Some(v10));
+
+	// Allowed to be empty.
+	let pending_v9 = v9::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v10 = Vec::new();
+
+	for (session, v9) in pending_v9.into_iter() {
+		let v10 = translate::<T>(v9);
+		pending_v10.push((session, v10));
+	}
+	v10::PendingConfigs::<T>::set(Some(pending_v10.clone()));
+
+	let num_configs = (pending_v10.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+	use pezkuwi_primitives::LEGACY_MIN_BACKING_VOTES;
+
+	#[test]
+	fn v10_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		// referenced        block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex!["
+	0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000000000000000001027000080b2e60e80c3c90180969800000000000000000000000000050000001400000004000000010000000101000000000600000064000000020000001900000000000000020000000200000002000000050000000200000000"
+	];
+
+		let v10 =
+			V10HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v10.max_code_size, 3_145_728);
+		assert_eq!(v10.validation_upgrade_cooldown, 2);
+		assert_eq!(v10.max_pov_size, 5_242_880);
+		assert_eq!(v10.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v10.n_delay_tranches, 25);
+		assert_eq!(v10.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v10.group_rotation_frequency, 20);
+		assert_eq!(v10.on_demand_cores, 0);
+		assert_eq!(v10.on_demand_base_fee, 10_000_000);
+		assert_eq!(v10.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
+		assert_eq!(v10.node_features, NodeFeatures::EMPTY);
+	}
+
+	// Test that `migrate_to_v10`` correctly applies the `translate` function to current and pending
+	// configs.
+	#[test]
+	fn test_migrate_to_v10() {
+		// Host configuration has lots of fields. However, in this migration we only add one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v9 = V9HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			paras_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			minimum_validation_upgrade_delay: 20,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v9.clone()));
+		pending_configs.push((300, v9.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v9 version in the state.
+			v9::ActiveConfig::<Test>::set(Some(v9.clone()));
+			v9::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v10::<Test>();
+
+			let v10 = translate::<Test>(v9);
+			let mut configs_to_check = v10::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v10::ActiveConfig::<Test>::get().unwrap()));
+
+			for (_, config) in configs_to_check {
+				assert_eq!(config, v10);
+				assert_eq!(config.node_features, NodeFeatures::EMPTY);
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v10_no_pending() {
+		let v9 = V9HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v9 version in the state.
+			v9::ActiveConfig::<Test>::set(Some(v9));
+			// Ensure there're no pending configs.
+			v9::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v10::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v11.rs

@@ -0,0 +1,440 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	migrations::VersionedMigration,
+	pallet_prelude::*,
+	traits::{Defensive, UncheckedOnRuntimeUpgrade},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::{
+	ApprovalVotingParams, AsyncBackingParams, ExecutorParams, NodeFeatures, SessionIndex,
+	LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+};
+
+use pezkuwi_core_primitives::Balance;
+use sp_arithmetic::Perbill;
+
+use super::v10::V10HostConfiguration;
+
+#[derive(Clone, Encode, PartialEq, Decode, Debug)]
+pub struct V11HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	pub code_retention_period: BlockNumber,
+	pub coretime_cores: u32,
+	pub on_demand_retries: u32,
+	pub on_demand_queue_max_size: u32,
+	pub on_demand_target_queue_utilization: Perbill,
+	pub on_demand_fee_variability: Perbill,
+	pub on_demand_base_fee: Balance,
+	pub on_demand_ttl: BlockNumber,
+	pub group_rotation_frequency: BlockNumber,
+	pub paras_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 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 pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+	pub minimum_backing_votes: u32,
+	pub node_features: NodeFeatures,
+	pub approval_voting_params: ApprovalVotingParams,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V11HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			paras_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			coretime_cores: Default::default(),
+			on_demand_retries: Default::default(),
+			scheduling_lookahead: 1,
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+			approval_voting_params: ApprovalVotingParams { max_approval_coalesce_count: 1 },
+			on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+			on_demand_base_fee: 10_000_000u128,
+			on_demand_fee_variability: Perbill::from_percent(3),
+			on_demand_target_queue_utilization: Perbill::from_percent(25),
+			on_demand_ttl: 5u32.into(),
+			minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
+			node_features: NodeFeatures::EMPTY,
+		}
+	}
+}
+
+mod v10 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V10HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V10HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v11 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V11HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V11HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub type MigrateToV11<T> = VersionedMigration<
+	10,
+	11,
+	UncheckedMigrateToV11<T>,
+	Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
+
+pub struct UncheckedMigrateToV11<T>(core::marker::PhantomData<T>);
+impl<T: Config> UncheckedOnRuntimeUpgrade for UncheckedMigrateToV11<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV11");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV11 started");
+		let weight_consumed = migrate_to_v11::<T>();
+
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV11 executed successfully");
+
+		weight_consumed
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV11");
+		ensure!(
+			StorageVersion::get::<Pallet<T>>() >= 11,
+			"Storage version should be >= 11 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+fn migrate_to_v11<T: Config>() -> Weight {
+	// Unusual formatting is justified:
+	// - make it easier to verify that fields assign what they supposed to assign.
+	// - this code is transient and will be removed after all migrations are done.
+	// - this code is important enough to optimize for legibility sacrificing consistency.
+	#[rustfmt::skip]
+	let translate =
+		|pre: V10HostConfiguration<BlockNumberFor<T>>| ->
+		V11HostConfiguration<BlockNumberFor<T>>
+	{
+		V11HostConfiguration {
+max_code_size                            : pre.max_code_size,
+max_head_data_size                       : pre.max_head_data_size,
+max_upward_queue_count                   : pre.max_upward_queue_count,
+max_upward_queue_size                    : pre.max_upward_queue_size,
+max_upward_message_size                  : pre.max_upward_message_size,
+max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+validation_upgrade_delay                 : pre.validation_upgrade_delay,
+max_pov_size                             : pre.max_pov_size,
+max_downward_message_size                : pre.max_downward_message_size,
+hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+code_retention_period                    : pre.code_retention_period,
+coretime_cores                           : pre.on_demand_cores,
+on_demand_retries                        : pre.on_demand_retries,
+group_rotation_frequency                 : pre.group_rotation_frequency,
+paras_availability_period                : pre.paras_availability_period,
+scheduling_lookahead                     : pre.scheduling_lookahead,
+max_validators_per_core                  : pre.max_validators_per_core,
+max_validators                           : pre.max_validators,
+dispute_period                           : pre.dispute_period,
+dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+no_show_slots                            : pre.no_show_slots,
+n_delay_tranches                         : pre.n_delay_tranches,
+zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+needed_approvals                         : pre.needed_approvals,
+relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+pvf_voting_ttl                           : pre.pvf_voting_ttl,
+minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+async_backing_params                     : pre.async_backing_params,
+executor_params                          : pre.executor_params,
+on_demand_queue_max_size                 : pre.on_demand_queue_max_size,
+on_demand_base_fee                       : pre.on_demand_base_fee,
+on_demand_fee_variability                : pre.on_demand_fee_variability,
+on_demand_target_queue_utilization       : pre.on_demand_target_queue_utilization,
+on_demand_ttl                            : pre.on_demand_ttl,
+minimum_backing_votes                    : pre.minimum_backing_votes,
+node_features							 : pre.node_features,
+approval_voting_params                   : ApprovalVotingParams {
+												max_approval_coalesce_count: 1,
+											}
+		}
+	};
+
+	let v10 = v10::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v11 = translate(v10);
+	v11::ActiveConfig::<T>::set(Some(v11));
+
+	// Allowed to be empty.
+	let pending_v9 = v10::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v10 = Vec::new();
+
+	for (session, v10) in pending_v9.into_iter() {
+		let v11 = translate(v10);
+		pending_v10.push((session, v11));
+	}
+	v11::PendingConfigs::<T>::set(Some(pending_v10.clone()));
+
+	let num_configs = (pending_v10.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use pezkuwi_primitives::LEGACY_MIN_BACKING_VOTES;
+
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+
+	#[test]
+	fn v11_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		// referenced        block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex!["
+	0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000000000000000001027000080b2e60e80c3c9018096980000000000000000000000000005000000140000000400000001000000010100000000060000006400000002000000190000000000000002000000020000000200000005000000020000000001000000"
+	];
+
+		let v11 =
+			V11HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v11.max_code_size, 3_145_728);
+		assert_eq!(v11.validation_upgrade_cooldown, 2);
+		assert_eq!(v11.max_pov_size, 5_242_880);
+		assert_eq!(v11.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v11.n_delay_tranches, 25);
+		assert_eq!(v11.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v11.group_rotation_frequency, 20);
+		assert_eq!(v11.coretime_cores, 0);
+		assert_eq!(v11.on_demand_base_fee, 10_000_000);
+		assert_eq!(v11.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
+		assert_eq!(v11.approval_voting_params.max_approval_coalesce_count, 1);
+	}
+
+	#[test]
+	fn test_migrate_to_v11() {
+		// Host configuration has lots of fields. However, in this migration we only add one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v10 = V10HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			paras_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			minimum_validation_upgrade_delay: 20,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v10.clone()));
+		pending_configs.push((300, v10.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v10 version in the state.
+			v10::ActiveConfig::<Test>::set(Some(v10.clone()));
+			v10::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v11::<Test>();
+
+			let v11 = v11::ActiveConfig::<Test>::get().unwrap();
+			assert_eq!(v11.approval_voting_params.max_approval_coalesce_count, 1);
+
+			let mut configs_to_check = v11::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v11.clone()));
+
+			for (_, v11) in configs_to_check {
+				#[rustfmt::skip]
+				{
+					assert_eq!(v10.max_code_size                            , v11.max_code_size);
+					assert_eq!(v10.max_head_data_size                       , v11.max_head_data_size);
+					assert_eq!(v10.max_upward_queue_count                   , v11.max_upward_queue_count);
+					assert_eq!(v10.max_upward_queue_size                    , v11.max_upward_queue_size);
+					assert_eq!(v10.max_upward_message_size                  , v11.max_upward_message_size);
+					assert_eq!(v10.max_upward_message_num_per_candidate     , v11.max_upward_message_num_per_candidate);
+					assert_eq!(v10.hrmp_max_message_num_per_candidate       , v11.hrmp_max_message_num_per_candidate);
+					assert_eq!(v10.validation_upgrade_cooldown              , v11.validation_upgrade_cooldown);
+					assert_eq!(v10.validation_upgrade_delay                 , v11.validation_upgrade_delay);
+					assert_eq!(v10.max_pov_size                             , v11.max_pov_size);
+					assert_eq!(v10.max_downward_message_size                , v11.max_downward_message_size);
+					assert_eq!(v10.hrmp_max_teyrchain_outbound_channels     , v11.hrmp_max_teyrchain_outbound_channels);
+					assert_eq!(v10.hrmp_sender_deposit                      , v11.hrmp_sender_deposit);
+					assert_eq!(v10.hrmp_recipient_deposit                   , v11.hrmp_recipient_deposit);
+					assert_eq!(v10.hrmp_channel_max_capacity                , v11.hrmp_channel_max_capacity);
+					assert_eq!(v10.hrmp_channel_max_total_size              , v11.hrmp_channel_max_total_size);
+					assert_eq!(v10.hrmp_max_teyrchain_inbound_channels      , v11.hrmp_max_teyrchain_inbound_channels);
+					assert_eq!(v10.hrmp_channel_max_message_size            , v11.hrmp_channel_max_message_size);
+					assert_eq!(v10.code_retention_period                    , v11.code_retention_period);
+					assert_eq!(v10.on_demand_cores                          , v11.coretime_cores);
+					assert_eq!(v10.on_demand_retries                        , v11.on_demand_retries);
+					assert_eq!(v10.group_rotation_frequency                 , v11.group_rotation_frequency);
+					assert_eq!(v10.paras_availability_period                , v11.paras_availability_period);
+					assert_eq!(v10.scheduling_lookahead                     , v11.scheduling_lookahead);
+					assert_eq!(v10.max_validators_per_core                  , v11.max_validators_per_core);
+					assert_eq!(v10.max_validators                           , v11.max_validators);
+					assert_eq!(v10.dispute_period                           , v11.dispute_period);
+					assert_eq!(v10.no_show_slots                            , v11.no_show_slots);
+					assert_eq!(v10.n_delay_tranches                         , v11.n_delay_tranches);
+					assert_eq!(v10.zeroth_delay_tranche_width               , v11.zeroth_delay_tranche_width);
+					assert_eq!(v10.needed_approvals                         , v11.needed_approvals);
+					assert_eq!(v10.relay_vrf_modulo_samples                 , v11.relay_vrf_modulo_samples);
+					assert_eq!(v10.pvf_voting_ttl                           , v11.pvf_voting_ttl);
+					assert_eq!(v10.minimum_validation_upgrade_delay         , v11.minimum_validation_upgrade_delay);
+					assert_eq!(v10.async_backing_params.allowed_ancestry_len, v11.async_backing_params.allowed_ancestry_len);
+					assert_eq!(v10.async_backing_params.max_candidate_depth , v11.async_backing_params.max_candidate_depth);
+					assert_eq!(v10.executor_params						    , v11.executor_params);
+				    assert_eq!(v10.minimum_backing_votes					, v11.minimum_backing_votes);
+				}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v11_no_pending() {
+		let v10 = V10HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v10 version in the state.
+			v10::ActiveConfig::<Test>::set(Some(v10));
+			// Ensure there're no pending configs.
+			v11::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v11::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v12.rs

@@ -0,0 +1,358 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, migration::v11::V11HostConfiguration, Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	migrations::VersionedMigration,
+	pallet_prelude::*,
+	traits::{Defensive, UncheckedOnRuntimeUpgrade},
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::SchedulerParams;
+use sp_core::Get;
+use sp_staking::SessionIndex;
+
+type V12HostConfiguration<BlockNumber> = configuration::HostConfiguration<BlockNumber>;
+
+mod v11 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V11HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V11HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v12 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V12HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V12HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub type MigrateToV12<T> = VersionedMigration<
+	11,
+	12,
+	UncheckedMigrateToV12<T>,
+	Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
+
+pub struct UncheckedMigrateToV12<T>(core::marker::PhantomData<T>);
+
+impl<T: Config> UncheckedOnRuntimeUpgrade for UncheckedMigrateToV12<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV12");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV12 started");
+		let weight_consumed = migrate_to_v12::<T>();
+
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV12 executed successfully");
+
+		weight_consumed
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV12");
+		ensure!(
+			StorageVersion::get::<Pallet<T>>() >= 12,
+			"Storage version should be >= 12 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+fn migrate_to_v12<T: Config>() -> Weight {
+	// Unusual formatting is justified:
+	// - make it easier to verify that fields assign what they supposed to assign.
+	// - this code is transient and will be removed after all migrations are done.
+	// - this code is important enough to optimize for legibility sacrificing consistency.
+	#[rustfmt::skip]
+		let translate =
+		|pre: V11HostConfiguration<BlockNumberFor<T>>| ->
+		V12HostConfiguration<BlockNumberFor<T>>
+			{
+				V12HostConfiguration {
+					max_code_size                            : pre.max_code_size,
+					max_head_data_size                       : pre.max_head_data_size,
+					max_upward_queue_count                   : pre.max_upward_queue_count,
+					max_upward_queue_size                    : pre.max_upward_queue_size,
+					max_upward_message_size                  : pre.max_upward_message_size,
+					max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+					hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+					validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+					validation_upgrade_delay                 : pre.validation_upgrade_delay,
+					max_pov_size                             : pre.max_pov_size,
+					max_downward_message_size                : pre.max_downward_message_size,
+					hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+					hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+					hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+					hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+					hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+					hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+					hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+					code_retention_period                    : pre.code_retention_period,
+					max_validators                           : pre.max_validators,
+					dispute_period                           : pre.dispute_period,
+					dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+					no_show_slots                            : pre.no_show_slots,
+					n_delay_tranches                         : pre.n_delay_tranches,
+					zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+					needed_approvals                         : pre.needed_approvals,
+					relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+					pvf_voting_ttl                           : pre.pvf_voting_ttl,
+					minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+					async_backing_params                     : pre.async_backing_params,
+					executor_params                          : pre.executor_params,
+					minimum_backing_votes                    : pre.minimum_backing_votes,
+					node_features                            : pre.node_features,
+					approval_voting_params                   : pre.approval_voting_params,
+					#[allow(deprecated)]
+					scheduler_params: SchedulerParams {
+							group_rotation_frequency             : pre.group_rotation_frequency,
+							paras_availability_period            : pre.paras_availability_period,
+							max_validators_per_core              : pre.max_validators_per_core,
+							lookahead                            : pre.scheduling_lookahead,
+							num_cores                            : pre.coretime_cores,
+							max_availability_timeouts            : pre.on_demand_retries,
+							on_demand_queue_max_size             : pre.on_demand_queue_max_size,
+							on_demand_target_queue_utilization   : pre.on_demand_target_queue_utilization,
+							on_demand_fee_variability            : pre.on_demand_fee_variability,
+							on_demand_base_fee                   : pre.on_demand_base_fee,
+							ttl                                  : pre.on_demand_ttl,
+					}
+				}
+			};
+
+	let v11 = v11::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v12 = translate(v11);
+	v12::ActiveConfig::<T>::set(Some(v12));
+
+	// Allowed to be empty.
+	let pending_v11 = v11::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v12 = Vec::new();
+
+	for (session, v11) in pending_v11.into_iter() {
+		let v12 = translate(v11);
+		pending_v12.push((session, v12));
+	}
+	v12::PendingConfigs::<T>::set(Some(pending_v12.clone()));
+
+	let num_configs = (pending_v12.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use pezkuwi_primitives::LEGACY_MIN_BACKING_VOTES;
+	use sp_arithmetic::Perbill;
+
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+
+	#[test]
+	fn v12_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		//        referenced block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex![
+	"0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000060000006400000002000000190000000000000002000000020000000200000005000000020000000001000000140000000400000001010000000100000001000000000000001027000080b2e60e80c3c9018096980000000000000000000000000005000000"
+	];
+
+		let v12 =
+			V12HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v12.max_code_size, 3_145_728);
+		assert_eq!(v12.validation_upgrade_cooldown, 2);
+		assert_eq!(v12.max_pov_size, 5_242_880);
+		assert_eq!(v12.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v12.n_delay_tranches, 25);
+		assert_eq!(v12.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v12.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
+		assert_eq!(v12.approval_voting_params.max_approval_coalesce_count, 1);
+		assert_eq!(v12.scheduler_params.group_rotation_frequency, 20);
+		assert_eq!(v12.scheduler_params.paras_availability_period, 4);
+		assert_eq!(v12.scheduler_params.lookahead, 1);
+		assert_eq!(v12.scheduler_params.num_cores, 1);
+		#[allow(deprecated)]
+		{
+			assert_eq!(v12.scheduler_params.max_availability_timeouts, 0);
+		}
+		assert_eq!(v12.scheduler_params.on_demand_queue_max_size, 10_000);
+		assert_eq!(
+			v12.scheduler_params.on_demand_target_queue_utilization,
+			Perbill::from_percent(25)
+		);
+		assert_eq!(v12.scheduler_params.on_demand_fee_variability, Perbill::from_percent(3));
+		assert_eq!(v12.scheduler_params.on_demand_base_fee, 10_000_000);
+		#[allow(deprecated)]
+		{
+			assert_eq!(v12.scheduler_params.ttl, 5);
+		}
+	}
+
+	#[test]
+	fn test_migrate_to_v12() {
+		// Host configuration has lots of fields. However, in this migration we only add one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v11 = V11HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			paras_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			minimum_validation_upgrade_delay: 20,
+			on_demand_ttl: 3,
+			on_demand_retries: 10,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v11.clone()));
+		pending_configs.push((300, v11.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v10 version in the state.
+			v11::ActiveConfig::<Test>::set(Some(v11.clone()));
+			v11::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v12::<Test>();
+
+			let v12 = v12::ActiveConfig::<Test>::get().unwrap();
+			assert_eq!(v12.approval_voting_params.max_approval_coalesce_count, 1);
+
+			let mut configs_to_check = v12::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v12.clone()));
+
+			for (_, v12) in configs_to_check {
+				#[rustfmt::skip]
+				#[allow(deprecated)]
+				{
+					assert_eq!(v11.max_code_size                            , v12.max_code_size);
+					assert_eq!(v11.max_head_data_size                       , v12.max_head_data_size);
+					assert_eq!(v11.max_upward_queue_count                   , v12.max_upward_queue_count);
+					assert_eq!(v11.max_upward_queue_size                    , v12.max_upward_queue_size);
+					assert_eq!(v11.max_upward_message_size                  , v12.max_upward_message_size);
+					assert_eq!(v11.max_upward_message_num_per_candidate     , v12.max_upward_message_num_per_candidate);
+					assert_eq!(v11.hrmp_max_message_num_per_candidate       , v12.hrmp_max_message_num_per_candidate);
+					assert_eq!(v11.validation_upgrade_cooldown              , v12.validation_upgrade_cooldown);
+					assert_eq!(v11.validation_upgrade_delay                 , v12.validation_upgrade_delay);
+					assert_eq!(v11.max_pov_size                             , v12.max_pov_size);
+					assert_eq!(v11.max_downward_message_size                , v12.max_downward_message_size);
+					assert_eq!(v11.hrmp_max_teyrchain_outbound_channels     , v12.hrmp_max_teyrchain_outbound_channels);
+					assert_eq!(v11.hrmp_sender_deposit                      , v12.hrmp_sender_deposit);
+					assert_eq!(v11.hrmp_recipient_deposit                   , v12.hrmp_recipient_deposit);
+					assert_eq!(v11.hrmp_channel_max_capacity                , v12.hrmp_channel_max_capacity);
+					assert_eq!(v11.hrmp_channel_max_total_size              , v12.hrmp_channel_max_total_size);
+					assert_eq!(v11.hrmp_max_teyrchain_inbound_channels      , v12.hrmp_max_teyrchain_inbound_channels);
+					assert_eq!(v11.hrmp_channel_max_message_size            , v12.hrmp_channel_max_message_size);
+					assert_eq!(v11.code_retention_period                    , v12.code_retention_period);
+					assert_eq!(v11.max_validators                           , v12.max_validators);
+					assert_eq!(v11.dispute_period                           , v12.dispute_period);
+					assert_eq!(v11.no_show_slots                            , v12.no_show_slots);
+					assert_eq!(v11.n_delay_tranches                         , v12.n_delay_tranches);
+					assert_eq!(v11.zeroth_delay_tranche_width               , v12.zeroth_delay_tranche_width);
+					assert_eq!(v11.needed_approvals                         , v12.needed_approvals);
+					assert_eq!(v11.relay_vrf_modulo_samples                 , v12.relay_vrf_modulo_samples);
+					assert_eq!(v11.pvf_voting_ttl                           , v12.pvf_voting_ttl);
+					assert_eq!(v11.minimum_validation_upgrade_delay         , v12.minimum_validation_upgrade_delay);
+					assert_eq!(v11.async_backing_params.allowed_ancestry_len, v12.async_backing_params.allowed_ancestry_len);
+					assert_eq!(v11.async_backing_params.max_candidate_depth , v12.async_backing_params.max_candidate_depth);
+					assert_eq!(v11.executor_params                          , v12.executor_params);
+				    assert_eq!(v11.minimum_backing_votes                    , v12.minimum_backing_votes);
+					assert_eq!(v11.group_rotation_frequency                 , v12.scheduler_params.group_rotation_frequency);
+					assert_eq!(v11.paras_availability_period                , v12.scheduler_params.paras_availability_period);
+					assert_eq!(v11.max_validators_per_core                  , v12.scheduler_params.max_validators_per_core);
+					assert_eq!(v11.scheduling_lookahead                     , v12.scheduler_params.lookahead);
+					assert_eq!(v11.coretime_cores                           , v12.scheduler_params.num_cores);
+					assert_eq!(v11.on_demand_retries                        , v12.scheduler_params.max_availability_timeouts);
+					assert_eq!(v11.on_demand_queue_max_size                 , v12.scheduler_params.on_demand_queue_max_size);
+					assert_eq!(v11.on_demand_target_queue_utilization       , v12.scheduler_params.on_demand_target_queue_utilization);
+					assert_eq!(v11.on_demand_fee_variability                , v12.scheduler_params.on_demand_fee_variability);
+					assert_eq!(v11.on_demand_base_fee                       , v12.scheduler_params.on_demand_base_fee);
+					assert_eq!(v11.on_demand_ttl                            , v12.scheduler_params.ttl);
+				}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there are no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v12_no_pending() {
+		let v11 = V11HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v10 version in the state.
+			v11::ActiveConfig::<Test>::set(Some(v11));
+			// Ensure there are no pending configs.
+			v12::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v12::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v6.rs

@@ -0,0 +1,135 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Contains the V6 storage definition of the host configuration.
+
+use crate::configuration::{Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::BlockNumberFor;
+
+use pezkuwi_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
+
+#[derive(codec::Encode, codec::Decode, Debug, Clone)]
+pub struct V6HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_max_parathread_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	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 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 pvf_checking_enabled: bool,
+	pub pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V6HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			chain_availability_period: 1u32.into(),
+			thread_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			parathread_cores: Default::default(),
+			parathread_retries: Default::default(),
+			scheduling_lookahead: Default::default(),
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_max_parathread_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_parathread_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_checking_enabled: false,
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+		}
+	}
+}
+
+mod v6 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V6HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V6HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v7.rs

@@ -0,0 +1,406 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Defensive, StorageVersion},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
+
+use frame_support::traits::OnRuntimeUpgrade;
+
+use super::v6::V6HostConfiguration;
+
+#[derive(codec::Encode, codec::Decode, Debug, Clone)]
+pub struct V7HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_max_parathread_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	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 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 pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V7HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			chain_availability_period: 1u32.into(),
+			thread_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			parathread_cores: Default::default(),
+			parathread_retries: Default::default(),
+			scheduling_lookahead: Default::default(),
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_max_parathread_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_parathread_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+		}
+	}
+}
+
+mod v6 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V6HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V6HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v7 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V7HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V7HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub struct MigrateToV7<T>(core::marker::PhantomData<T>);
+impl<T: Config> OnRuntimeUpgrade for MigrateToV7<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade()");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		log::info!(target: configuration::LOG_TARGET, "MigrateToV7 started");
+		if StorageVersion::get::<Pallet<T>>() == 6 {
+			let weight_consumed = migrate_to_v7::<T>();
+
+			log::info!(target: configuration::LOG_TARGET, "MigrateToV7 executed successfully");
+			StorageVersion::new(7).put::<Pallet<T>>();
+
+			weight_consumed
+		} else {
+			log::warn!(target: configuration::LOG_TARGET, "MigrateToV7 should be removed.");
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade()");
+		ensure!(
+			StorageVersion::get::<Pallet<T>>() >= 7,
+			"Storage version should be >= 7 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+fn migrate_to_v7<T: Config>() -> Weight {
+	// Unusual formatting is justified:
+	// - make it easier to verify that fields assign what they supposed to assign.
+	// - this code is transient and will be removed after all migrations are done.
+	// - this code is important enough to optimize for legibility sacrificing consistency.
+	#[rustfmt::skip]
+	let translate =
+		|pre: V6HostConfiguration<BlockNumberFor<T>>| ->
+		V7HostConfiguration<BlockNumberFor<T>>
+	{
+		V7HostConfiguration {
+max_code_size                            : pre.max_code_size,
+max_head_data_size                       : pre.max_head_data_size,
+max_upward_queue_count                   : pre.max_upward_queue_count,
+max_upward_queue_size                    : pre.max_upward_queue_size,
+max_upward_message_size                  : pre.max_upward_message_size,
+max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+validation_upgrade_delay                 : pre.validation_upgrade_delay,
+max_pov_size                             : pre.max_pov_size,
+max_downward_message_size                : pre.max_downward_message_size,
+hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+hrmp_max_parathread_outbound_channels    : pre.hrmp_max_parathread_outbound_channels,
+hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+hrmp_max_parathread_inbound_channels     : pre.hrmp_max_parathread_inbound_channels,
+hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+code_retention_period                    : pre.code_retention_period,
+parathread_cores                         : pre.parathread_cores,
+parathread_retries                       : pre.parathread_retries,
+group_rotation_frequency                 : pre.group_rotation_frequency,
+chain_availability_period                : pre.chain_availability_period,
+thread_availability_period               : pre.thread_availability_period,
+scheduling_lookahead                     : pre.scheduling_lookahead,
+max_validators_per_core                  : pre.max_validators_per_core,
+max_validators                           : pre.max_validators,
+dispute_period                           : pre.dispute_period,
+dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+no_show_slots                            : pre.no_show_slots,
+n_delay_tranches                         : pre.n_delay_tranches,
+zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+needed_approvals                         : pre.needed_approvals,
+relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+pvf_voting_ttl                           : pre.pvf_voting_ttl,
+minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+async_backing_params                     : pre.async_backing_params,
+executor_params                          : pre.executor_params,
+		}
+	};
+
+	let v6 = v6::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v7 = translate(v6);
+	v7::ActiveConfig::<T>::set(Some(v7));
+
+	// Allowed to be empty.
+	let pending_v6 = v6::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v7 = Vec::new();
+
+	for (session, v6) in pending_v6.into_iter() {
+		let v7 = translate(v6);
+		pending_v7.push((session, v7));
+	}
+	v7::PendingConfigs::<T>::set(Some(pending_v7.clone()));
+
+	let num_configs = (pending_v7.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+
+	#[test]
+	fn v6_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		// PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration   2.2. blockhash to query at:
+		// 0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of the
+		// block)   2.3. Note the value of encoded storage key ->
+		// 0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the referenced
+		// block.   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config = hex_literal::hex!["00003000005000005555150000008000fbff0100000200000a000000c80000006400000000000000000000000000500000c800000a0000000000000000c0220fca950300000000000000000000c0220fca9503000000000000000000e8030000009001000a0000000000000000900100008070000000000000000000000a000000050000000500000001000000010500000001c80000000600000058020000020000002800000000000000020000000100000001020000000f000000"];
+
+		let v6 =
+			V6HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v6.max_code_size, 3_145_728);
+		assert_eq!(v6.validation_upgrade_cooldown, 200);
+		assert_eq!(v6.max_pov_size, 5_242_880);
+		assert_eq!(v6.hrmp_channel_max_message_size, 102_400);
+		assert_eq!(v6.n_delay_tranches, 40);
+		assert_eq!(v6.minimum_validation_upgrade_delay, 15);
+		assert_eq!(v6.group_rotation_frequency, 10);
+	}
+
+	#[test]
+	fn test_migrate_to_v7() {
+		// Host configuration has lots of fields. However, in this migration we only remove one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v6 = V6HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			thread_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			chain_availability_period: 33,
+			minimum_validation_upgrade_delay: 20,
+			pvf_checking_enabled: true,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v6.clone()));
+		pending_configs.push((300, v6.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v6 version in the state.
+			v6::ActiveConfig::<Test>::set(Some(v6));
+			v6::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v7::<Test>();
+
+			let v7 = v7::ActiveConfig::<Test>::get().unwrap();
+			let mut configs_to_check = v7::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v7.clone()));
+
+			for (_, v6) in configs_to_check {
+				#[rustfmt::skip]
+				{
+					assert_eq!(v6.max_code_size                            , v7.max_code_size);
+					assert_eq!(v6.max_head_data_size                       , v7.max_head_data_size);
+					assert_eq!(v6.max_upward_queue_count                   , v7.max_upward_queue_count);
+					assert_eq!(v6.max_upward_queue_size                    , v7.max_upward_queue_size);
+					assert_eq!(v6.max_upward_message_size                  , v7.max_upward_message_size);
+					assert_eq!(v6.max_upward_message_num_per_candidate     , v7.max_upward_message_num_per_candidate);
+					assert_eq!(v6.hrmp_max_message_num_per_candidate       , v7.hrmp_max_message_num_per_candidate);
+					assert_eq!(v6.validation_upgrade_cooldown              , v7.validation_upgrade_cooldown);
+					assert_eq!(v6.validation_upgrade_delay                 , v7.validation_upgrade_delay);
+					assert_eq!(v6.max_pov_size                             , v7.max_pov_size);
+					assert_eq!(v6.max_downward_message_size                , v7.max_downward_message_size);
+					assert_eq!(v6.hrmp_max_teyrchain_outbound_channels     , v7.hrmp_max_teyrchain_outbound_channels);
+					assert_eq!(v6.hrmp_max_parathread_outbound_channels    , v7.hrmp_max_parathread_outbound_channels);
+					assert_eq!(v6.hrmp_sender_deposit                      , v7.hrmp_sender_deposit);
+					assert_eq!(v6.hrmp_recipient_deposit                   , v7.hrmp_recipient_deposit);
+					assert_eq!(v6.hrmp_channel_max_capacity                , v7.hrmp_channel_max_capacity);
+					assert_eq!(v6.hrmp_channel_max_total_size              , v7.hrmp_channel_max_total_size);
+					assert_eq!(v6.hrmp_max_teyrchain_inbound_channels      , v7.hrmp_max_teyrchain_inbound_channels);
+					assert_eq!(v6.hrmp_max_parathread_inbound_channels     , v7.hrmp_max_parathread_inbound_channels);
+					assert_eq!(v6.hrmp_channel_max_message_size            , v7.hrmp_channel_max_message_size);
+					assert_eq!(v6.code_retention_period                    , v7.code_retention_period);
+					assert_eq!(v6.parathread_cores                         , v7.parathread_cores);
+					assert_eq!(v6.parathread_retries                       , v7.parathread_retries);
+					assert_eq!(v6.group_rotation_frequency                 , v7.group_rotation_frequency);
+					assert_eq!(v6.chain_availability_period                , v7.chain_availability_period);
+					assert_eq!(v6.thread_availability_period               , v7.thread_availability_period);
+					assert_eq!(v6.scheduling_lookahead                     , v7.scheduling_lookahead);
+					assert_eq!(v6.max_validators_per_core                  , v7.max_validators_per_core);
+					assert_eq!(v6.max_validators                           , v7.max_validators);
+					assert_eq!(v6.dispute_period                           , v7.dispute_period);
+					assert_eq!(v6.no_show_slots                            , v7.no_show_slots);
+					assert_eq!(v6.n_delay_tranches                         , v7.n_delay_tranches);
+					assert_eq!(v6.zeroth_delay_tranche_width               , v7.zeroth_delay_tranche_width);
+					assert_eq!(v6.needed_approvals                         , v7.needed_approvals);
+					assert_eq!(v6.relay_vrf_modulo_samples                 , v7.relay_vrf_modulo_samples);
+					assert_eq!(v6.pvf_voting_ttl                           , v7.pvf_voting_ttl);
+					assert_eq!(v6.minimum_validation_upgrade_delay         , v7.minimum_validation_upgrade_delay);
+					assert_eq!(v6.async_backing_params.allowed_ancestry_len, v7.async_backing_params.allowed_ancestry_len);
+					assert_eq!(v6.async_backing_params.max_candidate_depth , v7.async_backing_params.max_candidate_depth);
+					assert_eq!(v6.executor_params						   , v7.executor_params);
+				}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v7_no_pending() {
+		let v6 = V6HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v6 version in the state.
+			v6::ActiveConfig::<Test>::set(Some(v6));
+			// Ensure there're no pending configs.
+			v6::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v7::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v8.rs

@@ -0,0 +1,419 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Defensive, StorageVersion},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::{
+	AsyncBackingParams, Balance, ExecutorParams, SessionIndex, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+};
+use sp_runtime::Perbill;
+
+use frame_support::traits::OnRuntimeUpgrade;
+
+use super::v7::V7HostConfiguration;
+/// All configuration of the runtime with respect to paras.
+#[derive(Clone, Encode, Decode, Debug)]
+pub struct V8HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	pub code_retention_period: BlockNumber,
+	pub on_demand_cores: u32,
+	pub on_demand_retries: u32,
+	pub on_demand_queue_max_size: u32,
+	pub on_demand_target_queue_utilization: Perbill,
+	pub on_demand_fee_variability: Perbill,
+	pub on_demand_base_fee: Balance,
+	pub on_demand_ttl: BlockNumber,
+	pub group_rotation_frequency: BlockNumber,
+	pub paras_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 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 pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V8HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			paras_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			on_demand_cores: Default::default(),
+			on_demand_retries: Default::default(),
+			scheduling_lookahead: 1,
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+			on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+			on_demand_base_fee: 10_000_000u128,
+			on_demand_fee_variability: Perbill::from_percent(3),
+			on_demand_target_queue_utilization: Perbill::from_percent(25),
+			on_demand_ttl: 5u32.into(),
+		}
+	}
+}
+
+mod v7 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V7HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V7HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v8 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V8HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V8HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub struct MigrateToV8<T>(core::marker::PhantomData<T>);
+impl<T: Config> OnRuntimeUpgrade for MigrateToV8<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV8");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV8 started");
+		if StorageVersion::get::<Pallet<T>>() == 7 {
+			let weight_consumed = migrate_to_v8::<T>();
+
+			log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV8 executed successfully");
+			StorageVersion::new(8).put::<Pallet<T>>();
+
+			weight_consumed
+		} else {
+			log::warn!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV8 should be removed.");
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV8");
+		ensure!(
+			StorageVersion::get::<Pallet<T>>() >= 8,
+			"Storage version should be >= 8 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+fn migrate_to_v8<T: Config>() -> Weight {
+	// Unusual formatting is justified:
+	// - make it easier to verify that fields assign what they supposed to assign.
+	// - this code is transient and will be removed after all migrations are done.
+	// - this code is important enough to optimize for legibility sacrificing consistency.
+	#[rustfmt::skip]
+	let translate =
+		|pre: V7HostConfiguration<BlockNumberFor<T>>| ->
+		V8HostConfiguration<BlockNumberFor<T>>
+	{
+		V8HostConfiguration {
+max_code_size                            : pre.max_code_size,
+max_head_data_size                       : pre.max_head_data_size,
+max_upward_queue_count                   : pre.max_upward_queue_count,
+max_upward_queue_size                    : pre.max_upward_queue_size,
+max_upward_message_size                  : pre.max_upward_message_size,
+max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+validation_upgrade_delay                 : pre.validation_upgrade_delay,
+max_pov_size                             : pre.max_pov_size,
+max_downward_message_size                : pre.max_downward_message_size,
+hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+code_retention_period                    : pre.code_retention_period,
+on_demand_cores                          : pre.parathread_cores,
+on_demand_retries                        : pre.parathread_retries,
+group_rotation_frequency                 : pre.group_rotation_frequency,
+paras_availability_period                : pre.chain_availability_period,
+scheduling_lookahead                     : pre.scheduling_lookahead,
+max_validators_per_core                  : pre.max_validators_per_core,
+max_validators                           : pre.max_validators,
+dispute_period                           : pre.dispute_period,
+dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+no_show_slots                            : pre.no_show_slots,
+n_delay_tranches                         : pre.n_delay_tranches,
+zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+needed_approvals                         : pre.needed_approvals,
+relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+pvf_voting_ttl                           : pre.pvf_voting_ttl,
+minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+async_backing_params                     : pre.async_backing_params,
+executor_params                          : pre.executor_params,
+on_demand_queue_max_size                 : 10_000u32,
+on_demand_base_fee                       : 10_000_000u128,
+on_demand_fee_variability                : Perbill::from_percent(3),
+on_demand_target_queue_utilization       : Perbill::from_percent(25),
+on_demand_ttl                            : 5u32.into(),
+		}
+};
+
+	let v7 = v7::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v8 = translate(v7);
+	v8::ActiveConfig::<T>::set(Some(v8));
+
+	// Allowed to be empty.
+	let pending_v7 = v7::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v8 = Vec::new();
+
+	for (session, v7) in pending_v7.into_iter() {
+		let v8 = translate(v7);
+		pending_v8.push((session, v8));
+	}
+	v8::PendingConfigs::<T>::set(Some(pending_v8.clone()));
+
+	let num_configs = (pending_v8.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+
+	#[test]
+	fn v8_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		// referenced        block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex!["
+	0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000000000000000001027000080b2e60e80c3c9018096980000000000000000000000000005000000140000000400000001000000010100000000060000006400000002000000190000000000000002000000020000000200000005000000"
+	];
+
+		let v8 =
+			V8HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v8.max_code_size, 3_145_728);
+		assert_eq!(v8.validation_upgrade_cooldown, 2);
+		assert_eq!(v8.max_pov_size, 5_242_880);
+		assert_eq!(v8.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v8.n_delay_tranches, 25);
+		assert_eq!(v8.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v8.group_rotation_frequency, 20);
+		assert_eq!(v8.on_demand_cores, 0);
+		assert_eq!(v8.on_demand_base_fee, 10_000_000);
+	}
+
+	#[test]
+	fn test_migrate_to_v8() {
+		// Host configuration has lots of fields. However, in this migration we only remove one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v7 = V7HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			thread_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			chain_availability_period: 33,
+			minimum_validation_upgrade_delay: 20,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v7.clone()));
+		pending_configs.push((300, v7.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v6 version in the state.
+			v7::ActiveConfig::<Test>::set(Some(v7));
+			v7::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v8::<Test>();
+
+			let v8 = v8::ActiveConfig::<Test>::get().unwrap();
+			let mut configs_to_check = v8::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v8.clone()));
+
+			for (_, v7) in configs_to_check {
+				#[rustfmt::skip]
+				{
+					assert_eq!(v7.max_code_size                            , v8.max_code_size);
+					assert_eq!(v7.max_head_data_size                       , v8.max_head_data_size);
+					assert_eq!(v7.max_upward_queue_count                   , v8.max_upward_queue_count);
+					assert_eq!(v7.max_upward_queue_size                    , v8.max_upward_queue_size);
+					assert_eq!(v7.max_upward_message_size                  , v8.max_upward_message_size);
+					assert_eq!(v7.max_upward_message_num_per_candidate     , v8.max_upward_message_num_per_candidate);
+					assert_eq!(v7.hrmp_max_message_num_per_candidate       , v8.hrmp_max_message_num_per_candidate);
+					assert_eq!(v7.validation_upgrade_cooldown              , v8.validation_upgrade_cooldown);
+					assert_eq!(v7.validation_upgrade_delay                 , v8.validation_upgrade_delay);
+					assert_eq!(v7.max_pov_size                             , v8.max_pov_size);
+					assert_eq!(v7.max_downward_message_size                , v8.max_downward_message_size);
+					assert_eq!(v7.hrmp_max_teyrchain_outbound_channels     , v8.hrmp_max_teyrchain_outbound_channels);
+					assert_eq!(v7.hrmp_sender_deposit                      , v8.hrmp_sender_deposit);
+					assert_eq!(v7.hrmp_recipient_deposit                   , v8.hrmp_recipient_deposit);
+					assert_eq!(v7.hrmp_channel_max_capacity                , v8.hrmp_channel_max_capacity);
+					assert_eq!(v7.hrmp_channel_max_total_size              , v8.hrmp_channel_max_total_size);
+					assert_eq!(v7.hrmp_max_teyrchain_inbound_channels      , v8.hrmp_max_teyrchain_inbound_channels);
+					assert_eq!(v7.hrmp_channel_max_message_size            , v8.hrmp_channel_max_message_size);
+					assert_eq!(v7.code_retention_period                    , v8.code_retention_period);
+					assert_eq!(v7.on_demand_cores                          , v8.on_demand_cores);
+					assert_eq!(v7.on_demand_retries                        , v8.on_demand_retries);
+					assert_eq!(v7.group_rotation_frequency                 , v8.group_rotation_frequency);
+					assert_eq!(v7.paras_availability_period                , v8.paras_availability_period);
+					assert_eq!(v7.scheduling_lookahead                     , v8.scheduling_lookahead);
+					assert_eq!(v7.max_validators_per_core                  , v8.max_validators_per_core);
+					assert_eq!(v7.max_validators                           , v8.max_validators);
+					assert_eq!(v7.dispute_period                           , v8.dispute_period);
+					assert_eq!(v7.no_show_slots                            , v8.no_show_slots);
+					assert_eq!(v7.n_delay_tranches                         , v8.n_delay_tranches);
+					assert_eq!(v7.zeroth_delay_tranche_width               , v8.zeroth_delay_tranche_width);
+					assert_eq!(v7.needed_approvals                         , v8.needed_approvals);
+					assert_eq!(v7.relay_vrf_modulo_samples                 , v8.relay_vrf_modulo_samples);
+					assert_eq!(v7.pvf_voting_ttl                           , v8.pvf_voting_ttl);
+					assert_eq!(v7.minimum_validation_upgrade_delay         , v8.minimum_validation_upgrade_delay);
+					assert_eq!(v7.async_backing_params.allowed_ancestry_len, v8.async_backing_params.allowed_ancestry_len);
+					assert_eq!(v7.async_backing_params.max_candidate_depth , v8.async_backing_params.max_candidate_depth);
+					assert_eq!(v7.executor_params						   , v8.executor_params);
+				}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v8_no_pending() {
+		let v7 = V7HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v6 version in the state.
+			v7::ActiveConfig::<Test>::set(Some(v7));
+			// Ensure there're no pending configs.
+			v7::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v8::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/migration/v9.rs

@@ -0,0 +1,424 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A module that is responsible for migration of storage.
+
+use crate::configuration::{self, Config, Pallet};
+use alloc::vec::Vec;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Defensive, StorageVersion},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use pezkuwi_primitives::{
+	AsyncBackingParams, Balance, ExecutorParams, SessionIndex, LEGACY_MIN_BACKING_VOTES,
+	ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+};
+use sp_runtime::Perbill;
+
+use frame_support::traits::OnRuntimeUpgrade;
+
+use super::v8::V8HostConfiguration;
+/// All configuration of the runtime with respect to paras.
+#[derive(Clone, Encode, Decode, Debug)]
+pub struct V9HostConfiguration<BlockNumber> {
+	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_cooldown: BlockNumber,
+	pub validation_upgrade_delay: BlockNumber,
+	pub async_backing_params: AsyncBackingParams,
+	pub max_pov_size: u32,
+	pub max_downward_message_size: u32,
+	pub hrmp_max_teyrchain_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_teyrchain_inbound_channels: u32,
+	pub hrmp_channel_max_message_size: u32,
+	pub executor_params: ExecutorParams,
+	pub code_retention_period: BlockNumber,
+	pub on_demand_cores: u32,
+	pub on_demand_retries: u32,
+	pub on_demand_queue_max_size: u32,
+	pub on_demand_target_queue_utilization: Perbill,
+	pub on_demand_fee_variability: Perbill,
+	pub on_demand_base_fee: Balance,
+	pub on_demand_ttl: BlockNumber,
+	pub group_rotation_frequency: BlockNumber,
+	pub paras_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 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 pvf_voting_ttl: SessionIndex,
+	pub minimum_validation_upgrade_delay: BlockNumber,
+	pub minimum_backing_votes: u32,
+}
+
+impl<BlockNumber: Default + From<u32>> Default for V9HostConfiguration<BlockNumber> {
+	fn default() -> Self {
+		Self {
+			async_backing_params: AsyncBackingParams {
+				max_candidate_depth: 0,
+				allowed_ancestry_len: 0,
+			},
+			group_rotation_frequency: 1u32.into(),
+			paras_availability_period: 1u32.into(),
+			no_show_slots: 1u32.into(),
+			validation_upgrade_cooldown: Default::default(),
+			validation_upgrade_delay: 2u32.into(),
+			code_retention_period: Default::default(),
+			max_code_size: Default::default(),
+			max_pov_size: Default::default(),
+			max_head_data_size: Default::default(),
+			on_demand_cores: Default::default(),
+			on_demand_retries: Default::default(),
+			scheduling_lookahead: 1,
+			max_validators_per_core: Default::default(),
+			max_validators: None,
+			dispute_period: 6,
+			dispute_post_conclusion_acceptance_period: 100.into(),
+			n_delay_tranches: Default::default(),
+			zeroth_delay_tranche_width: Default::default(),
+			needed_approvals: Default::default(),
+			relay_vrf_modulo_samples: Default::default(),
+			max_upward_queue_count: Default::default(),
+			max_upward_queue_size: Default::default(),
+			max_downward_message_size: Default::default(),
+			max_upward_message_size: Default::default(),
+			max_upward_message_num_per_candidate: Default::default(),
+			hrmp_sender_deposit: Default::default(),
+			hrmp_recipient_deposit: Default::default(),
+			hrmp_channel_max_capacity: Default::default(),
+			hrmp_channel_max_total_size: Default::default(),
+			hrmp_max_teyrchain_inbound_channels: Default::default(),
+			hrmp_channel_max_message_size: Default::default(),
+			hrmp_max_teyrchain_outbound_channels: Default::default(),
+			hrmp_max_message_num_per_candidate: Default::default(),
+			pvf_voting_ttl: 2u32.into(),
+			minimum_validation_upgrade_delay: 2.into(),
+			executor_params: Default::default(),
+			on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
+			on_demand_base_fee: 10_000_000u128,
+			on_demand_fee_variability: Perbill::from_percent(3),
+			on_demand_target_queue_utilization: Perbill::from_percent(25),
+			on_demand_ttl: 5u32.into(),
+			minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
+		}
+	}
+}
+
+mod v8 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V8HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V8HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+mod v9 {
+	use super::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type ActiveConfig<T: Config> =
+		StorageValue<Pallet<T>, V9HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type PendingConfigs<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(SessionIndex, V9HostConfiguration<BlockNumberFor<T>>)>,
+		OptionQuery,
+	>;
+}
+
+pub struct MigrateToV9<T>(core::marker::PhantomData<T>);
+impl<T: Config> OnRuntimeUpgrade for MigrateToV9<T> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV9");
+		Ok(Vec::new())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV9 started");
+		if StorageVersion::get::<Pallet<T>>() == 8 {
+			let weight_consumed = migrate_to_v9::<T>();
+
+			log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV9 executed successfully");
+			StorageVersion::new(9).put::<Pallet<T>>();
+
+			weight_consumed
+		} else {
+			log::warn!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV9 should be removed.");
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV9");
+		ensure!(
+			StorageVersion::get::<Pallet<T>>() >= 9,
+			"Storage version should be >= 9 after the migration"
+		);
+
+		Ok(())
+	}
+}
+
+fn migrate_to_v9<T: Config>() -> Weight {
+	// Unusual formatting is justified:
+	// - make it easier to verify that fields assign what they supposed to assign.
+	// - this code is transient and will be removed after all migrations are done.
+	// - this code is important enough to optimize for legibility sacrificing consistency.
+	#[rustfmt::skip]
+	let translate =
+		|pre: V8HostConfiguration<BlockNumberFor<T>>| ->
+		V9HostConfiguration<BlockNumberFor<T>>
+	{
+		V9HostConfiguration {
+max_code_size                            : pre.max_code_size,
+max_head_data_size                       : pre.max_head_data_size,
+max_upward_queue_count                   : pre.max_upward_queue_count,
+max_upward_queue_size                    : pre.max_upward_queue_size,
+max_upward_message_size                  : pre.max_upward_message_size,
+max_upward_message_num_per_candidate     : pre.max_upward_message_num_per_candidate,
+hrmp_max_message_num_per_candidate       : pre.hrmp_max_message_num_per_candidate,
+validation_upgrade_cooldown              : pre.validation_upgrade_cooldown,
+validation_upgrade_delay                 : pre.validation_upgrade_delay,
+max_pov_size                             : pre.max_pov_size,
+max_downward_message_size                : pre.max_downward_message_size,
+hrmp_sender_deposit                      : pre.hrmp_sender_deposit,
+hrmp_recipient_deposit                   : pre.hrmp_recipient_deposit,
+hrmp_channel_max_capacity                : pre.hrmp_channel_max_capacity,
+hrmp_channel_max_total_size              : pre.hrmp_channel_max_total_size,
+hrmp_max_teyrchain_inbound_channels      : pre.hrmp_max_teyrchain_inbound_channels,
+hrmp_max_teyrchain_outbound_channels     : pre.hrmp_max_teyrchain_outbound_channels,
+hrmp_channel_max_message_size            : pre.hrmp_channel_max_message_size,
+code_retention_period                    : pre.code_retention_period,
+on_demand_cores                          : pre.on_demand_cores,
+on_demand_retries                        : pre.on_demand_retries,
+group_rotation_frequency                 : pre.group_rotation_frequency,
+paras_availability_period                : pre.paras_availability_period,
+scheduling_lookahead                     : pre.scheduling_lookahead,
+max_validators_per_core                  : pre.max_validators_per_core,
+max_validators                           : pre.max_validators,
+dispute_period                           : pre.dispute_period,
+dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
+no_show_slots                            : pre.no_show_slots,
+n_delay_tranches                         : pre.n_delay_tranches,
+zeroth_delay_tranche_width               : pre.zeroth_delay_tranche_width,
+needed_approvals                         : pre.needed_approvals,
+relay_vrf_modulo_samples                 : pre.relay_vrf_modulo_samples,
+pvf_voting_ttl                           : pre.pvf_voting_ttl,
+minimum_validation_upgrade_delay         : pre.minimum_validation_upgrade_delay,
+async_backing_params                     : pre.async_backing_params,
+executor_params                          : pre.executor_params,
+on_demand_queue_max_size                 : pre.on_demand_queue_max_size,
+on_demand_base_fee                       : pre.on_demand_base_fee,
+on_demand_fee_variability                : pre.on_demand_fee_variability,
+on_demand_target_queue_utilization       : pre.on_demand_target_queue_utilization,
+on_demand_ttl                            : pre.on_demand_ttl,
+minimum_backing_votes                    : LEGACY_MIN_BACKING_VOTES
+		}
+	};
+
+	let v8 = v8::ActiveConfig::<T>::get()
+		.defensive_proof("Could not decode old config")
+		.unwrap_or_default();
+	let v9 = translate(v8);
+	v9::ActiveConfig::<T>::set(Some(v9));
+
+	// Allowed to be empty.
+	let pending_v8 = v8::PendingConfigs::<T>::get().unwrap_or_default();
+	let mut pending_v9 = Vec::new();
+
+	for (session, v8) in pending_v8.into_iter() {
+		let v9 = translate(v8);
+		pending_v9.push((session, v9));
+	}
+	v9::PendingConfigs::<T>::set(Some(pending_v9.clone()));
+
+	let num_configs = (pending_v9.len() + 1) as u64;
+	T::DbWeight::get().reads_writes(num_configs, num_configs)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test};
+
+	#[test]
+	fn v9_deserialized_from_actual_data() {
+		// Example how to get new `raw_config`:
+		// We'll obtain the raw_config at a specified a block
+		// Steps:
+		// 1. Go to Pezkuwi.js -> Developer -> Chain state -> Storage: https://pezkuwichain.io/#/chainstate
+		// 2. Set these parameters:
+		//   2.1. selected state query: configuration; activeConfig():
+		//        PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration
+		//   2.2. blockhash to query at:
+		//        0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
+		//        the block)
+		//   2.3. Note the value of encoded storage key ->
+		//        0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
+		// referenced        block.
+		//   2.4. You'll also need the decoded values to update the test.
+		// 3. Go to Pezkuwi.js -> Developer -> Chain state -> Raw storage
+		//   3.1 Enter the encoded storage key and you get the raw config.
+
+		// This exceeds the maximal line width length, but that's fine, since this is not code and
+		// doesn't need to be read and also leaving it as one line allows to easily copy it.
+		let raw_config =
+	hex_literal::hex!["
+	0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000000000000000001027000080b2e60e80c3c901809698000000000000000000000000000500000014000000040000000100000001010000000006000000640000000200000019000000000000000300000002000000020000000500000002000000"
+	];
+
+		let v9 =
+			V9HostConfiguration::<pezkuwi_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
+
+		// We check only a sample of the values here. If we missed any fields or messed up data
+		// types that would skew all the fields coming after.
+		assert_eq!(v9.max_code_size, 3_145_728);
+		assert_eq!(v9.validation_upgrade_cooldown, 2);
+		assert_eq!(v9.max_pov_size, 5_242_880);
+		assert_eq!(v9.hrmp_channel_max_message_size, 1_048_576);
+		assert_eq!(v9.n_delay_tranches, 25);
+		assert_eq!(v9.minimum_validation_upgrade_delay, 5);
+		assert_eq!(v9.group_rotation_frequency, 20);
+		assert_eq!(v9.on_demand_cores, 0);
+		assert_eq!(v9.on_demand_base_fee, 10_000_000);
+		assert_eq!(v9.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
+	}
+
+	#[test]
+	fn test_migrate_to_v9() {
+		// Host configuration has lots of fields. However, in this migration we only add one
+		// field. The most important part to check are a couple of the last fields. We also pick
+		// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
+		// also their type.
+		//
+		// We specify only the picked fields and the rest should be provided by the `Default`
+		// implementation. That implementation is copied over between the two types and should work
+		// fine.
+		let v8 = V8HostConfiguration::<pezkuwi_primitives::BlockNumber> {
+			needed_approvals: 69,
+			paras_availability_period: 55,
+			hrmp_recipient_deposit: 1337,
+			max_pov_size: 1111,
+			minimum_validation_upgrade_delay: 20,
+			..Default::default()
+		};
+
+		let mut pending_configs = Vec::new();
+		pending_configs.push((100, v8.clone()));
+		pending_configs.push((300, v8.clone()));
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v8 version in the state.
+			v8::ActiveConfig::<Test>::set(Some(v8));
+			v8::PendingConfigs::<Test>::set(Some(pending_configs));
+
+			migrate_to_v9::<Test>();
+
+			let v9 = v9::ActiveConfig::<Test>::get().unwrap();
+			let mut configs_to_check = v9::PendingConfigs::<Test>::get().unwrap();
+			configs_to_check.push((0, v9.clone()));
+
+			for (_, v8) in configs_to_check {
+				#[rustfmt::skip]
+				{
+					assert_eq!(v8.max_code_size                            , v9.max_code_size);
+					assert_eq!(v8.max_head_data_size                       , v9.max_head_data_size);
+					assert_eq!(v8.max_upward_queue_count                   , v9.max_upward_queue_count);
+					assert_eq!(v8.max_upward_queue_size                    , v9.max_upward_queue_size);
+					assert_eq!(v8.max_upward_message_size                  , v9.max_upward_message_size);
+					assert_eq!(v8.max_upward_message_num_per_candidate     , v9.max_upward_message_num_per_candidate);
+					assert_eq!(v8.hrmp_max_message_num_per_candidate       , v9.hrmp_max_message_num_per_candidate);
+					assert_eq!(v8.validation_upgrade_cooldown              , v9.validation_upgrade_cooldown);
+					assert_eq!(v8.validation_upgrade_delay                 , v9.validation_upgrade_delay);
+					assert_eq!(v8.max_pov_size                             , v9.max_pov_size);
+					assert_eq!(v8.max_downward_message_size                , v9.max_downward_message_size);
+					assert_eq!(v8.hrmp_max_teyrchain_outbound_channels     , v9.hrmp_max_teyrchain_outbound_channels);
+					assert_eq!(v8.hrmp_sender_deposit                      , v9.hrmp_sender_deposit);
+					assert_eq!(v8.hrmp_recipient_deposit                   , v9.hrmp_recipient_deposit);
+					assert_eq!(v8.hrmp_channel_max_capacity                , v9.hrmp_channel_max_capacity);
+					assert_eq!(v8.hrmp_channel_max_total_size              , v9.hrmp_channel_max_total_size);
+					assert_eq!(v8.hrmp_max_teyrchain_inbound_channels      , v9.hrmp_max_teyrchain_inbound_channels);
+					assert_eq!(v8.hrmp_channel_max_message_size            , v9.hrmp_channel_max_message_size);
+					assert_eq!(v8.code_retention_period                    , v9.code_retention_period);
+					assert_eq!(v8.on_demand_cores                          , v9.on_demand_cores);
+					assert_eq!(v8.on_demand_retries                        , v9.on_demand_retries);
+					assert_eq!(v8.group_rotation_frequency                 , v9.group_rotation_frequency);
+					assert_eq!(v8.paras_availability_period                , v9.paras_availability_period);
+					assert_eq!(v8.scheduling_lookahead                     , v9.scheduling_lookahead);
+					assert_eq!(v8.max_validators_per_core                  , v9.max_validators_per_core);
+					assert_eq!(v8.max_validators                           , v9.max_validators);
+					assert_eq!(v8.dispute_period                           , v9.dispute_period);
+					assert_eq!(v8.no_show_slots                            , v9.no_show_slots);
+					assert_eq!(v8.n_delay_tranches                         , v9.n_delay_tranches);
+					assert_eq!(v8.zeroth_delay_tranche_width               , v9.zeroth_delay_tranche_width);
+					assert_eq!(v8.needed_approvals                         , v9.needed_approvals);
+					assert_eq!(v8.relay_vrf_modulo_samples                 , v9.relay_vrf_modulo_samples);
+					assert_eq!(v8.pvf_voting_ttl                           , v9.pvf_voting_ttl);
+					assert_eq!(v8.minimum_validation_upgrade_delay         , v9.minimum_validation_upgrade_delay);
+					assert_eq!(v8.async_backing_params.allowed_ancestry_len, v9.async_backing_params.allowed_ancestry_len);
+					assert_eq!(v8.async_backing_params.max_candidate_depth , v9.async_backing_params.max_candidate_depth);
+					assert_eq!(v8.executor_params						   , v9.executor_params);
+				    assert_eq!(v8.minimum_backing_votes					   , v9.minimum_backing_votes);
+				}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
+			}
+		});
+	}
+
+	// Test that migration doesn't panic in case there're no pending configurations upgrades in
+	// pallet's storage.
+	#[test]
+	fn test_migrate_to_v9_no_pending() {
+		let v8 = V8HostConfiguration::<pezkuwi_primitives::BlockNumber>::default();
+
+		new_test_ext(Default::default()).execute_with(|| {
+			// Implant the v8 version in the state.
+			v8::ActiveConfig::<Test>::set(Some(v8));
+			// Ensure there're no pending configs.
+			v8::PendingConfigs::<Test>::set(None);
+
+			// Shouldn't fail.
+			migrate_to_v9::<Test>();
+		});
+	}
+}

pezkuwi/runtime/teyrchains/src/configuration/tests.rs

@@ -0,0 +1,586 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezkuwi.
+
+// Pezkuwi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Pezkuwi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
+
+use super::*;
+use crate::{
+	configuration,
+	mock::{new_test_ext, Configuration, MockGenesisConfig, ParasShared, RuntimeOrigin, Test},
+};
+use bitvec::{bitvec, prelude::Lsb0};
+use frame_support::{assert_err, assert_ok};
+
+fn on_new_session(session_index: SessionIndex) -> (HostConfiguration<u32>, HostConfiguration<u32>) {
+	ParasShared::set_session_index(session_index);
+	let SessionChangeOutcome { prev_config, new_config } =
+		Configuration::initializer_on_new_session(&session_index);
+	let new_config = new_config.unwrap_or_else(|| prev_config.clone());
+	(prev_config, new_config)
+}
+
+#[test]
+fn default_is_consistent() {
+	new_test_ext(Default::default()).execute_with(|| {
+		configuration::ActiveConfig::<Test>::get().panic_if_not_consistent();
+	});
+}
+
+#[test]
+fn scheduled_session_is_two_sessions_from_now() {
+	new_test_ext(Default::default()).execute_with(|| {
+		// The logic here is really tested only with scheduled_session = 2. It should work
+		// with other values, but that should receive a more rigorous testing.
+		on_new_session(1);
+		assert_eq!(Configuration::scheduled_session(), 3);
+	});
+}
+
+#[test]
+fn initializer_on_new_session() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let (prev_config, new_config) = on_new_session(1);
+		assert_eq!(prev_config, new_config);
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+
+		let (prev_config, new_config) = on_new_session(2);
+		assert_eq!(prev_config, new_config);
+
+		let (prev_config, new_config) = on_new_session(3);
+		assert_eq!(prev_config, HostConfiguration::default());
+		assert_eq!(new_config, HostConfiguration { validation_upgrade_delay: 100, ..prev_config });
+	});
+}
+
+#[test]
+fn config_changes_after_2_session_boundary() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let old_config = configuration::ActiveConfig::<Test>::get();
+		let mut config = old_config.clone();
+		config.validation_upgrade_delay = 100;
+		assert!(old_config != config);
+
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+
+		// Verify that the current configuration has not changed and that there is a scheduled
+		// change for the SESSION_DELAY sessions in advance.
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), old_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, config.clone())]);
+
+		on_new_session(1);
+
+		// One session has passed, we should be still waiting for the pending configuration.
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), old_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, config.clone())]);
+
+		on_new_session(2);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![]);
+	})
+}
+
+#[test]
+fn consecutive_changes_within_one_session() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let old_config = configuration::ActiveConfig::<Test>::get();
+		let mut config = old_config.clone();
+		config.validation_upgrade_delay = 100;
+		config.validation_upgrade_cooldown = 100;
+		assert!(old_config != config);
+
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 100));
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), old_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, config.clone())]);
+
+		on_new_session(1);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), old_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, config.clone())]);
+
+		on_new_session(2);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![]);
+	});
+}
+
+#[test]
+fn pending_next_session_but_we_upgrade_once_more() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let initial_config = configuration::ActiveConfig::<Test>::get();
+		let intermediate_config =
+			HostConfiguration { validation_upgrade_delay: 100, ..initial_config.clone() };
+		let final_config = HostConfiguration {
+			validation_upgrade_delay: 100,
+			validation_upgrade_cooldown: 99,
+			..initial_config.clone()
+		};
+
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), initial_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, intermediate_config.clone())]);
+
+		on_new_session(1);
+
+		// We are still waiting until the pending configuration is applied and we add another
+		// update.
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
+
+		// This should result in yet another configuration change scheduled.
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), initial_config);
+		assert_eq!(
+			PendingConfigs::<Test>::get(),
+			vec![(2, intermediate_config.clone()), (3, final_config.clone())]
+		);
+
+		on_new_session(2);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), intermediate_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(3, final_config.clone())]);
+
+		on_new_session(3);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), final_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![]);
+	});
+}
+
+#[test]
+fn scheduled_session_config_update_while_next_session_pending() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let initial_config = configuration::ActiveConfig::<Test>::get();
+		let intermediate_config =
+			HostConfiguration { validation_upgrade_delay: 100, ..initial_config.clone() };
+		let final_config = HostConfiguration {
+			validation_upgrade_delay: 100,
+			validation_upgrade_cooldown: 99,
+			code_retention_period: 98,
+			..initial_config.clone()
+		};
+
+		assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), initial_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(2, intermediate_config.clone())]);
+
+		on_new_session(1);
+
+		// The second call should fall into the case where we already have a pending config
+		// update for the scheduled_session, but we want to update it once more.
+		assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
+		assert_ok!(Configuration::set_code_retention_period(RuntimeOrigin::root(), 98));
+
+		// This should result in yet another configuration change scheduled.
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), initial_config);
+		assert_eq!(
+			PendingConfigs::<Test>::get(),
+			vec![(2, intermediate_config.clone()), (3, final_config.clone())]
+		);
+
+		on_new_session(2);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), intermediate_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(3, final_config.clone())]);
+
+		on_new_session(3);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get(), final_config);
+		assert_eq!(PendingConfigs::<Test>::get(), vec![]);
+	});
+}
+
+#[test]
+fn invariants() {
+	new_test_ext(Default::default()).execute_with(|| {
+		assert_err!(
+			Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
+			Error::<Test>::InvalidNewValue
+		);
+
+		assert_err!(
+			Configuration::set_max_pov_size(RuntimeOrigin::root(), POV_SIZE_HARD_LIMIT + 1),
+			Error::<Test>::InvalidNewValue
+		);
+
+		assert_err!(
+			Configuration::set_max_head_data_size(RuntimeOrigin::root(), MAX_HEAD_DATA_SIZE + 1),
+			Error::<Test>::InvalidNewValue
+		);
+
+		assert_err!(
+			Configuration::set_paras_availability_period(RuntimeOrigin::root(), 0),
+			Error::<Test>::InvalidNewValue
+		);
+		assert_err!(
+			Configuration::set_no_show_slots(RuntimeOrigin::root(), 0),
+			Error::<Test>::InvalidNewValue
+		);
+
+		ActiveConfig::<Test>::put(HostConfiguration {
+			minimum_validation_upgrade_delay: 11,
+			scheduler_params: SchedulerParams {
+				paras_availability_period: 10,
+				..Default::default()
+			},
+			..Default::default()
+		});
+		assert_err!(
+			Configuration::set_paras_availability_period(RuntimeOrigin::root(), 12),
+			Error::<Test>::InvalidNewValue
+		);
+		assert_err!(
+			Configuration::set_minimum_validation_upgrade_delay(RuntimeOrigin::root(), 9),
+			Error::<Test>::InvalidNewValue
+		);
+
+		assert_err!(
+			Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 0),
+			Error::<Test>::InvalidNewValue
+		);
+	});
+}
+
+#[test]
+fn consistency_bypass_works() {
+	new_test_ext(Default::default()).execute_with(|| {
+		assert_err!(
+			Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
+			Error::<Test>::InvalidNewValue
+		);
+
+		assert_ok!(Configuration::set_bypass_consistency_check(RuntimeOrigin::root(), true));
+		assert_ok!(Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1));
+
+		assert_eq!(
+			configuration::ActiveConfig::<Test>::get().max_code_size,
+			HostConfiguration::<u32>::default().max_code_size
+		);
+
+		on_new_session(1);
+		on_new_session(2);
+
+		assert_eq!(configuration::ActiveConfig::<Test>::get().max_code_size, MAX_CODE_SIZE + 1);
+	});
+}
+
+#[test]
+fn setting_pending_config_members() {
+	new_test_ext(Default::default()).execute_with(|| {
+		let new_config = HostConfiguration {
+			async_backing_params: AsyncBackingParams {
+				allowed_ancestry_len: 0,
+				max_candidate_depth: 0,
+			},
+			validation_upgrade_cooldown: 100,
+			validation_upgrade_delay: 10,
+			code_retention_period: 5,
+			max_code_size: 100_000,
+			max_pov_size: 1024,
+			max_head_data_size: 1_000,
+			max_validators: None,
+			dispute_period: 239,
+			dispute_post_conclusion_acceptance_period: 10,
+			no_show_slots: 240,
+			n_delay_tranches: 241,
+			zeroth_delay_tranche_width: 242,
+			needed_approvals: 242,
+			relay_vrf_modulo_samples: 243,
+			max_upward_queue_count: 1337,
+			max_upward_queue_size: 228,
+			max_downward_message_size: 2048,
+			max_upward_message_size: 448,
+			max_upward_message_num_per_candidate: 5,
+			hrmp_sender_deposit: 22,
+			hrmp_recipient_deposit: 4905,
+			hrmp_channel_max_capacity: 3921,
+			hrmp_channel_max_total_size: 7687,
+			hrmp_max_teyrchain_inbound_channels: 37,
+			hrmp_channel_max_message_size: 8192,
+			hrmp_max_teyrchain_outbound_channels: 10,
+			hrmp_max_message_num_per_candidate: 20,
+			pvf_voting_ttl: 3,
+			minimum_validation_upgrade_delay: 20,
+			executor_params: Default::default(),
+			approval_voting_params: ApprovalVotingParams { max_approval_coalesce_count: 1 },
+			minimum_backing_votes: 5,
+			node_features: bitvec![u8, Lsb0; 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
+			#[allow(deprecated)]
+			scheduler_params: SchedulerParams {
+				group_rotation_frequency: 20,
+				paras_availability_period: 10,
+				max_validators_per_core: None,
+				lookahead: 3,
+				num_cores: 2,
+				max_availability_timeouts: 0,
+				on_demand_queue_max_size: 10_000u32,
+				on_demand_base_fee: 10_000_000u128,
+				on_demand_fee_variability: Perbill::from_percent(3),
+				on_demand_target_queue_utilization: Perbill::from_percent(25),
+				ttl: 5u32,
+			},
+		};
+
+		Configuration::set_validation_upgrade_cooldown(
+			RuntimeOrigin::root(),
+			new_config.validation_upgrade_cooldown,
+		)
+		.unwrap();
+		Configuration::set_validation_upgrade_delay(
+			RuntimeOrigin::root(),
+			new_config.validation_upgrade_delay,
+		)
+		.unwrap();
+		Configuration::set_code_retention_period(
+			RuntimeOrigin::root(),
+			new_config.code_retention_period,
+		)
+		.unwrap();
+		Configuration::set_max_code_size(RuntimeOrigin::root(), new_config.max_code_size).unwrap();
+		Configuration::set_max_pov_size(RuntimeOrigin::root(), new_config.max_pov_size).unwrap();
+		Configuration::set_max_head_data_size(RuntimeOrigin::root(), new_config.max_head_data_size)
+			.unwrap();
+		Configuration::set_coretime_cores(
+			RuntimeOrigin::root(),
+			new_config.scheduler_params.num_cores,
+		)
+		.unwrap();
+		Configuration::set_group_rotation_frequency(
+			RuntimeOrigin::root(),
+			new_config.scheduler_params.group_rotation_frequency,
+		)
+		.unwrap();
+		// This comes out of order to satisfy the validity criteria for the chain and thread
+		// availability periods.
+		Configuration::set_minimum_validation_upgrade_delay(
+			RuntimeOrigin::root(),
+			new_config.minimum_validation_upgrade_delay,
+		)
+		.unwrap();
+		Configuration::set_paras_availability_period(
+			RuntimeOrigin::root(),
+			new_config.scheduler_params.paras_availability_period,
+		)
+		.unwrap();
+		Configuration::set_scheduling_lookahead(
+			RuntimeOrigin::root(),
+			new_config.scheduler_params.lookahead,
+		)
+		.unwrap();
+		Configuration::set_max_validators_per_core(
+			RuntimeOrigin::root(),
+			new_config.scheduler_params.max_validators_per_core,
+		)
+		.unwrap();
+		Configuration::set_max_validators(RuntimeOrigin::root(), new_config.max_validators)
+			.unwrap();
+		Configuration::set_dispute_period(RuntimeOrigin::root(), new_config.dispute_period)
+			.unwrap();
+		Configuration::set_dispute_post_conclusion_acceptance_period(
+			RuntimeOrigin::root(),
+			new_config.dispute_post_conclusion_acceptance_period,
+		)
+		.unwrap();
+		Configuration::set_no_show_slots(RuntimeOrigin::root(), new_config.no_show_slots).unwrap();
+		Configuration::set_n_delay_tranches(RuntimeOrigin::root(), new_config.n_delay_tranches)
+			.unwrap();
+		Configuration::set_zeroth_delay_tranche_width(
+			RuntimeOrigin::root(),
+			new_config.zeroth_delay_tranche_width,
+		)
+		.unwrap();
+		Configuration::set_needed_approvals(RuntimeOrigin::root(), new_config.needed_approvals)
+			.unwrap();
+		Configuration::set_relay_vrf_modulo_samples(
+			RuntimeOrigin::root(),
+			new_config.relay_vrf_modulo_samples,
+		)
+		.unwrap();
+		Configuration::set_max_upward_queue_count(
+			RuntimeOrigin::root(),
+			new_config.max_upward_queue_count,
+		)
+		.unwrap();
+		Configuration::set_max_upward_queue_size(
+			RuntimeOrigin::root(),
+			new_config.max_upward_queue_size,
+		)
+		.unwrap();
+		Configuration::set_max_downward_message_size(
+			RuntimeOrigin::root(),
+			new_config.max_downward_message_size,
+		)
+		.unwrap();
+		Configuration::set_max_upward_message_size(
+			RuntimeOrigin::root(),
+			new_config.max_upward_message_size,
+		)
+		.unwrap();
+		Configuration::set_max_upward_message_num_per_candidate(
+			RuntimeOrigin::root(),
+			new_config.max_upward_message_num_per_candidate,
+		)
+		.unwrap();
+		Configuration::set_hrmp_sender_deposit(
+			RuntimeOrigin::root(),
+			new_config.hrmp_sender_deposit,
+		)
+		.unwrap();
+		Configuration::set_hrmp_recipient_deposit(
+			RuntimeOrigin::root(),
+			new_config.hrmp_recipient_deposit,
+		)
+		.unwrap();
+		Configuration::set_hrmp_channel_max_capacity(
+			RuntimeOrigin::root(),
+			new_config.hrmp_channel_max_capacity,
+		)
+		.unwrap();
+		Configuration::set_hrmp_channel_max_total_size(
+			RuntimeOrigin::root(),
+			new_config.hrmp_channel_max_total_size,
+		)
+		.unwrap();
+		Configuration::set_hrmp_max_teyrchain_inbound_channels(
+			RuntimeOrigin::root(),
+			new_config.hrmp_max_teyrchain_inbound_channels,
+		)
+		.unwrap();
+		Configuration::set_hrmp_channel_max_message_size(
+			RuntimeOrigin::root(),
+			new_config.hrmp_channel_max_message_size,
+		)
+		.unwrap();
+		Configuration::set_hrmp_max_teyrchain_outbound_channels(
+			RuntimeOrigin::root(),
+			new_config.hrmp_max_teyrchain_outbound_channels,
+		)
+		.unwrap();
+		Configuration::set_hrmp_max_message_num_per_candidate(
+			RuntimeOrigin::root(),
+			new_config.hrmp_max_message_num_per_candidate,
+		)
+		.unwrap();
+		Configuration::set_pvf_voting_ttl(RuntimeOrigin::root(), new_config.pvf_voting_ttl)
+			.unwrap();
+		Configuration::set_minimum_backing_votes(
+			RuntimeOrigin::root(),
+			new_config.minimum_backing_votes,
+		)
+		.unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 1, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 1, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 3, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 10, true).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 10, false).unwrap();
+		Configuration::set_node_feature(RuntimeOrigin::root(), 11, true).unwrap();
+
+		assert_eq!(PendingConfigs::<Test>::get(), vec![(shared::SESSION_DELAY, new_config)],);
+	})
+}
+
+#[test]
+fn non_root_cannot_set_config() {
+	new_test_ext(Default::default()).execute_with(|| {
+		assert!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::signed(1), 100).is_err());
+	});
+}
+
+#[test]
+fn verify_externally_accessible() {
+	// This test verifies that the value can be accessed through the well known keys and the
+	// host configuration decodes into the abridged version.
+
+	use pezkuwi_primitives::{well_known_keys, AbridgedHostConfiguration};
+
+	new_test_ext(Default::default()).execute_with(|| {
+		let mut ground_truth = HostConfiguration::default();
+		ground_truth.async_backing_params =
+			AsyncBackingParams { allowed_ancestry_len: 111, max_candidate_depth: 222 };
+
+		// Make sure that the configuration is stored in the storage.
+		ActiveConfig::<Test>::put(ground_truth.clone());
+
+		// Extract the active config via the well known key.
+		let raw_active_config = sp_io::storage::get(well_known_keys::ACTIVE_CONFIG)
+			.expect("config must be present in storage under ACTIVE_CONFIG");
+		let abridged_config = AbridgedHostConfiguration::decode(&mut &raw_active_config[..])
+			.expect("HostConfiguration must be decodable into AbridgedHostConfiguration");
+
+		assert_eq!(
+			abridged_config,
+			AbridgedHostConfiguration {
+				max_code_size: ground_truth.max_code_size,
+				max_head_data_size: ground_truth.max_head_data_size,
+				max_upward_queue_count: ground_truth.max_upward_queue_count,
+				max_upward_queue_size: ground_truth.max_upward_queue_size,
+				max_upward_message_size: ground_truth.max_upward_message_size,
+				max_upward_message_num_per_candidate: ground_truth
+					.max_upward_message_num_per_candidate,
+				hrmp_max_message_num_per_candidate: ground_truth.hrmp_max_message_num_per_candidate,
+				validation_upgrade_cooldown: ground_truth.validation_upgrade_cooldown,
+				validation_upgrade_delay: ground_truth.validation_upgrade_delay,
+				async_backing_params: ground_truth.async_backing_params,
+			},
+		);
+	});
+}
+
+#[test]
+fn active_config_hrmp_channel_size_and_capacity_ratio_works() {
+	frame_support::parameter_types! {
+		pub Ratio100: Percent = Percent::from_percent(100);
+		pub Ratio50: Percent = Percent::from_percent(50);
+	}
+
+	let mut genesis: MockGenesisConfig = Default::default();
+	genesis.configuration.config.hrmp_channel_max_message_size = 1024;
+	genesis.configuration.config.hrmp_channel_max_capacity = 100;
+
+	new_test_ext(genesis).execute_with(|| {
+		let active_config = configuration::ActiveConfig::<Test>::get();
+		assert_eq!(active_config.hrmp_channel_max_message_size, 1024);
+		assert_eq!(active_config.hrmp_channel_max_capacity, 100);
+
+		assert_eq!(
+			ActiveConfigHrmpChannelSizeAndCapacityRatio::<Test, Ratio100>::get(),
+			(1024, 100)
+		);
+		assert_eq!(ActiveConfigHrmpChannelSizeAndCapacityRatio::<Test, Ratio50>::get(), (512, 50));
+
+		// change ActiveConfig
+		assert_ok!(Configuration::set_hrmp_channel_max_message_size(
+			RuntimeOrigin::root(),
+			active_config.hrmp_channel_max_message_size * 4
+		));
+		assert_ok!(Configuration::set_hrmp_channel_max_capacity(
+			RuntimeOrigin::root(),
+			active_config.hrmp_channel_max_capacity * 4
+		));
+		on_new_session(1);
+		on_new_session(2);
+		let active_config = configuration::ActiveConfig::<Test>::get();
+		assert_eq!(active_config.hrmp_channel_max_message_size, 4096);
+		assert_eq!(active_config.hrmp_channel_max_capacity, 400);
+
+		assert_eq!(
+			ActiveConfigHrmpChannelSizeAndCapacityRatio::<Test, Ratio100>::get(),
+			(4096, 400)
+		);
+		assert_eq!(
+			ActiveConfigHrmpChannelSizeAndCapacityRatio::<Test, Ratio50>::get(),
+			(2048, 200)
+		);
+	})
+}