Metadata V15: Generate Runtime APIs

cli/src/commands/compatibility.rs

@@ -11,6 +11,7 @@ use frame_metadata::{
 use jsonrpsee::client_transport::ws::Uri;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use subxt_codegen::utils::MetadataVersion;
 use subxt_metadata::{get_metadata_hash, get_pallet_hash, metadata_v14_to_latest};
 
 /// Verify metadata compatibility between substrate nodes.
@@ -25,16 +26,35 @@ pub struct Opts {
     /// The validation will omit the full metadata check and focus instead on the pallet.
     #[clap(long, value_parser)]
     pallet: Option<String>,
+    /// Specify the metadata version.
+    ///
+    ///  - unstable:
+    ///
+    ///    Use the latest unstable metadata of the node.
+    ///
+    ///  - number
+    ///
+    ///    Use this specific metadata version.
+    ///
+    /// Defaults to latest.
+    #[clap(long = "version", default_value = "latest")]
+    version: MetadataVersion,
 }
 
 pub async fn run(opts: Opts) -> color_eyre::Result<()> {
     match opts.pallet {
-        Some(pallet) => handle_pallet_metadata(opts.nodes.as_slice(), pallet.as_str()).await,
-        None => handle_full_metadata(opts.nodes.as_slice()).await,
+        Some(pallet) => {
+            handle_pallet_metadata(opts.nodes.as_slice(), pallet.as_str(), opts.version).await
+        }
+        None => handle_full_metadata(opts.nodes.as_slice(), opts.version).await,
     }
 }
 
-async fn handle_pallet_metadata(nodes: &[Uri], name: &str) -> color_eyre::Result<()> {
+async fn handle_pallet_metadata(
+    nodes: &[Uri],
+    name: &str,
+    version: MetadataVersion,
+) -> color_eyre::Result<()> {
     #[derive(Serialize, Deserialize, Default)]
     #[serde(rename_all = "camelCase")]
     struct CompatibilityPallet {
@@ -44,7 +64,7 @@ async fn handle_pallet_metadata(nodes: &[Uri], name: &str) -> color_eyre::Result
 
     let mut compatibility: CompatibilityPallet = Default::default();
     for node in nodes.iter() {
-        let metadata = fetch_runtime_metadata(node).await?;
+        let metadata = fetch_runtime_metadata(node, version).await?;
 
         match metadata.pallets.iter().find(|pallet| pallet.name == name) {
             Some(pallet_metadata) => {
@@ -73,10 +93,10 @@ async fn handle_pallet_metadata(nodes: &[Uri], name: &str) -> color_eyre::Result
     Ok(())
 }
 
-async fn handle_full_metadata(nodes: &[Uri]) -> color_eyre::Result<()> {
+async fn handle_full_metadata(nodes: &[Uri], version: MetadataVersion) -> color_eyre::Result<()> {
     let mut compatibility_map: HashMap<String, Vec<String>> = HashMap::new();
     for node in nodes.iter() {
-        let metadata = fetch_runtime_metadata(node).await?;
+        let metadata = fetch_runtime_metadata(node, version).await?;
         let hash = get_metadata_hash(&metadata);
         let hex_hash = hex::encode(hash);
         println!("Node {node:?} has metadata hash {hex_hash:?}",);
@@ -96,8 +116,11 @@ async fn handle_full_metadata(nodes: &[Uri]) -> color_eyre::Result<()> {
     Ok(())
 }
 
-async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result<RuntimeMetadataV15> {
-    let bytes = subxt_codegen::utils::fetch_metadata_bytes(url).await?;
+async fn fetch_runtime_metadata(
+    url: &Uri,
+    version: MetadataVersion,
+) -> color_eyre::Result<RuntimeMetadataV15> {
+    let bytes = subxt_codegen::utils::fetch_metadata_bytes(url, version).await?;
 
     let metadata = <RuntimeMetadataPrefixed as Decode>::decode(&mut &bytes[..])?;
     if metadata.0 != META_RESERVED {

cli/src/utils.rs

@@ -5,7 +5,7 @@
 use clap::Args;
 use color_eyre::eyre;
 use std::{fs, io::Read, path::PathBuf};
-use subxt_codegen::utils::Uri;
+use subxt_codegen::utils::{MetadataVersion, Uri};
 
 /// The source of the metadata.
 #[derive(Debug, Args)]
@@ -16,29 +16,57 @@ pub struct FileOrUrl {
     /// The path to the encoded metadata file.
     #[clap(long, value_parser)]
     file: Option<PathBuf>,
+    /// Specify the metadata version.
+    ///
+    ///  - unstable:
+    ///
+    ///    Use the latest unstable metadata of the node.
+    ///
+    ///  - number
+    ///
+    ///    Use this specific metadata version.
+    ///
+    /// Defaults to 14.
+    #[clap(long)]
+    version: Option<MetadataVersion>,
 }
 
 impl FileOrUrl {
     /// Fetch the metadata bytes.
     pub async fn fetch(&self) -> color_eyre::Result<Vec<u8>> {
-        match (&self.file, &self.url) {
+        match (&self.file, &self.url, self.version) {
             // Can't provide both --file and --url
-            (Some(_), Some(_)) => {
+            (Some(_), Some(_), _) => {
                 eyre::bail!("specify one of `--url` or `--file` but not both")
             }
             // Load from --file path
-            (Some(path), None) => {
+            (Some(path), None, None) => {
                 let mut file = fs::File::open(path)?;
                 let mut bytes = Vec::new();
                 file.read_to_end(&mut bytes)?;
                 Ok(bytes)
             }
+            // Cannot load the metadata from the file and specify a version to fetch.
+            (Some(_), None, Some(_)) => {
+                // Note: we could provide the ability to convert between metadata versions
+                // but that would be involved because we'd need to convert
+                // from each metadata to the latest one and from the
+                // latest one to each metadata version. For now, disable the conversion.
+                eyre::bail!("`--file` is incompatible with `--version`")
+            }
             // Fetch from --url
-            (None, Some(uri)) => Ok(subxt_codegen::utils::fetch_metadata_bytes(uri).await?),
+            (None, Some(uri), version) => Ok(subxt_codegen::utils::fetch_metadata_bytes(
+                uri,
+                version.unwrap_or_default(),
+            )
+            .await?),
             // Default if neither is provided; fetch from local url
-            (None, None) => {
+            (None, None, version) => {
                 let uri = Uri::from_static("http://localhost:9933");
-                Ok(subxt_codegen::utils::fetch_metadata_bytes(&uri).await?)
+                Ok(
+                    subxt_codegen::utils::fetch_metadata_bytes(&uri, version.unwrap_or_default())
+                        .await?,
+                )
             }
         }
     }

codegen/src/api/calls.rs

@@ -90,11 +90,11 @@ pub fn generate_calls(
                 pub fn #fn_name(
                     &self,
                     #( #call_fn_args, )*
-                ) -> #crate_path::tx::Payload<#struct_name> {
+                ) -> #crate_path::tx::Payload<types::#struct_name> {
                     #crate_path::tx::Payload::new_static(
                         #pallet_name,
                         #call_name,
-                        #struct_name { #( #call_args, )* },
+                        types::#struct_name { #( #call_args, )* },
                         [#(#call_hash,)*]
                     )
                 }
@@ -120,7 +120,11 @@ pub fn generate_calls(
 
             type DispatchError = #types_mod_ident::sp_runtime::DispatchError;
 
-            #( #call_structs )*
+            pub mod types {
+                use super::#types_mod_ident;
+
+                #( #call_structs )*
+            }
 
             pub struct TransactionApi;
 

codegen/src/api/mod.rs

@@ -8,6 +8,7 @@ mod calls;
 mod constants;
 mod errors;
 mod events;
+mod runtime_apis;
 mod storage;
 
 use frame_metadata::v15::RuntimeMetadataV15;
@@ -18,7 +19,7 @@ use crate::error::CodegenError;
 use crate::{
     ir,
     types::{CompositeDef, CompositeDefFields, TypeGenerator, TypeSubstitutes},
-    utils::{fetch_metadata_bytes_blocking, Uri},
+    utils::{fetch_metadata_bytes_blocking, MetadataVersion, Uri},
     CratePath,
 };
 use codec::Decode;
@@ -95,7 +96,11 @@ pub fn generate_runtime_api_from_url(
     should_gen_docs: bool,
     runtime_types_only: bool,
 ) -> Result<TokenStream2, CodegenError> {
-    let bytes = fetch_metadata_bytes_blocking(url)?;
+    // Fetch latest unstable version, if that fails fall back to the latest stable.
+    let bytes = match fetch_metadata_bytes_blocking(url, MetadataVersion::Unstable) {
+        Ok(bytes) => bytes,
+        Err(_) => fetch_metadata_bytes_blocking(url, MetadataVersion::Latest)?,
+    };
 
     generate_runtime_api_from_bytes(
         item_mod,
@@ -434,6 +439,14 @@ impl RuntimeGenerator {
 
         let rust_items = item_mod_ir.rust_items();
 
+        let apis_mod = runtime_apis::generate_runtime_apis(
+            &self.metadata,
+            &type_gen,
+            types_mod_ident,
+            &crate_path,
+            should_gen_docs,
+        )?;
+
         Ok(quote! {
             #( #item_mod_attrs )*
             #[allow(dead_code, unused_imports, non_camel_case_types)]
@@ -487,6 +500,12 @@ impl RuntimeGenerator {
                     TransactionApi
                 }
 
+                pub fn apis() -> runtime_apis::RuntimeApi {
+                    runtime_apis::RuntimeApi
+                }
+
+                #apis_mod
+
                 pub struct ConstantsApi;
                 impl ConstantsApi {
                     #(