From 365e78d7395f0df0fe0784a13eb673950408e41f Mon Sep 17 00:00:00 2001 From: Alexandru Vasile Date: Thu, 13 Apr 2023 19:28:51 +0300 Subject: [PATCH] Adjust to v15 metadata Signed-off-by: Alexandru Vasile --- cli/src/commands/compatibility.rs | 11 +++++---- cli/src/commands/metadata.rs | 11 +++++---- codegen/src/api/mod.rs | 15 +++++------- metadata/src/lib.rs | 19 ++++++++++++++- metadata/src/retain.rs | 18 +++++++------- subxt/src/metadata/metadata_type.rs | 24 +++++++++++-------- subxt/src/storage/storage_address.rs | 2 +- subxt/src/storage/storage_type.rs | 2 +- .../src/codegen/codegen_documentation.rs | 3 ++- .../src/utils/pallet_metadata_test_runner.rs | 11 +++++---- 10 files changed, 71 insertions(+), 45 deletions(-) diff --git a/cli/src/commands/compatibility.rs b/cli/src/commands/compatibility.rs index a3860487be..2e0c66dfbd 100644 --- a/cli/src/commands/compatibility.rs +++ b/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 { +async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result { let bytes = subxt_codegen::utils::fetch_metadata_bytes(url).await?; let metadata = ::decode(&mut &bytes[..])?; @@ -108,7 +110,8 @@ async fn fetch_runtime_metadata(url: &Uri) -> color_eyre::Result 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, diff --git a/cli/src/commands/metadata.rs b/cli/src/commands/metadata.rs index f8d3aec83a..014d2cf6bc 100644 --- a/cli/src/commands/metadata.rs +++ b/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 = ::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() { diff --git a/codegen/src/api/mod.rs b/codegen/src/api/mod.rs index 5427436f18..7f9beaaa58 100644 --- a/codegen/src/api/mod.rs +++ b/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), } } diff --git a/metadata/src/lib.rs b/metadata/src/lib.rs index 49e23d9a04..c173f7e4f7 100644 --- a/metadata/src/lib.rs +++ b/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), + } +} diff --git a/metadata/src/retain.rs b/metadata/src/retain.rs index 67cd06a05b..dcdabccd47 100644 --- a/metadata/src/retain.rs +++ b/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, map_ids: &BTreeMap) { /// 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(metadata: &mut RuntimeMetadataV14, mut filter: F) +fn retain_pallets_in_runtime_call_type(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(metadata: &mut RuntimeMetadataV14, mut filter: F) +pub fn retain_metadata_pallets(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] diff --git a/subxt/src/metadata/metadata_type.rs b/subxt/src/metadata/metadata_type.rs index d9668bff3f..7a8966d3ea 100644 --- a/subxt/src/metadata/metadata_type.rs +++ b/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 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 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::(), }), 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); diff --git a/subxt/src/storage/storage_address.rs b/subxt/src/storage/storage_address.rs index b2cb21964e..527d8c31bd 100644 --- a/subxt/src/storage/storage_address.rs +++ b/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; diff --git a/subxt/src/storage/storage_type.rs b/subxt/src/storage/storage_type.rs index 44170818d8..6033b00bf6 100644 --- a/subxt/src/storage/storage_type.rs +++ b/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}; diff --git a/testing/integration-tests/src/codegen/codegen_documentation.rs b/testing/integration-tests/src/codegen/codegen_documentation.rs index b81722afcf..b8356d5bd9 100644 --- a/testing/integration-tests/src/codegen/codegen_documentation.rs +++ b/testing/integration-tests/src/codegen/codegen_documentation.rs @@ -14,7 +14,8 @@ fn metadata_docs() -> Vec { // 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), }; diff --git a/testing/ui-tests/src/utils/pallet_metadata_test_runner.rs b/testing/ui-tests/src/utils/pallet_metadata_test_runner.rs index a27450c9f5..e87c755f23 100644 --- a/testing/ui-tests/src/utils/pallet_metadata_test_runner.rs +++ b/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 }