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.

pezkuwi/node/core/pvf/common/src/error.rs

@@ -16,7 +16,7 @@
 
 use crate::prepare::{PrepareSuccess, PrepareWorkerSuccess};
 use codec::{Decode, Encode};
-pub use sc_executor_common::error::Error as ExecuteError;
+pub use pezsc_executor_common::error::Error as ExecuteError;
 
 /// Result of PVF preparation from a worker, with checksum of the compiled PVF and stats of the
 /// preparation if successful.

pezkuwi/node/core/pvf/common/src/executor_interface.rs

@@ -14,26 +14,26 @@
 // You should have received a copy of the GNU General Public License
 // along with Pezkuwi.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Interface to the Substrate Executor
+//! Interface to the Bizinikiwi Executor
 
 use crate::error::ExecuteError;
 use pezkuwi_primitives::{
 	executor_params::{DEFAULT_LOGICAL_STACK_MAX, DEFAULT_NATIVE_STACK_MAX},
 	ExecutorParam, ExecutorParams,
 };
-use sc_executor_common::{
+use pezsc_executor_common::{
 	error::WasmError,
 	runtime_blob::RuntimeBlob,
 	wasm_runtime::{HeapAllocStrategy, WasmModule as _},
 };
-use sc_executor_wasmtime::{Config, DeterministicStackLimit, Semantics, WasmtimeRuntime};
-use sp_core::storage::{ChildInfo, TrackedStorageKey};
-use sp_externalities::MultiRemovalResults;
+use pezsc_executor_wasmtime::{Config, DeterministicStackLimit, Semantics, WasmtimeRuntime};
+use pezsp_core::storage::{ChildInfo, TrackedStorageKey};
+use pezsp_externalities::MultiRemovalResults;
 use std::any::{Any, TypeId};
 
 // Memory configuration
 //
-// When Substrate Runtime is instantiated, a number of WASM pages are allocated for the Substrate
+// When Bizinikiwi Runtime is instantiated, a number of WASM pages are allocated for the Bizinikiwi
 // Runtime instance's linear memory. The exact number of pages is a sum of whatever the WASM blob
 // itself requests (by default at least enough to hold the data section as well as have some space
 // left for the stack; this is, of course, overridable at link time when compiling the runtime)
@@ -54,12 +54,12 @@ pub const DEFAULT_CONFIG: Config = Config {
 	allow_missing_func_imports: true,
 	cache_path: None,
 	semantics: Semantics {
-		heap_alloc_strategy: sc_executor_common::wasm_runtime::HeapAllocStrategy::Dynamic {
+		heap_alloc_strategy: pezsc_executor_common::wasm_runtime::HeapAllocStrategy::Dynamic {
 			maximum_pages: Some(DEFAULT_HEAP_PAGES_ESTIMATE + EXTRA_HEAP_PAGES),
 		},
 
 		instantiation_strategy:
-			sc_executor_wasmtime::InstantiationStrategy::RecreateInstanceCopyOnWrite,
+			pezsc_executor_wasmtime::InstantiationStrategy::RecreateInstanceCopyOnWrite,
 
 		// Enable deterministic stack limit to pin down the exact number of items the wasmtime stack
 		// can contain before it traps with stack overflow.
@@ -111,13 +111,13 @@ pub unsafe fn execute_artifact(
 	executor_params: &ExecutorParams,
 	params: &[u8],
 ) -> Result<Vec<u8>, ExecuteError> {
-	let mut extensions = sp_externalities::Extensions::new();
+	let mut extensions = pezsp_externalities::Extensions::new();
 
-	extensions.register(sp_core::traits::ReadRuntimeVersionExt::new(ReadRuntimeVersion));
+	extensions.register(pezsp_core::traits::ReadRuntimeVersionExt::new(ReadRuntimeVersion));
 
 	let mut ext = ValidationExternalities(extensions);
 
-	match sc_executor::with_externalities_safe(&mut ext, || {
+	match pezsc_executor::with_externalities_safe(&mut ext, || {
 		let runtime = create_runtime_from_artifact_bytes(compiled_artifact_blob, executor_params)?;
 		runtime.new_instance()?.call("validate_block", params)
 	}) {
@@ -142,7 +142,7 @@ pub unsafe fn create_runtime_from_artifact_bytes(
 	let mut config = DEFAULT_CONFIG.clone();
 	config.semantics = params_to_wasmtime_semantics(executor_params).0;
 
-	sc_executor_wasmtime::create_runtime_from_artifact_bytes::<HostFunctions>(
+	pezsc_executor_wasmtime::create_runtime_from_artifact_bytes::<HostFunctions>(
 		compiled_artifact_blob,
 		config,
 	)
@@ -177,7 +177,7 @@ pub fn params_to_wasmtime_semantics(par: &ExecutorParams) -> (Semantics, Determi
 }
 
 /// Runs the prevalidation on the given code. Returns a [`RuntimeBlob`] if it succeeds.
-pub fn prevalidate(code: &[u8]) -> Result<RuntimeBlob, sc_executor_common::error::WasmError> {
+pub fn prevalidate(code: &[u8]) -> Result<RuntimeBlob, pezsc_executor_common::error::WasmError> {
 	// Construct the runtime blob and do some basic checks for consistency.
 	let blob = RuntimeBlob::new(code)?;
 	// In the future this function should take care of any further prevalidation logic.
@@ -189,9 +189,9 @@ pub fn prevalidate(code: &[u8]) -> Result<RuntimeBlob, sc_executor_common::error
 pub fn prepare(
 	blob: RuntimeBlob,
 	executor_params: &ExecutorParams,
-) -> Result<Vec<u8>, sc_executor_common::error::WasmError> {
+) -> Result<Vec<u8>, pezsc_executor_common::error::WasmError> {
 	let (semantics, _) = params_to_wasmtime_semantics(executor_params);
-	sc_executor_wasmtime::prepare_runtime_artifact(blob, &semantics)
+	pezsc_executor_wasmtime::prepare_runtime_artifact(blob, &semantics)
 }
 
 /// Available host functions. We leave out:
@@ -202,19 +202,19 @@ pub fn prepare(
 /// 4. runtime tasks
 /// 5. sandbox
 type HostFunctions = (
-	sp_io::misc::HostFunctions,
-	sp_io::crypto::HostFunctions,
-	sp_io::hashing::HostFunctions,
-	sp_io::allocator::HostFunctions,
-	sp_io::logging::HostFunctions,
-	sp_io::trie::HostFunctions,
+	pezsp_io::misc::HostFunctions,
+	pezsp_io::crypto::HostFunctions,
+	pezsp_io::hashing::HostFunctions,
+	pezsp_io::allocator::HostFunctions,
+	pezsp_io::logging::HostFunctions,
+	pezsp_io::trie::HostFunctions,
 );
 
 /// The validation externalities that will panic on any storage related access. (PVFs should not
 /// have a notion of a persistent storage/trie.)
-struct ValidationExternalities(sp_externalities::Extensions);
+struct ValidationExternalities(pezsp_externalities::Extensions);
 
-impl sp_externalities::Externalities for ValidationExternalities {
+impl pezsp_externalities::Externalities for ValidationExternalities {
 	fn storage(&mut self, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("storage: unsupported feature for teyrchain validation")
 	}
@@ -267,11 +267,11 @@ impl sp_externalities::Externalities for ValidationExternalities {
 		panic!("place_child_storage: unsupported feature for teyrchain validation")
 	}
 
-	fn storage_root(&mut self, _: sp_core::storage::StateVersion) -> Vec<u8> {
+	fn storage_root(&mut self, _: pezsp_core::storage::StateVersion) -> Vec<u8> {
 		panic!("storage_root: unsupported feature for teyrchain validation")
 	}
 
-	fn child_storage_root(&mut self, _: &ChildInfo, _: sp_core::storage::StateVersion) -> Vec<u8> {
+	fn child_storage_root(&mut self, _: &ChildInfo, _: pezsp_core::storage::StateVersion) -> Vec<u8> {
 		panic!("child_storage_root: unsupported feature for teyrchain validation")
 	}
 
@@ -332,7 +332,7 @@ impl sp_externalities::Externalities for ValidationExternalities {
 	}
 }
 
-impl sp_externalities::ExtensionStore for ValidationExternalities {
+impl pezsp_externalities::ExtensionStore for ValidationExternalities {
 	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
 		self.0.get_mut(type_id)
 	}
@@ -340,35 +340,35 @@ impl sp_externalities::ExtensionStore for ValidationExternalities {
 	fn register_extension_with_type_id(
 		&mut self,
 		type_id: TypeId,
-		extension: Box<dyn sp_externalities::Extension>,
-	) -> Result<(), sp_externalities::Error> {
+		extension: Box<dyn pezsp_externalities::Extension>,
+	) -> Result<(), pezsp_externalities::Error> {
 		self.0.register_with_type_id(type_id, extension)
 	}
 
 	fn deregister_extension_by_type_id(
 		&mut self,
 		type_id: TypeId,
-	) -> Result<(), sp_externalities::Error> {
+	) -> Result<(), pezsp_externalities::Error> {
 		if self.0.deregister(type_id) {
 			Ok(())
 		} else {
-			Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
+			Err(pezsp_externalities::Error::ExtensionIsNotRegistered(type_id))
 		}
 	}
 }
 
 struct ReadRuntimeVersion;
 
-impl sp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion {
+impl pezsp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion {
 	fn read_runtime_version(
 		&self,
 		wasm_code: &[u8],
-		_ext: &mut dyn sp_externalities::Externalities,
+		_ext: &mut dyn pezsp_externalities::Externalities,
 	) -> Result<Vec<u8>, String> {
 		let blob = RuntimeBlob::uncompress_if_needed(wasm_code)
 			.map_err(|e| format!("Failed to read the PVF runtime blob: {:?}", e))?;
 
-		match sc_executor::read_embedded_version(&blob)
+		match pezsc_executor::read_embedded_version(&blob)
 			.map_err(|e| format!("Failed to read the static section from the PVF blob: {:?}", e))?
 		{
 			Some(version) => {

pezkuwi/node/core/pvf/common/src/lib.rs

@@ -28,12 +28,12 @@ pub mod worker_dir;
 pub use cpu_time::ProcessTime;
 
 // Used by `decl_worker_main!`.
-pub use sp_tracing;
+pub use pezsp_tracing;
 
 const LOG_TARGET: &str = "teyrchain::pvf-common";
 
 use codec::{Decode, Encode};
-use sp_core::H256;
+use pezsp_core::H256;
 use std::{
 	io::{self, Read, Write},
 	mem,
@@ -95,7 +95,7 @@ pub struct ArtifactChecksum(H256);
 
 /// Compute the checksum of the given artifact.
 pub fn compute_checksum(data: &[u8]) -> ArtifactChecksum {
-	ArtifactChecksum(H256::from_slice(&sp_crypto_hashing::twox_256(data)))
+	ArtifactChecksum(H256::from_slice(&pezsp_crypto_hashing::twox_256(data)))
 }
 
 #[cfg(all(test, not(feature = "test-utils")))]

pezkuwi/node/core/pvf/common/src/pvf.rs

@@ -50,7 +50,7 @@ impl PvfPrepData {
 		validation_code_bomb_limit: u32,
 	) -> Self {
 		let maybe_compressed_code = Arc::new(code);
-		let code_hash = sp_crypto_hashing::blake2_256(&maybe_compressed_code).into();
+		let code_hash = pezsp_crypto_hashing::blake2_256(&maybe_compressed_code).into();
 		let executor_params = Arc::new(executor_params);
 		Self {
 			maybe_compressed_code,

pezkuwi/node/core/pvf/common/src/worker/mod.rs

@@ -59,7 +59,7 @@ macro_rules! decl_worker_main {
 			#[cfg(target_os = "linux")]
 			use $crate::worker::security;
 
-			$crate::sp_tracing::try_init_simple();
+			$crate::pezsp_tracing::try_init_simple();
 
 			let args = std::env::args().collect::<Vec<_>>();
 			if args.len() == 1 {

pezkuwi/node/core/pvf/common/src/worker/security/seccomp.rs

@@ -34,7 +34,7 @@
 //! reasons.
 //!
 //! Considering `io_uring`'s status discussed above, and that it very likely would get detected
-//! either by our [static analysis](https://github.com/paritytech/polkadot-sdk/pull/1663) or by
+//! either by our [static analysis](https://github.com/pezkuwichain/kurdistan-sdk/issues/106) or by
 //! testing, we think it is safe to block it.
 //!
 //! ## Consensus analysis