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/crypto/hashing/proc-macro/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "pezsp-crypto-hashing-proc-macro"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Procedural macros for calculating static hashes."
+documentation = "https://docs.rs/pezsp-crypto-hashing-proc-macro"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = { workspace = true }
+pezsp-crypto-hashing = { workspace = true }
+syn = { features = ["full", "parsing"], workspace = true }

bizinikiwi/primitives/crypto/hashing/proc-macro/src/impls.rs

@@ -0,0 +1,124 @@
+// 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.
+
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
+
+use proc_macro::TokenStream;
+
+pub(super) struct InputBytes(pub Vec<u8>);
+
+pub(super) struct MultipleInputBytes(pub Vec<Vec<u8>>);
+
+impl MultipleInputBytes {
+	pub(super) fn concatenated(mut self) -> Vec<u8> {
+		if self.0.is_empty() {
+			Vec::new()
+		} else {
+			let mut result = core::mem::take(&mut self.0[0]);
+			for other in self.0[1..].iter_mut() {
+				result.append(other);
+			}
+			result
+		}
+	}
+}
+
+impl Parse for InputBytes {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		match syn::ExprArray::parse(input) {
+			Ok(array) => {
+				let mut bytes = Vec::<u8>::new();
+				for expr in array.elems.iter() {
+					match expr {
+						syn::Expr::Lit(lit) => match &lit.lit {
+							syn::Lit::Int(b) => bytes.push(b.base10_parse()?),
+							syn::Lit::Byte(b) => bytes.push(b.value()),
+							_ =>
+								return Err(syn::Error::new(
+									input.span(),
+									"Expected array of u8 elements.".to_string(),
+								)),
+						},
+						_ =>
+							return Err(syn::Error::new(
+								input.span(),
+								"Expected array of u8 elements.".to_string(),
+							)),
+					}
+				}
+				return Ok(InputBytes(bytes));
+			},
+			Err(_e) => (),
+		}
+		// use rust names as a vec of their utf8 bytecode.
+		match syn::Ident::parse(input) {
+			Ok(ident) => return Ok(InputBytes(ident.to_string().as_bytes().to_vec())),
+			Err(_e) => (),
+		}
+		Ok(InputBytes(syn::LitByteStr::parse(input)?.value()))
+	}
+}
+
+impl Parse for MultipleInputBytes {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		let elts =
+			syn::punctuated::Punctuated::<InputBytes, syn::token::Comma>::parse_terminated(input)?;
+		Ok(MultipleInputBytes(elts.into_iter().map(|elt| elt.0).collect()))
+	}
+}
+
+pub(super) fn twox_64(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::twox_64(bytes.as_slice()))
+}
+
+pub(super) fn twox_128(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::twox_128(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_512(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::blake2_512(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::blake2_256(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_64(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::blake2_64(bytes.as_slice()))
+}
+
+pub(super) fn keccak_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::keccak_256(bytes.as_slice()))
+}
+
+pub(super) fn keccak_512(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::keccak_512(bytes.as_slice()))
+}
+
+pub(super) fn sha2_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(pezsp_crypto_hashing::sha2_256(bytes.as_slice()))
+}
+
+fn bytes_to_array(bytes: impl IntoIterator<Item = u8>) -> TokenStream {
+	let bytes = bytes.into_iter();
+
+	quote!(
+		[ #( #bytes ),* ]
+	)
+	.into()
+}

bizinikiwi/primitives/crypto/hashing/proc-macro/src/lib.rs

@@ -0,0 +1,129 @@
+// 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.
+
+//! Macros to calculate constant hash bytes result.
+//!
+//! Macros from this crate does apply a specific hash function on input.
+//! Input can be literal byte array as `b"content"` or array of bytes
+//! as `[1, 2, 3]`.
+//! Rust identifier can also be use, in this case we use their utf8 string
+//! byte representation, for instance if the ident is `MyStruct`, then
+//! `b"MyStruct"` will be hashed.
+//! If multiple arguments comma separated are passed, they are concatenated
+//! then hashed.
+//!
+//! Examples:
+//!
+//! ```rust
+//! assert_eq!(
+//! 	pezsp_crypto_hashing_proc_macro::blake2b_256!(b"test"),
+//! 	pezsp_crypto_hashing::blake2_256(b"test"),
+//! );
+//! assert_eq!(
+//! 	pezsp_crypto_hashing_proc_macro::blake2b_256!([1u8]),
+//! 	pezsp_crypto_hashing::blake2_256(&[1u8]),
+//! );
+//! assert_eq!(
+//! 	pezsp_crypto_hashing_proc_macro::blake2b_256!([1, 2, 3]),
+//! 	pezsp_crypto_hashing::blake2_256(&[1, 2, 3]),
+//! );
+//! assert_eq!(
+//! 	pezsp_crypto_hashing_proc_macro::blake2b_256!(identifier),
+//! 	pezsp_crypto_hashing::blake2_256(b"identifier"),
+//! );
+//! assert_eq!(
+//! 	pezsp_crypto_hashing_proc_macro::blake2b_256!(identifier, b"/string"),
+//! 	pezsp_crypto_hashing::blake2_256(b"identifier/string"),
+//! );
+//! ```
+
+mod impls;
+
+use impls::MultipleInputBytes;
+use proc_macro::TokenStream;
+
+/// Process a Blake2 64-bit hash of bytes parameter outputs a `[u8; 8]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_64(input: TokenStream) -> TokenStream {
+	impls::blake2b_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a Blake2 256-bit hash of bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_256(input: TokenStream) -> TokenStream {
+	impls::blake2b_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a Blake2 512-bit hash of bytes parameter, outputs a `[u8; 64]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_512(input: TokenStream) -> TokenStream {
+	impls::blake2b_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a XX 64-bit hash on its bytes parameter, outputs a `[u8; 8]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn twox_64(input: TokenStream) -> TokenStream {
+	impls::twox_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a XX 128-bit hash on its bytes parameter, outputs a `[u8; 16]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn twox_128(input: TokenStream) -> TokenStream {
+	impls::twox_128(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a keccak 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn keccak_256(input: TokenStream) -> TokenStream {
+	impls::keccak_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a keccak 512-bit hash on its bytes parameter, outputs a `[u8; 64]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn keccak_512(input: TokenStream) -> TokenStream {
+	impls::keccak_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a sha2 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn sha2_256(input: TokenStream) -> TokenStream {
+	impls::sha2_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}