use snafu in metadata

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"] }

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<frame_metadata::RuntimeMetadataPrefixed> for crate::Metadata {
     fn try_from(value: frame_metadata::RuntimeMetadataPrefixed) -> Result<Self, Self::Error> {
         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(),

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::<Result<_, _>>()?;
 
         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<Address, Signature, Extra> {
@@ -639,7 +658,12 @@ mod tests {
         }
         let metadata = generate_metadata(meta_type::<ExtrinsicNoCall<(), (), ()>>());
         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<Call, Address, Extra> {
@@ -647,7 +671,12 @@ mod tests {
         }
         let metadata = generate_metadata(meta_type::<ExtrinsicNoSign<(), (), ()>>());
         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<Call, Address, Signature> {
@@ -655,7 +684,12 @@ mod tests {
         }
         let metadata = generate_metadata(meta_type::<ExtrinsicNoExtra<(), (), ()>>());
         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()
+                }
+            );
         }
     }
 }