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/primitives/api/test/tests/decl_and_impl.rs

@@ -0,0 +1,378 @@
+// 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.
+
+use pezsp_api::{
+	decl_runtime_apis, impl_runtime_apis, mock_impl_runtime_apis, ApiError, ApiExt, RuntimeApiInfo,
+};
+use pezsp_runtime::traits::Block as BlockT;
+
+use bizinikiwi_test_runtime_client::runtime::{Block, Hash};
+
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+pub struct Runtime {}
+
+decl_runtime_apis! {
+	#[deprecated]
+	pub trait Api {
+		fn test(data: u64);
+		fn something_with_block(block: Block) -> Block;
+		fn function_with_two_args(data: u64, block: Block);
+		fn same_name();
+		fn wild_card(_: u32);
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithCustomVersion {
+		fn same_name();
+		#[changed_in(2)]
+		fn same_name() -> String;
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithMultipleVersions {
+		fn stable_one(data: u64);
+		#[api_version(3)]
+		fn new_one();
+		#[api_version(4)]
+		fn glory_one();
+	}
+
+	pub trait ApiWithStagingMethod {
+		fn stable_one(data: u64);
+		#[api_version(99)]
+		fn pezstaging_one();
+	}
+
+	pub trait ApiWithStagingAndVersionedMethods {
+		fn stable_one(data: u64);
+		#[api_version(2)]
+		fn new_one();
+		#[api_version(99)]
+		fn pezstaging_one();
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithStagingAndChangedBase {
+		fn stable_one(data: u64);
+		fn new_one();
+		#[api_version(99)]
+		fn pezstaging_one();
+	}
+
+}
+
+impl_runtime_apis! {
+	#[allow(deprecated)]
+	impl self::Api<Block> for Runtime {
+		fn test(_: u64) {
+			unimplemented!()
+		}
+
+		// Ensure that we accept `mut`
+		fn something_with_block(mut _block: Block) -> Block {
+			unimplemented!()
+		}
+
+		fn function_with_two_args(_: u64, _: Block) {
+			unimplemented!()
+		}
+
+		fn same_name() {}
+
+		fn wild_card(_: u32) {}
+	}
+
+	impl self::ApiWithCustomVersion<Block> for Runtime {
+		fn same_name() {}
+	}
+
+	#[api_version(3)]
+	impl self::ApiWithMultipleVersions<Block> for Runtime {
+		fn stable_one(_: u64) {}
+
+		fn new_one() {}
+	}
+
+	#[cfg_attr(feature = "enable-pezstaging-api", api_version(99))]
+	impl self::ApiWithStagingMethod<Block> for Runtime {
+		fn stable_one(_: u64) {}
+
+		#[cfg(feature = "enable-pezstaging-api")]
+		fn pezstaging_one() { }
+	}
+
+	#[cfg_attr(feature = "enable-pezstaging-api", api_version(99))]
+	#[api_version(2)]
+	impl self::ApiWithStagingAndVersionedMethods<Block> for Runtime {
+		fn stable_one(_: u64) {}
+		fn new_one() {}
+
+		#[cfg(feature = "enable-pezstaging-api")]
+		fn pezstaging_one() {}
+	}
+
+	#[cfg_attr(feature = "enable-pezstaging-api", api_version(99))]
+	impl self::ApiWithStagingAndChangedBase<Block> for Runtime {
+		fn stable_one(_: u64) {}
+		fn new_one() {}
+
+		#[cfg(feature = "enable-pezstaging-api")]
+		fn pezstaging_one() {}
+	}
+
+	impl pezsp_api::Core<Block> for Runtime {
+		fn version() -> pezsp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: <Block as BlockT>::LazyBlock) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) -> pezsp_runtime::ExtrinsicInclusionMode {
+			unimplemented!()
+		}
+	}
+}
+
+struct MockApi {
+	block: Option<Block>,
+}
+
+mock_impl_runtime_apis! {
+	#[allow(deprecated)]
+	impl Api<Block> for MockApi {
+		fn test(_: u64) {
+			unimplemented!()
+		}
+
+		fn something_with_block(&self, _: Block) -> Block {
+			self.block.clone().unwrap()
+		}
+
+		fn function_with_two_args(_: u64, _: Block) {
+			unimplemented!()
+		}
+
+		#[advanced]
+		fn same_name(_: <Block as BlockT>::Hash) -> Result<(), ApiError> {
+			Ok(().into())
+		}
+
+		#[advanced]
+		fn wild_card(at: <Block as BlockT>::Hash, _: u32) -> Result<(), ApiError> {
+			if Hash::repeat_byte(0x0f) == at {
+				// yeah
+				Ok(().into())
+			} else {
+				Err((Box::from("Test error") as Box<dyn std::error::Error + Send + Sync>).into())
+			}
+		}
+	}
+
+	impl ApiWithCustomVersion<Block> for MockApi {
+		fn same_name() {}
+	}
+}
+
+type TestClient = bizinikiwi_test_runtime_client::client::Client<
+	bizinikiwi_test_runtime_client::Backend,
+	bizinikiwi_test_runtime_client::ExecutorDispatch,
+	Block,
+	RuntimeApi,
+>;
+
+#[test]
+#[allow(deprecated)]
+fn test_client_side_function_signature() {
+	let _test: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+		u64,
+	) -> Result<(), ApiError> = RuntimeApiImpl::<Block, TestClient>::test;
+	let _something_with_block: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+		Block,
+	) -> Result<Block, ApiError> = RuntimeApiImpl::<Block, TestClient>::something_with_block;
+
+	#[allow(deprecated)]
+	let _same_name_before_version_2: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+	) -> Result<String, ApiError> = RuntimeApiImpl::<Block, TestClient>::same_name_before_version_2;
+}
+
+#[test]
+#[allow(deprecated)]
+fn check_runtime_api_info() {
+	assert_eq!(&<dyn Api::<Block>>::ID, &runtime_decl_for_api::ID);
+	assert_eq!(<dyn Api::<Block>>::VERSION, runtime_decl_for_api::VERSION);
+	assert_eq!(<dyn Api::<Block>>::VERSION, 1);
+
+	assert_eq!(
+		<dyn ApiWithCustomVersion::<Block>>::VERSION,
+		runtime_decl_for_api_with_custom_version::VERSION,
+	);
+	assert_eq!(
+		&<dyn ApiWithCustomVersion::<Block>>::ID,
+		&runtime_decl_for_api_with_custom_version::ID,
+	);
+	assert_eq!(<dyn ApiWithCustomVersion::<Block>>::VERSION, 2);
+
+	// The stable version of the API
+	assert_eq!(<dyn ApiWithMultipleVersions::<Block>>::VERSION, 2);
+
+	assert_eq!(<dyn ApiWithStagingMethod::<Block>>::VERSION, 1);
+	assert_eq!(<dyn ApiWithStagingAndVersionedMethods::<Block>>::VERSION, 1);
+	assert_eq!(<dyn ApiWithStagingAndChangedBase::<Block>>::VERSION, 2);
+}
+
+fn check_runtime_api_versions_contains<T: RuntimeApiInfo + ?Sized>() {
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, T::VERSION)));
+}
+
+fn check_staging_runtime_api_versions<T: RuntimeApiInfo + ?Sized>(_staging_ver: u32) {
+	// Staging APIs should contain staging version if the feature is set...
+	#[cfg(feature = "enable-pezstaging-api")]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _staging_ver)));
+	//... otherwise the base version should be set
+	#[cfg(not(feature = "enable-pezstaging-api"))]
+	check_runtime_api_versions_contains::<dyn ApiWithStagingMethod<Block>>();
+}
+
+#[allow(unused_assignments)]
+fn check_staging_multiver_runtime_api_versions<T: RuntimeApiInfo + ?Sized>(
+	_staging_ver: u32,
+	_stable_ver: u32,
+) {
+	// Staging APIs should contain staging version if the feature is set...
+	#[cfg(feature = "enable-pezstaging-api")]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _staging_ver)));
+	//... otherwise the base version should be set
+	#[cfg(not(feature = "enable-pezstaging-api"))]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _stable_ver)));
+}
+
+#[test]
+#[allow(deprecated)]
+fn check_runtime_api_versions() {
+	check_runtime_api_versions_contains::<dyn Api<Block>>();
+	check_runtime_api_versions_contains::<dyn ApiWithCustomVersion<Block>>();
+	assert!(RUNTIME_API_VERSIONS
+		.iter()
+		.any(|v| v == &(<dyn ApiWithMultipleVersions<Block>>::ID, 3)));
+
+	check_staging_runtime_api_versions::<dyn ApiWithStagingMethod<Block>>(99);
+	check_staging_multiver_runtime_api_versions::<dyn ApiWithStagingAndVersionedMethods<Block>>(
+		99, 2,
+	);
+	check_staging_runtime_api_versions::<dyn ApiWithStagingAndChangedBase<Block>>(99);
+
+	check_runtime_api_versions_contains::<dyn pezsp_api::Core<Block>>();
+}
+
+#[test]
+#[allow(deprecated)]
+fn mock_runtime_api_has_api() {
+	let mock = MockApi { block: None };
+
+	assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(Hash::default()).unwrap());
+	assert!(mock.has_api::<dyn Api<Block>>(Hash::default()).unwrap());
+}
+
+#[test]
+#[should_panic(expected = "Calling deprecated methods is not supported by mocked runtime api.")]
+fn mock_runtime_api_panics_on_calling_old_version() {
+	let mock = MockApi { block: None };
+
+	#[allow(deprecated)]
+	let _ = mock.same_name_before_version_2(Hash::default());
+}
+
+#[test]
+#[allow(deprecated)]
+fn mock_runtime_api_works_with_advanced() {
+	let mock = MockApi { block: None };
+
+	Api::<Block>::same_name(&mock, Hash::default()).unwrap();
+	mock.wild_card(Hash::repeat_byte(0x0f), 1).unwrap();
+	assert_eq!(
+		"Test error".to_string(),
+		mock.wild_card(Hash::repeat_byte(0x01), 1).unwrap_err().to_string(),
+	);
+}
+
+#[test]
+fn runtime_api_metadata_matches_version_implemented() {
+	use pezsp_metadata_ir::InternalImplRuntimeApis;
+
+	let rt = Runtime {};
+	let runtime_metadata = rt.runtime_metadata();
+
+	// Check that the metadata for some runtime API matches expectation.
+	let assert_has_api_with_methods = |api_name: &str, api_methods: &[&str]| {
+		let Some(api) = runtime_metadata.iter().find(|api| api.name == api_name) else {
+			panic!("Can't find runtime API '{api_name}'");
+		};
+		if api.methods.len() != api_methods.len() {
+			panic!(
+				"Wrong number of methods in '{api_name}'; expected {} methods but got {}: {:?}",
+				api_methods.len(),
+				api.methods.len(),
+				api.methods
+			);
+		}
+		for expected_name in api_methods {
+			if !api.methods.iter().any(|method| &method.name == expected_name) {
+				panic!("Can't find API method '{expected_name}' in '{api_name}'");
+			}
+		}
+	};
+
+	assert_has_api_with_methods("ApiWithCustomVersion", &["same_name"]);
+
+	assert_has_api_with_methods("ApiWithMultipleVersions", &["stable_one", "new_one"]);
+
+	assert_has_api_with_methods(
+		"ApiWithStagingMethod",
+		&[
+			"stable_one",
+			#[cfg(feature = "enable-pezstaging-api")]
+			"pezstaging_one",
+		],
+	);
+
+	assert_has_api_with_methods(
+		"ApiWithStagingAndVersionedMethods",
+		&[
+			"stable_one",
+			"new_one",
+			#[cfg(feature = "enable-pezstaging-api")]
+			"pezstaging_one",
+		],
+	);
+
+	assert_has_api_with_methods(
+		"ApiWithStagingAndChangedBase",
+		&[
+			"stable_one",
+			"new_one",
+			#[cfg(feature = "enable-pezstaging-api")]
+			"pezstaging_one",
+		],
+	);
+}