Subxt Metadata: #[no_std] compatibility (#1401)

* no-std tests and porting of subxt-metadata

* update pipeline

* fix generate custom metadata test

* fix cargo run command

* adjust pipeline

* remove prelude from subxt-metadata

* revert autoformatting of Cargo.toml

* remove alloc::format! again, still causes linker errors

* add no-std-build for thumbv7em-none-eabi target

* remove std feature flag

* remove libc and add small readme with test instructions

* change ci for nightly no std

metadata/src/from_into/mod.rs

@@ -2,31 +2,37 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
+use alloc::string::String;
+use derive_more::Display;
+
 mod v14;
 mod v15;
 
 /// An error emitted if something goes wrong converting [`frame_metadata`]
 /// types into [`crate::Metadata`].
-#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+#[derive(Debug, Display, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum TryFromError {
     /// Type missing from type registry
-    #[error("Type id {0} is expected but not found in the type registry")]
+    #[display(fmt = "Type id {_0} is expected but not found in the type registry")]
     TypeNotFound(u32),
     /// Type was not a variant/enum type
-    #[error("Type {0} was not a variant/enum type, but is expected to be one")]
+    #[display(fmt = "Type {_0} was not a variant/enum type, but is expected to be one")]
     VariantExpected(u32),
     /// An unsupported metadata version was provided.
-    #[error("Cannot convert v{0} metadata into Metadata type")]
+    #[display(fmt = "Cannot convert v{_0} metadata into Metadata type")]
     UnsupportedMetadataVersion(u32),
     /// Type name missing from type registry
-    #[error("Type name {0} is expected but not found in the type registry")]
+    #[display(fmt = "Type name {_0} is expected but not found in the type registry")]
     TypeNameNotFound(String),
     /// Invalid type path.
-    #[error("Type has an invalid path {0}")]
+    #[display(fmt = "Type has an invalid path {_0}")]
     InvalidTypePath(String),
 }
 
+#[cfg(feature = "std")]
+impl std::error::Error for TryFromError {}
+
 impl From<crate::Metadata> for frame_metadata::RuntimeMetadataPrefixed {
     fn from(value: crate::Metadata) -> Self {
         let m: frame_metadata::v15::RuntimeMetadataV15 = value.into();

metadata/src/from_into/v14.rs

@@ -2,11 +2,15 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use std::collections::HashMap;
-
 use super::TryFromError;
 use crate::Metadata;
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::fmt::Write;
 use frame_metadata::{v14, v15};
+use hashbrown::HashMap;
 use scale_info::TypeDef;
 
 impl TryFrom<v14::RuntimeMetadataV14> for Metadata {
@@ -31,27 +35,27 @@ fn v15_to_v14(mut metadata: v15::RuntimeMetadataV15) -> v14::RuntimeMetadataV14
     let extrinsic_type = scale_info::Type {
         path: scale_info::Path {
             segments: vec![
-                "primitives".to_string(),
-                "runtime".to_string(),
-                "generic".to_string(),
-                "UncheckedExtrinsic".to_string(),
+                "primitives".to_owned(),
+                "runtime".to_owned(),
+                "generic".to_owned(),
+                "UncheckedExtrinsic".to_owned(),
             ],
         },
         type_params: vec![
             scale_info::TypeParameter::<scale_info::form::PortableForm> {
-                name: "Address".to_string(),
+                name: "Address".to_owned(),
                 ty: Some(metadata.extrinsic.address_ty),
             },
             scale_info::TypeParameter::<scale_info::form::PortableForm> {
-                name: "Call".to_string(),
+                name: "Call".to_owned(),
                 ty: Some(metadata.extrinsic.call_ty),
             },
             scale_info::TypeParameter::<scale_info::form::PortableForm> {
-                name: "Signature".to_string(),
+                name: "Signature".to_owned(),
                 ty: Some(metadata.extrinsic.signature_ty),
             },
             scale_info::TypeParameter::<scale_info::form::PortableForm> {
-                name: "Extra".to_string(),
+                name: "Extra".to_owned(),
                 ty: Some(metadata.extrinsic.extra_ty),
             },
         ],
@@ -342,7 +346,7 @@ fn generate_outer_enums(
         let Some(last) = call_path.last_mut() else {
             return Err(TryFromError::InvalidTypePath("RuntimeCall".into()));
         };
-        *last = "RuntimeError".to_string();
+        *last = "RuntimeError".to_owned();
         generate_outer_error_enum_type(metadata, call_path)
     };
 
@@ -368,7 +372,10 @@ fn generate_outer_error_enum_type(
                 return None;
             };
 
-            let path = format!("{}Error", pallet.name);
+            // Note:  using the `alloc::format!` macro like in `let path = format!("{}Error", pallet.name);`
+            // leads to linker errors about extern function `_Unwind_Resume` not being defined.
+            let mut path = String::new();
+            write!(path, "{}Error", pallet.name).expect("Cannot panic, qed;");
             let ty = error.ty.id.into();
 
             Some(scale_info::Variant {

metadata/src/from_into/v15.rs

@@ -3,6 +3,7 @@
 // see LICENSE for license details.
 
 use super::TryFromError;
+
 use crate::utils::variant_index::VariantIndex;
 use crate::{
     utils::ordered_map::OrderedMap, ArcStr, ConstantMetadata, ExtrinsicMetadata, Metadata,
@@ -10,9 +11,10 @@ use crate::{
     RuntimeApiMethodParamMetadata, SignedExtensionMetadata, StorageEntryMetadata,
     StorageEntryModifier, StorageEntryType, StorageHasher, StorageMetadata,
 };
+use alloc::borrow::ToOwned;
 use frame_metadata::v15;
+use hashbrown::HashMap;
 use scale_info::form::PortableForm;
-use std::collections::HashMap;
 
 // Converting from V15 metadata into our Subxt repr.
 mod from_v15 {