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-api/src/system/error.rs

@@ -0,0 +1,66 @@
+// 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/>.
+
+//! System RPC module errors.
+
+use crate::system::helpers::Health;
+use jsonrpsee::types::{
+	error::{ErrorCode, ErrorObject},
+	ErrorObjectOwned,
+};
+
+/// System RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// System RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Provided block range couldn't be resolved to a list of blocks.
+	#[error("Node is not fully functional: {}", .0)]
+	NotHealthy(Health),
+	/// Peer argument is malformatted.
+	#[error("{0}")]
+	MalformattedPeerArg(String),
+	/// Call to an unsafe RPC was denied.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+	/// Internal error.
+	#[error("{0}")]
+	Internal(String),
+}
+
+// Base code for all system errors.
+const BASE_ERROR: i32 = crate::error::base::SYSTEM;
+// Provided block range couldn't be resolved to a list of blocks.
+const NOT_HEALTHY_ERROR: i32 = BASE_ERROR + 1;
+// Peer argument is malformatted.
+const MALFORMATTED_PEER_ARG_ERROR: i32 = BASE_ERROR + 2;
+
+impl From<Error> for ErrorObjectOwned {
+	fn from(e: Error) -> ErrorObjectOwned {
+		match e {
+			Error::NotHealthy(ref h) =>
+				ErrorObject::owned(NOT_HEALTHY_ERROR, e.to_string(), Some(h)),
+			Error::MalformattedPeerArg(e) =>
+				ErrorObject::owned(MALFORMATTED_PEER_ARG_ERROR, e, None::<()>),
+			Error::UnsafeRpcCalled(e) => e.into(),
+			Error::Internal(e) =>
+				ErrorObjectOwned::owned(ErrorCode::InternalError.code(), e, None::<()>),
+		}
+	}
+}

bizinikiwi/client/rpc-api/src/system/helpers.rs

@@ -0,0 +1,148 @@
+// 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 helpers.
+
+use pezsc_chain_spec::{ChainType, Properties};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// Running node's static details.
+#[derive(Clone, Debug)]
+pub struct SystemInfo {
+	/// Implementation name.
+	pub impl_name: String,
+	/// Implementation version.
+	pub impl_version: String,
+	/// Chain name.
+	pub chain_name: String,
+	/// A custom set of properties defined in the chain spec.
+	pub properties: Properties,
+	/// The type of this chain.
+	pub chain_type: ChainType,
+}
+
+/// Health struct returned by the RPC
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Health {
+	/// Number of connected peers
+	pub peers: usize,
+	/// Is the node syncing
+	pub is_syncing: bool,
+	/// Should this node have any peers
+	///
+	/// Might be false for local chains or when running without discovery.
+	pub should_have_peers: bool,
+}
+
+impl fmt::Display for Health {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		write!(fmt, "{} peers ({})", self.peers, if self.is_syncing { "syncing" } else { "idle" })
+	}
+}
+
+/// Network Peer information
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeerInfo<Hash, Number> {
+	/// Peer ID
+	pub peer_id: String,
+	/// Roles
+	pub roles: String,
+	/// Peer best block hash
+	pub best_hash: Hash,
+	/// Peer best block number
+	pub best_number: Number,
+}
+
+/// The role the node is running as
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NodeRole {
+	/// The node is a full node
+	Full,
+	/// The node is an authority
+	Authority,
+}
+
+/// The state of the syncing of the node.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncState<Number> {
+	/// Height of the block at which syncing started.
+	pub starting_block: Number,
+	/// Height of the current best block of the node.
+	pub current_block: Number,
+	/// Height of the highest block in the network.
+	pub highest_block: Number,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_serialize_health() {
+		assert_eq!(
+			::serde_json::to_string(&Health {
+				peers: 1,
+				is_syncing: false,
+				should_have_peers: true,
+			})
+			.unwrap(),
+			r#"{"peers":1,"isSyncing":false,"shouldHavePeers":true}"#,
+		);
+	}
+
+	#[test]
+	fn should_serialize_peer_info() {
+		assert_eq!(
+			::serde_json::to_string(&PeerInfo {
+				peer_id: "2".into(),
+				roles: "a".into(),
+				best_hash: 5u32,
+				best_number: 6u32,
+			})
+			.unwrap(),
+			r#"{"peerId":"2","roles":"a","bestHash":5,"bestNumber":6}"#,
+		);
+	}
+
+	#[test]
+	fn should_serialize_sync_state() {
+		assert_eq!(
+			::serde_json::to_string(&SyncState {
+				starting_block: 12u32,
+				current_block: 50u32,
+				highest_block: 128u32,
+			})
+			.unwrap(),
+			r#"{"startingBlock":12,"currentBlock":50,"highestBlock":128}"#,
+		);
+
+		assert_eq!(
+			::serde_json::to_string(&SyncState {
+				starting_block: 12u32,
+				current_block: 50u32,
+				highest_block: 50u32,
+			})
+			.unwrap(),
+			r#"{"startingBlock":12,"currentBlock":50,"highestBlock":50}"#,
+		);
+	}
+}

bizinikiwi/client/rpc-api/src/system/mod.rs

@@ -0,0 +1,121 @@
+// 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.
+
+pub mod error;
+pub mod helpers;
+
+use jsonrpsee::{core::JsonValue, proc_macros::rpc};
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
+pub use error::Error;
+
+/// Bizinikiwi system RPC API
+#[rpc(client, server)]
+pub trait SystemApi<Hash, Number> {
+	/// Get the node's implementation name. Plain old string.
+	#[method(name = "system_name")]
+	fn system_name(&self) -> Result<String, Error>;
+
+	/// Get the node implementation's version. Should be a semver string.
+	#[method(name = "system_version")]
+	fn system_version(&self) -> Result<String, Error>;
+
+	/// Get the chain's name. Given as a string identifier.
+	#[method(name = "system_chain")]
+	fn system_chain(&self) -> Result<String, Error>;
+
+	/// Get the chain's type.
+	#[method(name = "system_chainType")]
+	fn system_type(&self) -> Result<pezsc_chain_spec::ChainType, Error>;
+
+	/// Get a custom set of properties as a JSON object, defined in the chain spec.
+	#[method(name = "system_properties")]
+	fn system_properties(&self) -> Result<pezsc_chain_spec::Properties, Error>;
+
+	/// Return health status of the node.
+	///
+	/// Node is considered healthy if it is:
+	/// - connected to some peers (unless running in dev mode)
+	/// - not performing a major sync
+	#[method(name = "system_health")]
+	async fn system_health(&self) -> Result<Health, Error>;
+
+	/// Returns the base58-encoded PeerId of the node.
+	#[method(name = "system_localPeerId")]
+	async fn system_local_peer_id(&self) -> Result<String, Error>;
+
+	/// Returns the multi-addresses that the local node is listening on
+	///
+	/// The addresses include a trailing `/p2p/` with the local PeerId, and are thus suitable to
+	/// be passed to `addReservedPeer` or as a bootnode address for example.
+	#[method(name = "system_localListenAddresses")]
+	async fn system_local_listen_addresses(&self) -> Result<Vec<String>, Error>;
+
+	/// Returns currently connected peers
+	#[method(name = "system_peers", with_extensions)]
+	async fn system_peers(&self) -> Result<Vec<PeerInfo<Hash, Number>>, Error>;
+
+	/// Returns current state of the network.
+	///
+	/// **Warning**: This API is not stable. Please do not programmatically interpret its output,
+	/// as its format might change at any time.
+	// TODO: the future of this call is uncertain: https://github.com/pezkuwichain/kurdistan-sdk/issues/22
+	// https://github.com/pezkuwichain/kurdistan-sdk/issues/26
+	#[method(name = "system_unstable_networkState", with_extensions)]
+	async fn system_network_state(&self) -> Result<JsonValue, Error>;
+
+	/// Adds a reserved peer. Returns the empty string or an error. The string
+	/// parameter should encode a `p2p` multiaddr.
+	///
+	/// `/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`
+	/// is an example of a valid, passing multiaddr with PeerId attached.
+	#[method(name = "system_addReservedPeer", with_extensions)]
+	async fn system_add_reserved_peer(&self, peer: String) -> Result<(), Error>;
+
+	/// Remove a reserved peer. Returns the empty string or an error. The string
+	/// should encode only the PeerId e.g. `QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`.
+	#[method(name = "system_removeReservedPeer", with_extensions)]
+	async fn system_remove_reserved_peer(&self, peer_id: String) -> Result<(), Error>;
+
+	/// Returns the list of reserved peers
+	#[method(name = "system_reservedPeers")]
+	async fn system_reserved_peers(&self) -> Result<Vec<String>, Error>;
+
+	/// Returns the roles the node is running as.
+	#[method(name = "system_nodeRoles")]
+	async fn system_node_roles(&self) -> Result<Vec<NodeRole>, Error>;
+
+	/// Returns the state of the syncing of the node: starting block, current best block, highest
+	/// known block.
+	#[method(name = "system_syncState")]
+	async fn system_sync_state(&self) -> Result<SyncState<Number>, Error>;
+
+	/// Adds the supplied directives to the current log filter
+	///
+	/// The syntax is identical to the CLI `<target>=<level>`:
+	///
+	/// `sync=debug,state=trace`
+	#[method(name = "system_addLogFilter", with_extensions)]
+	fn system_add_log_filter(&self, directives: String) -> Result<(), Error>;
+
+	/// Resets the log filter to Bizinikiwi defaults
+	#[method(name = "system_resetLogFilter", with_extensions)]
+	fn system_reset_log_filter(&self) -> Result<(), Error>;
+}