feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

2025-12-13 15:44:15 +03:00
commit e4778b4576
6838 changed files with 1847450 additions and 0 deletions
@@ -0,0 +1,500 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![recursion_limit = "128"]
+
+use frame_support::{
+	derive_impl,
+	inherent::{InherentData, InherentIdentifier, MakeFatalError, ProvideInherent},
+	traits::ConstU32,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_core::sr25519;
+use sp_metadata_ir::{
+	PalletStorageMetadataIR, StorageEntryMetadataIR, StorageEntryModifierIR, StorageEntryTypeIR,
+	StorageHasherIR,
+};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+	BuildStorage,
+};
+
+pub trait Currency {}
+
+// Test for:
+// * No default instance
+// * Origin, Inherent, Event
+#[frame_support::pallet(dev_mode)]
+mod module1 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type RuntimeOrigin: From<Origin<Self, I>>;
+		type SomeParameter: Get<u32>;
+		type GenericType: Parameter + Member + MaybeSerializeDeserialize + Default + MaxEncodedLen;
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		#[pallet::weight(0)]
+		pub fn one(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::deposit_event(Event::AnotherVariant(3));
+			Ok(())
+		}
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn value)]
+	pub type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, T::GenericType, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn map)]
+	pub type Map<T: Config<I>, I: 'static = ()> = StorageMap<_, Identity, u32, u64, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub value: <T as Config<I>>::GenericType,
+		pub test: BlockNumberFor<T>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self { value: Default::default(), test: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I>
+	where
+		BlockNumberFor<T>: std::fmt::Display,
+	{
+		fn build(&self) {
+			<Value<T, I>>::put(self.value.clone());
+			println!("{}", self.test);
+		}
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Test
+		Test,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		_Phantom(PhantomData<T>),
+		AnotherVariant(u32),
+	}
+
+	#[pallet::origin]
+	#[derive(
+		Clone,
+		PartialEq,
+		Eq,
+		RuntimeDebug,
+		Encode,
+		Decode,
+		DecodeWithMemTracking,
+		MaxEncodedLen,
+		TypeInfo,
+	)]
+	#[scale_info(skip_type_params(I))]
+	pub enum Origin<T, I = ()> {
+		Members(u32),
+		_Phantom(PhantomData<(T, I)>),
+	}
+
+	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"12345678";
+
+	#[pallet::inherent]
+	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I>
+	where
+		BlockNumberFor<T>: From<u32>,
+	{
+		type Call = Call<T, I>;
+		type Error = MakeFatalError<()>;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn check_inherent(_: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!();
+		}
+	}
+}
+
+// Test for:
+// * default instance
+// * use of no_genesis_config_phantom_data
+#[frame_support::pallet]
+mod module2 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type Amount: Parameter + MaybeSerializeDeserialize + Default + MaxEncodedLen;
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type RuntimeOrigin: From<Origin<Self, I>>;
+	}
+
+	impl<T: Config<I>, I: 'static> Currency for Pallet<T, I> {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+
+	#[pallet::storage]
+	pub type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Amount, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Map<T: Config<I>, I: 'static = ()> = StorageMap<_, Identity, u64, u64, ValueQuery>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Identity, u64, Identity, u64, u64, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub value: T::Amount,
+		pub map: Vec<(u64, u64)>,
+		pub double_map: Vec<(u64, u64, u64)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self {
+				value: Default::default(),
+				map: Default::default(),
+				double_map: Default::default(),
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I>
+	where
+		BlockNumberFor<T>: std::fmt::Display,
+	{
+		fn build(&self) {
+			<Value<T, I>>::put(self.value.clone());
+			for (k, v) in &self.map {
+				<Map<T, I>>::insert(k, v);
+			}
+			for (k1, k2, v) in &self.double_map {
+				<DoubleMap<T, I>>::insert(k1, k2, v);
+			}
+		}
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		Variant(T::Amount),
+	}
+
+	#[pallet::origin]
+	#[derive(
+		Clone,
+		PartialEq,
+		Eq,
+		RuntimeDebug,
+		Encode,
+		Decode,
+		DecodeWithMemTracking,
+		MaxEncodedLen,
+		TypeInfo,
+	)]
+	#[scale_info(skip_type_params(I))]
+	pub enum Origin<T, I = ()> {
+		Members(u32),
+		_Phantom(PhantomData<(T, I)>),
+	}
+
+	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"12345678";
+
+	#[pallet::inherent]
+	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I> {
+		type Call = Call<T, I>;
+		type Error = MakeFatalError<()>;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn check_inherent(_call: &Self::Call, _data: &InherentData) -> Result<(), Self::Error> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!();
+		}
+	}
+}
+
+// Test for:
+// * Depends on multiple instances of a module with instances
+#[frame_support::pallet]
+mod module3 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>:
+		frame_system::Config + module2::Config<I> + module2::Config<module2::Instance1>
+	{
+		type Currency: Currency;
+		type Currency2: Currency;
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+}
+
+pub type BlockNumber = u32;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system,
+		Module1_1: module1::<Instance1>,
+		Module1_2: module1::<Instance2>,
+		Module2: module2,
+		Module2_1: module2::<Instance1>,
+		Module2_2: module2::<Instance2>,
+		Module2_3: module2::<Instance3>,
+		Module3: module3,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type Block = Block;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl module1::Config<module1::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type SomeParameter = ConstU32<100>;
+	type GenericType = u32;
+}
+impl module1::Config<module1::Instance2> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type SomeParameter = ConstU32<100>;
+	type GenericType = u32;
+}
+impl module2::Config for Runtime {
+	type Amount = u16;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance1> for Runtime {
+	type Amount = u32;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance2> for Runtime {
+	type Amount = u32;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance3> for Runtime {
+	type Amount = u64;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module3::Config for Runtime {
+	type Currency = Module2_2;
+	type Currency2 = Module2_3;
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+	RuntimeGenesisConfig {
+		system: Default::default(),
+		module_1_1: module1::GenesisConfig { value: 3, test: 2 },
+		module_1_2: module1::GenesisConfig { value: 4, test: 5 },
+		module_2: module2::GenesisConfig {
+			value: 4,
+			map: vec![(0, 0)],
+			double_map: vec![(0, 0, 0)],
+		},
+		module_2_1: module2::GenesisConfig {
+			value: 4,
+			map: vec![(0, 0)],
+			double_map: vec![(0, 0, 0)],
+		},
+		module_2_2: Default::default(),
+		module_2_3: Default::default(),
+	}
+	.build_storage()
+	.unwrap()
+	.into()
+}
+
+#[test]
+fn storage_instance_independence() {
+	let mut storage = sp_core::storage::Storage {
+		top: std::collections::BTreeMap::new(),
+		children_default: std::collections::HashMap::new(),
+	};
+	sp_state_machine::BasicExternalities::execute_with_storage(&mut storage, || {
+		module2::Value::<Runtime>::put(0);
+		module2::Value::<Runtime, module2::Instance1>::put(0);
+		module2::Value::<Runtime, module2::Instance2>::put(0);
+		module2::Value::<Runtime, module2::Instance3>::put(0);
+		module2::Map::<Runtime>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance1>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance2>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance3>::insert(0, 0);
+		module2::DoubleMap::<Runtime>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance1>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance2>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance3>::insert(&0, &0, &0);
+	});
+	// 12 storage values.
+	assert_eq!(storage.top.len(), 12);
+}
+
+#[test]
+fn storage_with_instance_basic_operation() {
+	new_test_ext().execute_with(|| {
+		type Value = module2::Value<Runtime, module2::Instance1>;
+		type Map = module2::Map<Runtime, module2::Instance1>;
+		type DoubleMap = module2::DoubleMap<Runtime, module2::Instance1>;
+
+		assert_eq!(Value::exists(), true);
+		assert_eq!(Value::get(), 4);
+		Value::put(1);
+		assert_eq!(Value::get(), 1);
+		assert_eq!(Value::take(), 1);
+		assert_eq!(Value::get(), 0);
+		Value::mutate(|a| *a = 2);
+		assert_eq!(Value::get(), 2);
+		Value::kill();
+		assert_eq!(Value::exists(), false);
+		assert_eq!(Value::get(), 0);
+
+		let key = 1;
+		assert_eq!(Map::contains_key(0), true);
+		assert_eq!(Map::contains_key(key), false);
+		Map::insert(key, 1);
+		assert_eq!(Map::get(key), 1);
+		assert_eq!(Map::take(key), 1);
+		assert_eq!(Map::get(key), 0);
+		Map::mutate(key, |a| *a = 2);
+		assert_eq!(Map::get(key), 2);
+		Map::remove(key);
+		assert_eq!(Map::contains_key(key), false);
+		assert_eq!(Map::get(key), 0);
+
+		let key1 = 1;
+		let key2 = 1;
+		assert_eq!(DoubleMap::contains_key(&0, &0), true);
+		assert_eq!(DoubleMap::contains_key(&key1, &key2), false);
+		DoubleMap::insert(&key1, &key2, &1);
+		assert_eq!(DoubleMap::get(&key1, &key2), 1);
+		assert_eq!(DoubleMap::take(&key1, &key2), 1);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0);
+		DoubleMap::mutate(&key1, &key2, |a| *a = 2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 2);
+		DoubleMap::remove(&key1, &key2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0);
+	});
+}
+
+fn expected_metadata() -> PalletStorageMetadataIR {
+	PalletStorageMetadataIR {
+		prefix: "Module2_2",
+		entries: vec![
+			StorageEntryMetadataIR {
+				name: "Value",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+				default: vec![0, 0, 0, 0],
+				docs: vec![],
+				deprecation_info: sp_metadata_ir::ItemDeprecationInfoIR::NotDeprecated,
+			},
+			StorageEntryMetadataIR {
+				name: "Map",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Identity],
+					key: scale_info::meta_type::<u64>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: [0u8; 8].to_vec(),
+				docs: vec![],
+				deprecation_info: sp_metadata_ir::ItemDeprecationInfoIR::NotDeprecated,
+			},
+			StorageEntryMetadataIR {
+				name: "DoubleMap",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Identity, StorageHasherIR::Identity],
+					key: scale_info::meta_type::<(u64, u64)>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: [0u8; 8].to_vec(),
+				docs: vec![],
+				deprecation_info: sp_metadata_ir::ItemDeprecationInfoIR::NotDeprecated,
+			},
+		],
+	}
+}
+
+#[test]
+fn test_instance_storage_metadata() {
+	let metadata = Module2_2::storage_metadata();
+	pretty_assertions::assert_eq!(expected_metadata(), metadata);
+}