Adjust to v15 metadata

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

cli/src/commands/compatibility.rs

@@ -4,12 +4,14 @@
 
 use clap::Parser as ClapParser;
 use color_eyre::eyre::{self, WrapErr};
-use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed, RuntimeMetadataV14, META_RESERVED};
+use frame_metadata::{
+    v15::RuntimeMetadataV15, RuntimeMetadata, RuntimeMetadataPrefixed, META_RESERVED,
+};
 use jsonrpsee::client_transport::ws::Uri;
 use scale::Decode;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use subxt_metadata::{get_metadata_hash, get_pallet_hash};
+use subxt_metadata::{get_metadata_hash, get_pallet_hash, metadata_v14_to_latest};
 
 /// Verify metadata compatibility between substrate nodes.
 #[derive(Debug, ClapParser)]
@@ -94,7 +96,7 @@ async fn handle_full_metadata(nodes: &[Uri]) -> color_eyre::Result<()> {
     Ok(())
 }
 
-async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result<RuntimeMetadataV14> {
+async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result<RuntimeMetadataV15> {
     let bytes = subxt_codegen::utils::fetch_metadata_bytes(url).await?;
 
     let metadata = <RuntimeMetadataPrefixed as Decode>::decode(&mut &bytes[..])?;
@@ -108,7 +110,8 @@ async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result<RuntimeMetadata
     }
 
     match metadata.1 {
-        RuntimeMetadata::V14(v14) => Ok(v14),
+        RuntimeMetadata::V14(v14) => Ok(metadata_v14_to_latest(v14)),
+        RuntimeMetadata::V15(v15) => Ok(v15),
         _ => Err(eyre::eyre!(
             "Node {:?} with unsupported metadata version: {:?}",
             url,

cli/src/commands/metadata.rs

@@ -8,7 +8,7 @@ use color_eyre::eyre;
 use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed};
 use scale::{Decode, Encode};
 use std::io::{self, Write};
-use subxt_metadata::retain_metadata_pallets;
+use subxt_metadata::{metadata_v14_to_latest, retain_metadata_pallets};
 
 /// Download metadata from a substrate node, for use with `subxt` codegen.
 #[derive(Debug, ClapParser)]
@@ -29,8 +29,9 @@ pub async fn run(opts: Opts) -> color_eyre::Result<()> {
     let mut metadata = <RuntimeMetadataPrefixed as Decode>::decode(&mut &bytes[..])?;
 
     if let Some(pallets) = opts.pallets {
-        let metadata_v14 = match &mut metadata.1 {
-            RuntimeMetadata::V14(metadata_v14) => metadata_v14,
+        let mut metadata_v15 = match metadata.1 {
+            RuntimeMetadata::V14(metadata_v14) => metadata_v14_to_latest(metadata_v14),
+            RuntimeMetadata::V15(metadata_v15) => metadata_v15,
             _ => {
                 return Err(eyre::eyre!(
                     "Unsupported metadata version {:?}, expected V14.",
@@ -39,9 +40,11 @@ pub async fn run(opts: Opts) -> color_eyre::Result<()> {
             }
         };
 
-        retain_metadata_pallets(metadata_v14, |pallet_name| {
+        retain_metadata_pallets(&mut metadata_v15, |pallet_name| {
             pallets.iter().any(|p| &**p == pallet_name)
         });
+
+        metadata = metadata_v15.into();
     }
 
     match opts.format.as_str() {

codegen/src/api/mod.rs

@@ -21,7 +21,7 @@ use crate::{
     CratePath,
 };
 use codec::Decode;
-use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed};
+use frame_metadata::RuntimeMetadataPrefixed;
 use heck::ToSnakeCase as _;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{format_ident, quote};
@@ -165,15 +165,12 @@ impl RuntimeGenerator {
     ///
     /// # Panics
     ///
-    /// If the metadata version is not supported by subxt.
-    /// Only v14 and v15 versions are supported.
+    /// Panics if the runtime metadata version is not supported.
+    ///
+    /// Supported versions: v14 and v15.
     pub fn new(metadata: RuntimeMetadataPrefixed) -> Self {
-        match metadata.1 {
-            RuntimeMetadata::V14(v14) => Self {
-                metadata: subxt_metadata::metadata_v14_to_latest(v14),
-            },
-            RuntimeMetadata::V15(v15) => Self { metadata: v15 },
-            _ => panic!("Unsupported metadata version {:?}", metadata.1),
+        RuntimeGenerator {
+            metadata: subxt_metadata::metadata_to_latest(metadata),
         }
     }
 

metadata/src/lib.rs

@@ -5,7 +5,9 @@
 mod retain;
 mod validation;
 
-use frame_metadata::{v14::RuntimeMetadataV14, v15::RuntimeMetadataV15};
+use frame_metadata::{
+    v14::RuntimeMetadataV14, v15::RuntimeMetadataV15, RuntimeMetadata, RuntimeMetadataPrefixed,
+};
 
 pub use retain::retain_metadata_pallets;
 pub use validation::{
@@ -103,3 +105,18 @@ pub fn metadata_v14_to_latest(metadata: RuntimeMetadataV14) -> LatestRuntimeMeta
         apis: Default::default(),
     }
 }
+
+/// Convert a prefixed runtime metadata to the latest version of the runtime metadata.
+///
+/// # Panics
+///
+/// Panics if the runtime metadata version is not supported.
+///
+/// Supported versions: v14 and v15.
+pub fn metadata_to_latest(meta: RuntimeMetadataPrefixed) -> LatestRuntimeMetadata {
+    match meta.1 {
+        RuntimeMetadata::V14(v14) => metadata_v14_to_latest(v14),
+        RuntimeMetadata::V15(v15) => v15,
+        _ => panic!("Unsupported metadata version {:?}", meta.1),
+    }
+}

metadata/src/retain.rs

@@ -4,7 +4,9 @@
 
 //! Utility functions to generate a subset of the metadata.
 
-use frame_metadata::{ExtrinsicMetadata, PalletMetadata, RuntimeMetadataV14, StorageEntryType};
+use frame_metadata::v15::{
+    ExtrinsicMetadata, PalletMetadata, RuntimeMetadataV15, StorageEntryType,
+};
 use scale_info::{form::PortableForm, interner::UntrackedSymbol, TypeDef};
 use std::{
     any::TypeId,
@@ -120,7 +122,7 @@ fn update_type(ty: &mut UntrackedSymbol<TypeId>, map_ids: &BTreeMap<u32, u32>) {
 /// Strip any pallets out of the RuntimeCall type that aren't the ones we want to keep.
 /// The RuntimeCall type is referenced in a bunch of places, so doing this prevents us from
 /// holding on to stuff in pallets we've asked not to keep.
-fn retain_pallets_in_runtime_call_type<F>(metadata: &mut RuntimeMetadataV14, mut filter: F)
+fn retain_pallets_in_runtime_call_type<F>(metadata: &mut RuntimeMetadataV15, mut filter: F)
 where
     F: FnMut(&str) -> bool,
 {
@@ -161,7 +163,7 @@ where
 ///
 /// Panics if the [`scale_info::PortableRegistry`] did not retain all needed types,
 /// or the metadata does not contain the "sp_runtime::DispatchError" type.
-pub fn retain_metadata_pallets<F>(metadata: &mut RuntimeMetadataV14, mut filter: F)
+pub fn retain_metadata_pallets<F>(metadata: &mut RuntimeMetadataV15, mut filter: F)
 where
     F: FnMut(&str) -> bool,
 {
@@ -214,20 +216,18 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::metadata_to_latest;
     use codec::Decode;
-    use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed, RuntimeMetadataV14};
+    use frame_metadata::{v15::RuntimeMetadataV15, RuntimeMetadataPrefixed};
     use std::{fs, path::Path};
 
-    fn load_metadata() -> RuntimeMetadataV14 {
+    fn load_metadata() -> RuntimeMetadataV15 {
         let bytes = fs::read(Path::new("../artifacts/polkadot_metadata.scale"))
             .expect("Cannot read metadata blob");
         let meta: RuntimeMetadataPrefixed =
             Decode::decode(&mut &*bytes).expect("Cannot decode scale metadata");
 
-        match meta.1 {
-            RuntimeMetadata::V14(v14) => v14,
-            _ => panic!("Unsupported metadata version {:?}", meta.1),
-        }
+        metadata_to_latest(meta)
     }
 
     #[test]

subxt/src/metadata/metadata_type.rs

@@ -5,8 +5,8 @@
 use super::hash_cache::HashCache;
 use codec::Error as CodecError;
 use frame_metadata::{
-    PalletConstantMetadata, RuntimeMetadata, RuntimeMetadataPrefixed, RuntimeMetadataV14,
-    StorageEntryMetadata, META_RESERVED,
+    v15::PalletConstantMetadata, v15::RuntimeMetadataV15, v15::StorageEntryMetadata,
+    RuntimeMetadata, RuntimeMetadataPrefixed, META_RESERVED,
 };
 use parking_lot::RwLock;
 use scale_info::{form::PortableForm, PortableRegistry, Type};
@@ -65,7 +65,7 @@ pub enum MetadataError {
 // We hide the innards behind an Arc so that it's easy to clone and share.
 #[derive(Debug)]
 struct MetadataInner {
-    metadata: RuntimeMetadataV14,
+    metadata: RuntimeMetadataV15,
 
     // Events are hashed by pallet an error index (decode oriented)
     events: HashMap<(u8, u8), EventMetadata>,
@@ -147,7 +147,7 @@ impl Metadata {
     }
 
     /// Return the runtime metadata.
-    pub fn runtime_metadata(&self) -> &RuntimeMetadataV14 {
+    pub fn runtime_metadata(&self) -> &RuntimeMetadataV15 {
         &self.inner.metadata
     }
 
@@ -371,7 +371,8 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
             return Err(InvalidMetadataError::InvalidPrefix);
         }
         let metadata = match metadata.1 {
-            RuntimeMetadata::V14(meta) => meta,
+            RuntimeMetadata::V14(v14) => subxt_metadata::metadata_v14_to_latest(v14),
+            RuntimeMetadata::V15(v15) => v15,
             _ => return Err(InvalidMetadataError::InvalidVersion),
         };
 
@@ -503,8 +504,9 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use frame_metadata::{
-        ExtrinsicMetadata, PalletStorageMetadata, StorageEntryModifier, StorageEntryType,
+    use frame_metadata::v15::{
+        ExtrinsicMetadata, PalletCallMetadata, PalletMetadata, PalletStorageMetadata,
+        StorageEntryModifier, StorageEntryType,
     };
     use scale_info::{meta_type, TypeInfo};
 
@@ -531,19 +533,20 @@ mod tests {
             value: vec![1, 2, 3],
             docs: vec![],
         };
-        let pallet = frame_metadata::PalletMetadata {
+        let pallet = PalletMetadata {
             index: 0,
             name: "System",
-            calls: Some(frame_metadata::PalletCallMetadata {
+            calls: Some(PalletCallMetadata {
                 ty: meta_type::<Call>(),
             }),
             storage: Some(storage),
             constants: vec![constant],
             event: None,
             error: None,
+            docs: vec![],
         };
 
-        let metadata = RuntimeMetadataV14::new(
+        let metadata = RuntimeMetadataV15::new(
             vec![pallet],
             ExtrinsicMetadata {
                 ty: meta_type::<()>(),
@@ -551,6 +554,7 @@ mod tests {
                 signed_extensions: vec![],
             },
             meta_type::<()>(),
+            vec![],
         );
         let prefixed = RuntimeMetadataPrefixed::from(metadata);
 

subxt/src/storage/storage_address.rs

@@ -8,7 +8,7 @@ use crate::{
     metadata::{DecodeWithMetadata, EncodeWithMetadata, Metadata},
     utils::{Encoded, Static},
 };
-use frame_metadata::{StorageEntryType, StorageHasher};
+use frame_metadata::v15::{StorageEntryType, StorageHasher};
 use scale_info::TypeDef;
 use std::borrow::Cow;
 

subxt/src/storage/storage_type.rs

@@ -11,7 +11,7 @@ use crate::{
     Config,
 };
 use derivative::Derivative;
-use frame_metadata::StorageEntryType;
+use frame_metadata::v15::StorageEntryType;
 use scale_info::form::PortableForm;
 use std::{future::Future, marker::PhantomData};
 

testing/integration-tests/src/codegen/codegen_documentation.rs

@@ -14,7 +14,8 @@ fn metadata_docs() -> Vec<String> {
     // Load the runtime metadata downloaded from a node via `test-runtime`.
     let meta = load_test_metadata();
     let metadata = match meta.1 {
-        frame_metadata::RuntimeMetadata::V14(v14) => v14,
+        frame_metadata::RuntimeMetadata::V14(v14) => subxt_metadata::metadata_v14_to_latest(v14),
+        frame_metadata::RuntimeMetadata::V15(v15) => v15,
         _ => panic!("Unsupported metadata version {:?}", meta.1),
     };
 

testing/ui-tests/src/utils/pallet_metadata_test_runner.rs

@@ -3,15 +3,15 @@
 // see LICENSE for license details.
 
 use codec::{Decode, Encode};
-use frame_metadata::{RuntimeMetadataPrefixed, RuntimeMetadataV14};
+use frame_metadata::{v15::RuntimeMetadataV15, RuntimeMetadataPrefixed};
 use std::io::Read;
-use subxt_metadata::retain_metadata_pallets;
+use subxt_metadata::{metadata_v14_to_latest, retain_metadata_pallets};
 
 static TEST_DIR_PREFIX: &str = "subxt_generated_pallets_ui_tests_";
 static METADATA_FILE: &str = "../../artifacts/polkadot_metadata.scale";
 
 pub struct PalletMetadataTestRunner {
-    metadata: RuntimeMetadataV14,
+    metadata: RuntimeMetadataV15,
     index: usize,
 }
 
@@ -28,8 +28,9 @@ impl PalletMetadataTestRunner {
             Decode::decode(&mut &*bytes).expect("Cannot decode metadata bytes");
 
         let metadata = match meta.1 {
-            frame_metadata::RuntimeMetadata::V14(v14) => v14,
-            _ => panic!("Unsupported metadata version. Tests support only v14"),
+            frame_metadata::RuntimeMetadata::V14(v14) => metadata_v14_to_latest(v14),
+            frame_metadata::RuntimeMetadata::V15(v15) => v15,
+            _ => panic!("Unsupported metadata version {:?}", meta.1),
         };
 
         PalletMetadataTestRunner { metadata, index: 0 }