Refactoring Checkpoint: (WIP)

bizinikiwi/bin/node/cli/Cargo.toml

@@ -63,13 +63,13 @@ subxt-signer = { workspace = true, features = ["unstable-eth"] }
 
 # The Pezkuwi-SDK:
 pezkuwi-sdk = { features = [
-  "fork-tree",
+  "pez-fork-tree",
   "pezframe-benchmarking-cli",
   "frame-remote-externalities",
   "pezframe-support-procedural-tools",
-  "generate-bags",
-  "mmr-gadget",
-  "mmr-rpc",
+  "pez-generate-bags",
+  "pezmmr-gadget",
+  "pezmmr-rpc",
   "pezpallet-transaction-payment-rpc",
   "pezsc-allocator",
   "pezsc-authority-discovery",
@@ -135,7 +135,7 @@ pezkuwi-sdk = { features = [
   "pezstaging-node-inspect",
   "pezstaging-tracking-allocator",
   "std",
-  "subkey",
+  "pez-subkey",
   "bizinikiwi-build-script-utils",
   "bizinikiwi-frame-rpc-support",
   "bizinikiwi-frame-rpc-system",
@@ -143,14 +143,14 @@ pezkuwi-sdk = { features = [
   "bizinikiwi-rpc-client",
   "bizinikiwi-state-trie-migration-rpc",
   "bizinikiwi-wasm-builder",
-  "tracing-gum",
+  "pez-tracing-gum",
 ], workspace = true, default-features = true }
 
 # Shared code between the staging node and kitchensink runtime:
-kitchensink-runtime = { workspace = true }
+pez-kitchensink-runtime = { workspace = true }
 node-inspect = { optional = true, workspace = true, default-features = true }
-node-primitives = { workspace = true, default-features = true }
-node-rpc = { workspace = true }
+pez-node-primitives = { workspace = true, default-features = true }
+pez-node-rpc = { workspace = true }
 
 [dev-dependencies]
 assert_cmd = { workspace = true }
@@ -176,7 +176,7 @@ tokio-util = { features = ["compat"], workspace = true }
 wat = { workspace = true }
 
 # These testing-only dependencies are not exported by the Pezkuwi-SDK crate:
-node-testing = { workspace = true }
+pez-node-testing = { workspace = true }
 pezsc-service-test = { workspace = true }
 bizinikiwi-cli-test-utils = { workspace = true }
 
@@ -197,18 +197,18 @@ pezkuwi-sdk = { features = [
 default = ["cli"]
 cli = ["clap", "clap_complete", "node-inspect", "pezkuwi-sdk"]
 runtime-benchmarks = [
-  "kitchensink-runtime/runtime-benchmarks",
+  "pez-kitchensink-runtime/runtime-benchmarks",
   "node-inspect?/runtime-benchmarks",
-  "node-primitives/runtime-benchmarks",
-  "node-rpc/runtime-benchmarks",
-  "node-testing/runtime-benchmarks",
+  "pez-node-primitives/runtime-benchmarks",
+  "pez-node-rpc/runtime-benchmarks",
+  "pez-node-testing/runtime-benchmarks",
   "pezkuwi-sdk/runtime-benchmarks",
   "pezsc-service-test/runtime-benchmarks",
   "pezsp-keyring/runtime-benchmarks",
   "bizinikiwi-cli-test-utils/runtime-benchmarks",
 ]
 try-runtime = [
-  "kitchensink-runtime/try-runtime",
+  "pez-kitchensink-runtime/try-runtime",
   "pezkuwi-sdk/try-runtime",
   "bizinikiwi-cli-test-utils/try-runtime",
 ]

bizinikiwi/bin/node/cli/benches/block_production.rs

@@ -20,7 +20,7 @@ use pezkuwi_sdk::*;
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
 
-use kitchensink_runtime::{constants::currency::*, BalancesCall};
+use pez_kitchensink_runtime::{constants::currency::*, BalancesCall};
 use node_cli::service::{create_extrinsic, FullClient};
 use pezkuwi_sdk::pezsc_service::config::{ExecutorConfiguration, RpcConfiguration};
 use pezsc_block_builder::{BlockBuilderBuilder, BuiltBlock};
@@ -123,14 +123,14 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
 }
 
 fn extrinsic_set_time(now: u64) -> OpaqueExtrinsic {
-	let utx: kitchensink_runtime::UncheckedExtrinsic = generic::UncheckedExtrinsic::new_bare(
-		kitchensink_runtime::RuntimeCall::Timestamp(pezpallet_timestamp::Call::set { now }),
+	let utx: pez_kitchensink_runtime::UncheckedExtrinsic = generic::UncheckedExtrinsic::new_bare(
+		pez_kitchensink_runtime::RuntimeCall::Timestamp(pezpallet_timestamp::Call::set { now }),
 	)
 	.into();
 	utx.into()
 }
 
-fn import_block(client: &FullClient, built: BuiltBlock<node_primitives::Block>) {
+fn import_block(client: &FullClient, built: BuiltBlock<pez_node_primitives::Block>) {
 	let mut params = BlockImportParams::new(BlockOrigin::File, built.block.header);
 	params.state_action =
 		StateAction::ApplyChanges(pezsc_consensus::StorageChanges::Changes(built.storage_changes));

bizinikiwi/bin/node/cli/benches/executor.rs

@@ -21,12 +21,12 @@ use pezkuwi_sdk::*;
 use codec::{Decode, Encode};
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use pezframe_support::Hashable;
-use kitchensink_runtime::{
+use pez_kitchensink_runtime::{
 	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, RuntimeCall,
 	RuntimeGenesisConfig, UncheckedExtrinsic,
 };
-use node_primitives::{BlockNumber, Hash};
-use node_testing::keyring::*;
+use pez_node_primitives::{BlockNumber, Hash};
+use pez_node_testing::keyring::*;
 use pezsc_executor::{Externalities, RuntimeVersionOf};
 use pezsp_core::{
 	storage::well_known_keys,
@@ -41,7 +41,7 @@ criterion_main!(benches);
 
 /// The wasm runtime code.
 pub fn compact_code_unwrap() -> &'static [u8] {
-	kitchensink_runtime::WASM_BINARY.expect(
+	pez_kitchensink_runtime::WASM_BINARY.expect(
 		"Development wasm binary is not available. Testing is only supported with the flag \
 		 disabled.",
 	)
@@ -49,16 +49,16 @@ pub fn compact_code_unwrap() -> &'static [u8] {
 
 const GENESIS_HASH: [u8; 32] = [69u8; 32];
 
-const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+const TRANSACTION_VERSION: u32 = pez_kitchensink_runtime::VERSION.transaction_version;
 
-const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+const SPEC_VERSION: u32 = pez_kitchensink_runtime::VERSION.spec_version;
 
 const HEAP_PAGES: u64 = 20;
 
 type TestExternalities<H> = CoreTestExternalities<H>;
 
 fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
-	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
+	pez_node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
 }
 
 fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities<BlakeTwo256> {
@@ -167,7 +167,7 @@ fn bench_execute_block(c: &mut Criterion) {
 	let mut group = c.benchmark_group("execute blocks");
 
 	group.bench_function("wasm", |b| {
-		let genesis_config = node_testing::genesis::config();
+		let genesis_config = pez_node_testing::genesis::config();
 
 		let executor = RuntimeExecutor::builder().build();
 		let runtime_code = RuntimeCode {

bizinikiwi/bin/node/cli/benches/transaction_pool.rs

@@ -18,9 +18,9 @@
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
 use futures::{future, StreamExt};
-use kitchensink_runtime::{constants::currency::*, BalancesCall, SudoCall};
+use pez_kitchensink_runtime::{constants::currency::*, BalancesCall, SudoCall};
 use node_cli::service::{create_extrinsic, fetch_nonce, FullClient, TransactionPool};
-use node_primitives::AccountId;
+use pez_node_primitives::AccountId;
 use pezkuwi_sdk::{
 	pezsc_service::config::{ExecutorConfiguration, RpcConfiguration},
 	pezsc_transaction_pool_api::TransactionPool as _,

bizinikiwi/bin/node/cli/src/benchmarking.rs

@@ -24,8 +24,8 @@ use crate::service::{create_extrinsic, FullClient};
 
 use pezkuwi_sdk::*;
 
-use kitchensink_runtime::{BalancesCall, SystemCall};
-use node_primitives::{AccountId, Balance};
+use pez_kitchensink_runtime::{BalancesCall, SystemCall};
+use pez_node_primitives::{AccountId, Balance};
 use pezsc_cli::Result;
 use pezsp_inherents::{InherentData, InherentDataProvider};
 use pezsp_keyring::Sr25519Keyring;

bizinikiwi/bin/node/cli/src/chain_spec.rs

@@ -21,7 +21,7 @@
 use pezkuwi_sdk::*;
 
 use crate::chain_spec::pezsc_service::Properties;
-use kitchensink_runtime::{
+use pez_kitchensink_runtime::{
 	genesis_config_presets::{Staker, ENDOWMENT, STASH},
 	wasm_binary_unwrap, Block, MaxNominations, StakerStatus,
 };
@@ -38,8 +38,8 @@ use pezsp_consensus_grandpa::AuthorityId as GrandpaId;
 use pezsp_core::crypto::UncheckedInto;
 use pezsp_mixnet::types::AuthorityId as MixnetId;
 
-pub use kitchensink_runtime::RuntimeGenesisConfig;
-pub use node_primitives::{AccountId, Balance, Signature};
+pub use pez_kitchensink_runtime::RuntimeGenesisConfig;
+pub use pez_node_primitives::{AccountId, Balance, Signature};
 
 const STAGING_TELEMETRY_URL: &str = "wss://telemetry.pezkuwichain.io/submit/";
 
@@ -82,15 +82,15 @@ fn configure_accounts_for_staging_testnet() -> (
 	#[rustfmt::skip]
 	// stash, controller, session-key, beefy id
 	// generated with secret:
-	// for i in 1 2 3 4 ; do for j in stash controller; do subkey inspect "$secret"/fir/$j/$i; done; done
+	// for i in 1 2 3 4 ; do for j in stash controller; do pez_subkey inspect "$secret"/fir/$j/$i; done; done
 	//
 	// and
 	//
-	// for i in 1 2 3 4 ; do for j in session; do subkey inspect --scheme ed25519 "$secret"//fir//$j//$i; done; done
+	// for i in 1 2 3 4 ; do for j in session; do pez_subkey inspect --scheme ed25519 "$secret"//fir//$j//$i; done; done
 	//
 	// and
 	//
-	// for i in 1 2 3 4 ; do for j in session; do subkey inspect --scheme ecdsa "$secret"//fir//$j//$i; done; done
+	// for i in 1 2 3 4 ; do for j in session; do pez_subkey inspect --scheme ecdsa "$secret"//fir//$j//$i; done; done
 
 	let initial_authorities: Vec<(
 		AccountId,
@@ -200,7 +200,7 @@ fn configure_accounts_for_staging_testnet() -> (
 		),
 	];
 
-	// generated with secret: subkey inspect "$secret"/fir
+	// generated with secret: pez_subkey inspect "$secret"/fir
 	let root_key: AccountId = array_bytes::hex_n_into_unchecked(
 		// 5Ff3iXP75ruzroPWRP2FYBHWnmGGBSb63857BgnzCoXNxfPo
 		"9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
@@ -430,7 +430,7 @@ pub fn local_testnet_config() -> ChainSpec {
 pub(crate) mod tests {
 	use super::*;
 	use crate::service::{new_full_base, NewFullBase};
-	use kitchensink_runtime::genesis_config_presets::well_known_including_eth_accounts;
+	use pez_kitchensink_runtime::genesis_config_presets::well_known_including_eth_accounts;
 	use pezsc_service_test;
 	use pezsp_runtime::{AccountId32, BuildStorage};
 

bizinikiwi/bin/node/cli/src/command.rs

@@ -25,8 +25,8 @@ use crate::{
 	Cli, Subcommand,
 };
 use pezframe_benchmarking_cli::*;
-use kitchensink_runtime::{ExistentialDeposit, RuntimeApi};
-use node_primitives::Block;
+use pez_kitchensink_runtime::{ExistentialDeposit, RuntimeApi};
+use pez_node_primitives::Block;
 use pezsc_cli::{Result, BizinikiwiCli};
 use pezsc_service::PartialComponents;
 use pezsp_keyring::Sr25519Keyring;

bizinikiwi/bin/node/cli/src/service.rs

@@ -31,8 +31,8 @@ use codec::Encode;
 use pezframe_benchmarking_cli::BIZINIKIWI_REFERENCE_HARDWARE;
 use pezframe_system_rpc_runtime_api::AccountNonceApi;
 use futures::prelude::*;
-use kitchensink_runtime::RuntimeApi;
-use node_primitives::Block;
+use pez_kitchensink_runtime::RuntimeApi;
+use pez_node_primitives::Block;
 use pezsc_client_api::{Backend, BlockBackend};
 use pezsc_consensus_babe::{self, SlotProportion};
 use pezsc_network::{
@@ -107,51 +107,51 @@ pub fn fetch_nonce(client: &FullClient, account: pezsp_core::sr25519::Pair) -> u
 pub fn create_extrinsic(
 	client: &FullClient,
 	sender: pezsp_core::sr25519::Pair,
-	function: impl Into<kitchensink_runtime::RuntimeCall>,
+	function: impl Into<pez_kitchensink_runtime::RuntimeCall>,
 	nonce: Option<u32>,
-) -> kitchensink_runtime::UncheckedExtrinsic {
+) -> pez_kitchensink_runtime::UncheckedExtrinsic {
 	let function = function.into();
 	let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
 	let best_hash = client.chain_info().best_hash;
 	let best_block = client.chain_info().best_number;
 	let nonce = nonce.unwrap_or_else(|| fetch_nonce(client, sender.clone()));
 
-	let period = kitchensink_runtime::BlockHashCount::get()
+	let period = pez_kitchensink_runtime::BlockHashCount::get()
 		.checked_next_power_of_two()
 		.map(|c| c / 2)
 		.unwrap_or(2) as u64;
 	let tip = 0;
-	let tx_ext: kitchensink_runtime::TxExtension =
+	let tx_ext: pez_kitchensink_runtime::TxExtension =
 		(
-			pezframe_system::AuthorizeCall::<kitchensink_runtime::Runtime>::new(),
-			pezframe_system::CheckNonZeroSender::<kitchensink_runtime::Runtime>::new(),
-			pezframe_system::CheckSpecVersion::<kitchensink_runtime::Runtime>::new(),
-			pezframe_system::CheckTxVersion::<kitchensink_runtime::Runtime>::new(),
-			pezframe_system::CheckGenesis::<kitchensink_runtime::Runtime>::new(),
-			pezframe_system::CheckEra::<kitchensink_runtime::Runtime>::from(generic::Era::mortal(
+			pezframe_system::AuthorizeCall::<pez_kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckNonZeroSender::<pez_kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckSpecVersion::<pez_kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckTxVersion::<pez_kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckGenesis::<pez_kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckEra::<pez_kitchensink_runtime::Runtime>::from(generic::Era::mortal(
 				period,
 				best_block.saturated_into(),
 			)),
-			pezframe_system::CheckNonce::<kitchensink_runtime::Runtime>::from(nonce),
-			pezframe_system::CheckWeight::<kitchensink_runtime::Runtime>::new(),
+			pezframe_system::CheckNonce::<pez_kitchensink_runtime::Runtime>::from(nonce),
+			pezframe_system::CheckWeight::<pez_kitchensink_runtime::Runtime>::new(),
 			pezpallet_skip_feeless_payment::SkipCheckIfFeeless::from(
 				pezpallet_asset_conversion_tx_payment::ChargeAssetTxPayment::<
-					kitchensink_runtime::Runtime,
+					pez_kitchensink_runtime::Runtime,
 				>::from(tip, None),
 			),
 			pezframe_metadata_hash_extension::CheckMetadataHash::new(false),
-			pezpallet_revive::evm::tx_extension::SetOrigin::<kitchensink_runtime::Runtime>::default(),
-			pezframe_system::WeightReclaim::<kitchensink_runtime::Runtime>::new(),
+			pezpallet_revive::evm::tx_extension::SetOrigin::<pez_kitchensink_runtime::Runtime>::default(),
+			pezframe_system::WeightReclaim::<pez_kitchensink_runtime::Runtime>::new(),
 		);
 
-	let raw_payload = kitchensink_runtime::SignedPayload::from_raw(
+	let raw_payload = pez_kitchensink_runtime::SignedPayload::from_raw(
 		function.clone(),
 		tx_ext.clone(),
 		(
 			(),
 			(),
-			kitchensink_runtime::VERSION.spec_version,
-			kitchensink_runtime::VERSION.transaction_version,
+			pez_kitchensink_runtime::VERSION.spec_version,
+			pez_kitchensink_runtime::VERSION.transaction_version,
 			genesis_hash,
 			best_hash,
 			(),
@@ -167,7 +167,7 @@ pub fn create_extrinsic(
 	generic::UncheckedExtrinsic::new_signed(
 		function,
 		pezsp_runtime::AccountId32::from(sender.public()).into(),
-		kitchensink_runtime::Signature::Sr25519(signature),
+		pez_kitchensink_runtime::Signature::Sr25519(signature),
 		tx_ext,
 	)
 	.into()
@@ -331,24 +331,24 @@ pub fn new_partial(
 		let rpc_backend = backend.clone();
 		let rpc_statement_store = statement_store.clone();
 		let rpc_extensions_builder =
-			move |subscription_executor: node_rpc::SubscriptionTaskExecutor| {
-				let deps = node_rpc::FullDeps {
+			move |subscription_executor: pez_node_rpc::SubscriptionTaskExecutor| {
+				let deps = pez_node_rpc::FullDeps {
 					client: client.clone(),
 					pool: pool.clone(),
 					select_chain: select_chain.clone(),
 					chain_spec: chain_spec.cloned_box(),
-					babe: node_rpc::BabeDeps {
+					babe: pez_node_rpc::BabeDeps {
 						keystore: keystore.clone(),
 						babe_worker_handle: babe_worker_handle.clone(),
 					},
-					grandpa: node_rpc::GrandpaDeps {
+					grandpa: pez_node_rpc::GrandpaDeps {
 						shared_voter_state: shared_voter_state.clone(),
 						shared_authority_set: shared_authority_set.clone(),
 						justification_stream: justification_stream.clone(),
 						subscription_executor: subscription_executor.clone(),
 						finality_provider: finality_proof_provider.clone(),
 					},
-					beefy: node_rpc::BeefyDeps::<beefy_primitives::ecdsa_crypto::AuthorityId> {
+					beefy: pez_node_rpc::BeefyDeps::<beefy_primitives::ecdsa_crypto::AuthorityId> {
 						beefy_finality_proof_stream: beefy_rpc_links
 							.from_voter_justif_stream
 							.clone(),
@@ -362,7 +362,7 @@ pub fn new_partial(
 					mixnet_api: mixnet_api.as_ref().cloned(),
 				};
 
-				node_rpc::create_full(deps).map_err(Into::into)
+				pez_node_rpc::create_full(deps).map_err(Into::into)
 			};
 
 		(rpc_extensions_builder, shared_voter_state2)
@@ -722,9 +722,9 @@ pub fn new_full_base<N: NetworkBackend<Block, <Block as BlockT>::Hash>>(
 	// When offchain indexing is enabled, MMR gadget should also run.
 	if is_offchain_indexing_enabled {
 		task_manager.spawn_essential_handle().spawn_blocking(
-			"mmr-gadget",
+			"pezmmr-gadget",
 			None,
-			mmr_gadget::MmrGadget::start(
+			pezmmr_gadget::MmrGadget::start(
 				client.clone(),
 				backend.clone(),
 				pezsp_mmr_primitives::INDEXING_PREFIX.to_vec(),
@@ -870,11 +870,11 @@ pub fn new_full(config: Configuration, cli: Cli) -> Result<TaskManager, ServiceE
 mod tests {
 	use crate::service::{new_full_base, NewFullBase};
 	use codec::Encode;
-	use kitchensink_runtime::{
+	use pez_kitchensink_runtime::{
 		constants::{currency::CENTS, time::SLOT_DURATION},
 		Address, BalancesCall, RuntimeCall, TxExtension,
 	};
-	use node_primitives::{Block, DigestItem, Signature};
+	use pez_node_primitives::{Block, DigestItem, Signature};
 	use pezkuwi_sdk::{pezsc_transaction_pool_api::MaintainedTransactionPool, *};
 	use pezsc_client_api::BlockBackend;
 	use pezsc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
@@ -1118,7 +1118,7 @@ mod tests {
 				let signature = raw_payload.using_encoded(|payload| signer.sign(payload));
 				let (function, tx_ext, _) = raw_payload.deconstruct();
 				index += 1;
-				let utx: kitchensink_runtime::UncheckedExtrinsic =
+				let utx: pez_kitchensink_runtime::UncheckedExtrinsic =
 					generic::UncheckedExtrinsic::new_signed(
 						function,
 						from.into(),

bizinikiwi/bin/node/cli/tests/basic.rs

@@ -29,13 +29,13 @@ use pezsp_runtime::{
 	traits::Hash as HashT, transaction_validity::InvalidTransaction, ApplyExtrinsicResult,
 };
 
-use kitchensink_runtime::{
+use pez_kitchensink_runtime::{
 	constants::{currency::*, time::SLOT_DURATION},
 	Balances, CheckedExtrinsic, Header, Runtime, RuntimeCall, RuntimeEvent, System,
 	TransactionPayment, Treasury, UncheckedExtrinsic,
 };
-use node_primitives::{Balance, Hash};
-use node_testing::keyring::*;
+use pez_node_primitives::{Balance, Hash};
+use pez_node_testing::keyring::*;
 use pretty_assertions::assert_eq;
 use wat;
 
@@ -48,7 +48,7 @@ use self::common::{sign, *};
 /// have to execute provided wasm code instead of the native equivalent. This trick is used to
 /// test code paths that differ between native and wasm versions.
 pub fn bloaty_code_unwrap() -> &'static [u8] {
-	kitchensink_runtime::WASM_BINARY_BLOATY.expect(
+	pez_kitchensink_runtime::WASM_BINARY_BLOATY.expect(
 		"Development wasm binary is not available. \
 											 Testing is only supported with the flag disabled.",
 	)
@@ -857,14 +857,14 @@ fn successful_execution_gives_ok() {
 
 #[test]
 fn should_import_block_with_test_client() {
-	use node_testing::client::{
+	use pez_node_testing::client::{
 		pezsp_consensus::BlockOrigin, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
 	};
 
 	let client = TestClientBuilder::new().build();
 	let block1 = changes_trie_block();
 	let block_data = block1.0;
-	let block = node_primitives::Block::decode(&mut &block_data[..]).unwrap();
+	let block = pez_node_primitives::Block::decode(&mut &block_data[..]).unwrap();
 
 	futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
 }

bizinikiwi/bin/node/cli/tests/common.rs

@@ -36,12 +36,12 @@ use pezsp_runtime::{
 };
 use pezsp_state_machine::TestExternalities as CoreTestExternalities;
 
-use kitchensink_runtime::{
+use pez_kitchensink_runtime::{
 	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, Runtime,
 	UncheckedExtrinsic,
 };
-use node_primitives::{BlockNumber, Hash};
-use node_testing::keyring::*;
+use pez_node_primitives::{BlockNumber, Hash};
+use pez_node_testing::keyring::*;
 use pezsp_externalities::Externalities;
 use pezstaging_node_cli::service::RuntimeExecutor;
 
@@ -70,7 +70,7 @@ impl AppCrypto<MultiSigner, MultiSignature> for TestAuthorityId {
 /// making the binary slimmer. There is a convention to use compact version of the runtime
 /// as canonical.
 pub fn compact_code_unwrap() -> &'static [u8] {
-	kitchensink_runtime::WASM_BINARY.expect(
+	pez_kitchensink_runtime::WASM_BINARY.expect(
 		"Development wasm binary is not available. Testing is only supported with the flag \
 		 disabled.",
 	)
@@ -78,14 +78,14 @@ pub fn compact_code_unwrap() -> &'static [u8] {
 
 pub const GENESIS_HASH: [u8; 32] = [69u8; 32];
 
-pub const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+pub const SPEC_VERSION: u32 = pez_kitchensink_runtime::VERSION.spec_version;
 
-pub const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+pub const TRANSACTION_VERSION: u32 = pez_kitchensink_runtime::VERSION.transaction_version;
 
 pub type TestExternalities<H> = CoreTestExternalities<H>;
 
 pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
-	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
+	pez_node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
 }
 
 pub fn default_transfer_call() -> pezpallet_balances::Call<Runtime> {
@@ -125,7 +125,7 @@ pub fn new_test_ext(code: &[u8]) -> TestExternalities<BlakeTwo256> {
 	pezsp_tracing::try_init_simple();
 	let ext = TestExternalities::new_with_code(
 		code,
-		node_testing::genesis::config().build_storage().unwrap(),
+		pez_node_testing::genesis::config().build_storage().unwrap(),
 	);
 	ext
 }

bizinikiwi/bin/node/cli/tests/fees.rs

@@ -22,13 +22,13 @@ use pezframe_support::{
 	traits::Currency,
 	weights::{constants::ExtrinsicBaseWeight, IdentityFee, WeightToFee},
 };
-use kitchensink_runtime::{
+use pez_kitchensink_runtime::{
 	constants::{currency::*, time::SLOT_DURATION},
 	Balances, CheckedExtrinsic, Multiplier, Runtime, RuntimeCall, TransactionByteFee,
 	TransactionPayment,
 };
-use node_primitives::Balance;
-use node_testing::keyring::*;
+use pez_node_primitives::Balance;
+use pez_node_testing::keyring::*;
 use pezkuwi_sdk::*;
 use pezsp_runtime::{traits::One, Perbill};
 

bizinikiwi/bin/node/cli/tests/submit_transaction.rs

@@ -18,7 +18,7 @@
 
 use codec::Decode;
 use pezframe_system::offchain::{SendSignedTransaction, Signer, SubmitTransaction};
-use kitchensink_runtime::{Executive, ExistentialDeposit, Indices, Runtime, UncheckedExtrinsic};
+use pez_kitchensink_runtime::{Executive, ExistentialDeposit, Indices, Runtime, UncheckedExtrinsic};
 use pezkuwi_sdk::*;
 use pezsp_application_crypto::AppCrypto;
 use pezsp_core::offchain::{testing::TestTransactionPoolExt, TransactionPoolExt};