pezkuwichain
1c0e57d984
This commit systematically rebrands various references from Parity Technologies' Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk. Key changes include: - Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks. - Modified internal documentation and code comments to reflect PezkuwiChain naming and structure. - Replaced direct references to with or specific paths within the for XCM, Pezkuwi, and other modules. - Cleaned up deprecated issue and PR references in various and files, particularly in and modules. - Adjusted image and logo URLs in documentation to point to PezkuwiChain assets. - Removed or rephrased comments related to external Polkadot/Substrate PRs and issues. This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.
420 lines
18 KiB
Rust
420 lines
18 KiB
Rust
// 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 pezframe_support::{
|
|
pezpallet_prelude::*,
|
|
traits::{Defensive, StorageVersion},
|
|
weights::Weight,
|
|
};
|
|
use pezframe_system::pezpallet_prelude::BlockNumberFor;
|
|
use pezkuwi_primitives::{
|
|
AsyncBackingParams, Balance, ExecutorParams, SessionIndex, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
|
|
};
|
|
use pezsp_runtime::Perbill;
|
|
|
|
use pezframe_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::*;
|
|
|
|
#[pezframe_support::storage_alias]
|
|
pub(crate) type ActiveConfig<T: Config> =
|
|
StorageValue<Pallet<T>, V7HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
|
|
|
|
#[pezframe_support::storage_alias]
|
|
pub(crate) type PendingConfigs<T: Config> = StorageValue<
|
|
Pallet<T>,
|
|
Vec<(SessionIndex, V7HostConfiguration<BlockNumberFor<T>>)>,
|
|
OptionQuery,
|
|
>;
|
|
}
|
|
|
|
mod v8 {
|
|
use super::*;
|
|
|
|
#[pezframe_support::storage_alias]
|
|
pub(crate) type ActiveConfig<T: Config> =
|
|
StorageValue<Pallet<T>, V8HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
|
|
|
|
#[pezframe_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>, pezsp_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<(), pezsp_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>();
|
|
});
|
|
}
|
|
}
|