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.

templates/teyrchain/node/src/chain_spec.rs

@@ -1,12 +1,12 @@
 use pezkuwi_sdk::*;
 
-use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
-use sc_service::ChainType;
+use pezsc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
+use pezsc_service::ChainType;
 use serde::{Deserialize, Serialize};
 use teyrchain_template_runtime as runtime;
 
 /// Specialized `ChainSpec` for the normal teyrchain runtime.
-pub type ChainSpec = sc_service::GenericChainSpec<Extensions>;
+pub type ChainSpec = pezsc_service::GenericChainSpec<Extensions>;
 /// The relay chain that you want to configure this teyrchain to connect to.
 pub const RELAY_CHAIN: &str = "pezkuwichain-local";
 
@@ -20,14 +20,14 @@ pub struct Extensions {
 
 impl Extensions {
 	/// Try to get the extension from the given `ChainSpec`.
-	pub fn try_get(chain_spec: &dyn sc_service::ChainSpec) -> Option<&Self> {
-		sc_chain_spec::get_extension(chain_spec.extensions())
+	pub fn try_get(chain_spec: &dyn pezsc_service::ChainSpec) -> Option<&Self> {
+		pezsc_chain_spec::get_extension(chain_spec.extensions())
 	}
 }
 
 pub fn development_chain_spec() -> ChainSpec {
 	// Give your base currency a unit name and decimal places
-	let mut properties = sc_chain_spec::Properties::new();
+	let mut properties = pezsc_chain_spec::Properties::new();
 	properties.insert("tokenSymbol".into(), "UNIT".into());
 	properties.insert("tokenDecimals".into(), 12.into());
 	properties.insert("ss58Format".into(), 42.into());
@@ -39,14 +39,14 @@ pub fn development_chain_spec() -> ChainSpec {
 	.with_name("Development")
 	.with_id("dev")
 	.with_chain_type(ChainType::Development)
-	.with_genesis_config_preset_name(sp_genesis_builder::DEV_RUNTIME_PRESET)
+	.with_genesis_config_preset_name(pezsp_genesis_builder::DEV_RUNTIME_PRESET)
 	.with_properties(properties)
 	.build()
 }
 
 pub fn local_chain_spec() -> ChainSpec {
 	// Give your base currency a unit name and decimal places
-	let mut properties = sc_chain_spec::Properties::new();
+	let mut properties = pezsc_chain_spec::Properties::new();
 	properties.insert("tokenSymbol".into(), "UNIT".into());
 	properties.insert("tokenDecimals".into(), 12.into());
 	properties.insert("ss58Format".into(), 42.into());
@@ -58,7 +58,7 @@ pub fn local_chain_spec() -> ChainSpec {
 	.with_name("Local Testnet")
 	.with_id("local_testnet")
 	.with_chain_type(ChainType::Local)
-	.with_genesis_config_preset_name(sc_chain_spec::LOCAL_TESTNET_RUNTIME_PRESET)
+	.with_genesis_config_preset_name(pezsc_chain_spec::LOCAL_TESTNET_RUNTIME_PRESET)
 	.with_protocol_id("template-local")
 	.with_properties(properties)
 	.build()

templates/teyrchain/node/src/cli.rs

@@ -11,25 +11,25 @@ pub enum Subcommand {
 	#[deprecated(
 		note = "build-spec command will be removed after 1/04/2026. Use export-chain-spec command instead"
 	)]
-	BuildSpec(sc_cli::BuildSpecCmd),
+	BuildSpec(pezsc_cli::BuildSpecCmd),
 
 	/// Export the chain specification.
-	ExportChainSpec(sc_cli::ExportChainSpecCmd),
+	ExportChainSpec(pezsc_cli::ExportChainSpecCmd),
 
 	/// Validate blocks.
-	CheckBlock(sc_cli::CheckBlockCmd),
+	CheckBlock(pezsc_cli::CheckBlockCmd),
 
 	/// Export blocks.
-	ExportBlocks(sc_cli::ExportBlocksCmd),
+	ExportBlocks(pezsc_cli::ExportBlocksCmd),
 
 	/// Export the state of a given block into a chain spec.
-	ExportState(sc_cli::ExportStateCmd),
+	ExportState(pezsc_cli::ExportStateCmd),
 
 	/// Import blocks.
-	ImportBlocks(sc_cli::ImportBlocksCmd),
+	ImportBlocks(pezsc_cli::ImportBlocksCmd),
 
 	/// Revert the chain to a previous state.
-	Revert(sc_cli::RevertCmd),
+	Revert(pezsc_cli::RevertCmd),
 
 	/// Remove the whole chain.
 	PurgeChain(cumulus_client_cli::PurgeChainCmd),
@@ -46,7 +46,7 @@ pub enum Subcommand {
 	/// Sub-commands concerned with benchmarking.
 	/// The pallet benchmarking moved to the `pallet` sub-command.
 	#[command(subcommand)]
-	Benchmark(frame_benchmarking_cli::BenchmarkCmd),
+	Benchmark(pezframe_benchmarking_cli::BenchmarkCmd),
 }
 
 const AFTER_HELP_EXAMPLE: &str = color_print::cstr!(
@@ -105,7 +105,7 @@ pub struct RelayChainCli {
 impl RelayChainCli {
 	/// Parse the relay chain CLI parameters using the para chain `Configuration`.
 	pub fn new<'a>(
-		para_config: &sc_service::Configuration,
+		para_config: &pezsc_service::Configuration,
 		relay_chain_args: impl Iterator<Item = &'a String>,
 	) -> Self {
 		let extension = crate::chain_spec::Extensions::try_get(&*para_config.chain_spec);

templates/teyrchain/node/src/command.rs

@@ -1,13 +1,13 @@
 use pezkuwi_sdk::*;
 
 use cumulus_client_service::storage_proof_size::HostFunctions as ReclaimHostFunctions;
-use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE};
+use pezframe_benchmarking_cli::{BenchmarkCmd, BIZINIKIWI_REFERENCE_HARDWARE};
 use log::info;
-use sc_cli::{
+use pezsc_cli::{
 	ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,
-	NetworkParams, Result, RpcEndpoint, SharedParams, SubstrateCli,
+	NetworkParams, Result, RpcEndpoint, SharedParams, BizinikiwiCli,
 };
-use sc_service::config::{BasePath, PrometheusConfig};
+use pezsc_service::config::{BasePath, PrometheusConfig};
 use teyrchain_template_runtime::Block;
 
 use crate::{
@@ -25,13 +25,13 @@ fn load_spec(id: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
 	})
 }
 
-impl SubstrateCli for Cli {
+impl BizinikiwiCli for Cli {
 	fn impl_name() -> String {
 		"Teyrchain Collator Template".into()
 	}
 
 	fn impl_version() -> String {
-		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
+		env!("BIZINIKIWI_CLI_IMPL_VERSION").into()
 	}
 
 	fn description() -> String {
@@ -56,18 +56,18 @@ impl SubstrateCli for Cli {
 		2020
 	}
 
-	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn pezsc_service::ChainSpec>, String> {
 		load_spec(id)
 	}
 }
 
-impl SubstrateCli for RelayChainCli {
+impl BizinikiwiCli for RelayChainCli {
 	fn impl_name() -> String {
 		"Teyrchain Collator Template".into()
 	}
 
 	fn impl_version() -> String {
-		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
+		env!("BIZINIKIWI_CLI_IMPL_VERSION").into()
 	}
 
 	fn description() -> String {
@@ -92,7 +92,7 @@ impl SubstrateCli for RelayChainCli {
 		2020
 	}
 
-	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn pezsc_service::ChainSpec>, String> {
 		pezkuwi_cli::Cli::from_iter([RelayChainCli::executable_name()].iter()).load_spec(id)
 	}
 }
@@ -156,7 +156,7 @@ pub fn run() -> Result<()> {
 					[RelayChainCli::executable_name()].iter().chain(cli.relay_chain_args.iter()),
 				);
 
-				let pezkuwi_config = SubstrateCli::create_configuration(
+				let pezkuwi_config = BizinikiwiCli::create_configuration(
 					&pezkuwi_cli,
 					&pezkuwi_cli,
 					config.tokio_handle.clone(),
@@ -187,7 +187,7 @@ pub fn run() -> Result<()> {
 			match cmd {
 				BenchmarkCmd::Pallet(cmd) =>
 					if cfg!(feature = "runtime-benchmarks") {
-						runner.sync_run(|config| cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>, ReclaimHostFunctions>(Some(config.chain_spec)))
+						runner.sync_run(|config| cmd.run_with_spec::<pezsp_runtime::traits::HashingFor<Block>, ReclaimHostFunctions>(Some(config.chain_spec)))
 					} else {
 						Err("Benchmarking wasn't enabled when building the node. \
 					You can enable it with `--features runtime-benchmarks`."
@@ -198,7 +198,7 @@ pub fn run() -> Result<()> {
 					cmd.run(partials.client)
 				}),
 				#[cfg(not(feature = "runtime-benchmarks"))]
-				BenchmarkCmd::Storage(_) => Err(sc_cli::Error::Input(
+				BenchmarkCmd::Storage(_) => Err(pezsc_cli::Error::Input(
 					"Compile with --features=runtime-benchmarks \
 						to enable storage benchmarks."
 						.into(),
@@ -213,7 +213,7 @@ pub fn run() -> Result<()> {
 					cmd.run(config, partials.client.clone(), db, storage, shared_cache)
 				}),
 				BenchmarkCmd::Machine(cmd) =>
-					runner.sync_run(|config| cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone())),
+					runner.sync_run(|config| cmd.run(&config, BIZINIKIWI_REFERENCE_HARDWARE.clone())),
 				// NOTE: this allows the Client to leniently implement
 				// new benchmark commands without requiring a companion MR.
 				#[allow(unreachable_patterns)]
@@ -229,9 +229,9 @@ pub fn run() -> Result<()> {
 					.then(|| {
 						config.database.path().map(|database_path| {
 							let _ = std::fs::create_dir_all(database_path);
-							sc_sysinfo::gather_hwbench(
+							pezsc_sysinfo::gather_hwbench(
 								Some(database_path),
-								&SUBSTRATE_REFERENCE_HARDWARE,
+								&BIZINIKIWI_REFERENCE_HARDWARE,
 							)
 						})
 					})
@@ -244,7 +244,7 @@ pub fn run() -> Result<()> {
 
 				let tokio_handle = config.tokio_handle.clone();
 				let pezkuwi_config =
-					SubstrateCli::create_configuration(&pezkuwi_cli, &pezkuwi_cli, tokio_handle)
+					BizinikiwiCli::create_configuration(&pezkuwi_cli, &pezkuwi_cli, tokio_handle)
 						.map_err(|err| format!("Relay chain argument error: {err}"))?;
 
 				info!("Is collating: {}", if config.role.is_authority() { "yes" } else { "no" });
@@ -315,7 +315,7 @@ impl CliConfiguration<Self> for RelayChainCli {
 
 	fn init<F>(&self, _support_url: &String, _impl_version: &String, _logger_hook: F) -> Result<()>
 	where
-		F: FnOnce(&mut sc_cli::LoggerBuilder),
+		F: FnOnce(&mut pezsc_cli::LoggerBuilder),
 	{
 		unreachable!("PezkuwiCli is never initialized; qed");
 	}
@@ -326,11 +326,11 @@ impl CliConfiguration<Self> for RelayChainCli {
 		Ok(if chain_id.is_empty() { self.chain_id.clone().unwrap_or_default() } else { chain_id })
 	}
 
-	fn role(&self, is_dev: bool) -> Result<sc_service::Role> {
+	fn role(&self, is_dev: bool) -> Result<pezsc_service::Role> {
 		self.base.base.role(is_dev)
 	}
 
-	fn transaction_pool(&self, is_dev: bool) -> Result<sc_service::config::TransactionPoolOptions> {
+	fn transaction_pool(&self, is_dev: bool) -> Result<pezsc_service::config::TransactionPoolOptions> {
 		self.base.base.transaction_pool(is_dev)
 	}
 
@@ -338,7 +338,7 @@ impl CliConfiguration<Self> for RelayChainCli {
 		self.base.base.trie_cache_maximum_size()
 	}
 
-	fn rpc_methods(&self) -> Result<sc_service::config::RpcMethods> {
+	fn rpc_methods(&self) -> Result<pezsc_service::config::RpcMethods> {
 		self.base.base.rpc_methods()
 	}
 
@@ -373,7 +373,7 @@ impl CliConfiguration<Self> for RelayChainCli {
 	fn telemetry_endpoints(
 		&self,
 		chain_spec: &Box<dyn ChainSpec>,
-	) -> Result<Option<sc_telemetry::TelemetryEndpoints>> {
+	) -> Result<Option<pezsc_telemetry::TelemetryEndpoints>> {
 		self.base.base.telemetry_endpoints(chain_spec)
 	}
 

templates/teyrchain/node/src/main.rs

@@ -1,4 +1,4 @@
-//! Substrate Teyrchain Node Template CLI
+//! Bizinikiwi Teyrchain Node Template CLI
 
 #![warn(missing_docs)]
 
@@ -10,6 +10,6 @@ mod command;
 mod rpc;
 mod service;
 
-fn main() -> sc_cli::Result<()> {
+fn main() -> pezsc_cli::Result<()> {
 	command::run()
 }

templates/teyrchain/node/src/rpc.rs

@@ -1,6 +1,6 @@
 //! A collection of node-specific RPC methods.
-//! Substrate provides the `sc-rpc` crate, which defines the core RPC layer
-//! used by Substrate nodes. This file extends those RPC definitions with
+//! Bizinikiwi provides the `sc-rpc` crate, which defines the core RPC layer
+//! used by Bizinikiwi nodes. This file extends those RPC definitions with
 //! capabilities that are specific to this project's runtime configuration.
 
 #![warn(missing_docs)]
@@ -11,10 +11,10 @@ use teyrchain_template_runtime::{opaque::Block, AccountId, Balance, Nonce};
 
 use pezkuwi_sdk::*;
 
-use sc_transaction_pool_api::TransactionPool;
-use sp_api::ProvideRuntimeApi;
-use sp_block_builder::BlockBuilder;
-use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+use pezsc_transaction_pool_api::TransactionPool;
+use pezsp_api::ProvideRuntimeApi;
+use pezsp_block_builder::BlockBuilder;
+use pezsp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 
 /// A type representing all RPC extensions.
 pub type RpcExtension = jsonrpsee::RpcModule<()>;
@@ -38,13 +38,13 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
-	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: pezpallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
+	C::Api: bizinikiwi_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 	C::Api: BlockBuilder<Block>,
 	P: TransactionPool + Sync + Send + 'static,
 {
-	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
-	use substrate_frame_rpc_system::{System, SystemApiServer};
+	use pezpallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
+	use bizinikiwi_frame_rpc_system::{System, SystemApiServer};
 
 	let mut module = RpcExtension::new(());
 	let FullDeps { client, pool } = deps;

templates/teyrchain/node/src/service.rs

@@ -1,4 +1,4 @@
-//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+//! Service and ServiceFactory implementation. Specialized wrapper over bizinikiwi service.
 
 // std
 use std::{sync::Arc, time::Duration};
@@ -12,7 +12,7 @@ use teyrchain_template_runtime::{
 use codec::Encode;
 use pezkuwi_sdk::{cumulus_client_service::TeyrchainTracingExecuteBlock, *};
 
-// Cumulus Imports
+// Pezcumulus Imports
 use cumulus_client_bootnodes::{start_bootnode_tasks, StartBootnodeTasksParams};
 use cumulus_client_cli::CollatorOptions;
 use cumulus_client_collator::service::CollatorService;
@@ -31,19 +31,19 @@ use cumulus_primitives_core::{
 };
 use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
 
-// Substrate Imports
-use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
-use pezkuwi_sdk::sc_network::PeerId;
+// Bizinikiwi Imports
+use pezframe_benchmarking_cli::BIZINIKIWI_REFERENCE_HARDWARE;
+use pezkuwi_sdk::pezsc_network::PeerId;
 use prometheus_endpoint::Registry;
-use sc_client_api::Backend;
-use sc_consensus::ImportQueue;
-use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
-use sc_network::{NetworkBackend, NetworkBlock};
-use sc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, TaskManager};
-use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
-use sc_transaction_pool_api::OffchainTransactionPoolFactory;
-use sp_api::ProvideRuntimeApi;
-use sp_keystore::KeystorePtr;
+use pezsc_client_api::Backend;
+use pezsc_consensus::ImportQueue;
+use pezsc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
+use pezsc_network::{NetworkBackend, NetworkBlock};
+use pezsc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, TaskManager};
+use pezsc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
+use pezsc_transaction_pool_api::OffchainTransactionPoolFactory;
+use pezsp_api::ProvideRuntimeApi;
+use pezsp_keystore::KeystorePtr;
 
 #[docify::export(wasm_executor)]
 type TeyrchainExecutor = WasmExecutor<TeyrchainHostFunctions>;
@@ -59,8 +59,8 @@ pub type Service = PartialComponents<
 	TeyrchainClient,
 	TeyrchainBackend,
 	(),
-	sc_consensus::DefaultImportQueue<Block>,
-	sc_transaction_pool::TransactionPoolHandle<Block, TeyrchainClient>,
+	pezsc_consensus::DefaultImportQueue<Block>,
+	pezsc_transaction_pool::TransactionPoolHandle<Block, TeyrchainClient>,
 	(TeyrchainBlockImport, Option<Telemetry>, Option<TelemetryWorkerHandle>),
 >;
 
@@ -69,12 +69,12 @@ pub type Service = PartialComponents<
 /// Use this macro if you don't actually need the full service, but just the builder in order to
 /// be able to perform chain operations.
 #[docify::export(component_instantiation)]
-pub fn new_partial(config: &Configuration) -> Result<Service, sc_service::Error> {
+pub fn new_partial(config: &Configuration) -> Result<Service, pezsc_service::Error> {
 	let telemetry = config
 		.telemetry_endpoints
 		.clone()
 		.filter(|x| !x.is_empty())
-		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+		.map(|endpoints| -> Result<_, pezsc_telemetry::Error> {
 			let worker = TelemetryWorker::new(16)?;
 			let telemetry = worker.handle().new_telemetry(endpoints);
 			Ok((worker, telemetry))
@@ -95,7 +95,7 @@ pub fn new_partial(config: &Configuration) -> Result<Service, sc_service::Error>
 		.build();
 
 	let (client, backend, keystore_container, task_manager) =
-		sc_service::new_full_parts_record_import::<Block, RuntimeApi, _>(
+		pezsc_service::new_full_parts_record_import::<Block, RuntimeApi, _>(
 			config,
 			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
 			executor,
@@ -111,7 +111,7 @@ pub fn new_partial(config: &Configuration) -> Result<Service, sc_service::Error>
 	});
 
 	let transaction_pool = Arc::from(
-		sc_transaction_pool::Builder::new(
+		pezsc_transaction_pool::Builder::new(
 			task_manager.spawn_essential_handle(),
 			client.clone(),
 			config.role.is_authority().into(),
@@ -150,9 +150,9 @@ fn build_import_queue(
 	config: &Configuration,
 	telemetry: Option<TelemetryHandle>,
 	task_manager: &TaskManager,
-) -> sc_consensus::DefaultImportQueue<Block> {
+) -> pezsc_consensus::DefaultImportQueue<Block> {
 	cumulus_client_consensus_aura::equivocation_import_queue::fully_verifying_import_queue::<
-		sp_consensus_aura::sr25519::AuthorityPair,
+		pezsp_consensus_aura::sr25519::AuthorityPair,
 		_,
 		_,
 		_,
@@ -161,7 +161,7 @@ fn build_import_queue(
 		client,
 		block_import,
 		move |_, _| async move {
-			let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+			let timestamp = pezsp_timestamp::InherentDataProvider::from_system_time();
 			Ok(timestamp)
 		},
 		&task_manager.spawn_essential_handle(),
@@ -179,7 +179,7 @@ fn start_consensus(
 	telemetry: Option<TelemetryHandle>,
 	task_manager: &TaskManager,
 	relay_chain_interface: Arc<dyn RelayChainInterface>,
-	transaction_pool: Arc<sc_transaction_pool::TransactionPoolHandle<Block, TeyrchainClient>>,
+	transaction_pool: Arc<pezsc_transaction_pool::TransactionPoolHandle<Block, TeyrchainClient>>,
 	keystore: KeystorePtr,
 	relay_chain_slot_duration: Duration,
 	para_id: ParaId,
@@ -187,8 +187,8 @@ fn start_consensus(
 	collator_peer_id: PeerId,
 	overseer_handle: OverseerHandle,
 	announce_block: Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>,
-) -> Result<(), sc_service::Error> {
-	let proposer = sc_basic_authorship::ProposerFactory::with_proof_recording(
+) -> Result<(), pezsc_service::Error> {
+	let proposer = pezsc_basic_authorship::ProposerFactory::with_proof_recording(
 		task_manager.spawn_handle(),
 		client.clone(),
 		transaction_pool,
@@ -223,7 +223,7 @@ fn start_consensus(
 		reinitialize: false,
 		max_pov_percentage: None,
 	};
-	let fut = aura::run::<Block, sp_consensus_aura::sr25519::AuthorityPair, _, _, _, _, _, _, _, _>(
+	let fut = aura::run::<Block, pezsp_consensus_aura::sr25519::AuthorityPair, _, _, _, _, _, _, _, _>(
 		params,
 	);
 	task_manager.spawn_essential_handle().spawn("aura", None, fut);
@@ -232,23 +232,23 @@ fn start_consensus(
 }
 
 /// Start a node with the given teyrchain `Configuration` and relay chain `Configuration`.
-#[sc_tracing::logging::prefix_logs_with("Teyrchain")]
+#[pezsc_tracing::logging::prefix_logs_with("Teyrchain")]
 pub async fn start_teyrchain_node(
 	teyrchain_config: Configuration,
 	pezkuwi_config: Configuration,
 	collator_options: CollatorOptions,
-	hwbench: Option<sc_sysinfo::HwBench>,
-) -> sc_service::error::Result<(TaskManager, Arc<TeyrchainClient>)> {
+	hwbench: Option<pezsc_sysinfo::HwBench>,
+) -> pezsc_service::error::Result<(TaskManager, Arc<TeyrchainClient>)> {
 	let teyrchain_config = prepare_node_config(teyrchain_config);
 
 	let params = new_partial(&teyrchain_config)?;
 	let (block_import, mut telemetry, telemetry_worker_handle) = params.other;
 
 	let prometheus_registry = teyrchain_config.prometheus_registry().cloned();
-	let net_config = sc_network::config::FullNetworkConfiguration::<
+	let net_config = pezsc_network::config::FullNetworkConfiguration::<
 		_,
 		_,
-		sc_network::NetworkWorker<Block, Hash>,
+		pezsc_network::NetworkWorker<Block, Hash>,
 	>::new(&teyrchain_config.network, prometheus_registry.clone());
 
 	let client = params.client.clone();
@@ -270,7 +270,7 @@ pub async fn start_teyrchain_node(
 			hwbench.clone(),
 		)
 		.await
-		.map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;
+		.map_err(|e| pezsc_service::Error::Application(Box::new(e) as Box<_>))?;
 
 	let validator = teyrchain_config.role.is_authority();
 	let transaction_pool = params.transaction_pool.clone();
@@ -296,7 +296,7 @@ pub async fn start_teyrchain_node(
 			relay_chain_interface: relay_chain_interface.clone(),
 			import_queue: params.import_queue,
 			sybil_resistance_level: CollatorSybilResistance::Resistant, // because of Aura
-			metrics: sc_network::NetworkWorker::<Block, Hash>::register_notification_metrics(
+			metrics: pezsc_network::NetworkWorker::<Block, Hash>::register_notification_metrics(
 				teyrchain_config.prometheus_config.as_ref().map(|config| &config.registry),
 			),
 		})
@@ -307,7 +307,7 @@ pub async fn start_teyrchain_node(
 		use futures::FutureExt;
 
 		let offchain_workers =
-			sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
+			pezsc_offchain::OffchainWorkers::new(pezsc_offchain::OffchainWorkerOptions {
 				runtime_api_provider: client.clone(),
 				keystore: Some(params.keystore_container.keystore()),
 				offchain_db: backend.offchain_storage(),
@@ -338,7 +338,7 @@ pub async fn start_teyrchain_node(
 		})
 	};
 
-	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+	pezsc_service::spawn_tasks(pezsc_service::SpawnTasksParams {
 		rpc_builder,
 		client: client.clone(),
 		transaction_pool: transaction_pool.clone(),
@@ -355,11 +355,11 @@ pub async fn start_teyrchain_node(
 	})?;
 
 	if let Some(hwbench) = hwbench {
-		sc_sysinfo::print_hwbench(&hwbench);
+		pezsc_sysinfo::print_hwbench(&hwbench);
 		// Here you can check whether the hardware meets your chains' requirements. Putting a link
 		// in there and swapping out the requirements for your own are probably a good idea. The
 		// requirements for a para-chain are dictated by its relay-chain.
-		match SUBSTRATE_REFERENCE_HARDWARE.check_hardware(&hwbench, false) {
+		match BIZINIKIWI_REFERENCE_HARDWARE.check_hardware(&hwbench, false) {
 			Err(err) if validator => {
 				log::warn!(
 				"⚠️  The hardware does not meet the minimal requirements {} for role 'Authority'.",
@@ -374,7 +374,7 @@ pub async fn start_teyrchain_node(
 			task_manager.spawn_handle().spawn(
 				"telemetry_hwbench",
 				None,
-				sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench),
+				pezsc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench),
 			);
 		}
 	}
@@ -388,7 +388,7 @@ pub async fn start_teyrchain_node(
 
 	let overseer_handle = relay_chain_interface
 		.overseer_handle()
-		.map_err(|e| sc_service::Error::Application(Box::new(e)))?;
+		.map_err(|e| pezsc_service::Error::Application(Box::new(e)))?;
 
 	start_relay_chain_tasks(StartRelayChainTasksParams {
 		client: client.clone(),