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/client/rpc/src/system/mod.rs

@@ -0,0 +1,190 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! Bizinikiwi system API.
+
+#[cfg(test)]
+mod tests;
+
+use futures::channel::oneshot;
+use jsonrpsee::{
+	core::{async_trait, JsonValue},
+	Extensions,
+};
+use pezsc_rpc_api::check_if_safe;
+use pezsc_tracing::logging;
+use pezsc_utils::mpsc::TracingUnboundedSender;
+use pezsp_runtime::traits::{self, Header as HeaderT};
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
+pub use pezsc_rpc_api::system::*;
+
+/// System API implementation
+pub struct System<B: traits::Block> {
+	info: SystemInfo,
+	send_back: TracingUnboundedSender<Request<B>>,
+}
+
+/// Request to be processed.
+pub enum Request<B: traits::Block> {
+	/// Must return the health of the network.
+	Health(oneshot::Sender<Health>),
+	/// Must return the base58-encoded local `PeerId`.
+	LocalPeerId(oneshot::Sender<String>),
+	/// Must return the string representation of the addresses we listen on, including the
+	/// trailing `/p2p/`.
+	LocalListenAddresses(oneshot::Sender<Vec<String>>),
+	/// Must return information about the peers we are connected to.
+	Peers(oneshot::Sender<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>),
+	/// Must return the state of the network.
+	NetworkState(oneshot::Sender<serde_json::Value>),
+	/// Must return any potential parse error.
+	NetworkAddReservedPeer(String, oneshot::Sender<error::Result<()>>),
+	/// Must return any potential parse error.
+	NetworkRemoveReservedPeer(String, oneshot::Sender<error::Result<()>>),
+	/// Must return the list of reserved peers
+	NetworkReservedPeers(oneshot::Sender<Vec<String>>),
+	/// Must return the node role.
+	NodeRoles(oneshot::Sender<Vec<NodeRole>>),
+	/// Must return the state of the node syncing.
+	SyncState(oneshot::Sender<SyncState<<B::Header as HeaderT>::Number>>),
+}
+
+impl<B: traits::Block> System<B> {
+	/// Creates new `System`.
+	///
+	/// The `send_back` will be used to transmit some of the requests. The user is responsible for
+	/// reading from that channel and answering the requests.
+	pub fn new(info: SystemInfo, send_back: TracingUnboundedSender<Request<B>>) -> Self {
+		System { info, send_back }
+	}
+}
+
+#[async_trait]
+impl<B: traits::Block> SystemApiServer<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
+	fn system_name(&self) -> Result<String, Error> {
+		Ok(self.info.impl_name.clone())
+	}
+
+	fn system_version(&self) -> Result<String, Error> {
+		Ok(self.info.impl_version.clone())
+	}
+
+	fn system_chain(&self) -> Result<String, Error> {
+		Ok(self.info.chain_name.clone())
+	}
+
+	fn system_type(&self) -> Result<pezsc_chain_spec::ChainType, Error> {
+		Ok(self.info.chain_type.clone())
+	}
+
+	fn system_properties(&self) -> Result<pezsc_chain_spec::Properties, Error> {
+		Ok(self.info.properties.clone())
+	}
+
+	async fn system_health(&self) -> Result<Health, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Health(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_local_peer_id(&self) -> Result<String, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::LocalPeerId(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_local_listen_addresses(&self) -> Result<Vec<String>, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::LocalListenAddresses(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_peers(
+		&self,
+		ext: &Extensions,
+	) -> Result<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>, Error> {
+		check_if_safe(ext)?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Peers(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_network_state(&self, ext: &Extensions) -> Result<JsonValue, Error> {
+		check_if_safe(ext)?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_add_reserved_peer(&self, ext: &Extensions, peer: String) -> Result<(), Error> {
+		check_if_safe(ext)?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkAddReservedPeer(peer, tx));
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(e),
+			Err(e) => Err(Error::Internal(e.to_string())),
+		}
+	}
+
+	async fn system_remove_reserved_peer(
+		&self,
+		ext: &Extensions,
+		peer: String,
+	) -> Result<(), Error> {
+		check_if_safe(ext)?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkRemoveReservedPeer(peer, tx));
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(e),
+			Err(e) => Err(Error::Internal(e.to_string())),
+		}
+	}
+
+	async fn system_reserved_peers(&self) -> Result<Vec<String>, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkReservedPeers(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_node_roles(&self) -> Result<Vec<NodeRole>, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	async fn system_sync_state(&self) -> Result<SyncState<<B::Header as HeaderT>::Number>, Error> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::SyncState(tx));
+		rx.await.map_err(|e| Error::Internal(e.to_string()))
+	}
+
+	fn system_add_log_filter(&self, ext: &Extensions, directives: String) -> Result<(), Error> {
+		check_if_safe(ext)?;
+
+		logging::add_directives(&directives);
+		logging::reload_filter().map_err(|e| Error::Internal(e))
+	}
+
+	fn system_reset_log_filter(&self, ext: &Extensions) -> Result<(), Error> {
+		check_if_safe(ext)?;
+		logging::reset_log_filter().map_err(|e| Error::Internal(e))
+	}
+}