feat: Rebrand Polkadot/Substrate references to PezkuwiChain

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.

bizinikiwi/pezframe/democracy/src/tests.rs

@@ -0,0 +1,261 @@
+// This file is part of Bizinikiwi.
+
+// 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.
+
+//! The crate's tests.
+
+use super::*;
+use crate as pezpallet_democracy;
+use pezframe_support::{
+	assert_noop, assert_ok, derive_impl, ord_parameter_types, parameter_types,
+	traits::{
+		ConstU32, ConstU64, Contains, EqualPrivilegeOnly, OnInitialize, SortedMembers,
+		StorePreimage,
+	},
+	weights::Weight,
+};
+use pezframe_system::{EnsureRoot, EnsureSigned, EnsureSignedBy};
+use pezpallet_balances::{BalanceLock, Error as BalancesError};
+use pezsp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, Hash},
+	BuildStorage, Perbill,
+};
+mod cancellation;
+mod decoders;
+mod delegation;
+mod external_proposing;
+mod fast_tracking;
+mod lock_voting;
+mod metadata;
+mod public_proposals;
+mod scheduling;
+mod voting;
+
+const AYE: Vote = Vote { aye: true, conviction: Conviction::None };
+const NAY: Vote = Vote { aye: false, conviction: Conviction::None };
+const BIG_AYE: Vote = Vote { aye: true, conviction: Conviction::Locked1x };
+const BIG_NAY: Vote = Vote { aye: false, conviction: Conviction::Locked1x };
+
+type Block = pezframe_system::mocking::MockBlock<Test>;
+
+pezframe_support::construct_runtime!(
+	pub enum Test
+	{
+		System: pezframe_system,
+		Balances: pezpallet_balances,
+		Preimage: pezpallet_preimage,
+		Scheduler: pezpallet_scheduler,
+		Democracy: pezpallet_democracy,
+	}
+);
+
+// Test that a filtered call can be dispatched.
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		!matches!(call, &RuntimeCall::Balances(pezpallet_balances::Call::force_set_balance { .. }))
+	}
+}
+
+parameter_types! {
+	pub BlockWeights: pezframe_system::limits::BlockWeights =
+		pezframe_system::limits::BlockWeights::simple_max(
+			Weight::from_parts(pezframe_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+		);
+}
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Test {
+	type BaseCallFilter = BaseFilter;
+	type Block = Block;
+	type AccountData = pezpallet_balances::AccountData<u64>;
+}
+parameter_types! {
+	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;
+}
+
+impl pezpallet_preimage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type ManagerOrigin = EnsureRoot<u64>;
+	type Consideration = ();
+}
+
+impl pezpallet_scheduler::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaximumSchedulerWeight;
+	type ScheduleOrigin = EnsureRoot<u64>;
+	type MaxScheduledPerBlock = ConstU32<100>;
+	type WeightInfo = ();
+	type OriginPrivilegeCmp = EqualPrivilegeOnly;
+	type Preimages = ();
+	type BlockNumberProvider = pezframe_system::Pallet<Test>;
+}
+
+#[derive_impl(pezpallet_balances::config_preludes::TestDefaultConfig)]
+impl pezpallet_balances::Config for Test {
+	type AccountStore = System;
+}
+parameter_types! {
+	pub static PreimageByteDeposit: u64 = 0;
+	pub static InstantAllowed: bool = false;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+	pub const Five: u64 = 5;
+	pub const Six: u64 = 6;
+}
+pub struct OneToFive;
+impl SortedMembers<u64> for OneToFive {
+	fn sorted_members() -> Vec<u64> {
+		vec![1, 2, 3, 4, 5]
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(_m: &u64) {}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = pezpallet_balances::Pallet<Self>;
+	type EnactmentPeriod = ConstU64<2>;
+	type LaunchPeriod = ConstU64<2>;
+	type VotingPeriod = ConstU64<2>;
+	type VoteLockingPeriod = ConstU64<3>;
+	type FastTrackVotingPeriod = ConstU64<2>;
+	type MinimumDeposit = ConstU64<1>;
+	type MaxDeposits = ConstU32<1000>;
+	type MaxBlacklisted = ConstU32<5>;
+	type SubmitOrigin = EnsureSigned<Self::AccountId>;
+	type ExternalOrigin = EnsureSignedBy<Two, u64>;
+	type ExternalMajorityOrigin = EnsureSignedBy<Three, u64>;
+	type ExternalDefaultOrigin = EnsureSignedBy<One, u64>;
+	type FastTrackOrigin = EnsureSignedBy<Five, u64>;
+	type CancellationOrigin = EnsureSignedBy<Four, u64>;
+	type BlacklistOrigin = EnsureRoot<u64>;
+	type CancelProposalOrigin = EnsureRoot<u64>;
+	type VetoOrigin = EnsureSignedBy<OneToFive, u64>;
+	type CooloffPeriod = ConstU64<2>;
+	type Slash = ();
+	type InstantOrigin = EnsureSignedBy<Six, u64>;
+	type InstantAllowed = InstantAllowed;
+	type Scheduler = Scheduler;
+	type MaxVotes = ConstU32<100>;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+	type MaxProposals = ConstU32<100>;
+	type Preimages = Preimage;
+}
+
+pub fn new_test_ext() -> pezsp_io::TestExternalities {
+	let mut t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pezpallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)],
+		..Default::default()
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pezpallet_democracy::GenesisConfig::<Test>::default()
+		.assimilate_storage(&mut t)
+		.unwrap();
+	let mut ext = pezsp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+#[test]
+fn params_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(ReferendumCount::<Test>::get(), 0);
+		assert_eq!(Balances::free_balance(42), 0);
+		assert_eq!(pezpallet_balances::TotalIssuance::<Test>::get(), 210);
+	});
+}
+
+fn set_balance_proposal(value: u64) -> BoundedCallOf<Test> {
+	let inner = pezpallet_balances::Call::force_set_balance { who: 42, new_free: value };
+	let outer = RuntimeCall::Balances(inner);
+	Preimage::bound(outer).unwrap()
+}
+
+#[test]
+fn set_balance_proposal_is_correctly_filtered_out() {
+	for i in 0..10 {
+		let call = Preimage::realize(&set_balance_proposal(i)).unwrap().0;
+		assert!(!<Test as pezframe_system::Config>::BaseCallFilter::contains(&call));
+	}
+}
+
+fn propose_set_balance(who: u64, value: u64, delay: u64) -> DispatchResult {
+	Democracy::propose(RuntimeOrigin::signed(who), set_balance_proposal(value), delay)
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+	Scheduler::on_initialize(System::block_number());
+	Democracy::begin_block(System::block_number());
+}
+
+fn fast_forward_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn begin_referendum() -> ReferendumIndex {
+	System::set_block_number(0);
+	assert_ok!(propose_set_balance(1, 2, 1));
+	fast_forward_to(2);
+	0
+}
+
+fn aye(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: AYE, balance: Balances::free_balance(&who) }
+}
+
+fn nay(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: NAY, balance: Balances::free_balance(&who) }
+}
+
+fn big_aye(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: BIG_AYE, balance: Balances::free_balance(&who) }
+}
+
+fn big_nay(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: BIG_NAY, balance: Balances::free_balance(&who) }
+}
+
+fn tally(r: ReferendumIndex) -> Tally<u64> {
+	Democracy::referendum_status(r).unwrap().tally
+}
+
+/// note a new preimage without registering.
+fn note_preimage(who: u64) -> <Test as pezframe_system::Config>::Hash {
+	use std::sync::atomic::{AtomicU8, Ordering};
+	// note a new preimage on every function invoke.
+	static COUNTER: AtomicU8 = AtomicU8::new(0);
+	let data = vec![COUNTER.fetch_add(1, Ordering::Relaxed)];
+	assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(who), data.clone()));
+	let hash = BlakeTwo256::hash(&data);
+	assert!(!Preimage::is_requested(&hash));
+	hash
+}