Static Metadata Validation

Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "codegen",
     "examples",
     "macro",
+    "metadata",
     "subxt",
     "test-runtime"
 ]

RELEASING.md

@@ -67,7 +67,8 @@ We also assume that ongoing work done is being merged directly to the `master` b
         a little time in between each to let crates.io catch up with what we've published).
 
         ```
-        (cd codegen && cargo publish) && \
+        (cd metadata && cargo publish) && \
+            (cd codegen && cargo publish) && \
             sleep 10 && \
             (cd macro && cargo publish) && \
             sleep 10 && \

cli/Cargo.toml

@@ -17,6 +17,10 @@ path = "src/main.rs"
 [dependencies]
 # perform subxt codegen
 subxt-codegen = { version = "0.20.0", path = "../codegen" }
+# perform node compatibility
+subxt-metadata = { version = "0.20.0", path = "../metadata" }
+# information of portable registry
+scale-info = "2.0.0"
 # parse command line args
 structopt = "0.3.25"
 # make the request to a substrate node to get the metadata

cli/src/main.rs

@@ -18,12 +18,22 @@ use color_eyre::eyre::{
     self,
     WrapErr,
 };
-use frame_metadata::RuntimeMetadataPrefixed;
+use frame_metadata::{
+    RuntimeMetadata,
+    RuntimeMetadataPrefixed,
+    RuntimeMetadataV14,
+    META_RESERVED,
+};
 use scale::{
     Decode,
     Input,
 };
+use serde::{
+    Deserialize,
+    Serialize,
+};
 use std::{
+    collections::HashMap,
     fs,
     io::{
         self,
@@ -34,6 +44,10 @@ use std::{
 };
 use structopt::StructOpt;
 use subxt_codegen::GeneratedTypeDerives;
+use subxt_metadata::{
+    get_metadata_hash,
+    get_pallet_hash,
+};
 
 /// Utilities for working with substrate metadata for subxt.
 #[derive(Debug, StructOpt)]
@@ -75,6 +89,18 @@ enum Command {
         #[structopt(long = "derive")]
         derives: Vec<String>,
     },
+    /// Verify metadata compatibility between substrate nodes.
+    Compatibility {
+        /// Urls of the substrate nodes to verify for metadata compatibility.
+        #[structopt(name = "nodes", long, use_delimiter = true, parse(try_from_str))]
+        nodes: Vec<url::Url>,
+        /// Check the compatibility of metadata for a particular pallet.
+        ///
+        /// ### Note
+        /// The validation will omit the full metadata check and focus instead on the pallet.
+        #[structopt(long, parse(try_from_str))]
+        pallet: Option<String>,
+    },
 }
 
 fn main() -> color_eyre::Result<()> {
@@ -126,6 +152,105 @@ fn main() -> color_eyre::Result<()> {
             codegen(&mut &bytes[..], derives)?;
             Ok(())
         }
+        Command::Compatibility { nodes, pallet } => {
+            match pallet {
+                Some(pallet) => handle_pallet_metadata(nodes.as_slice(), pallet.as_str()),
+                None => handle_full_metadata(nodes.as_slice()),
+            }
+        }
+    }
+}
+
+fn handle_pallet_metadata(nodes: &[url::Url], name: &str) -> color_eyre::Result<()> {
+    #[derive(Serialize, Deserialize, Default)]
+    #[serde(rename_all = "camelCase")]
+    struct CompatibilityPallet {
+        pallet_present: HashMap<String, Vec<String>>,
+        pallet_not_found: Vec<String>,
+    }
+
+    let mut compatibility: CompatibilityPallet = Default::default();
+    for node in nodes.iter() {
+        let metadata = fetch_runtime_metadata(node)?;
+
+        match metadata.pallets.iter().find(|pallet| pallet.name == name) {
+            Some(pallet_metadata) => {
+                let hash = get_pallet_hash(&metadata.types, pallet_metadata);
+                let hex_hash = hex::encode(hash);
+                println!(
+                    "Node {:?} has pallet metadata hash {:?}",
+                    node.as_str(),
+                    hex_hash
+                );
+
+                compatibility
+                    .pallet_present
+                    .entry(hex_hash)
+                    .or_insert_with(Vec::new)
+                    .push(node.as_str().to_string());
+            }
+            None => {
+                compatibility
+                    .pallet_not_found
+                    .push(node.as_str().to_string());
+            }
+        }
+    }
+
+    println!(
+        "\nCompatible nodes by pallet\n{}",
+        serde_json::to_string_pretty(&compatibility)
+            .context("Failed to parse compatibility map")?
+    );
+
+    Ok(())
+}
+
+fn handle_full_metadata(nodes: &[url::Url]) -> color_eyre::Result<()> {
+    let mut compatibility_map: HashMap<String, Vec<String>> = HashMap::new();
+    for node in nodes.iter() {
+        let metadata = fetch_runtime_metadata(node)?;
+        let hash = get_metadata_hash(&metadata);
+        let hex_hash = hex::encode(hash);
+        println!("Node {:?} has metadata hash {:?}", node.as_str(), hex_hash,);
+
+        compatibility_map
+            .entry(hex_hash)
+            .or_insert_with(Vec::new)
+            .push(node.as_str().to_string());
+    }
+
+    println!(
+        "\nCompatible nodes\n{}",
+        serde_json::to_string_pretty(&compatibility_map)
+            .context("Failed to parse compatibility map")?
+    );
+
+    Ok(())
+}
+
+fn fetch_runtime_metadata(url: &url::Url) -> color_eyre::Result<RuntimeMetadataV14> {
+    let (_, bytes) = fetch_metadata(url)?;
+
+    let metadata = <RuntimeMetadataPrefixed as Decode>::decode(&mut &bytes[..])?;
+    if metadata.0 != META_RESERVED {
+        return Err(eyre::eyre!(
+            "Node {:?} has invalid metadata prefix: {:?} expected prefix: {:?}",
+            url.as_str(),
+            metadata.0,
+            META_RESERVED
+        ))
+    }
+
+    match metadata.1 {
+        RuntimeMetadata::V14(v14) => Ok(v14),
+        _ => {
+            Err(eyre::eyre!(
+                "Node {:?} with unsupported metadata version: {:?}",
+                url.as_str(),
+                metadata.1
+            ))
+        }
     }
 }
 

codegen/Cargo.toml

@@ -22,6 +22,8 @@ proc-macro-error = "1.0.4"
 quote = "1.0.8"
 syn = "1.0.58"
 scale-info = { version = "2.0.0", features = ["bit-vec"] }
+sp-core = { version = "6.0.0"  }
+subxt-metadata = { version = "0.20.0", path = "../metadata" }
 
 [dev-dependencies]
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }

codegen/src/api/calls.rs

@@ -19,6 +19,7 @@ use crate::types::{
     TypeGenerator,
 };
 use frame_metadata::{
+    v14::RuntimeMetadataV14,
     PalletCallMetadata,
     PalletMetadata,
 };
@@ -35,6 +36,7 @@ use quote::{
 use scale_info::form::PortableForm;
 
 pub fn generate_calls(
+    metadata: &RuntimeMetadataV14,
     type_gen: &TypeGenerator,
     pallet: &PalletMetadata<PortableForm>,
     call: &PalletCallMetadata<PortableForm>,
@@ -48,7 +50,7 @@ pub fn generate_calls(
     );
     let (call_structs, call_fns): (Vec<_>, Vec<_>) = struct_defs
         .iter_mut()
-        .map(|struct_def| {
+        .map(|(variant_name, struct_def)| {
             let (call_fn_args, call_args): (Vec<_>, Vec<_>) =
                 match struct_def.fields {
                     CompositeDefFields::Named(ref named_fields) => {
@@ -74,30 +76,36 @@ pub fn generate_calls(
                 };
 
             let pallet_name = &pallet.name;
-            let call_struct_name = &struct_def.name;
-            let function_name = struct_def.name.to_string().to_snake_case();
-            let fn_name = format_ident!("{}", function_name);
+            let call_name = &variant_name;
+            let struct_name = &struct_def.name;
+            let call_hash = subxt_metadata::get_call_hash(metadata, pallet_name, call_name)
+                .unwrap_or_else(|_| abort_call_site!("Metadata information for the call {}_{} could not be found", pallet_name, call_name));
 
+            let fn_name = format_ident!("{}", variant_name.to_snake_case());
             // Propagate the documentation just to `TransactionApi` methods, while
             // draining the documentation of inner call structures.
             let docs = struct_def.docs.take();
             // The call structure's documentation was stripped above.
             let call_struct = quote! {
                 #struct_def
 
-                impl ::subxt::Call for #call_struct_name {
+                impl ::subxt::Call for #struct_name {
                     const PALLET: &'static str = #pallet_name;
-                    const FUNCTION: &'static str = #function_name;
+                    const FUNCTION: &'static str = #call_name;
                 }
             };
             let client_fn = quote! {
                 #docs
                 pub fn #fn_name(
                     &self,
                     #( #call_fn_args, )*
-                ) -> ::subxt::SubmittableExtrinsic<'a, T, X, #call_struct_name, DispatchError, root_mod::Event> {
-                    let call = #call_struct_name { #( #call_args, )* };
-                    ::subxt::SubmittableExtrinsic::new(self.client, call)
+                ) -> Result<::subxt::SubmittableExtrinsic<'a, T, X, #struct_name, DispatchError, root_mod::Event>, ::subxt::BasicError> {
+                    if self.client.metadata().call_hash::<#struct_name>()? == [#(#call_hash,)*] {
+                        let call = #struct_name { #( #call_args, )* };
+                        Ok(::subxt::SubmittableExtrinsic::new(self.client, call))
+                    } else {
+                        Err(::subxt::MetadataError::IncompatibleMetadata.into())
+                    }
                 }
             };
             (call_struct, client_fn)

codegen/src/api/constants.rs

@@ -16,18 +16,21 @@
 
 use crate::types::TypeGenerator;
 use frame_metadata::{
+    v14::RuntimeMetadataV14,
     PalletConstantMetadata,
     PalletMetadata,
 };
 use heck::ToSnakeCase as _;
 use proc_macro2::TokenStream as TokenStream2;
+use proc_macro_error::abort_call_site;
 use quote::{
     format_ident,
     quote,
 };
 use scale_info::form::PortableForm;
 
 pub fn generate_constants(
+    metadata: &RuntimeMetadataV14,
     type_gen: &TypeGenerator,
     pallet: &PalletMetadata<PortableForm>,
     constants: &[PalletConstantMetadata<PortableForm>],
@@ -37,16 +40,23 @@ pub fn generate_constants(
         let fn_name = format_ident!("{}", constant.name.to_snake_case());
         let pallet_name = &pallet.name;
         let constant_name = &constant.name;
+        let constant_hash = subxt_metadata::get_constant_hash(metadata, pallet_name, constant_name)
+            .unwrap_or_else(|_| abort_call_site!("Metadata information for the constant {}_{} could not be found", pallet_name, constant_name));
+
         let return_ty = type_gen.resolve_type_path(constant.ty.id(), &[]);
         let docs = &constant.docs;
 
         quote! {
             #( #[doc = #docs ] )*
             pub fn #fn_name(&self) -> ::core::result::Result<#return_ty, ::subxt::BasicError> {
-                let pallet = self.client.metadata().pallet(#pallet_name)?;
-                let constant = pallet.constant(#constant_name)?;
-                let value = ::subxt::codec::Decode::decode(&mut &constant.value[..])?;
-                Ok(value)
+                if self.client.metadata().constant_hash(#pallet_name, #constant_name)? == [#(#constant_hash,)*] {
+                    let pallet = self.client.metadata().pallet(#pallet_name)?;
+                    let constant = pallet.constant(#constant_name)?;
+                    let value = ::subxt::codec::Decode::decode(&mut &constant.value[..])?;
+                    Ok(value)
+                } else {
+                    Err(::subxt::MetadataError::IncompatibleMetadata.into())
+                }
             }
         }
     });

codegen/src/api/events.rs

@@ -35,10 +35,10 @@ pub fn generate_events(
         |name| name.into(),
         "Event",
     );
-    let event_structs = struct_defs.iter().map(|struct_def| {
+    let event_structs = struct_defs.iter().map(|(variant_name, struct_def)| {
         let pallet_name = &pallet.name;
         let event_struct = &struct_def.name;
-        let event_name = struct_def.name.to_string();
+        let event_name = variant_name;
 
         quote! {
             #struct_def