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/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
+}