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/utils/pezframe/benchmarking-cli/src/block/cmd.rs

@@ -0,0 +1,116 @@
+// 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.
+
+//! Contains the [`BlockCmd`] as entry point for the CLI to execute
+//! the *block* benchmark.
+
+use pezsc_block_builder::BlockBuilderApi;
+use pezsc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
+use pezsc_client_api::{Backend as ClientBackend, BlockBackend, StorageProvider, UsageProvider};
+use pezsp_api::{ApiExt, ProvideRuntimeApi};
+use pezsp_blockchain::HeaderBackend;
+use pezsp_runtime::{traits::Block as BlockT, OpaqueExtrinsic};
+
+use clap::Parser;
+use std::{fmt::Debug, sync::Arc};
+
+use super::bench::{Benchmark, BenchmarkParams};
+
+/// Benchmark the execution time of historic blocks.
+///
+/// This can be used to verify that blocks do not use more weight than they consumed
+/// in their `WeightInfo`. Example:
+///
+/// Let's say you are on a Bizinikiwi chain and want to verify that the first 3 blocks
+/// did not use more weight than declared which would otherwise be an issue.
+/// To test this with a dev node, first create one with a temp directory:
+///
+/// $ bizinikiwi --dev -d /tmp/my-dev --wasm-execution compiled
+///
+/// And wait some time to let it produce 3 blocks. Then benchmark them with:
+///
+/// $ bizinikiwi benchmark-block --from 1 --to 3 --dev -d /tmp/my-dev
+///   --wasm-execution compiled --pruning archive
+///
+/// The output will be similar to this:
+///
+/// Block 1 with 1 tx used 77.34% of its weight ( 5,308,964 of 6,864,645 ns)
+/// Block 2 with 1 tx used 77.99% of its weight ( 5,353,992 of 6,864,645 ns)
+/// Block 3 with 1 tx used 75.91% of its weight ( 5,305,938 of 6,989,645 ns)
+///
+/// The percent number is important and indicates how much weight
+/// was used as compared to the consumed weight.
+/// This number should be below 100% for reference hardware.
+#[derive(Debug, Parser)]
+pub struct BlockCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub params: BenchmarkParams,
+
+	/// Enable the Trie cache.
+	///
+	/// This should only be used for performance analysis and not for final results.
+	#[arg(long)]
+	pub enable_trie_cache: bool,
+}
+
+impl BlockCmd {
+	/// Benchmark the execution time of historic blocks and compare it to their consumed weight.
+	///
+	/// Output will be printed to console.
+	pub fn run<Block, BA, C>(&self, client: Arc<C>) -> Result<()>
+	where
+		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+		BA: ClientBackend<Block>,
+		C: BlockBackend<Block>
+			+ ProvideRuntimeApi<Block>
+			+ StorageProvider<Block, BA>
+			+ UsageProvider<Block>
+			+ HeaderBackend<Block>,
+		C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	{
+		// Put everything in the benchmark type to have the generic types handy.
+		Benchmark::new(client, self.params.clone()).run()
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for BlockCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		if self.enable_trie_cache {
+			Ok(self.import_params().map(|x| x.trie_cache_maximum_size()).unwrap_or_default())
+		} else {
+			Ok(None)
+		}
+	}
+}