Make the codegen more accessible for running in WASM

cli/src/commands/diff.rs

@@ -13,7 +13,6 @@ use scale_info::Variant;
 
 use subxt_metadata::{
     ConstantMetadata, Metadata, PalletMetadata, RuntimeApiMetadata, StorageEntryMetadata,
-    StorageEntryType,
 };
 
 /// Explore the differences between two nodes
@@ -220,40 +219,34 @@ impl StorageEntryDiff {
         metadata_1: &Metadata,
         metadata_2: &Metadata,
     ) -> Self {
-        let value_1_ty_id = match storage_entry_1.entry_type() {
-            StorageEntryType::Plain(value_ty) | StorageEntryType::Map { value_ty, .. } => value_ty,
-        };
+        let value_1_ty_id = storage_entry_1.entry_type().value_ty();
         let value_1_hash = metadata_1
-            .type_hash(*value_1_ty_id)
+            .type_hash(value_1_ty_id)
             .expect("type should be present");
-        let value_2_ty_id = match storage_entry_2.entry_type() {
-            StorageEntryType::Plain(value_ty) | StorageEntryType::Map { value_ty, .. } => value_ty,
-        };
+        let value_2_ty_id = storage_entry_2.entry_type().value_ty();
         let value_2_hash = metadata_1
-            .type_hash(*value_2_ty_id)
+            .type_hash(value_2_ty_id)
             .expect("type should be present");
         let value_different = value_1_hash != value_2_hash;
 
-        let key_1_hash = match storage_entry_1.entry_type() {
-            StorageEntryType::Plain(_) => None,
-            StorageEntryType::Map { key_ty, .. } => Some(*key_ty),
-        }
-        .map(|key_ty| {
-            metadata_1
-                .type_hash(key_ty)
-                .expect("type should be present")
-        })
-        .unwrap_or_default();
-        let key_2_hash = match storage_entry_2.entry_type() {
-            StorageEntryType::Plain(_) => None,
-            StorageEntryType::Map { key_ty, .. } => Some(*key_ty),
-        }
-        .map(|key_ty| {
-            metadata_2
-                .type_hash(key_ty)
-                .expect("type should be present")
-        })
-        .unwrap_or_default();
+        let key_1_hash = storage_entry_1
+            .entry_type()
+            .key_ty()
+            .map(|key_ty| {
+                metadata_1
+                    .type_hash(key_ty)
+                    .expect("type should be present")
+            })
+            .unwrap_or_default();
+        let key_2_hash = storage_entry_2
+            .entry_type()
+            .key_ty()
+            .map(|key_ty| {
+                metadata_2
+                    .type_hash(key_ty)
+                    .expect("type should be present")
+            })
+            .unwrap_or_default();
         let key_different = key_1_hash != key_2_hash;
 
         StorageEntryDiff {

codegen/Cargo.toml

@@ -12,19 +12,30 @@ documentation = "https://docs.rs/subxt-codegen"
 homepage.workspace = true
 description = "Generate an API for interacting with a substrate node from FRAME metadata"
 
+[features]
+default = ["fetch_metadata"]
+fetch_metadata = ["dep:jsonrpsee", "dep:tokio", "dep:frame-metadata"]
+web = ["getrandom/js"]
+
 [dependencies]
 codec = { package = "parity-scale-codec", workspace = true, features = ["derive"] }
-frame-metadata = { workspace = true }
+frame-metadata = { workspace = true, optional = true }
 heck = { workspace = true }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
 syn = { workspace = true }
 scale-info = { workspace = true }
 subxt-metadata = { workspace = true }
-jsonrpsee = { workspace = true, features = ["async-client", "client-ws-transport-native-tls", "http-client"] }
+jsonrpsee = { workspace = true, features = [
+    "async-client",
+    "client-ws-transport-native-tls",
+    "http-client",
+], optional = true }
 hex = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread"] }
+tokio = { workspace = true, features = ["rt-multi-thread"], optional = true }
 thiserror = { workspace = true }
+getrandom = { workspace = true, optional = true }
+
 
 [dev-dependencies]
 bitvec = { workspace = true }

codegen/src/api/custom_values.rs

@@ -9,6 +9,7 @@ use heck::ToSnakeCase as _;
 use subxt_metadata::{CustomValueMetadata, Metadata};
 
 use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
 use quote::{quote, ToTokens};
 
 /// Generate the custom values mod, if there are any custom values in the metadata. Else returns None.

codegen/src/api/mod.rs

@@ -20,9 +20,12 @@ use crate::error::CodegenError;
 use crate::{
     ir,
     types::{CompositeDef, CompositeDefFields, TypeGenerator, TypeSubstitutes},
-    utils::{fetch_metadata_bytes_blocking, MetadataVersion, Url},
     CratePath,
 };
+
+#[cfg(feature = "fetch_metadata")]
+use crate::utils::{fetch_metadata_bytes_blocking, MetadataVersion, Url};
+
 use codec::Decode;
 use heck::ToSnakeCase as _;
 use proc_macro2::TokenStream as TokenStream2;
@@ -146,6 +149,7 @@ impl GenerateRuntimeApi {
     /// # Warning
     ///
     /// Not recommended to be used in production environments.
+    #[cfg(feature = "fetch_metadata")]
     pub fn generate_from_url(self, url: Url) -> Result<TokenStream2, CodegenError> {
         fn fetch_metadata(url: Url, version: MetadataVersion) -> Result<Metadata, CodegenError> {
             let bytes = fetch_metadata_bytes_blocking(url, version)?;
@@ -233,7 +237,7 @@ impl RuntimeGenerator {
     /// unique path, so that types with matching paths don't end up overwriting each other
     /// in the codegen. We ignore any types with generics; Subxt actually endeavours to
     /// de-duplicate those into single types with a generic.
-    fn ensure_unique_type_paths(metadata: &mut Metadata) {
+    pub fn ensure_unique_type_paths(metadata: &mut Metadata) {
         let mut visited_path_counts = HashMap::<Vec<String>, usize>::new();
         for ty in metadata.types_mut().types.iter_mut() {
             // Ignore types without a path (ie prelude types).

codegen/src/api/storage.rs

@@ -96,10 +96,7 @@ fn generate_storage_entry_fns(
     };
 
     let snake_case_name = storage_entry.name().to_snake_case();
-    let storage_entry_ty = match storage_entry.entry_type() {
-        StorageEntryType::Plain(ty) => *ty,
-        StorageEntryType::Map { value_ty, .. } => *value_ty,
-    };
+    let storage_entry_ty = storage_entry.entry_type().value_ty();
     let storage_entry_value_ty = type_gen.resolve_type_path(storage_entry_ty);
     let docs = storage_entry.docs();
     let docs = should_gen_docs
@@ -173,6 +170,7 @@ fn primitive_type_alias(type_path: &TypePath) -> TokenStream {
     quote!(#type_path)
 }
 
+#[cfg(feature = "fetch_metadata")]
 #[cfg(test)]
 mod tests {
     use crate::RuntimeGenerator;

codegen/src/error.rs

@@ -87,6 +87,7 @@ pub enum FetchMetadataError {
     DecodeError(#[from] hex::FromHexError),
     #[error("Cannot scale encode/decode value: {0}")]
     CodecError(#[from] codec::Error),
+    #[cfg(feature = "fetch_metadata")]
     #[error("Request error: {0}")]
     RequestError(#[from] jsonrpsee::core::Error),
     #[error("'{0}' not supported, supported URI schemes are http, https, ws or wss.")]

codegen/src/lib.rs

@@ -50,10 +50,21 @@ mod error;
 mod ir;
 mod types;
 
+#[cfg(feature = "fetch_metadata")]
 pub mod utils;
 
+#[cfg(all(feature = "web", feature = "fetch_metadata"))]
+compile_error!("subxt-codegen: the features 'web' and 'fetch_metadata' cannot be used together.");
+
+#[cfg(feature = "web")]
+#[allow(unused_imports)]
+pub use getrandom as _;
+
 pub use self::{
     api::{GenerateRuntimeApi, RuntimeGenerator},
     error::{CodegenError, TypeSubstitutionError},
-    types::{CratePath, Derives, DerivesRegistry, Module, TypeGenerator, TypeSubstitutes},
+    types::{
+        CratePath, Derives, DerivesRegistry, Module, TypeDefGen, TypeDefParameters, TypeGenerator,
+        TypeSubstitutes,
+    },
 };

codegen/src/types/mod.rs

@@ -262,6 +262,11 @@ impl<'a> TypeGenerator<'a> {
         self.derives.default_derives()
     }
 
+    /// Returns the type registry.
+    pub fn types(&self) -> &PortableRegistry {
+        self.type_registry
+    }
+
     /// Returns the derives to be applied to a generated type.
     pub fn type_derives(&self, ty: &Type<PortableForm>) -> Result<Derives, CodegenError> {
         let joined_path = ty.path.segments.join("::");

codegen/src/types/type_def.rs

@@ -118,6 +118,11 @@ impl TypeDefGen {
             ty_docs,
         })
     }
+
+    /// are there unused type params?
+    pub fn has_unused_type_params(&self) -> bool {
+        self.type_params.has_unused_type_params()
+    }
 }
 
 impl quote::ToTokens for TypeDefGen {

codegen/src/types/type_def_params.rs

@@ -60,6 +60,11 @@ impl TypeDefParameters {
     pub fn params(&self) -> &[TypeParameter] {
         &self.params
     }
+
+    /// Returns true if there are any unused type params
+    pub fn has_unused_type_params(&self) -> bool {
+        !self.unused.is_empty()
+    }
 }
 
 impl quote::ToTokens for TypeDefParameters {

metadata/Cargo.toml

@@ -14,7 +14,9 @@ homepage.workspace = true
 description = "Command line utilities for checking metadata compatibility between nodes."
 
 [dependencies]
-codec = { package = "parity-scale-codec", workspace = true, features = ["derive"] }
+codec = { package = "parity-scale-codec", workspace = true, features = [
+    "derive",
+] }
 frame-metadata = { workspace = true }
 scale-info = { workspace = true }
 sp-core-hashing = { workspace = true }

metadata/src/lib.rs

@@ -395,6 +395,23 @@ pub enum StorageEntryType {
     },
 }
 
+impl StorageEntryType {
+    /// The type of the value.
+    pub fn value_ty(&self) -> u32 {
+        match self {
+            StorageEntryType::Map { value_ty, .. } | StorageEntryType::Plain(value_ty) => *value_ty,
+        }
+    }
+
+    /// The type of the key, can be a tuple with elements for each of the hashers. None for a Plain storage entry.
+    pub fn key_ty(&self) -> Option<u32> {
+        match self {
+            StorageEntryType::Map { key_ty, .. } => Some(*key_ty),
+            StorageEntryType::Plain(_) => None,
+        }
+    }
+}
+
 /// Hasher used by storage maps.
 #[derive(Debug, Clone, Copy)]
 pub enum StorageHasher {