Codegen for custom values in metadata

codegen/src/api/custom_values.rs

@@ -0,0 +1,104 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use std::collections::HashSet;
+
+use crate::{types::TypeGenerator, CratePath};
+use heck::ToSnakeCase as _;
+use subxt_metadata::Metadata;
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{format_ident, quote};
+
+/// Generate the custom values mod, if there are any custom values in the metadata. Else returns None.
+pub fn generate_custom_values(
+    metadata: &Metadata,
+    type_gen: &TypeGenerator,
+    types_mod_ident: &syn::Ident,
+    crate_path: &CratePath,
+) -> Option<TokenStream2> {
+    let mut fn_names_taken = HashSet::new();
+    let custom_value_fns: Vec<_> = metadata
+        .custom()
+        .iter()
+        .filter_map(|(key, custom)| {
+            generate_custom_value_fn(
+                key,
+                custom.type_id(),
+                type_gen,
+                crate_path,
+                &mut fn_names_taken,
+            )
+        })
+        .collect();
+
+    (!custom_value_fns.is_empty()).then(|| {
+        quote!(
+            pub fn custom() -> custom::CustomValuesApi {
+                custom::CustomValuesApi
+            }
+
+            pub mod custom{
+                use super::#types_mod_ident;
+
+                pub struct CustomValuesApi;
+
+                impl CustomValuesApi {
+                    #( #custom_value_fns )*
+                }
+            }
+
+
+        )
+    });
+
+    if custom_value_fns.is_empty() {
+        None
+    } else {
+        Some(quote!(
+            pub fn custom() -> custom::CustomValuesApi {
+                custom::CustomValuesApi
+            }
+
+            pub mod custom{
+                use super::#types_mod_ident;
+
+                pub struct CustomValuesApi;
+
+                impl CustomValuesApi {
+                    #( #custom_value_fns )*
+                }
+            }
+
+
+        ))
+    }
+}
+
+/// Generates runtime functions for the given API metadata.
+/// Returns None, if the name would not make for a valid identifier.
+fn generate_custom_value_fn(
+    name: &str,
+    type_id: u32,
+    type_gen: &TypeGenerator,
+    crate_path: &CratePath,
+    fn_names_taken: &mut HashSet<String>,
+) -> Option<TokenStream2> {
+    // names are transformed to snake case to make for good function identifiers.
+    let fn_name = name.to_snake_case();
+    // Skip elements where the fn name is already occupied. E.g. if you have custom values with names "Foo" and "foo" in the metadata.
+    if fn_names_taken.contains(&fn_name) {
+        return None;
+    }
+    let fn_name_ident = format_ident!("{fn_name}");
+    fn_names_taken.insert(fn_name);
+
+    let return_ty = type_gen.resolve_type_path(type_id);
+
+    Some(quote!(
+        pub fn #fn_name_ident() -> #crate_path::custom_values::StaticAddress<#return_ty> {
+            #crate_path::custom_values::StaticAddress::new(#name)
+        }
+    ))
+}

codegen/src/api/mod.rs

@@ -6,13 +6,16 @@
 
 mod calls;
 mod constants;
+mod custom_values;
 mod errors;
 mod events;
 mod runtime_apis;
 mod storage;
 
 use subxt_metadata::Metadata;
 
+use self::custom_values::generate_custom_values;
+
 use super::DerivesRegistry;
 use crate::error::CodegenError;
 use crate::{
@@ -469,6 +472,11 @@ impl RuntimeGenerator {
         let event_path = type_gen.resolve_type_path(self.metadata.outer_enums().event_enum_ty());
         let error_path = type_gen.resolve_type_path(self.metadata.outer_enums().error_enum_ty());
 
+        // if there are no custom values this will be empty:
+        let custom_values_mod_and_fn =
+            generate_custom_values(&self.metadata, &type_gen, types_mod_ident, &crate_path)
+                .unwrap_or_default();
+
         Ok(quote! {
             #( #item_mod_attrs )*
             #[allow(dead_code, unused_imports, non_camel_case_types)]
@@ -521,6 +529,8 @@ impl RuntimeGenerator {
 
                 #apis_mod
 
+                #custom_values_mod_and_fn
+
                 pub struct ConstantsApi;
                 impl ConstantsApi {
                     #(

metadata/src/lib.rs

@@ -641,26 +641,40 @@ pub struct RuntimeApiMethodParamMetadata {
 /// Metadata of custom types with custom values, basically the same as `frame_metadata::v15::CustomMetadata<PortableForm>>`.
 #[derive(Debug, Clone)]
 pub struct CustomMetadata {
+    /// custom values accessible via a name.
     map: BTreeMap<String, frame_metadata::v15::CustomValueMetadata<PortableForm>>,
 }
 
 impl CustomMetadata {
-    /// Get a certain [CustomMetadataValue] by its name.
-    pub fn get(&self, name: &str) -> Option<CustomMetadataValue<'_>> {
-        self.map.get(name).map(|e| CustomMetadataValue {
+    /// Get a certain [CustomValueMetadata] by its name.
+    pub fn get(&self, name: &str) -> Option<CustomValueMetadata<'_>> {
+        self.map.get(name).map(|e| CustomValueMetadata {
             type_id: e.ty.id,
             data: &e.value,
         })
     }
+
+    /// Iterates over names (keys) and associated custom values
+    pub fn iter(&self) -> impl Iterator<Item = (&str, CustomValueMetadata)> {
+        self.map.iter().map(|(name, el)| {
+            (
+                name.as_ref(),
+                CustomValueMetadata {
+                    type_id: el.ty.id,
+                    data: &el.value,
+                },
+            )
+        })
+    }
 }
 
 /// Basically the same as `frame_metadata::v15::CustomValueMetadata<PortableForm>>`, but borrowed.
-pub struct CustomMetadataValue<'a> {
+pub struct CustomValueMetadata<'a> {
     type_id: u32,
     data: &'a [u8],
 }
 
-impl<'a> CustomMetadataValue<'a> {
+impl<'a> CustomValueMetadata<'a> {
     /// the scale encoded value
     pub fn bytes(&self) -> &'a [u8] {
         self.data

metadata/src/utils/validation.rs

@@ -5,8 +5,9 @@
 //! Utility functions for metadata validation.
 
 use crate::{
-    ExtrinsicMetadata, Metadata, OuterEnumsMetadata, PalletMetadata, RuntimeApiMetadata,
-    RuntimeApiMethodMetadata, StorageEntryMetadata, StorageEntryType,
+    CustomMetadata, CustomValueMetadata, ExtrinsicMetadata, Metadata, OuterEnumsMetadata,
+    PalletMetadata, RuntimeApiMetadata, RuntimeApiMethodMetadata, StorageEntryMetadata,
+    StorageEntryType,
 };
 use scale_info::{form::PortableForm, Field, PortableRegistry, TypeDef, TypeDefVariant, Variant};
 use std::collections::HashMap;
@@ -67,6 +68,7 @@ concat_and_hash_n!(concat_and_hash2(a b));
 concat_and_hash_n!(concat_and_hash3(a b c));
 concat_and_hash_n!(concat_and_hash4(a b c d));
 concat_and_hash_n!(concat_and_hash5(a b c d e));
+concat_and_hash_n!(concat_and_hash6(a b c d e f));
 
 /// Obtain the hash representation of a `scale_info::Field`.
 fn get_field_hash(
@@ -393,6 +395,35 @@ pub fn get_runtime_trait_hash(trait_metadata: RuntimeApiMetadata) -> [u8; HASH_L
     concat_and_hash2(&hash(trait_name.as_bytes()), &method_bytes)
 }
 
+pub fn get_custom_metadata_hash(
+    custom_metadata: &CustomMetadata,
+    registry: &PortableRegistry,
+) -> [u8; HASH_LEN] {
+    let mut cache = HashMap::new();
+    custom_metadata
+        .iter()
+        .fold([0u8; HASH_LEN], |bytes, (key, custom_value)| {
+            xor(
+                bytes,
+                get_custom_value_hash(registry, key, custom_value, &mut cache),
+            )
+        })
+}
+
+/// Obtain the hash of some custom value in the metadata including it's name/key.
+pub fn get_custom_value_hash(
+    registry: &PortableRegistry,
+    name: &str,
+    metadata: CustomValueMetadata,
+    cache: &mut HashMap<u32, CachedHash>,
+) -> [u8; HASH_LEN] {
+    concat_and_hash3(
+        &hash(name.as_bytes()),
+        &get_type_hash(registry, metadata.type_id(), cache),
+        &hash(metadata.bytes()),
+    )
+}
+
 /// Obtain the hash for a specific storage item, or an error if it's not found.
 pub fn get_storage_hash(pallet: &PalletMetadata, entry_name: &str) -> Option<[u8; HASH_LEN]> {
     let storage = pallet.storage()?;
@@ -494,6 +525,7 @@ pub struct MetadataHasher<'a> {
     metadata: &'a Metadata,
     specific_pallets: Option<Vec<&'a str>>,
     specific_runtime_apis: Option<Vec<&'a str>>,
+    include_custom_values: bool,
 }
 
 impl<'a> MetadataHasher<'a> {
@@ -503,6 +535,7 @@ impl<'a> MetadataHasher<'a> {
             metadata,
             specific_pallets: None,
             specific_runtime_apis: None,
+            include_custom_values: true,
         }
     }
 
@@ -554,7 +587,7 @@ impl<'a> MetadataHasher<'a> {
                 // We don't care what order the runtime APIs are seen in, so XOR their
                 // hashes together to be order independent.
                 if should_hash {
-                    xor(bytes, xor(bytes, get_runtime_trait_hash(api)))
+                    xor(bytes, get_runtime_trait_hash(api))
                 } else {
                     bytes
                 }
@@ -569,12 +602,18 @@ impl<'a> MetadataHasher<'a> {
             self.specific_pallets.as_deref(),
         );
 
-        concat_and_hash5(
+        let custom_values_hash = self
+            .include_custom_values
+            .then(|| get_custom_metadata_hash(metadata.custom(), &metadata.types))
+            .unwrap_or_default();
+
+        concat_and_hash6(
             &pallet_hash,
             &apis_hash,
             &extrinsic_hash,
             &runtime_hash,
             &outer_enums_hash,
+            &custom_values_hash,
         )
     }
 }

subxt/src/custom_values/custom_value_address.rs

@@ -1,9 +1,12 @@
+use std::marker::PhantomData;
+
 use crate::dynamic::DecodedValueThunk;
 use crate::metadata::DecodeWithMetadata;
 
 /// This represents the address of a custom value in in the metadata.
 /// Anything, that implements the [CustomValueAddress] trait can be used, to fetch
 /// custom values from the metadata.
+/// The trait is implemented by [str] for dynamic loopup and [StaticAddress] for static queries.
 pub trait CustomValueAddress {
     /// The type of the custom value.
     type Target: DecodeWithMetadata;
@@ -19,3 +22,27 @@ impl CustomValueAddress for str {
         self
     }
 }
+
+/// A static address to a custom value.
+pub struct StaticAddress<R> {
+    name: &'static str,
+    phantom: PhantomData<R>,
+}
+
+impl<R> StaticAddress<R> {
+    /// Creates a new StaticAddress.
+    pub fn new(name: &'static str) -> Self {
+        StaticAddress {
+            name,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<R: DecodeWithMetadata> CustomValueAddress for StaticAddress<R> {
+    type Target = R;
+
+    fn name(&self) -> &str {
+        self.name
+    }
+}

subxt/src/custom_values/mod.rs

@@ -7,5 +7,5 @@
 mod custom_value_address;
 mod custom_values_client;
 
-pub use custom_value_address::CustomValueAddress;
+pub use custom_value_address::{CustomValueAddress, StaticAddress};
 pub use custom_values_client::CustomValuesClient;