fix: Add workspace dependencies for vendored pezkuwi-subxt and zombienet-sdk

- Add all missing workspace dependencies required by vendor crates
- Include external crates: scale-*, sp-core, sc-chain-spec, kube, etc.
- Include subxt dependencies: smoldot, web-time, wasm-bindgen, etc.
- Regenerate umbrella crate with updated dependencies
- Apply zepter std feature propagation fixes to vendor crates
- Apply rustfmt formatting to vendor and pezframe files

vendor/pezkuwi-subxt/core/Cargo.toml

@@ -30,6 +30,11 @@ std = [
 	"serde/std",
 	"serde_json/std",
 	"tracing/std",
+	"bitvec/std",
+	"blake2/std",
+	"frame-decode/std",
+	"keccak-hash/std",
+	"pezkuwi-subxt-signer/std"
 ]
 
 [dependencies]

vendor/pezkuwi-subxt/core/src/blocks/extrinsic_transaction_extensions.rs

@@ -3,13 +3,13 @@
 // see LICENSE for license details.
 
 use crate::{
-	Metadata,
 	config::{
-		Config, TransactionExtension,
 		transaction_extensions::{ChargeAssetTxPayment, ChargeTransactionPayment, CheckNonce},
+		Config, TransactionExtension,
 	},
 	dynamic::Value,
 	error::ExtrinsicError,
+	Metadata,
 };
 use alloc::borrow::ToOwned;
 use frame_decode::extrinsics::ExtrinsicExtensions;

vendor/pezkuwi-subxt/core/src/blocks/extrinsics.rs

@@ -3,10 +3,10 @@
 // see LICENSE for license details.
 
 use crate::{
-	Metadata,
 	blocks::extrinsic_transaction_extensions::ExtrinsicTransactionExtensions,
 	config::{Config, HashFor, Hasher},
 	error::{ExtrinsicDecodeErrorAt, ExtrinsicDecodeErrorAtReason, ExtrinsicError},
+	Metadata,
 };
 use alloc::{sync::Arc, vec::Vec};
 use frame_decode::extrinsics::Extrinsic;
@@ -284,8 +284,8 @@ where
 	/// Attempt to decode these [`ExtrinsicDetails`] into a type representing the extrinsic fields.
 	/// Such types are exposed in the codegen as `pallet_name::calls::types::CallName` types.
 	pub fn as_extrinsic<E: StaticExtrinsic>(&self) -> Result<Option<E>, ExtrinsicError> {
-		if self.decoded_info().pallet_name() == E::PALLET &&
-			self.decoded_info().call_name() == E::CALL
+		if self.decoded_info().pallet_name() == E::PALLET
+			&& self.decoded_info().call_name() == E::CALL
 		{
 			let mut fields = self.decoded_info().call_data().map(|d| {
 				let name = if d.name().is_empty() { None } else { Some(d.name()) };
@@ -340,13 +340,13 @@ mod tests {
 	use assert_matches::assert_matches;
 	use codec::{Decode, Encode};
 	use frame_metadata::{
-		RuntimeMetadataPrefixed,
 		v15::{
 			CustomMetadata, ExtrinsicMetadata, OuterEnums, PalletCallMetadata, PalletMetadata,
 			RuntimeMetadataV15,
 		},
+		RuntimeMetadataPrefixed,
 	};
-	use scale_info::{TypeInfo, meta_type};
+	use scale_info::{meta_type, TypeInfo};
 	use scale_value::Value;
 
 	// Extrinsic needs to contain at least the generic type parameter "Call"

vendor/pezkuwi-subxt/core/src/blocks/mod.rs

@@ -69,7 +69,7 @@ mod extrinsics;
 mod static_extrinsic;
 
 pub use crate::error::ExtrinsicError;
-use crate::{Metadata, config::Config, error::ExtrinsicDecodeErrorAt};
+use crate::{config::Config, error::ExtrinsicDecodeErrorAt, Metadata};
 use alloc::vec::Vec;
 pub use extrinsic_transaction_extensions::{
 	ExtrinsicTransactionExtension, ExtrinsicTransactionExtensions,

vendor/pezkuwi-subxt/core/src/client.rs

@@ -5,8 +5,8 @@
 //! A couple of client types that we use elsewhere.
 
 use crate::{
-	Metadata,
 	config::{Config, HashFor},
+	Metadata,
 };
 use derive_where::derive_where;
 

vendor/pezkuwi-subxt/core/src/config/default_extrinsic_params.rs

@@ -4,7 +4,7 @@
 
 use crate::config::transaction_extensions::CheckMortalityParams;
 
-use super::{Config, ExtrinsicParams, HashFor, transaction_extensions};
+use super::{transaction_extensions, Config, ExtrinsicParams, HashFor};
 
 /// The default [`super::ExtrinsicParams`] implementation understands common signed extensions
 /// and how to apply them to a given chain.

vendor/pezkuwi-subxt/core/src/config/mod.rs

@@ -11,8 +11,8 @@
 mod default_extrinsic_params;
 mod extrinsic_params;
 
-pub mod pezkuwi;
 pub mod bizinikiwi;
+pub mod pezkuwi;
 pub mod transaction_extensions;
 
 use codec::{Decode, Encode};
@@ -20,12 +20,14 @@ use core::fmt::Debug;
 use pezkuwi_subxt_metadata::Metadata;
 use scale_decode::DecodeAsType;
 use scale_encode::EncodeAsType;
-use serde::{Serialize, de::DeserializeOwned};
+use serde::{de::DeserializeOwned, Serialize};
 
+pub use bizinikiwi::{
+	BizinikiwConfig, BizinikiwiExtrinsicParams, BizinikiwiExtrinsicParamsBuilder,
+};
 pub use default_extrinsic_params::{DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder};
 pub use extrinsic_params::{ExtrinsicParams, ExtrinsicParamsEncoder};
 pub use pezkuwi::{PezkuwiConfig, PezkuwiExtrinsicParams, PezkuwiExtrinsicParamsBuilder};
-pub use bizinikiwi::{BizinikiwConfig, BizinikiwiExtrinsicParams, BizinikiwiExtrinsicParamsBuilder};
 pub use transaction_extensions::TransactionExtension;
 
 /// Runtime types.

vendor/pezkuwi-subxt/core/src/config/transaction_extensions.rs

@@ -398,13 +398,14 @@ impl<T: Config> CheckMortalityParams<T> {
 impl<T: Config> Params<T> for CheckMortalityParams<T> {
 	fn inject_block(&mut self, from_block_n: u64, from_block_hash: HashFor<T>) {
 		match &self.0 {
-			CheckMortalityParamsInner::MortalForBlocks(n) |
-			CheckMortalityParamsInner::MortalForBlocksOrImmortalIfNotPossible(n) =>
+			CheckMortalityParamsInner::MortalForBlocks(n)
+			| CheckMortalityParamsInner::MortalForBlocksOrImmortalIfNotPossible(n) => {
 				self.0 = CheckMortalityParamsInner::MortalFromBlock {
 					for_n_blocks: *n,
 					from_block_n,
 					from_block_hash,
-				},
+				}
+			},
 			_ => {
 				// Don't change anything if explicit Immortal or explicit block set.
 			},
@@ -670,10 +671,10 @@ fn is_type_empty(type_id: u32, types: &scale_info::PortableRegistry) -> bool {
 		TypeDef::Array(a) => a.len == 0 || is_type_empty(a.type_param.id, types),
 		TypeDef::Tuple(t) => t.fields.iter().all(|f| is_type_empty(f.id, types)),
 		// Explicitly list these in case any additions are made in the future.
-		TypeDef::BitSequence(_) |
-		TypeDef::Variant(_) |
-		TypeDef::Sequence(_) |
-		TypeDef::Compact(_) |
-		TypeDef::Primitive(_) => false,
+		TypeDef::BitSequence(_)
+		| TypeDef::Variant(_)
+		| TypeDef::Sequence(_)
+		| TypeDef::Compact(_)
+		| TypeDef::Primitive(_) => false,
 	}
 }

vendor/pezkuwi-subxt/core/src/constants/mod.rs

@@ -40,7 +40,7 @@
 
 pub mod address;
 
-use crate::{Metadata, error::ConstantError};
+use crate::{error::ConstantError, Metadata};
 use address::Address;
 use alloc::{borrow::ToOwned, string::ToString, vec::Vec};
 use frame_decode::constants::ConstantTypeInfo;

vendor/pezkuwi-subxt/core/src/custom_values/mod.rs

@@ -32,7 +32,7 @@
 
 pub mod address;
 
-use crate::{Metadata, error::CustomValueError, utils::Maybe};
+use crate::{error::CustomValueError, utils::Maybe, Metadata};
 use address::Address;
 use alloc::vec::Vec;
 use frame_decode::custom_values::CustomValueTypeInfo;
@@ -99,7 +99,7 @@ mod tests {
 	use alloc::collections::BTreeMap;
 	use codec::Encode;
 	use scale_decode::DecodeAsType;
-	use scale_info::{TypeInfo, form::PortableForm};
+	use scale_info::{form::PortableForm, TypeInfo};
 
 	use alloc::{borrow::ToOwned, string::String, vec};
 

vendor/pezkuwi-subxt/core/src/events.rs

@@ -46,9 +46,9 @@ use pezkuwi_subxt_metadata::PalletMetadata;
 use scale_decode::{DecodeAsFields, DecodeAsType};
 
 use crate::{
-	Metadata,
 	config::{Config, HashFor},
 	error::EventsError,
+	Metadata,
 };
 
 /// Create a new [`Events`] instance from the given bytes.
@@ -466,16 +466,16 @@ pub struct EventMetadataDetails<'a> {
 #[cfg(test)]
 pub(crate) mod test_utils {
 	use super::*;
-	use crate::config::{HashFor, BizinikiwConfig};
+	use crate::config::{BizinikiwConfig, HashFor};
 	use codec::Encode;
 	use frame_metadata::{
-		RuntimeMetadataPrefixed,
 		v15::{
 			CustomMetadata, ExtrinsicMetadata, OuterEnums, PalletEventMetadata, PalletMetadata,
 			RuntimeMetadataV15,
 		},
+		RuntimeMetadataPrefixed,
 	};
-	use scale_info::{TypeInfo, meta_type};
+	use scale_info::{meta_type, TypeInfo};
 
 	/// An "outer" events enum containing exactly one event.
 	#[derive(
@@ -611,7 +611,7 @@ pub(crate) mod test_utils {
 #[cfg(test)]
 mod tests {
 	use super::{
-		test_utils::{AllEvents, EventRecord, event_record, events, events_raw},
+		test_utils::{event_record, events, events_raw, AllEvents, EventRecord},
 		*,
 	};
 	use crate::{config::BizinikiwConfig, events::Phase};

vendor/pezkuwi-subxt/core/src/runtime_api/mod.rs

@@ -43,7 +43,7 @@
 
 pub mod payload;
 
-use crate::{Metadata, error::RuntimeApiError};
+use crate::{error::RuntimeApiError, Metadata};
 use alloc::{
 	format,
 	string::{String, ToString},
@@ -75,7 +75,11 @@ pub fn validate<P: Payload>(payload: P, metadata: &Metadata) -> Result<(), Runti
 				method_name: method_name.to_string(),
 			})?;
 
-	if hash != api_method.hash() { Err(RuntimeApiError::IncompatibleCodegen) } else { Ok(()) }
+	if hash != api_method.hash() {
+		Err(RuntimeApiError::IncompatibleCodegen)
+	} else {
+		Ok(())
+	}
 }
 
 /// Return the name of the runtime API call from the payload.

vendor/pezkuwi-subxt/core/src/storage/mod.rs

@@ -53,12 +53,12 @@ mod storage_value;
 
 pub mod address;
 
-use crate::{Metadata, error::StorageError};
+use crate::{error::StorageError, Metadata};
 use address::Address;
 use alloc::string::ToString;
 
 pub use prefix_of::{EqualOrPrefixOf, PrefixOf};
-pub use storage_entry::{StorageEntry, entry};
+pub use storage_entry::{entry, StorageEntry};
 pub use storage_key::{StorageHasher, StorageKey, StorageKeyPart};
 pub use storage_key_value::StorageKeyValue;
 pub use storage_value::StorageValue;
@@ -86,5 +86,9 @@ pub fn validate<Addr: Address>(address: Addr, metadata: &Metadata) -> Result<(),
 		}
 	})?;
 
-	if storage_hash != hash { Err(StorageError::IncompatibleCodegen) } else { Ok(()) }
+	if storage_hash != hash {
+		Err(StorageError::IncompatibleCodegen)
+	} else {
+		Ok(())
+	}
 }

vendor/pezkuwi-subxt/core/src/storage/storage_entry.rs

@@ -2,7 +2,7 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use super::{PrefixOf, StorageKeyValue, StorageValue, address::Address};
+use super::{address::Address, PrefixOf, StorageKeyValue, StorageValue};
 use crate::{error::StorageError, utils::YesMaybe};
 use alloc::{sync::Arc, vec::Vec};
 use frame_decode::storage::{IntoEncodableValues, StorageInfo};

vendor/pezkuwi-subxt/core/src/tx/mod.rs

@@ -60,10 +60,10 @@ pub mod payload;
 pub mod signer;
 
 use crate::{
-	Metadata,
 	config::{Config, ExtrinsicParams, ExtrinsicParamsEncoder, HashFor, Hasher},
 	error::ExtrinsicError,
 	utils::Encoded,
+	Metadata,
 };
 use alloc::{borrow::Cow, string::ToString, vec::Vec};
 use codec::{Compact, Encode};
@@ -95,7 +95,11 @@ pub fn validate<Call: Payload>(call: &Call, metadata: &Metadata) -> Result<(), E
 			call_name: call_name.to_string(),
 		})?;
 
-	if details.hash != expected_hash { Err(ExtrinsicError::IncompatibleCodegen) } else { Ok(()) }
+	if details.hash != expected_hash {
+		Err(ExtrinsicError::IncompatibleCodegen)
+	} else {
+		Ok(())
+	}
 }
 
 /// Returns the suggested transaction versions to build for a given chain, or an error
@@ -252,7 +256,11 @@ impl<T: Config> PartialTransactionV4<T> {
 		self.additional_and_extra_params.encode_signer_payload_value_to(&mut bytes);
 		self.additional_and_extra_params.encode_implicit_to(&mut bytes);
 
-		if bytes.len() > 256 { f(Cow::Borrowed(&blake2_256(&bytes))) } else { f(Cow::Owned(bytes)) }
+		if bytes.len() > 256 {
+			f(Cow::Borrowed(&blake2_256(&bytes)))
+		} else {
+			f(Cow::Owned(bytes))
+		}
 	}
 
 	/// Return the V4 signer payload for this extrinsic. These are the bytes that must

vendor/pezkuwi-subxt/core/src/tx/payload.rs

@@ -5,7 +5,7 @@
 //! This module contains the trait and types used to represent
 //! transactions that can be submitted.
 
-use crate::{Metadata, error::ExtrinsicError};
+use crate::{error::ExtrinsicError, Metadata};
 use alloc::{
 	borrow::Cow,
 	boxed::Box,

vendor/pezkuwi-subxt/core/src/utils/bits.rs

@@ -8,8 +8,8 @@ use alloc::{vec, vec::Vec};
 use codec::{Compact, Input};
 use core::marker::PhantomData;
 use scale_bits::{
-	Bits,
 	scale::format::{Format, OrderFormat, StoreFormat},
+	Bits,
 };
 use scale_decode::{IntoVisitor, TypeResolver};
 

vendor/pezkuwi-subxt/core/src/utils/era.rs

@@ -5,12 +5,12 @@
 use alloc::{format, vec::Vec};
 use codec::{Decode, Encode};
 use scale_decode::{
-	IntoVisitor, TypeResolver, Visitor,
 	ext::scale_type_resolver,
 	visitor::{
-		TypeIdFor,
 		types::{Composite, Variant},
+		TypeIdFor,
 	},
+	IntoVisitor, TypeResolver, Visitor,
 };
 use scale_encode::EncodeAsType;
 
@@ -81,8 +81,8 @@ impl codec::Encode for Era {
 			Self::Immortal => output.push_byte(0),
 			Self::Mortal { period, phase } => {
 				let quantize_factor = (*period >> 12).max(1);
-				let encoded = (period.trailing_zeros() - 1).clamp(1, 15) as u16 |
-					((phase / quantize_factor) << 4) as u16;
+				let encoded = (period.trailing_zeros() - 1).clamp(1, 15) as u16
+					| ((phase / quantize_factor) << 4) as u16;
 				encoded.encode_to(output);
 			},
 		}

vendor/pezkuwi-subxt/core/src/utils/static_type.rs

@@ -3,7 +3,7 @@
 // see LICENSE for license details.
 
 use codec::{Decode, Encode};
-use scale_decode::{IntoVisitor, TypeResolver, Visitor, visitor::DecodeAsTypeResult};
+use scale_decode::{visitor::DecodeAsTypeResult, IntoVisitor, TypeResolver, Visitor};
 use scale_encode::EncodeAsType;
 
 use alloc::vec::Vec;
@@ -45,7 +45,7 @@ impl<T: Decode, R: TypeResolver> Visitor for StaticDecodeAsTypeVisitor<T, R> {
 		_type_id: R::TypeId,
 		_types: &'info R,
 	) -> DecodeAsTypeResult<Self, Result<Self::Value<'scale, 'info>, Self::Error>> {
-		use scale_decode::{Error, visitor::DecodeError};
+		use scale_decode::{visitor::DecodeError, Error};
 		let decoded = T::decode(input)
 			.map(Static)
 			.map_err(|e| Error::new(DecodeError::CodecError(e).into()));

vendor/pezkuwi-subxt/core/src/utils/unchecked_extrinsic.rs

@@ -12,7 +12,7 @@
 use core::marker::PhantomData;
 
 use codec::{Decode, Encode};
-use scale_decode::{DecodeAsType, IntoVisitor, TypeResolver, Visitor, visitor::DecodeAsTypeResult};
+use scale_decode::{visitor::DecodeAsTypeResult, DecodeAsType, IntoVisitor, TypeResolver, Visitor};
 
 use super::{Encoded, Static};
 use alloc::vec::Vec;
@@ -32,7 +32,7 @@ impl<Address, Call, Signature, Extra> UncheckedExtrinsic<Address, Call, Signatur
 
 	/// Get the bytes of the encoded extrinsic.
 	pub fn bytes(&self) -> &[u8] {
-		self.0.0.0.as_slice()
+		self.0 .0 .0.as_slice()
 	}
 }
 
@@ -75,7 +75,7 @@ impl<Address, Call, Signature, Extra> From<UncheckedExtrinsic<Address, Call, Sig
 	for Vec<u8>
 {
 	fn from(bytes: UncheckedExtrinsic<Address, Call, Signature, Extra>) -> Self {
-		bytes.0.0.0
+		bytes.0 .0 .0
 	}
 }
 
@@ -106,8 +106,8 @@ impl<Address, Call, Signature, Extra> IntoVisitor
 	type AnyVisitor<R: TypeResolver> =
 		UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R>;
 
-	fn into_visitor<R: TypeResolver>()
-	-> UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R> {
+	fn into_visitor<R: TypeResolver>(
+	) -> UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R> {
 		UncheckedExtrinsicDecodeAsTypeVisitor(PhantomData)
 	}
 }

vendor/pezkuwi-subxt/core/src/utils/wrapper_opaque.rs

@@ -5,7 +5,7 @@
 use super::PhantomDataSendSync;
 use codec::{Compact, Decode, DecodeAll, Encode};
 use derive_where::derive_where;
-use scale_decode::{IntoVisitor, TypeResolver, Visitor, ext::scale_type_resolver::visitor};
+use scale_decode::{ext::scale_type_resolver::visitor, IntoVisitor, TypeResolver, Visitor};
 use scale_encode::EncodeAsType;
 
 use alloc::{format, vec::Vec};
@@ -108,9 +108,12 @@ impl<T, R: TypeResolver> Visitor for WrapperKeepOpaqueVisitor<T, R> {
 		};
 
 		if value.name() != Some("WrapperKeepOpaque") {
-			return Err(Error::new(ErrorKind::VisitorDecodeError(DecodeError::TypeResolvingError(
-				format!("Expected a type named 'WrapperKeepOpaque', got: {:?}", value.name()),
-			))));
+			return Err(Error::new(ErrorKind::VisitorDecodeError(
+				DecodeError::TypeResolvingError(format!(
+					"Expected a type named 'WrapperKeepOpaque', got: {:?}",
+					value.name()
+				)),
+			)));
 		}
 
 		if value.remaining() != 2 {
@@ -159,7 +162,7 @@ mod test {
 	impl<T: scale_info::TypeInfo + 'static> scale_info::TypeInfo for WrapperKeepOpaque<T> {
 		type Identity = Self;
 		fn type_info() -> scale_info::Type {
-			use scale_info::{Path, Type, TypeParameter, build::Fields, meta_type};
+			use scale_info::{build::Fields, meta_type, Path, Type, TypeParameter};
 
 			Type::builder()
 				.path(Path::new("WrapperKeepOpaque", module_path!()))

vendor/pezkuwi-subxt/core/src/view_functions/mod.rs

@@ -7,7 +7,7 @@
 
 pub mod payload;
 
-use crate::{Metadata, error::ViewFunctionError};
+use crate::{error::ViewFunctionError, Metadata};
 use alloc::{string::ToString, vec::Vec};
 use payload::Payload;
 use scale_decode::IntoVisitor;
@@ -33,7 +33,11 @@ pub fn validate<P: Payload>(payload: P, metadata: &Metadata) -> Result<(), ViewF
 			function_name: function_name.to_string(),
 		})?;
 
-	if hash != view_function.hash() { Err(ViewFunctionError::IncompatibleCodegen) } else { Ok(()) }
+	if hash != view_function.hash() {
+		Err(ViewFunctionError::IncompatibleCodegen)
+	} else {
+		Ok(())
+	}
 }
 
 /// The name of the Runtime API call which can execute