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/support/procedural/tools/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "pezframe-support-procedural-tools"
+version = "10.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Proc macro helpers for procedural macros"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+pezframe-support-procedural-tools-derive = { workspace = true, default-features = true }
+proc-macro-crate = { workspace = true }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { features = ["extra-traits", "full", "visit"], workspace = true }

bizinikiwi/pezframe/support/procedural/tools/derive/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "pezframe-support-procedural-tools-derive"
+version = "11.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Use to derive parsing for parsing struct."
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = { workspace = true }
+quote = { features = ["proc-macro"], workspace = true }
+syn = { features = [
+	"extra-traits",
+	"full",
+	"parsing",
+	"proc-macro",
+], workspace = true }

bizinikiwi/pezframe/support/procedural/tools/derive/src/lib.rs

@@ -0,0 +1,152 @@
+// 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.
+
+// tag::description[]
+//! Use to derive parsing for parsing struct.
+// end::description[]
+
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::parse_macro_input;
+
+pub(crate) fn fields_idents(
+	fields: impl Iterator<Item = syn::Field>,
+) -> impl Iterator<Item = proc_macro2::TokenStream> {
+	fields.enumerate().map(|(ix, field)| {
+		field.ident.map(|i| quote! {#i}).unwrap_or_else(|| {
+			let f_ix: syn::Ident = syn::Ident::new(&format!("f_{}", ix), Span::call_site());
+			quote!( #f_ix )
+		})
+	})
+}
+
+pub(crate) fn fields_access(
+	fields: impl Iterator<Item = syn::Field>,
+) -> impl Iterator<Item = proc_macro2::TokenStream> {
+	fields.enumerate().map(|(ix, field)| {
+		field.ident.map(|i| quote!( #i )).unwrap_or_else(|| {
+			let f_ix: syn::Index = syn::Index { index: ix as u32, span: Span::call_site() };
+			quote!( #f_ix )
+		})
+	})
+}
+
+/// self defined parsing struct.
+/// not meant for any struct, just for fast
+/// parse implementation.
+#[proc_macro_derive(Parse)]
+pub fn derive_parse(input: TokenStream) -> TokenStream {
+	let item = parse_macro_input!(input as syn::Item);
+	match item {
+		syn::Item::Struct(input) => derive_parse_struct(input),
+		_ => TokenStream::new(), // ignore
+	}
+}
+
+fn derive_parse_struct(input: syn::ItemStruct) -> TokenStream {
+	let syn::ItemStruct { ident, generics, fields, .. } = input;
+	let field_names = {
+		let name = fields_idents(fields.iter().map(Clone::clone));
+		quote! {
+			#(
+				#name,
+			)*
+		}
+	};
+	let field = fields_idents(fields.iter().map(Clone::clone));
+	let tokens = quote! {
+		impl #generics syn::parse::Parse for #ident #generics {
+			fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> {
+				#(
+					let #field = input.parse()?;
+				)*
+				Ok(Self {
+					#field_names
+				})
+			}
+		}
+	};
+	tokens.into()
+}
+
+/// self defined parsing struct or enum.
+/// not meant for any struct/enum, just for fast
+/// parse implementation.
+/// For enum:
+///   it only output fields (empty field act as a None).
+#[proc_macro_derive(ToTokens)]
+pub fn derive_totokens(input: TokenStream) -> TokenStream {
+	let item = parse_macro_input!(input as syn::Item);
+	match item {
+		syn::Item::Enum(input) => derive_totokens_enum(input),
+		syn::Item::Struct(input) => derive_totokens_struct(input),
+		_ => TokenStream::new(), // ignore
+	}
+}
+
+fn derive_totokens_struct(input: syn::ItemStruct) -> TokenStream {
+	let syn::ItemStruct { ident, generics, fields, .. } = input;
+
+	let fields = fields_access(fields.iter().map(Clone::clone));
+	let tokens = quote! {
+
+		impl #generics quote::ToTokens for #ident #generics {
+			fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+				#(
+					self.#fields.to_tokens(tokens);
+				)*
+			}
+		}
+
+	};
+	tokens.into()
+}
+
+fn derive_totokens_enum(input: syn::ItemEnum) -> TokenStream {
+	let syn::ItemEnum { ident, generics, variants, .. } = input;
+	let variants = variants.iter().map(|v| {
+		let v_ident = v.ident.clone();
+		let fields_build = if v.fields.iter().count() > 0 {
+			let fields_id = fields_idents(v.fields.iter().map(Clone::clone));
+			quote!( (#(#fields_id), *) )
+		} else {
+			quote!()
+		};
+		let field = fields_idents(v.fields.iter().map(Clone::clone));
+		quote! {
+			#ident::#v_ident #fields_build => {
+				#(
+					#field.to_tokens(tokens);
+				)*
+			},
+		}
+	});
+	let tokens = quote! {
+		impl #generics quote::ToTokens for #ident #generics {
+			fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+				match self {
+					#(
+						#variants
+					)*
+				}
+			}
+		}
+	};
+
+	tokens.into()
+}

bizinikiwi/pezframe/support/procedural/tools/src/lib.rs

@@ -0,0 +1,197 @@
+// 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.
+
+// tag::description[]
+//! Proc macro helpers for procedural macros
+// end::description[]
+
+// reexport proc macros
+pub use pezframe_support_procedural_tools_derive::*;
+
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+use syn::parse::Error;
+
+pub mod syn_ext;
+
+// FIXME #1569, remove the following functions, which are copied from sp-api-macros
+use proc_macro2::{Span, TokenStream};
+use syn::Ident;
+
+fn generate_hidden_includes_mod_name(unique_id: &str) -> Ident {
+	Ident::new(&format!("pezsp_api_hidden_includes_{}", unique_id), Span::call_site())
+}
+
+/// Generates the access to the `pezframe-support` crate.
+pub fn generate_crate_access(unique_id: &str, def_crate: &str) -> TokenStream {
+	if std::env::var("CARGO_PKG_NAME").unwrap() == def_crate {
+		let pezframe_support = match generate_access_from_frame_or_crate("pezframe-support") {
+			Ok(c) => c,
+			Err(e) => return e.into_compile_error().into(),
+		};
+		quote::quote!(#pezframe_support)
+	} else {
+		let mod_name = generate_hidden_includes_mod_name(unique_id);
+		quote::quote!( self::#mod_name::hidden_include )
+	}
+}
+
+/// Check if a path is using the `frame` crate or not.
+///
+/// This will usually check the output of [`generate_access_from_frame_or_crate`].
+/// We want to know if whatever the `path` takes us to, is exported from `frame` or not. In that
+/// case `path` would start with `frame`, something like `pezkuwi_sdk_frame::x::y:z` or
+/// frame::x::y:z.
+pub fn is_using_frame_crate(path: &syn::Path) -> bool {
+	path.segments
+		.first()
+		.map(|s| s.ident == "pezkuwi_sdk_frame" || s.ident == "frame")
+		.unwrap_or(false)
+}
+
+/// Generate the crate access for the crate using 2018 syntax.
+///
+/// If `frame` is in scope, it will use `pezkuwi_sdk_frame::deps::<def_crate>`. Else, it will try
+/// and find `<def_crate>` directly.
+pub fn generate_access_from_frame_or_crate(def_crate: &str) -> Result<syn::Path, Error> {
+	if let Some(path) = get_frame_crate_path(def_crate) {
+		Ok(path)
+	} else if let Some(path) = get_sdk_crate_path(def_crate) {
+		Ok(path)
+	} else {
+		let ident = match crate_name(def_crate) {
+			Ok(FoundCrate::Itself) => {
+				let name = def_crate.to_string().replace("-", "_");
+				Ok(syn::Ident::new(&name, Span::call_site()))
+			},
+			Ok(FoundCrate::Name(name)) => Ok(Ident::new(&name, Span::call_site())),
+			Err(e) => Err(Error::new(Span::call_site(), e)),
+		}?;
+
+		Ok(syn::Path::from(ident))
+	}
+}
+
+/// Generates the hidden includes that are required to make the macro independent from its scope.
+pub fn generate_hidden_includes(unique_id: &str, def_crate: &str) -> TokenStream {
+	let mod_name = generate_hidden_includes_mod_name(unique_id);
+
+	if let Some(path) = get_frame_crate_path(def_crate) {
+		quote::quote!(
+			#[doc(hidden)]
+			mod #mod_name {
+				pub use #path as hidden_include;
+			}
+		)
+	} else if let Some(path) = get_sdk_crate_path(def_crate) {
+		quote::quote!(
+			#[doc(hidden)]
+			mod #mod_name {
+				pub use #path as hidden_include;
+			}
+		)
+	} else {
+		match crate_name(def_crate) {
+			Ok(FoundCrate::Itself) => quote!(),
+			Ok(FoundCrate::Name(name)) => {
+				let name = Ident::new(&name, Span::call_site());
+				quote::quote!(
+					#[doc(hidden)]
+					mod #mod_name {
+						pub use #name as hidden_include;
+					}
+				)
+			},
+			Err(e) => {
+				let err = Error::new(Span::call_site(), e).to_compile_error();
+				quote!( #err )
+			},
+		}
+	}
+}
+
+/// Generates the path to the frame crate deps.
+fn get_frame_crate_path(def_crate: &str) -> Option<syn::Path> {
+	// This does not work if the frame crate is renamed.
+	if let Ok(FoundCrate::Name(name)) =
+		crate_name(&"pezkuwi-sdk-frame").or_else(|_| crate_name(&"frame"))
+	{
+		let path = format!("{}::deps::{}", name, def_crate.to_string().replace("-", "_"));
+		Some(syn::parse_str::<syn::Path>(&path).expect("is a valid path; qed"))
+	} else {
+		None
+	}
+}
+
+fn get_sdk_crate_path(def_crate: &str) -> Option<syn::Path> {
+	if let Ok(FoundCrate::Name(name)) = crate_name(&"pezkuwi-sdk") {
+		let path = format!("{}::{}", name, def_crate.to_string()).replace("-", "_");
+		Some(syn::parse_str::<syn::Path>(&path).expect("is a valid path; qed"))
+	} else {
+		None
+	}
+}
+
+// fn to remove white spaces around string types
+// (basically whitespaces around tokens)
+pub fn clean_type_string(input: &str) -> String {
+	input
+		.replace(" ::", "::")
+		.replace(":: ", "::")
+		.replace(" ,", ",")
+		.replace(" ;", ";")
+		.replace(" [", "[")
+		.replace("[ ", "[")
+		.replace(" ]", "]")
+		.replace(" (", "(")
+		.replace("( ", "(")
+		.replace(" )", ")")
+		.replace(" <", "<")
+		.replace("< ", "<")
+		.replace(" >", ">")
+}
+
+/// Return all doc attributes literals found.
+pub fn get_doc_literals(attrs: &[syn::Attribute]) -> Vec<syn::Expr> {
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if let syn::Meta::NameValue(meta) = &attr.meta {
+				meta.path
+					.get_ident()
+					.filter(|ident| *ident == "doc")
+					.map(|_| meta.value.clone())
+			} else {
+				None
+			}
+		})
+		.collect()
+}
+
+/// Return all cfg attributes literals found.
+pub fn get_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if let syn::Meta::List(meta) = &attr.meta {
+				meta.path.get_ident().filter(|ident| *ident == "cfg").map(|_| attr.clone())
+			} else {
+				None
+			}
+		})
+		.collect()
+}

bizinikiwi/pezframe/support/procedural/tools/src/syn_ext.rs

@@ -0,0 +1,230 @@
+// 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.
+
+// tag::description[]
+//! Extension to syn types, mainly for parsing
+// end::description[]
+
+use pezframe_support_procedural_tools_derive::{Parse, ToTokens};
+use proc_macro2::{TokenStream, TokenTree};
+use quote::ToTokens;
+use std::iter::once;
+use syn::{
+	parse::{Parse, ParseStream, Result},
+	visit::{self, Visit},
+	Ident,
+};
+
+/// stop parsing here getting remaining token as content
+/// Warn duplicate stream (part of)
+#[derive(Parse, ToTokens, Debug)]
+pub struct StopParse {
+	pub inner: TokenStream,
+}
+
+// inner macro really dependant on syn naming convention, do not export
+macro_rules! groups_impl {
+	($name:ident, $tok:ident, $deli:ident, $parse:ident) => {
+		#[derive(Debug)]
+		pub struct $name<P> {
+			pub token: syn::token::$tok,
+			pub content: P,
+		}
+
+		impl<P: Parse> Parse for $name<P> {
+			fn parse(input: ParseStream) -> Result<Self> {
+				let content;
+				let token = syn::$parse!(content in input);
+				let content = content.parse()?;
+				Ok($name { token, content })
+			}
+		}
+
+		impl<P: ToTokens> ToTokens for $name<P> {
+			fn to_tokens(&self, tokens: &mut TokenStream) {
+				let mut inner_stream = TokenStream::new();
+				self.content.to_tokens(&mut inner_stream);
+				let token_tree: proc_macro2::TokenTree =
+					proc_macro2::Group::new(proc_macro2::Delimiter::$deli, inner_stream).into();
+				tokens.extend(once(token_tree));
+			}
+		}
+
+		impl<P: Clone> Clone for $name<P> {
+			fn clone(&self) -> Self {
+				Self { token: self.token.clone(), content: self.content.clone() }
+			}
+		}
+	};
+}
+
+groups_impl!(Braces, Brace, Brace, braced);
+groups_impl!(Brackets, Bracket, Bracket, bracketed);
+groups_impl!(Parens, Paren, Parenthesis, parenthesized);
+
+#[derive(Debug)]
+pub struct PunctuatedInner<P, T, V> {
+	pub inner: syn::punctuated::Punctuated<P, T>,
+	pub variant: V,
+}
+
+#[derive(Debug, Clone)]
+pub struct NoTrailing;
+
+#[derive(Debug, Clone)]
+pub struct Trailing;
+
+pub type Punctuated<P, T> = PunctuatedInner<P, T, NoTrailing>;
+
+pub type PunctuatedTrailing<P, T> = PunctuatedInner<P, T, Trailing>;
+
+impl<P: Parse, T: Parse + syn::token::Token> Parse for PunctuatedInner<P, T, Trailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_separated_nonempty(input)?,
+			variant: Trailing,
+		})
+	}
+}
+
+impl<P: Parse, T: Parse> Parse for PunctuatedInner<P, T, NoTrailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_terminated(input)?,
+			variant: NoTrailing,
+		})
+	}
+}
+
+impl<P: ToTokens, T: ToTokens, V> ToTokens for PunctuatedInner<P, T, V> {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.inner.to_tokens(tokens)
+	}
+}
+
+impl<P: Clone, T: Clone, V: Clone> Clone for PunctuatedInner<P, T, V> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner.clone(), variant: self.variant.clone() }
+	}
+}
+
+/// Note that syn Meta is almost fine for use case (lacks only `ToToken`)
+#[derive(Debug, Clone)]
+pub struct Meta {
+	pub inner: syn::Meta,
+}
+
+impl Parse for Meta {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(Meta { inner: syn::Meta::parse(input)? })
+	}
+}
+
+impl ToTokens for Meta {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self.inner {
+			syn::Meta::Path(ref path) => path.to_tokens(tokens),
+			syn::Meta::List(ref l) => l.to_tokens(tokens),
+			syn::Meta::NameValue(ref n) => n.to_tokens(tokens),
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct OuterAttributes {
+	pub inner: Vec<syn::Attribute>,
+}
+
+impl Parse for OuterAttributes {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let inner = syn::Attribute::parse_outer(input)?;
+		Ok(OuterAttributes { inner })
+	}
+}
+
+impl ToTokens for OuterAttributes {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		for att in self.inner.iter() {
+			att.to_tokens(tokens);
+		}
+	}
+}
+
+pub fn extract_type_option(typ: &syn::Type) -> Option<syn::Type> {
+	if let syn::Type::Path(ref path) = typ {
+		let v = path.path.segments.last()?;
+		if v.ident == "Option" {
+			// Option has only one type argument in angle bracket.
+			if let syn::PathArguments::AngleBracketed(a) = &v.arguments {
+				if let syn::GenericArgument::Type(typ) = a.args.last()? {
+					return Some(typ.clone());
+				}
+			}
+		}
+	}
+
+	None
+}
+
+/// Auxiliary structure to check if a given `Ident` is contained in an ast.
+struct ContainsIdent<'a> {
+	ident: &'a Ident,
+	result: bool,
+}
+
+impl<'ast> ContainsIdent<'ast> {
+	fn visit_tokenstream(&mut self, stream: TokenStream) {
+		stream.into_iter().for_each(|tt| match tt {
+			TokenTree::Ident(id) => self.visit_ident(&id),
+			TokenTree::Group(ref group) => self.visit_tokenstream(group.stream()),
+			_ => {},
+		})
+	}
+
+	fn visit_ident(&mut self, ident: &Ident) {
+		if ident == self.ident {
+			self.result = true;
+		}
+	}
+}
+
+impl<'ast> Visit<'ast> for ContainsIdent<'ast> {
+	fn visit_ident(&mut self, input: &'ast Ident) {
+		self.visit_ident(input);
+	}
+
+	fn visit_macro(&mut self, input: &'ast syn::Macro) {
+		self.visit_tokenstream(input.tokens.clone());
+		visit::visit_macro(self, input);
+	}
+}
+
+/// Check if a `Type` contains the given `Ident`.
+pub fn type_contains_ident(typ: &syn::Type, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent { result: false, ident };
+
+	visit::visit_type(&mut visit, typ);
+	visit.result
+}
+
+/// Check if a `Expr` contains the given `Ident`.
+pub fn expr_contains_ident(expr: &syn::Expr, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent { result: false, ident };
+
+	visit::visit_expr(&mut visit, expr);
+	visit.result
+}