feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

2025-12-13 15:44:15 +03:00
commit 286de54384
6841 changed files with 1848356 additions and 0 deletions
@@ -0,0 +1,572 @@
+// 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::Pallet as Configuration,
+	hrmp::{Pallet as Hrmp, *},
+	paras::{Pallet as Paras, ParaKind, TeyrchainsCache},
+	shared::Pallet as Shared,
+};
+use frame_benchmarking::{v2::*, whitelisted_caller};
+use frame_support::{assert_ok, traits::Currency};
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn register_teyrchain_with_balance<T: Config>(id: ParaId, balance: BalanceOf<T>) {
+	let mut teyrchains = TeyrchainsCache::new();
+	Paras::<T>::initialize_para_now(
+		&mut teyrchains,
+		id,
+		&crate::paras::ParaGenesisArgs {
+			para_kind: ParaKind::Teyrchain,
+			genesis_head: vec![1].into(),
+			validation_code: vec![1].into(),
+		},
+	);
+	T::Currency::make_free_balance_be(&id.into_account_truncating(), balance);
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+
+	assert!(events.iter().any(|record| record.event == system_event));
+}
+
+/// Enumerates the phase in the setup process of a channel between two teyrchains.
+enum TeyrchainSetupStep {
+	/// A channel open has been requested
+	Requested,
+	/// A channel open has been requested and accepted.
+	Accepted,
+	/// A channel open has been requested and accepted, and a session has passed and is now open.
+	Established,
+	/// A channel open has been requested and accepted, and a session has passed and is now
+	/// open, and now it has been requested to close down.
+	CloseRequested,
+}
+
+fn establish_para_connection<T: Config>(
+	from: u32,
+	to: u32,
+	until: TeyrchainSetupStep,
+) -> [(ParaId, crate::Origin); 2]
+where
+	<T as frame_system::Config>::RuntimeOrigin: From<crate::Origin>,
+{
+	let config = configuration::ActiveConfig::<T>::get();
+	let ed = T::Currency::minimum_balance();
+	let deposit: BalanceOf<T> = config.hrmp_sender_deposit.unique_saturated_into();
+	let capacity = config.hrmp_channel_max_capacity;
+	let message_size = config.hrmp_channel_max_message_size;
+	assert!(message_size > 0, "Invalid genesis for benchmarking");
+	assert!(capacity > 0, "Invalid genesis for benchmarking");
+
+	let sender: ParaId = from.into();
+	let sender_origin: crate::Origin = from.into();
+
+	let recipient: ParaId = to.into();
+	let recipient_origin: crate::Origin = to.into();
+
+	let output = [(sender, sender_origin.clone()), (recipient, recipient_origin.clone())];
+
+	// Make both a teyrchain if they are already not.
+	if !Paras::<T>::is_teyrchain(sender) {
+		register_teyrchain_with_balance::<T>(sender, deposit + ed);
+	}
+	if !Paras::<T>::is_teyrchain(recipient) {
+		register_teyrchain_with_balance::<T>(recipient, deposit + ed);
+	}
+
+	assert_ok!(Hrmp::<T>::hrmp_init_open_channel(
+		sender_origin.clone().into(),
+		recipient,
+		capacity,
+		message_size
+	));
+
+	if matches!(until, TeyrchainSetupStep::Requested) {
+		return output;
+	}
+
+	assert_ok!(Hrmp::<T>::hrmp_accept_open_channel(recipient_origin.into(), sender));
+	if matches!(until, TeyrchainSetupStep::Accepted) {
+		return output;
+	}
+
+	Hrmp::<T>::process_hrmp_open_channel_requests(&configuration::ActiveConfig::<T>::get());
+	if matches!(until, TeyrchainSetupStep::Established) {
+		return output;
+	}
+
+	let channel_id = HrmpChannelId { sender, recipient };
+	assert_ok!(Hrmp::<T>::hrmp_close_channel(sender_origin.clone().into(), channel_id));
+	if matches!(until, TeyrchainSetupStep::CloseRequested) {
+		// NOTE: this is just for expressiveness, otherwise the if-statement is 100% useless.
+		return output;
+	}
+
+	output
+}
+
+/// Prefix value for account generation. These numbers are used as seeds to create distinct (para)
+/// accounts.
+///
+/// To maintain sensibility created accounts should always be unique and never overlap. For example,
+/// if for some benchmarking component `c`, accounts are being created `for s in 0..c` with seed
+/// `PREFIX_0 + s`, then we must assert that `c <= PREFIX_1`, meaning that it won't overlap with
+/// `PREFIX_2`.
+///
+/// These values are chosen large enough so that the likelihood of any clash is already very low.
+const PREFIX_0: u32 = 10_000;
+const PREFIX_1: u32 = PREFIX_0 * 2;
+const MAX_UNIQUE_CHANNELS: u32 = 128;
+
+// Compile-time assertions for channel bounds
+const _: () = {
+	assert!(MAX_UNIQUE_CHANNELS < PREFIX_0);
+	assert!(HRMP_MAX_INBOUND_CHANNELS_BOUND < PREFIX_0);
+	assert!(HRMP_MAX_OUTBOUND_CHANNELS_BOUND < PREFIX_0);
+};
+
+#[benchmarks(where <T as frame_system::Config>::RuntimeOrigin: From<crate::Origin>)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn hrmp_init_open_channel() {
+		let sender_id: ParaId = 1u32.into();
+		let sender_origin: crate::Origin = 1u32.into();
+
+		let recipient_id: ParaId = 2u32.into();
+
+		// make sure para is registered, and has enough balance.
+		let ed = T::Currency::minimum_balance();
+		let deposit: BalanceOf<T> = configuration::ActiveConfig::<T>::get()
+			.hrmp_sender_deposit
+			.unique_saturated_into();
+		register_teyrchain_with_balance::<T>(sender_id, deposit + ed);
+		register_teyrchain_with_balance::<T>(recipient_id, deposit + ed);
+
+		let capacity = configuration::ActiveConfig::<T>::get().hrmp_channel_max_capacity;
+		let message_size = configuration::ActiveConfig::<T>::get().hrmp_channel_max_message_size;
+
+		#[extrinsic_call]
+		_(sender_origin, recipient_id, capacity, message_size);
+
+		assert_last_event::<T>(
+			Event::<T>::OpenChannelRequested {
+				sender: sender_id,
+				recipient: recipient_id,
+				proposed_max_capacity: capacity,
+				proposed_max_message_size: message_size,
+			}
+			.into(),
+		);
+	}
+
+	#[benchmark]
+	fn hrmp_accept_open_channel() {
+		let [(sender, _), (recipient, recipient_origin)] =
+			establish_para_connection::<T>(1, 2, TeyrchainSetupStep::Requested);
+
+		#[extrinsic_call]
+		_(recipient_origin, sender);
+
+		assert_last_event::<T>(Event::<T>::OpenChannelAccepted { sender, recipient }.into());
+	}
+
+	#[benchmark]
+	fn hrmp_close_channel() {
+		let [(sender, sender_origin), (recipient, _)] =
+			establish_para_connection::<T>(1, 2, TeyrchainSetupStep::Established);
+		let channel_id = HrmpChannelId { sender, recipient };
+
+		#[extrinsic_call]
+		_(sender_origin, channel_id.clone());
+
+		assert_last_event::<T>(
+			Event::<T>::ChannelClosed { by_teyrchain: sender, channel_id }.into(),
+		);
+	}
+
+	// NOTE: a single teyrchain should have the maximum number of allowed ingress and egress
+	// channels.
+	#[benchmark]
+	fn force_clean_hrmp(
+		// ingress channels to a single leaving teyrchain that need to be closed.
+		i: Linear<0, { HRMP_MAX_INBOUND_CHANNELS_BOUND - 1 }>,
+		// egress channels to a single leaving teyrchain that need to be closed.
+		e: Linear<0, { HRMP_MAX_OUTBOUND_CHANNELS_BOUND - 1 }>,
+	) {
+		// first, update the configs to support this many open channels...
+		assert_ok!(Configuration::<T>::set_hrmp_max_teyrchain_outbound_channels(
+			frame_system::RawOrigin::Root.into(),
+			e + 1
+		));
+		assert_ok!(Configuration::<T>::set_hrmp_max_teyrchain_inbound_channels(
+			frame_system::RawOrigin::Root.into(),
+			i + 1
+		));
+		assert_ok!(Configuration::<T>::set_max_downward_message_size(
+			frame_system::RawOrigin::Root.into(),
+			1024
+		));
+		// .. and enact it.
+		Configuration::<T>::initializer_on_new_session(&Shared::<T>::scheduled_session());
+
+		let config = configuration::ActiveConfig::<T>::get();
+		let deposit: BalanceOf<T> = config.hrmp_sender_deposit.unique_saturated_into();
+
+		let para: ParaId = 1u32.into();
+		register_teyrchain_with_balance::<T>(para, deposit);
+		T::Currency::make_free_balance_be(&para.into_account_truncating(), deposit * 256u32.into());
+
+		for ingress_para_id in 0..i {
+			// establish ingress channels to `para`.
+			let ingress_para_id = ingress_para_id + PREFIX_0;
+			let _ = establish_para_connection::<T>(
+				ingress_para_id,
+				para.into(),
+				TeyrchainSetupStep::Established,
+			);
+		}
+
+		// nothing should be left unprocessed.
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default(), 0);
+
+		for egress_para_id in 0..e {
+			// establish egress channels to `para`.
+			let egress_para_id = egress_para_id + PREFIX_1;
+			let _ = establish_para_connection::<T>(
+				para.into(),
+				egress_para_id,
+				TeyrchainSetupStep::Established,
+			);
+		}
+
+		// nothing should be left unprocessed.
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default(), 0);
+
+		// all in all, we have created this many channels.
+		assert_eq!(HrmpChannels::<T>::iter().count() as u32, i + e);
+
+		#[extrinsic_call]
+		_(frame_system::Origin::<T>::Root, para, i, e);
+
+		// all in all, all of them must be gone by now.
+		assert_eq!(HrmpChannels::<T>::iter().count() as u32, 0);
+		// borrow this function from the tests to make sure state is clear, given that we do a lot
+		// of out-of-ordinary ops here.
+		Hrmp::<T>::assert_storage_consistency_exhaustive();
+	}
+
+	#[benchmark]
+	fn force_process_hrmp_open(
+		// number of channels that need to be processed. Worse case is an N-M relation: unique
+		// sender and recipients for all channels.
+		c: Linear<0, MAX_UNIQUE_CHANNELS>,
+	) {
+		for id in 0..c {
+			let _ = establish_para_connection::<T>(
+				PREFIX_0 + id,
+				PREFIX_1 + id,
+				TeyrchainSetupStep::Accepted,
+			);
+		}
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, c);
+
+		#[extrinsic_call]
+		_(frame_system::Origin::<T>::Root, c);
+
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, 0);
+	}
+
+	#[benchmark]
+	fn force_process_hrmp_close(
+		// number of channels that need to be processed. Worse case is an N-M relation: unique
+		// sender and recipients for all channels.
+		c: Linear<0, MAX_UNIQUE_CHANNELS>,
+	) {
+		for id in 0..c {
+			let _ = establish_para_connection::<T>(
+				PREFIX_0 + id,
+				PREFIX_1 + id,
+				TeyrchainSetupStep::CloseRequested,
+			);
+		}
+
+		assert_eq!(HrmpCloseChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, c);
+
+		#[extrinsic_call]
+		_(frame_system::Origin::<T>::Root, c);
+
+		assert_eq!(HrmpCloseChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, 0);
+	}
+
+	#[benchmark]
+	fn hrmp_cancel_open_request(
+		// number of items already existing in the `HrmpOpenChannelRequestsList`, other than the
+		// one that we remove.
+		c: Linear<0, MAX_UNIQUE_CHANNELS>,
+	) {
+		for id in 0..c {
+			let _ = establish_para_connection::<T>(
+				PREFIX_0 + id,
+				PREFIX_1 + id,
+				TeyrchainSetupStep::Requested,
+			);
+		}
+
+		let [(sender, sender_origin), (recipient, _)] =
+			establish_para_connection::<T>(1, 2, TeyrchainSetupStep::Requested);
+		assert_eq!(
+			HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32,
+			c + 1
+		);
+		let channel_id = HrmpChannelId { sender, recipient };
+
+		#[extrinsic_call]
+		_(sender_origin, channel_id, c + 1);
+
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, c);
+	}
+
+	// worse case will be `n` teyrchain channel requests, where in all of them either the sender or
+	// the recipient need to be cleaned. This enforces the deposit of at least one to be processed.
+	// No code path for triggering two deposit process exists.
+	#[benchmark]
+	fn clean_open_channel_requests(c: Linear<0, MAX_UNIQUE_CHANNELS>) {
+		for id in 0..c {
+			let _ = establish_para_connection::<T>(
+				PREFIX_0 + id,
+				PREFIX_1 + id,
+				TeyrchainSetupStep::Requested,
+			);
+		}
+
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, c);
+		let outgoing = (0..c).map(|id| (id + PREFIX_1).into()).collect::<Vec<ParaId>>();
+		let config = configuration::ActiveConfig::<T>::get();
+
+		#[block]
+		{
+			Hrmp::<T>::clean_open_channel_requests(&config, &outgoing);
+		}
+
+		assert_eq!(HrmpOpenChannelRequestsList::<T>::decode_len().unwrap_or_default() as u32, 0);
+	}
+
+	#[benchmark]
+	fn force_open_hrmp_channel(
+		// Weight parameter only accepts `u32`, `0` and `1` used to represent `false` and `true`,
+		// respectively.
+		c: Linear<0, 1>,
+	) {
+		let sender_id: ParaId = 1u32.into();
+		let sender_origin: crate::Origin = 1u32.into();
+		let recipient_id: ParaId = 2u32.into();
+
+		// Make sure para is registered. The sender does actually need the normal deposit because it
+		// is first going the "init" route.
+		let ed = T::Currency::minimum_balance();
+		let sender_deposit: BalanceOf<T> = configuration::ActiveConfig::<T>::get()
+			.hrmp_sender_deposit
+			.unique_saturated_into();
+		register_teyrchain_with_balance::<T>(sender_id, sender_deposit + ed);
+		register_teyrchain_with_balance::<T>(recipient_id, Zero::zero());
+
+		let capacity = configuration::ActiveConfig::<T>::get().hrmp_channel_max_capacity;
+		let message_size = configuration::ActiveConfig::<T>::get().hrmp_channel_max_message_size;
+
+		let channel_id = HrmpChannelId { sender: sender_id, recipient: recipient_id };
+		if c == 1 {
+			// this will consume more weight if a channel _request_ already exists, because it
+			// will need to clear the request.
+			assert_ok!(Hrmp::<T>::hrmp_init_open_channel(
+				sender_origin.clone().into(),
+				recipient_id,
+				capacity,
+				message_size
+			));
+			assert!(HrmpOpenChannelRequests::<T>::get(&channel_id).is_some());
+		} else {
+			if HrmpOpenChannelRequests::<T>::get(&channel_id).is_some() {
+				assert_ok!(Hrmp::<T>::hrmp_cancel_open_request(
+					sender_origin.clone().into(),
+					channel_id.clone(),
+					MAX_UNIQUE_CHANNELS,
+				));
+			}
+			assert!(HrmpOpenChannelRequests::<T>::get(&channel_id).is_none());
+		}
+
+		// but the _channel_ should not exist
+		assert!(HrmpChannels::<T>::get(&channel_id).is_none());
+
+		#[extrinsic_call]
+		_(frame_system::Origin::<T>::Root, sender_id, recipient_id, capacity, message_size);
+
+		assert_last_event::<T>(
+			Event::<T>::HrmpChannelForceOpened {
+				sender: sender_id,
+				recipient: recipient_id,
+				proposed_max_capacity: capacity,
+				proposed_max_message_size: message_size,
+			}
+			.into(),
+		);
+	}
+
+	#[benchmark]
+	fn establish_system_channel() {
+		let sender_id: ParaId = 1u32.into();
+		let recipient_id: ParaId = 2u32.into();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let config = configuration::ActiveConfig::<T>::get();
+
+		// make sure para is registered, and has zero balance.
+		register_teyrchain_with_balance::<T>(sender_id, Zero::zero());
+		register_teyrchain_with_balance::<T>(recipient_id, Zero::zero());
+
+		let capacity = config.hrmp_channel_max_capacity;
+		let message_size = config.hrmp_channel_max_message_size;
+
+		#[extrinsic_call]
+		_(frame_system::RawOrigin::Signed(caller), sender_id, recipient_id);
+
+		assert_last_event::<T>(
+			Event::<T>::HrmpSystemChannelOpened {
+				sender: sender_id,
+				recipient: recipient_id,
+				proposed_max_capacity: capacity,
+				proposed_max_message_size: message_size,
+			}
+			.into(),
+		);
+	}
+
+	#[benchmark]
+	fn poke_channel_deposits() {
+		let sender_id: ParaId = 1u32.into();
+		let recipient_id: ParaId = 2u32.into();
+		let channel_id = HrmpChannelId { sender: sender_id, recipient: recipient_id };
+
+		let caller: T::AccountId = whitelisted_caller();
+		let config = configuration::ActiveConfig::<T>::get();
+
+		// make sure para is registered, and has balance to reserve.
+		let ed = T::Currency::minimum_balance();
+		let sender_deposit: BalanceOf<T> = config.hrmp_sender_deposit.unique_saturated_into();
+		let recipient_deposit: BalanceOf<T> = config.hrmp_recipient_deposit.unique_saturated_into();
+		register_teyrchain_with_balance::<T>(sender_id, ed + sender_deposit);
+		register_teyrchain_with_balance::<T>(recipient_id, ed + recipient_deposit);
+
+		// Our normal establishment won't actually reserve deposits, so just insert them directly.
+		HrmpChannels::<T>::insert(
+			&channel_id,
+			HrmpChannel {
+				sender_deposit: config.hrmp_sender_deposit,
+				recipient_deposit: config.hrmp_recipient_deposit,
+				max_capacity: config.hrmp_channel_max_capacity,
+				max_total_size: config.hrmp_channel_max_total_size,
+				max_message_size: config.hrmp_channel_max_message_size,
+				msg_count: 0,
+				total_size: 0,
+				mqc_head: None,
+			},
+		);
+		// Actually reserve the deposits.
+		let _ = T::Currency::reserve(&sender_id.into_account_truncating(), sender_deposit);
+		let _ = T::Currency::reserve(&recipient_id.into_account_truncating(), recipient_deposit);
+
+		#[extrinsic_call]
+		_(frame_system::RawOrigin::Signed(caller), sender_id, recipient_id);
+
+		assert_last_event::<T>(
+			Event::<T>::OpenChannelDepositsUpdated { sender: sender_id, recipient: recipient_id }
+				.into(),
+		);
+		let channel = HrmpChannels::<T>::get(&channel_id).unwrap();
+		// Check that the deposit was updated in the channel state.
+		assert_eq!(channel.sender_deposit, 0);
+		assert_eq!(channel.recipient_deposit, 0);
+		// And that the funds were unreserved.
+		assert_eq!(
+			T::Currency::reserved_balance(&sender_id.into_account_truncating()),
+			0u128.unique_saturated_into()
+		);
+		assert_eq!(
+			T::Currency::reserved_balance(&recipient_id.into_account_truncating()),
+			0u128.unique_saturated_into()
+		);
+	}
+
+	#[benchmark]
+	fn establish_channel_with_system() {
+		let sender_id = 1u32;
+		let recipient_id: ParaId = 2u32.into();
+
+		let sender_origin: crate::Origin = sender_id.into();
+
+		// make sure para is registered, and has zero balance.
+		register_teyrchain_with_balance::<T>(sender_id.into(), Zero::zero());
+		register_teyrchain_with_balance::<T>(recipient_id, Zero::zero());
+
+		#[extrinsic_call]
+		_(sender_origin, recipient_id);
+
+		let (max_message_size, max_capacity) = T::DefaultChannelSizeAndCapacityWithSystem::get();
+
+		assert_has_event::<T>(
+			Event::<T>::HrmpSystemChannelOpened {
+				sender: sender_id.into(),
+				recipient: recipient_id,
+				proposed_max_capacity: max_capacity,
+				proposed_max_message_size: max_message_size,
+			}
+			.into(),
+		);
+
+		assert_has_event::<T>(
+			Event::<T>::HrmpSystemChannelOpened {
+				sender: recipient_id,
+				recipient: sender_id.into(),
+				proposed_max_capacity: max_capacity,
+				proposed_max_message_size: max_message_size,
+			}
+			.into(),
+		);
+	}
+
+	impl_benchmark_test_suite!(
+		Hrmp,
+		crate::mock::new_test_ext(crate::hrmp::tests::GenesisConfigBuilder::default().build()),
+		crate::mock::Test
+	);
+}