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/nomination-pools/fuzzer/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "pezpallet-nomination-pools-fuzzer"
+version = "2.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Fuzzer for fixed point arithmetic primitives."
+documentation = "https://docs.rs/pezsp-arithmetic-fuzzer"
+publish = false
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[[bin]]
+name = "call"
+path = "src/call.rs"
+
+[dependencies]
+honggfuzz = { workspace = true }
+
+pezpallet-nomination-pools = { features = [
+	"fuzzing",
+], workspace = true, default-features = true }
+
+pezframe-support = { workspace = true, default-features = true }
+pezframe-system = { workspace = true, default-features = true }
+
+pezsp-io = { workspace = true, default-features = true }
+pezsp-runtime = { workspace = true, default-features = true }
+pezsp-tracing = { workspace = true, default-features = true }
+
+log = { workspace = true, default-features = true }
+rand = { features = ["small_rng"], workspace = true, default-features = true }
+
+[features]
+runtime-benchmarks = [
+	"pezframe-support/runtime-benchmarks",
+	"pezframe-system/runtime-benchmarks",
+	"pezpallet-nomination-pools/runtime-benchmarks",
+	"pezsp-io/runtime-benchmarks",
+	"pezsp-runtime/runtime-benchmarks",
+]

bizinikiwi/pezframe/nomination-pools/fuzzer/src/call.rs

@@ -0,0 +1,354 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run call`. `honggfuzz` CLI
+//! options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug per_thing_rational hfuzz_workspace/call/*.fuzz`.
+
+use pezframe_support::{
+	assert_ok,
+	traits::{Currency, GetCallName, UnfilteredDispatchable},
+};
+use honggfuzz::fuzz;
+use pezpallet_nomination_pools::{
+	log,
+	mock::*,
+	pallet as pools,
+	pallet::{BondedPools, Call as PoolsCall, Event as PoolsEvents, PoolMembers},
+	BondExtra, BondedPool, GlobalMaxCommission, LastPoolId, MaxPoolMembers, MaxPoolMembersPerPool,
+	MaxPools, MinCreateBond, MinJoinBond, PoolId,
+};
+use rand::{seq::SliceRandom, Rng};
+use pezsp_runtime::{assert_eq_error_rate, Perbill, Perquintill};
+
+const ERA: BlockNumber = 1000;
+const MAX_ED_MULTIPLE: Balance = 10_000;
+const MIN_ED_MULTIPLE: Balance = 10;
+
+// not quite elegant, just to make it available in random_signed_origin.
+const REWARD_AGENT_ACCOUNT: AccountId = 42;
+
+/// Grab random accounts, either known ones, or new ones.
+fn random_signed_origin<R: Rng>(rng: &mut R) -> (RuntimeOrigin, AccountId) {
+	let count = PoolMembers::<T>::count();
+	if rng.gen::<bool>() && count > 0 {
+		// take an existing account.
+		let skip = rng.gen_range(0..count as usize);
+
+		// this is tricky: the account might be our reward agent, which we never want to be
+		// randomly chosen here. Try another one, or, if it is only our agent, return a random
+		// one nonetheless.
+		let candidate = PoolMembers::<T>::iter_keys().skip(skip).take(1).next().unwrap();
+		let acc =
+			if candidate == REWARD_AGENT_ACCOUNT { rng.gen::<AccountId>() } else { candidate };
+
+		(RuntimeOrigin::signed(acc), acc)
+	} else {
+		// create a new account
+		let acc = rng.gen::<AccountId>();
+		(RuntimeOrigin::signed(acc), acc)
+	}
+}
+
+fn random_ed_multiple<R: Rng>(rng: &mut R) -> Balance {
+	let multiple = rng.gen_range(MIN_ED_MULTIPLE..MAX_ED_MULTIPLE);
+	ExistentialDeposit::get() * multiple
+}
+
+fn fund_account<R: Rng>(rng: &mut R, account: &AccountId) {
+	let target_amount = random_ed_multiple(rng);
+	if let Some(top_up) = target_amount.checked_sub(Balances::free_balance(account)) {
+		let _ = Balances::deposit_creating(account, top_up);
+	}
+	assert!(Balances::free_balance(account) >= target_amount);
+}
+
+fn random_existing_pool<R: Rng>(mut rng: &mut R) -> Option<PoolId> {
+	BondedPools::<T>::iter_keys().collect::<Vec<_>>().choose(&mut rng).map(|x| *x)
+}
+
+fn random_call<R: Rng>(mut rng: &mut R) -> (pools::Call<T>, RuntimeOrigin) {
+	let op = rng.gen::<usize>();
+	let mut op_count = <pools::Call<T> as GetCallName>::get_call_names().len();
+	// Exclude set_state, set_metadata, set_configs, update_roles and chill.
+	op_count -= 5;
+
+	match op % op_count {
+		0 => {
+			// join
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let (origin, who) = random_signed_origin(&mut rng);
+			fund_account(&mut rng, &who);
+			let amount = random_ed_multiple(&mut rng);
+			(PoolsCall::<T>::join { amount, pool_id }, origin)
+		},
+		1 => {
+			// bond_extra
+			let (origin, who) = random_signed_origin(&mut rng);
+			let extra = if rng.gen::<bool>() {
+				BondExtra::Rewards
+			} else {
+				fund_account(&mut rng, &who);
+				let amount = random_ed_multiple(&mut rng);
+				BondExtra::FreeBalance(amount)
+			};
+			(PoolsCall::<T>::bond_extra { extra }, origin)
+		},
+		2 => {
+			// claim_payout
+			let (origin, _) = random_signed_origin(&mut rng);
+			(PoolsCall::<T>::claim_payout {}, origin)
+		},
+		3 => {
+			// unbond
+			let (origin, who) = random_signed_origin(&mut rng);
+			let amount = random_ed_multiple(&mut rng);
+			(PoolsCall::<T>::unbond { member_account: who, unbonding_points: amount }, origin)
+		},
+		4 => {
+			// pool_withdraw_unbonded
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let (origin, _) = random_signed_origin(&mut rng);
+			(PoolsCall::<T>::pool_withdraw_unbonded { pool_id, num_slashing_spans: 0 }, origin)
+		},
+		5 => {
+			// withdraw_unbonded
+			let (origin, who) = random_signed_origin(&mut rng);
+			(
+				PoolsCall::<T>::withdraw_unbonded { member_account: who, num_slashing_spans: 0 },
+				origin,
+			)
+		},
+		6 => {
+			// create
+			let (origin, who) = random_signed_origin(&mut rng);
+			let amount = random_ed_multiple(&mut rng);
+			fund_account(&mut rng, &who);
+			let root = who;
+			let bouncer = who;
+			let nominator = who;
+			(PoolsCall::<T>::create { amount, root, bouncer, nominator }, origin)
+		},
+		7 => {
+			// nominate
+			let (origin, _) = random_signed_origin(&mut rng);
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let validators = Default::default();
+			(PoolsCall::<T>::nominate { pool_id, validators }, origin)
+		},
+		_ => unreachable!(),
+	}
+}
+
+#[derive(Default)]
+struct RewardAgent {
+	who: AccountId,
+	pool_id: Option<PoolId>,
+	expected_reward: Balance,
+}
+
+// TODO: inject some slashes into the game.
+impl RewardAgent {
+	fn new(who: AccountId) -> Self {
+		Self { who, ..Default::default() }
+	}
+
+	fn join(&mut self) {
+		if self.pool_id.is_some() {
+			return;
+		}
+		let pool_id = LastPoolId::<T>::get();
+		let amount = 10 * ExistentialDeposit::get();
+		let origin = RuntimeOrigin::signed(self.who);
+		let _ = Balances::deposit_creating(&self.who, 10 * amount);
+		self.pool_id = Some(pool_id);
+		log::info!(target: "reward-agent", "🤖 reward agent joining in {} with {}", pool_id, amount);
+		assert_ok!(PoolsCall::join::<T> { amount, pool_id }.dispatch_bypass_filter(origin));
+	}
+
+	fn claim_payout(&mut self) {
+		// 10 era later, we claim our payout. We expect our income to be roughly what we
+		// calculated.
+		if !PoolMembers::<T>::contains_key(&self.who) {
+			log!(warn, "reward agent is not in the pool yet, cannot claim");
+			return;
+		}
+		let pre = Balances::free_balance(&42);
+		let origin = RuntimeOrigin::signed(42);
+		assert_ok!(PoolsCall::<T>::claim_payout {}.dispatch_bypass_filter(origin));
+		let post = Balances::free_balance(&42);
+
+		let income = post - pre;
+		log::info!(
+			target: "reward-agent", "🤖 CLAIM: actual: {}, expected: {}",
+			income,
+			self.expected_reward,
+		);
+		assert_eq_error_rate!(income, self.expected_reward, 10);
+		self.expected_reward = 0;
+	}
+}
+
+fn main() {
+	let mut reward_agent = RewardAgent::new(REWARD_AGENT_ACCOUNT);
+	pezsp_tracing::try_init_simple();
+	let mut ext = pezsp_io::TestExternalities::new_empty();
+	let mut events_histogram = Vec::<(PoolsEvents<T>, u32)>::default();
+	let mut iteration = 0 as BlockNumber;
+	let mut ok = 0;
+	let mut err = 0;
+
+	let dot: Balance = (10 as Balance).pow(10);
+	ExistentialDeposit::set(dot);
+	BondingDuration::set(8);
+
+	ext.execute_with(|| {
+		MaxPoolMembers::<T>::set(Some(10_000));
+		MaxPoolMembersPerPool::<T>::set(Some(1000));
+		MaxPools::<T>::set(Some(1_000));
+		GlobalMaxCommission::<T>::set(Some(Perbill::from_percent(25)));
+
+		MinCreateBond::<T>::set(10 * ExistentialDeposit::get());
+		MinJoinBond::<T>::set(5 * ExistentialDeposit::get());
+		System::set_block_number(1);
+	});
+
+	loop {
+		fuzz!(|seed: [u8; 32]| {
+			use ::rand::{rngs::SmallRng, SeedableRng};
+			let mut rng = SmallRng::from_seed(seed);
+
+			ext.execute_with(|| {
+				let (call, origin) = random_call(&mut rng);
+				let outcome = call.clone().dispatch_bypass_filter(origin.clone());
+				iteration += 1;
+				match outcome {
+					Ok(_) => ok += 1,
+					Err(_) => err += 1,
+				};
+
+				log!(
+					trace,
+					"iteration {}, call {:?}, origin {:?}, outcome: {:?}, so far {} ok {} err",
+					iteration,
+					call,
+					origin,
+					outcome,
+					ok,
+					err,
+				);
+
+				// possibly join the reward_agent
+				if iteration > ERA / 2 && BondedPools::<T>::count() > 0 {
+					reward_agent.join();
+				}
+				// and possibly roughly every 4 era, trigger payout for the agent. Doing this more
+				// frequent is also harmless.
+				if rng.gen_range(0..(4 * ERA)) == 0 {
+					reward_agent.claim_payout();
+				}
+
+				// execute sanity checks at a fixed interval, possibly on every block.
+				if iteration %
+					(std::env::var("SANITY_CHECK_INTERVAL")
+						.ok()
+						.and_then(|x| x.parse::<u64>().ok()))
+					.unwrap_or(1) == 0
+				{
+					log!(info, "running sanity checks at {}", iteration);
+					Pools::do_try_state(u8::MAX).unwrap();
+				}
+
+				// collect and reset events.
+				System::events()
+					.into_iter()
+					.map(|r| r.event)
+					.filter_map(|e| {
+						if let pezpallet_nomination_pools::mock::RuntimeEvent::Pools(inner) = e {
+							Some(inner)
+						} else {
+							None
+						}
+					})
+					.for_each(|e| {
+						if let Some((_, c)) = events_histogram
+							.iter_mut()
+							.find(|(x, _)| std::mem::discriminant(x) == std::mem::discriminant(&e))
+						{
+							*c += 1;
+						} else {
+							events_histogram.push((e, 1))
+						}
+					});
+				System::reset_events();
+
+				// trigger an era change, and check the status of the reward agent.
+				if iteration % ERA == 0 {
+					CurrentEra::mutate(|c| *c += 1);
+					BondedPools::<T>::iter().for_each(|(id, _)| {
+						let amount = random_ed_multiple(&mut rng);
+						let _ =
+							Balances::deposit_creating(&Pools::generate_reward_account(id), amount);
+						// if we just paid out the reward agent, let's calculate how much we expect
+						// our reward agent to have earned.
+						if reward_agent.pool_id.map_or(false, |mid| mid == id) {
+							let all_points = BondedPool::<T>::get(id).map(|p| p.points).unwrap();
+							let member_points =
+								PoolMembers::<T>::get(reward_agent.who).map(|m| m.points).unwrap();
+							let agent_share = Perquintill::from_rational(member_points, all_points);
+							log::info!(
+								target: "reward-agent",
+								"🤖 REWARD = amount = {:?}, ratio: {:?}, share {:?}",
+								amount,
+								agent_share,
+								agent_share * amount,
+							);
+							reward_agent.expected_reward += agent_share * amount;
+						}
+					});
+
+					log!(
+						info,
+						"iteration {}, {} pools, {} members, {} ok {} err, events = {:?}",
+						iteration,
+						BondedPools::<T>::count(),
+						PoolMembers::<T>::count(),
+						ok,
+						err,
+						events_histogram
+							.iter()
+							.map(|(x, c)| (
+								format!("{:?}", x)
+									.split(" ")
+									.map(|x| x.to_string())
+									.collect::<Vec<_>>()
+									.first()
+									.cloned()
+									.unwrap(),
+								c,
+							))
+							.collect::<Vec<_>>(),
+					);
+				}
+			})
+		})
+	}
+}