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/primitives/std/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "pezsp-std"
+version = "14.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Lowest-abstraction level for the Bizinikiwi runtime: just exports useful primitives from std or client/alloc to be used with any code that depends on the runtime."
+documentation = "https://docs.rs/pezsp-std"
+readme = "README.md"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[features]
+default = ["std"]
+std = []

bizinikiwi/primitives/std/README.md

@@ -0,0 +1,4 @@
+Lowest-abstraction level for the Bizinikiwi runtime: just exports useful primitives from std
+or client/alloc to be used with any code that depends on the runtime.
+
+License: Apache-2.0

bizinikiwi/primitives/std/src/lib.rs

@@ -0,0 +1,114 @@
+// 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.
+
+//! Lowest-abstraction level for the Bizinikiwi runtime: just exports useful primitives from std
+//! or client/alloc to be used with any code that depends on the runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(
+	feature = "std",
+	doc = "Bizinikiwi runtime standard library as compiled when linked with Rust's standard library."
+)]
+#![cfg_attr(
+	not(feature = "std"),
+	doc = "Bizinikiwi's runtime standard library as compiled without Rust's standard library."
+)]
+
+/// Initialize a key-value collection from array.
+///
+/// Creates a vector of given pairs and calls `collect` on the iterator from it.
+/// Can be used to create a `HashMap`.
+#[macro_export]
+macro_rules! map {
+	($( $name:expr => $value:expr ),* $(,)? ) => (
+		vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+	)
+}
+
+/// Feature gate some code that should only be run when `std` feature is enabled.
+///
+/// # Example
+///
+/// ```
+/// use pezsp_std::if_std;
+///
+/// if_std! {
+///     // This code is only being compiled and executed when the `std` feature is enabled.
+///     println!("Hello native world");
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[macro_export]
+macro_rules! if_std {
+	( $( $code:tt )* ) => {
+		$( $code )*
+	}
+}
+
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! if_std {
+	( $( $code:tt )* ) => {};
+}
+
+#[cfg(feature = "std")]
+include!("../with_std.rs");
+
+#[cfg(not(feature = "std"))]
+include!("../without_std.rs");
+
+/// A target for `core::write!` macro - constructs a string in memory.
+#[derive(Default)]
+pub struct Writer(vec::Vec<u8>);
+
+impl fmt::Write for Writer {
+	fn write_str(&mut self, s: &str) -> fmt::Result {
+		self.0.extend(s.as_bytes());
+		Ok(())
+	}
+}
+
+impl Writer {
+	/// Access the content of this `Writer` e.g. for printout
+	pub fn inner(&self) -> &vec::Vec<u8> {
+		&self.0
+	}
+
+	/// Convert into the content of this `Writer`
+	pub fn into_inner(self) -> vec::Vec<u8> {
+		self.0
+	}
+}
+
+/// Prelude of common useful imports.
+///
+/// This should include only things which are in the normal std prelude.
+pub mod prelude {
+	pub use crate::{
+		borrow::ToOwned,
+		boxed::Box,
+		clone::Clone,
+		cmp::{Eq, PartialEq, Reverse},
+		iter::IntoIterator,
+		vec::Vec,
+	};
+
+	// Re-export `vec!` macro here, but not in `std` mode, since
+	// std's prelude already brings `vec!` into the scope.
+	#[cfg(not(feature = "std"))]
+	pub use crate::vec;
+}

bizinikiwi/primitives/std/with_std.rs

@@ -0,0 +1,51 @@
+// 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.
+
+pub use std::alloc;
+pub use std::any;
+pub use std::borrow;
+pub use std::boxed;
+pub use std::cell;
+pub use std::clone;
+pub use std::cmp;
+pub use std::convert;
+pub use std::default;
+pub use std::fmt;
+pub use std::hash;
+pub use std::iter;
+pub use std::marker;
+pub use std::mem;
+pub use std::num;
+pub use std::ops;
+pub use std::ptr;
+pub use std::rc;
+pub use std::sync;
+pub use std::result;
+pub use std::slice;
+pub use std::str;
+pub use core::time;
+pub use std::vec;
+
+pub mod collections {
+	pub use std::collections::btree_map;
+	pub use std::collections::btree_set;
+	pub use std::collections::vec_deque;
+}
+
+pub mod thread {
+	pub use std::thread::panicking;
+}

bizinikiwi/primitives/std/without_std.rs

@@ -0,0 +1,65 @@
+// 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.
+
+pub extern crate alloc;
+
+pub use alloc::boxed;
+pub use alloc::rc;
+pub use alloc::sync;
+pub use alloc::vec;
+pub use core::any;
+pub use core::cell;
+pub use core::clone;
+pub use core::cmp;
+pub use core::convert;
+pub use core::default;
+pub use core::fmt;
+pub use core::hash;
+pub use core::iter;
+pub use core::marker;
+pub use core::mem;
+pub use core::num;
+pub use core::ops;
+pub use core::ptr;
+pub use core::result;
+pub use core::slice;
+// Allow interpreting vectors of bytes as strings, but not constructing them.
+pub use core::str;
+pub use core::time;
+// We are trying to avoid certain things here, such as `core::string`
+// (if you need `String` you are probably doing something wrong, since
+// runtime doesn't require anything human readable).
+
+pub mod collections {
+	pub use alloc::collections::btree_map;
+	pub use alloc::collections::btree_set;
+	pub use alloc::collections::vec_deque;
+}
+
+pub mod borrow {
+	pub use core::borrow::*;
+	pub use alloc::borrow::*;
+}
+
+pub mod thread {
+	/// Returns if the current thread is panicking.
+	///
+	/// In wasm this always returns `false`, as we abort on any panic.
+	pub fn panicking() -> bool {
+		false
+	}
+}