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/utils/pezframe/rpc/system/src/lib.rs

@@ -0,0 +1,377 @@
+// 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.
+
+//! System FRAME specific RPC methods.
+
+use std::{fmt::Display, sync::Arc};
+
+use codec::{self, Codec, Decode, Encode};
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	proc_macros::rpc,
+	types::error::ErrorObject,
+	Extensions,
+};
+
+use pezsc_transaction_pool_api::{InPoolTransaction, TransactionPool};
+use pezsp_api::ApiExt;
+use pezsp_block_builder::BlockBuilder;
+use pezsp_blockchain::HeaderBackend;
+use pezsp_core::{hexdisplay::HexDisplay, Bytes};
+use pezsp_runtime::{legacy, traits};
+
+pub use pezframe_system_rpc_runtime_api::AccountNonceApi;
+
+/// System RPC methods.
+#[docify::export]
+#[rpc(client, server)]
+pub trait SystemApi<BlockHash, AccountId, Nonce> {
+	/// Returns the next valid index (aka nonce) for given account.
+	///
+	/// This method takes into consideration all pending transactions
+	/// currently in the pool and if no transactions are found in the pool
+	/// it fallbacks to query the index from the runtime (aka. state nonce).
+	#[method(name = "system_accountNextIndex", aliases = ["account_nextIndex"])]
+	async fn nonce(&self, account: AccountId) -> RpcResult<Nonce>;
+
+	/// Dry run an extrinsic at a given block. Return SCALE encoded ApplyExtrinsicResult.
+	#[method(name = "system_dryRun", aliases = ["system_dryRunAt"], with_extensions)]
+	async fn dry_run(&self, extrinsic: Bytes, at: Option<BlockHash>) -> RpcResult<Bytes>;
+}
+
+/// Error type of this RPC api.
+pub enum Error {
+	/// The transaction was not decodable.
+	DecodeError,
+	/// The call to runtime failed.
+	RuntimeError,
+}
+
+impl From<Error> for i32 {
+	fn from(e: Error) -> i32 {
+		match e {
+			Error::RuntimeError => 1,
+			Error::DecodeError => 2,
+		}
+	}
+}
+
+/// An implementation of System-specific RPC methods on full client.
+pub struct System<P: TransactionPool, C, B> {
+	client: Arc<C>,
+	pool: Arc<P>,
+	_marker: std::marker::PhantomData<B>,
+}
+
+impl<P: TransactionPool, C, B> System<P, C, B> {
+	/// Create new `FullSystem` given client and transaction pool.
+	pub fn new(client: Arc<C>, pool: Arc<P>) -> Self {
+		Self { client, pool, _marker: Default::default() }
+	}
+}
+
+#[async_trait]
+impl<P, C, Block, AccountId, Nonce>
+	SystemApiServer<<Block as traits::Block>::Hash, AccountId, Nonce> for System<P, C, Block>
+where
+	C: pezsp_api::ProvideRuntimeApi<Block>,
+	C: HeaderBackend<Block>,
+	C: Send + Sync + 'static,
+	C::Api: AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: BlockBuilder<Block>,
+	P: TransactionPool + 'static,
+	Block: traits::Block,
+	AccountId: Clone + Display + Codec + Send + 'static,
+	Nonce: Clone + Display + Codec + Send + traits::AtLeast32Bit + 'static,
+{
+	async fn nonce(&self, account: AccountId) -> RpcResult<Nonce> {
+		let api = self.client.runtime_api();
+		let best = self.client.info().best_hash;
+
+		let nonce = api.account_nonce(best, account.clone()).map_err(|e| {
+			ErrorObject::owned(
+				Error::RuntimeError.into(),
+				"Unable to query nonce.",
+				Some(e.to_string()),
+			)
+		})?;
+		Ok(adjust_nonce(&*self.pool, account, nonce))
+	}
+
+	async fn dry_run(
+		&self,
+		ext: &Extensions,
+		extrinsic: Bytes,
+		at: Option<<Block as traits::Block>::Hash>,
+	) -> RpcResult<Bytes> {
+		pezsc_rpc_api::check_if_safe(ext)?;
+
+		let api = self.client.runtime_api();
+		let best_hash = at.unwrap_or_else(||
+			// If the block hash is not supplied assume the best block.
+			self.client.info().best_hash);
+
+		let uxt: <Block as traits::Block>::Extrinsic =
+			Decode::decode(&mut &*extrinsic).map_err(|e| {
+				ErrorObject::owned(
+					Error::DecodeError.into(),
+					"Unable to dry run extrinsic",
+					Some(e.to_string()),
+				)
+			})?;
+
+		let api_version = api
+			.api_version::<dyn BlockBuilder<Block>>(best_hash)
+			.map_err(|e| {
+				ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(e.to_string()),
+				)
+			})?
+			.ok_or_else(|| {
+				ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(format!("Could not find `BlockBuilder` api for block `{:?}`.", best_hash)),
+				)
+			})?;
+
+		let result = if api_version < 6 {
+			#[allow(deprecated)]
+			api.apply_extrinsic_before_version_6(best_hash, uxt)
+				.map(legacy::byte_sized_error::convert_to_latest)
+				.map_err(|e| {
+					ErrorObject::owned(
+						Error::RuntimeError.into(),
+						"Unable to dry run extrinsic.",
+						Some(e.to_string()),
+					)
+				})?
+		} else {
+			api.apply_extrinsic(best_hash, uxt).map_err(|e| {
+				ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(e.to_string()),
+				)
+			})?
+		};
+
+		Ok(Encode::encode(&result).into())
+	}
+}
+
+/// Adjust account nonce from state, so that tx with the nonce will be
+/// placed after all ready txpool transactions.
+fn adjust_nonce<P, AccountId, Nonce>(pool: &P, account: AccountId, nonce: Nonce) -> Nonce
+where
+	P: TransactionPool,
+	AccountId: Clone + std::fmt::Display + Encode,
+	Nonce: Clone + std::fmt::Display + Encode + traits::AtLeast32Bit + 'static,
+{
+	log::debug!(target: "rpc", "State nonce for {}: {}", account, nonce);
+	// Now we need to query the transaction pool
+	// and find transactions originating from the same sender.
+	//
+	// Since extrinsics are opaque to us, we look for them using
+	// `provides` tag. And increment the nonce if we find a transaction
+	// that matches the current one.
+	let mut current_nonce = nonce.clone();
+	let mut current_tag = (account.clone(), nonce).encode();
+	for tx in pool.ready() {
+		log::debug!(
+			target: "rpc",
+			"Current nonce to {}, checking {} vs {:?}",
+			current_nonce,
+			HexDisplay::from(&current_tag),
+			tx.provides().iter().map(|x| format!("{}", HexDisplay::from(x))).collect::<Vec<_>>(),
+		);
+		// since transactions in `ready()` need to be ordered by nonce
+		// it's fine to continue with current iterator.
+		if tx.provides().get(0) == Some(&current_tag) {
+			current_nonce += traits::One::one();
+			current_tag = (account.clone(), current_nonce.clone()).encode();
+		}
+	}
+
+	current_nonce
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use assert_matches::assert_matches;
+	use futures::executor::block_on;
+	use pezsc_rpc_api::DenyUnsafe;
+	use pezsc_transaction_pool::BasicPool;
+	use pezsp_runtime::{
+		transaction_validity::{InvalidTransaction, TransactionValidityError},
+		ApplyExtrinsicResult,
+	};
+	use bizinikiwi_test_runtime_client::{runtime::Transfer, Sr25519Keyring};
+
+	fn deny_unsafe() -> Extensions {
+		let mut ext = Extensions::new();
+		ext.insert(DenyUnsafe::Yes);
+		ext
+	}
+
+	fn allow_unsafe() -> Extensions {
+		let mut ext = Extensions::new();
+		ext.insert(DenyUnsafe::No);
+		ext
+	}
+
+	#[tokio::test]
+	async fn should_return_next_nonce_for_some_account() {
+		pezsp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(bizinikiwi_test_runtime_client::new());
+		let spawner = pezsp_core::testing::TaskExecutor::new();
+		let pool = Arc::from(BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner,
+			client.clone(),
+		));
+
+		let source = pezsp_runtime::transaction_validity::TransactionSource::External;
+		let new_transaction = |nonce: u64| {
+			let t = Transfer {
+				from: Sr25519Keyring::Alice.into(),
+				to: Sr25519Keyring::Bob.into(),
+				amount: 5,
+				nonce,
+			};
+			t.into_unchecked_extrinsic()
+		};
+		let hash_of_block0 = client.info().genesis_hash;
+		// Populate the pool
+		let ext0 = new_transaction(0);
+		block_on(pool.submit_one(hash_of_block0, source, ext0)).unwrap();
+		let ext1 = new_transaction(1);
+		block_on(pool.submit_one(hash_of_block0, source, ext1)).unwrap();
+
+		let accounts = System::new(client, pool);
+
+		// when
+		let nonce = accounts.nonce(Sr25519Keyring::Alice.into()).await;
+
+		// then
+		assert_eq!(nonce.unwrap(), 2);
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_deny_unsafe() {
+		pezsp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(bizinikiwi_test_runtime_client::new());
+		let spawner = pezsp_core::testing::TaskExecutor::new();
+		let pool = Arc::from(BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner,
+			client.clone(),
+		));
+
+		let accounts = System::new(client, pool);
+
+		// when
+		let res = accounts.dry_run(&deny_unsafe(), vec![].into(), None).await;
+		assert_matches!(res, Err(e) => {
+			assert!(e.message().contains("RPC call is unsafe to be called externally"));
+		});
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_work() {
+		pezsp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(bizinikiwi_test_runtime_client::new());
+		let spawner = pezsp_core::testing::TaskExecutor::new();
+		let pool = Arc::from(BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner,
+			client.clone(),
+		));
+
+		let accounts = System::new(client, pool);
+
+		let tx = Transfer {
+			from: Sr25519Keyring::Alice.into(),
+			to: Sr25519Keyring::Bob.into(),
+			amount: 5,
+			nonce: 0,
+		}
+		.into_unchecked_extrinsic();
+
+		// when
+		let bytes = accounts
+			.dry_run(&allow_unsafe(), tx.encode().into(), None)
+			.await
+			.expect("Call is successful");
+
+		// then
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_ref()).unwrap();
+		assert_eq!(apply_res, Ok(Ok(())));
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_indicate_error() {
+		pezsp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(bizinikiwi_test_runtime_client::new());
+		let spawner = pezsp_core::testing::TaskExecutor::new();
+		let pool = Arc::from(BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner,
+			client.clone(),
+		));
+
+		let accounts = System::new(client, pool);
+
+		let tx = Transfer {
+			from: Sr25519Keyring::Alice.into(),
+			to: Sr25519Keyring::Bob.into(),
+			amount: 5,
+			nonce: 100,
+		}
+		.into_unchecked_extrinsic();
+
+		// when
+		let bytes = accounts
+			.dry_run(&allow_unsafe(), tx.encode().into(), None)
+			.await
+			.expect("Call is successful");
+
+		// then
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_ref()).unwrap();
+		assert_eq!(apply_res, Err(TransactionValidityError::Invalid(InvalidTransaction::Future)));
+	}
+}