From f8b8e1b8b2245ba4d78729d293d311ceb7f2377e Mon Sep 17 00:00:00 2001 From: Pavlo Khrystenko Date: Wed, 22 May 2024 18:10:37 +0200 Subject: [PATCH] use snafu in metadata --- metadata/Cargo.toml | 2 +- metadata/src/from_into/mod.rs | 68 +++++++++++++++++++------------- metadata/src/from_into/v14.rs | 74 ++++++++++++++++++++++++++++------- 3 files changed, 101 insertions(+), 43 deletions(-) diff --git a/metadata/Cargo.toml b/metadata/Cargo.toml index 1423122ed5..f7f28ff0a3 100644 --- a/metadata/Cargo.toml +++ b/metadata/Cargo.toml @@ -23,7 +23,7 @@ frame-metadata = { workspace = true, default-features = false, features = ["curr codec = { package = "parity-scale-codec", workspace = true, default-features = false, features = ["derive"] } sp-crypto-hashing = { workspace = true } hashbrown = { workspace = true } -derive_more = { workspace = true } +snafu = { workspace = true } [dev-dependencies] bitvec = { workspace = true, features = ["alloc"] } diff --git a/metadata/src/from_into/mod.rs b/metadata/src/from_into/mod.rs index 1a950e1d5a..70d294753a 100644 --- a/metadata/src/from_into/mod.rs +++ b/metadata/src/from_into/mod.rs @@ -3,31 +3,45 @@ // see LICENSE for license details. use alloc::string::String; -use derive_more::Display; - +use snafu::Snafu; mod v14; mod v15; /// An error emitted if something goes wrong converting [`frame_metadata`] /// types into [`crate::Metadata`]. -#[derive(Debug, Display, PartialEq, Eq)] +#[derive(Debug, PartialEq, Eq, Snafu)] #[non_exhaustive] pub enum TryFromError { /// Type missing from type registry - #[display(fmt = "Type id {_0} is expected but not found in the type registry")] - TypeNotFound(u32), + #[snafu(display("Type id {type_id} is expected but not found in the type registry"))] + TypeNotFound { + /// Id of the type + type_id: u32, + }, /// Type was not a variant/enum type - #[display(fmt = "Type {_0} was not a variant/enum type, but is expected to be one")] - VariantExpected(u32), + #[snafu(display("Type {type_id} was not a variant/enum type, but is expected to be one"))] + VariantExpected { + /// Id of the type + type_id: u32, + }, /// An unsupported metadata version was provided. - #[display(fmt = "Cannot convert v{_0} metadata into Metadata type")] - UnsupportedMetadataVersion(u32), + #[snafu(display("Cannot convert v{version} metadata into Metadata type"))] + UnsupportedMetadataVersion { + /// Metadata version + version: u32, + }, /// Type name missing from type registry - #[display(fmt = "Type name {_0} is expected but not found in the type registry")] - TypeNameNotFound(String), + #[snafu(display("Type name {name} is expected but not found in the type registry"))] + TypeNameNotFound { + /// Name of the type + name: String, + }, /// Invalid type path. - #[display(fmt = "Type has an invalid path {_0}")] - InvalidTypePath(String), + #[snafu(display("Type has an invalid path {path}"))] + InvalidTypePath { + /// Path of the type + path: String, + }, } #[cfg(feature = "std")] @@ -46,46 +60,46 @@ impl TryFrom for crate::Metadata { fn try_from(value: frame_metadata::RuntimeMetadataPrefixed) -> Result { match value.1 { frame_metadata::RuntimeMetadata::V0(_) => { - Err(TryFromError::UnsupportedMetadataVersion(0)) + Err(TryFromError::UnsupportedMetadataVersion { version: 0 }) } frame_metadata::RuntimeMetadata::V1(_) => { - Err(TryFromError::UnsupportedMetadataVersion(1)) + Err(TryFromError::UnsupportedMetadataVersion { version: 1 }) } frame_metadata::RuntimeMetadata::V2(_) => { - Err(TryFromError::UnsupportedMetadataVersion(2)) + Err(TryFromError::UnsupportedMetadataVersion { version: 2 }) } frame_metadata::RuntimeMetadata::V3(_) => { - Err(TryFromError::UnsupportedMetadataVersion(3)) + Err(TryFromError::UnsupportedMetadataVersion { version: 3 }) } frame_metadata::RuntimeMetadata::V4(_) => { - Err(TryFromError::UnsupportedMetadataVersion(4)) + Err(TryFromError::UnsupportedMetadataVersion { version: 4 }) } frame_metadata::RuntimeMetadata::V5(_) => { - Err(TryFromError::UnsupportedMetadataVersion(5)) + Err(TryFromError::UnsupportedMetadataVersion { version: 5 }) } frame_metadata::RuntimeMetadata::V6(_) => { - Err(TryFromError::UnsupportedMetadataVersion(6)) + Err(TryFromError::UnsupportedMetadataVersion { version: 6 }) } frame_metadata::RuntimeMetadata::V7(_) => { - Err(TryFromError::UnsupportedMetadataVersion(7)) + Err(TryFromError::UnsupportedMetadataVersion { version: 7 }) } frame_metadata::RuntimeMetadata::V8(_) => { - Err(TryFromError::UnsupportedMetadataVersion(8)) + Err(TryFromError::UnsupportedMetadataVersion { version: 8 }) } frame_metadata::RuntimeMetadata::V9(_) => { - Err(TryFromError::UnsupportedMetadataVersion(9)) + Err(TryFromError::UnsupportedMetadataVersion { version: 9 }) } frame_metadata::RuntimeMetadata::V10(_) => { - Err(TryFromError::UnsupportedMetadataVersion(10)) + Err(TryFromError::UnsupportedMetadataVersion { version: 10 }) } frame_metadata::RuntimeMetadata::V11(_) => { - Err(TryFromError::UnsupportedMetadataVersion(11)) + Err(TryFromError::UnsupportedMetadataVersion { version: 11 }) } frame_metadata::RuntimeMetadata::V12(_) => { - Err(TryFromError::UnsupportedMetadataVersion(12)) + Err(TryFromError::UnsupportedMetadataVersion { version: 12 }) } frame_metadata::RuntimeMetadata::V13(_) => { - Err(TryFromError::UnsupportedMetadataVersion(13)) + Err(TryFromError::UnsupportedMetadataVersion { version: 13 }) } frame_metadata::RuntimeMetadata::V14(m) => m.try_into(), frame_metadata::RuntimeMetadata::V15(m) => m.try_into(), diff --git a/metadata/src/from_into/v14.rs b/metadata/src/from_into/v14.rs index 5c00d24e7c..e12e29c209 100644 --- a/metadata/src/from_into/v14.rs +++ b/metadata/src/from_into/v14.rs @@ -274,7 +274,9 @@ impl ExtrinsicPartTypeIds { let extrinsic_id = metadata.extrinsic.ty.id; let Some(extrinsic_ty) = metadata.types.resolve(extrinsic_id) else { - return Err(TryFromError::TypeNotFound(extrinsic_id)); + return Err(TryFromError::TypeNotFound { + type_id: extrinsic_id, + }); }; let params: HashMap<_, _> = extrinsic_ty @@ -282,7 +284,9 @@ impl ExtrinsicPartTypeIds { .iter() .map(|ty_param| { let Some(ty) = ty_param.ty else { - return Err(TryFromError::TypeNameNotFound(ty_param.name.clone())); + return Err(TryFromError::TypeNameNotFound { + name: ty_param.name.clone(), + }); }; Ok((ty_param.name.as_str(), ty.id)) @@ -290,16 +294,20 @@ impl ExtrinsicPartTypeIds { .collect::>()?; let Some(address) = params.get(ADDRESS) else { - return Err(TryFromError::TypeNameNotFound(ADDRESS.into())); + return Err(TryFromError::TypeNameNotFound { + name: ADDRESS.into(), + }); }; let Some(call) = params.get(CALL) else { - return Err(TryFromError::TypeNameNotFound(CALL.into())); + return Err(TryFromError::TypeNameNotFound { name: CALL.into() }); }; let Some(signature) = params.get(SIGNATURE) else { - return Err(TryFromError::TypeNameNotFound(SIGNATURE.into())); + return Err(TryFromError::TypeNameNotFound { + name: SIGNATURE.into(), + }); }; let Some(extra) = params.get(EXTRA) else { - return Err(TryFromError::TypeNameNotFound(EXTRA.into())); + return Err(TryFromError::TypeNameNotFound { name: EXTRA.into() }); }; Ok(ExtrinsicPartTypeIds { @@ -331,18 +339,24 @@ fn generate_outer_enums( }; let Some((call_enum, mut call_path)) = find_type("RuntimeCall") else { - return Err(TryFromError::TypeNameNotFound("RuntimeCall".into())); + return Err(TryFromError::TypeNameNotFound { + name: "RuntimeCall".into(), + }); }; let Some((event_enum, _)) = find_type("RuntimeEvent") else { - return Err(TryFromError::TypeNameNotFound("RuntimeEvent".into())); + return Err(TryFromError::TypeNameNotFound { + name: "RuntimeEvent".into(), + }); }; let error_enum = if let Some((error_enum, _)) = find_type("RuntimeError") { error_enum } else { let Some(last) = call_path.last_mut() else { - return Err(TryFromError::InvalidTypePath("RuntimeCall".into())); + return Err(TryFromError::InvalidTypePath { + path: "RuntimeCall".into(), + }); }; "RuntimeError".clone_into(last); generate_outer_error_enum_type(metadata, call_path) @@ -631,7 +645,12 @@ mod tests { let metadata = generate_metadata(meta_type::<()>()); let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("Address".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "Address".into() + } + ); #[derive(TypeInfo)] struct ExtrinsicNoCall { @@ -639,7 +658,12 @@ mod tests { } let metadata = generate_metadata(meta_type::>()); let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("Call".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "Call".into() + } + ); #[derive(TypeInfo)] struct ExtrinsicNoSign { @@ -647,7 +671,12 @@ mod tests { } let metadata = generate_metadata(meta_type::>()); let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("Signature".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "Signature".into() + } + ); #[derive(TypeInfo)] struct ExtrinsicNoExtra { @@ -655,7 +684,12 @@ mod tests { } let metadata = generate_metadata(meta_type::>()); let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("Extra".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "Extra".into() + } + ); } #[test] @@ -696,7 +730,12 @@ mod tests { }; let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("RuntimeCall".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "RuntimeCall".into() + } + ); } // Missing runtime event. @@ -720,7 +759,12 @@ mod tests { }; let err = v14_to_v15(metadata).unwrap_err(); - assert_eq!(err, TryFromError::TypeNameNotFound("RuntimeEvent".into())); + assert_eq!( + err, + TryFromError::TypeNameNotFound { + name: "RuntimeEvent".into() + } + ); } } }