Merge v0.50.x to master (#2127)

* v0.50.0: Integrate frame-decode, redo storage APIs and break up Error. (#2100) * WIP integrating new frame-decode and working out new storage APIS * WIP: first pass adding new storage things to subxt-core * Second pass over Address type and start impl in Subxt * WIP new storage APIs * WIP New storage APIs roughly completed, lots of errors still * Remove PlainorMap enum; plain and map values now use same struct to simplify usage * Begin 'fixing' errors * WIP splitting errors and tidying payload/address traits * Get subxt-core compiling * Small fixes in subxt-core and remove metadata mod * subxt-core: cargo check --all-targets passes * Fix test * WIP starting to update subxt from subxt-core changes * WIP splitting up subxt errors into smaller variants * WIP errors: add DispatchError errors * Port new Storage APIs to subxt-core * cargo check -p subxt passes * Quick-fix errors in subxt-cli (explore subcommand) * fmt * Finish fixing codegen up and start fixing examples * get Subxt examples compiling and bytes_at for constants * Add some arcs to limit lifetimes in subxt/subxt-core storage APIs * A little Arcing to allow more method chaining in Storage APIs, aligning with Subxt * Update codegen test * cargo check --all-targets passing * cargo check --features 'unstable-light-client' passing * clippy * Remove unused dep in subxt * use published frame-decode * fix wasm-example * Add new tx extension to fix daily tests * Remove unused subxt_core::dynamic::DecodedValue type * Update book to match changes * Update docs to fix more broken bits * Add missing docs * fmt * allow larger result errs for now * Add missing alloc imports in subxt-core * Fix doc tests and fix bug getting constant info * Fix V14 -> Metadata transform for storage & constants * Fix parachain example * Fix FFI example * BlockLength decodes t ostruct, not u128 * use fetch/iter shorthands rather than entry in most storage tests * Fix some integration tests * Fix Runtime codegen tests * Expose the dynamic custom_value selecter and use in a UI test * Update codegen metadata * Tidy CLI storage query and support (str,str) as a storage address * Add (str,str) as valid constant address too * Show string tuple in constants example * Via the magic of traits, avoid needing any clones of queries/addresses and accept references to them * clippy * [v0.50] update scale-info-legacy and frame-decode to latest (#2119) * bump scale-info-legacy and frame-decode to latest * Remove something we don't need in this PR * Fully remove unused for now dep * [v0.50] Convert historic metadata to subxt::Metadata (#2120) * First pass converting historic metadatas to our subxt::Metadata type * use published frame-decode * fmt and rename legacy metadata macro * Enable legacy feature where needed in subxt_metadata so it compiles on its own * Use cargo hack more in CI and fix subxt-metadata features * Add tests for metadata conversion (need to optimise; some too expensive right now * Address performance and equality issues in metadata conversion testing * fmt * fmt all * clippy * Fix a doc link * Test codegen and fixes to make it work * Remove local frame-decode patch * bump frame-decode to latest * [v0.50.0] Allow visiting extrinsic fields in subxt_historic (#2124) * Allow visiting extrinsic fields * fmt * Don't use local scale-decode dep * Clippy and tidy * Extend 'subxt codegen' CLI to work with legacy metadatas * Simplify historic extrinsics example now that AccountId32s have paths/names * clippy * clippy * clippy.. * Allow visiting storage values, too, and clean up extrinsic visiting a little by narrowing lifetime * Try to fix flaky test * Add custom value decode to extrinsics example * Remove useless else branch ra thought I needed * Simplify examples * Prep to release v0.0.5 (#2126)
2026-06-20 11:41:02 +00:00 · 2025-11-22 10:44:03 +00:00
parent 586b814ecd
commit 8203679cbd
158 changed files with 13736 additions and 16451 deletions
@@ -24,13 +24,22 @@ mod utils;

 use alloc::borrow::Cow;
 use alloc::collections::BTreeMap;
-use alloc::string::String;
-use alloc::sync::Arc;
+use alloc::string::{String, ToString};
 use alloc::vec::Vec;
+use frame_decode::constants::{ConstantEntry, ConstantInfo, ConstantInfoError};
+use frame_decode::custom_values::{CustomValue, CustomValueInfo, CustomValueInfoError};
 use frame_decode::extrinsics::{
    ExtrinsicCallInfo, ExtrinsicExtensionInfo, ExtrinsicInfoArg, ExtrinsicInfoError,
    ExtrinsicSignatureInfo,
 };
+use frame_decode::runtime_apis::{
+    RuntimeApiEntry, RuntimeApiInfo, RuntimeApiInfoError, RuntimeApiInput,
+};
+use frame_decode::storage::{StorageEntry, StorageInfo, StorageInfoError, StorageKeyInfo};
+use frame_decode::view_functions::{
+    ViewFunctionEntry, ViewFunctionInfo, ViewFunctionInfoError, ViewFunctionInput,
+};
+
 use hashbrown::HashMap;
 use scale_info::{PortableRegistry, Variant, form::PortableForm};
 use utils::{
@@ -39,12 +48,14 @@ use utils::{
    variant_index::VariantIndex,
 };

-type ArcStr = Arc<str>;
-
+pub use frame_decode::storage::StorageHasher;
 pub use from::SUPPORTED_METADATA_VERSIONS;
 pub use from::TryFromError;
 pub use utils::validation::MetadataHasher;

+#[cfg(feature = "legacy")]
+pub use from::legacy::Error as LegacyFromError;
+
 type CustomMetadataInner = frame_metadata::v15::CustomMetadata<PortableForm>;

 /// Node metadata. This can be constructed by providing some compatible [`frame_metadata`]
@@ -55,9 +66,19 @@ pub struct Metadata {
    /// Type registry containing all types used in the metadata.
    types: PortableRegistry,
    /// Metadata of all the pallets.
-    pallets: OrderedMap<ArcStr, PalletMetadataInner>,
-    /// Find the location in the pallet Vec by pallet index.
-    pallets_by_index: HashMap<u8, usize>,
+    pallets: OrderedMap<String, PalletMetadataInner>,
+    /// Find the pallet for a given call index.
+    pallets_by_call_index: HashMap<u8, usize>,
+    /// Find the pallet for a given event index.
+    ///
+    /// for modern metadatas, this is the same as pallets_by_call_index,
+    /// but for old metadatas this can vary.
+    pallets_by_event_index: HashMap<u8, usize>,
+    /// Find the pallet for a given error index.
+    ///
+    /// for modern metadatas, this is the same as pallets_by_call_index,
+    /// but for old metadatas this can vary.
+    pallets_by_error_index: HashMap<u8, usize>,
    /// Metadata of the extrinsic.
    extrinsic: ExtrinsicMetadata,
    /// The types of the outer enums.
@@ -65,7 +86,7 @@ pub struct Metadata {
    /// The type Id of the `DispatchError` type, which Subxt makes use of.
    dispatch_error_ty: Option<u32>,
    /// Details about each of the runtime API traits.
-    apis: OrderedMap<ArcStr, RuntimeApiMetadataInner>,
+    apis: OrderedMap<String, RuntimeApiMetadataInner>,
    /// Allows users to add custom types to the metadata. A map that associates a string key to a `CustomValueMetadata`.
    custom: CustomMetadataInner,
 }
@@ -75,12 +96,12 @@ pub struct Metadata {
 impl frame_decode::extrinsics::ExtrinsicTypeInfo for Metadata {
    type TypeId = u32;

-    fn get_call_info(
+    fn extrinsic_call_info(
        &self,
        pallet_index: u8,
        call_index: u8,
    ) -> Result<ExtrinsicCallInfo<'_, Self::TypeId>, ExtrinsicInfoError<'_>> {
-        let pallet = self.pallet_by_index(pallet_index).ok_or({
+        let pallet = self.pallet_by_call_index(pallet_index).ok_or({
            ExtrinsicInfoError::PalletNotFound {
                index: pallet_index,
            }
@@ -108,7 +129,7 @@ impl frame_decode::extrinsics::ExtrinsicTypeInfo for Metadata {
        })
    }

-    fn get_signature_info(
+    fn extrinsic_signature_info(
        &self,
    ) -> Result<ExtrinsicSignatureInfo<Self::TypeId>, ExtrinsicInfoError<'_>> {
        Ok(ExtrinsicSignatureInfo {
@@ -117,7 +138,7 @@ impl frame_decode::extrinsics::ExtrinsicTypeInfo for Metadata {
        })
    }

-    fn get_extension_info(
+    fn extrinsic_extension_info(
        &self,
        extension_version: Option<u8>,
    ) -> Result<ExtrinsicExtensionInfo<'_, Self::TypeId>, ExtrinsicInfoError<'_>> {
@@ -142,8 +163,292 @@ impl frame_decode::extrinsics::ExtrinsicTypeInfo for Metadata {
        Ok(ExtrinsicExtensionInfo { extension_ids })
    }
 }
+impl frame_decode::storage::StorageTypeInfo for Metadata {
+    type TypeId = u32;
+
+    fn storage_info(
+        &self,
+        pallet_name: &str,
+        storage_entry: &str,
+    ) -> Result<StorageInfo<'_, Self::TypeId>, StorageInfoError<'_>> {
+        let pallet =
+            self.pallet_by_name(pallet_name)
+                .ok_or_else(|| StorageInfoError::PalletNotFound {
+                    pallet_name: pallet_name.to_string(),
+                })?;
+        let entry = pallet
+            .storage()
+            .and_then(|storage| storage.entry_by_name(storage_entry))
+            .ok_or_else(|| StorageInfoError::StorageNotFound {
+                name: storage_entry.to_string(),
+                pallet_name: Cow::Borrowed(pallet.name()),
+            })?;
+
+        let info = StorageInfo {
+            keys: Cow::Borrowed(&*entry.info.keys),
+            value_id: entry.info.value_id,
+            default_value: entry
+                .info
+                .default_value
+                .as_ref()
+                .map(|def| Cow::Borrowed(&**def)),
+        };
+
+        Ok(info)
+    }
+}
+impl frame_decode::storage::StorageEntryInfo for Metadata {
+    fn storage_entries(&self) -> impl Iterator<Item = StorageEntry<'_>> {
+        self.pallets().flat_map(|pallet| {
+            let pallet_name = pallet.name();
+            let pallet_iter = core::iter::once(StorageEntry::In(pallet_name.into()));
+            let entries_iter = pallet.storage().into_iter().flat_map(|storage| {
+                storage
+                    .entries()
+                    .iter()
+                    .map(|entry| StorageEntry::Name(entry.name().into()))
+            });
+
+            pallet_iter.chain(entries_iter)
+        })
+    }
+}
+impl frame_decode::runtime_apis::RuntimeApiTypeInfo for Metadata {
+    type TypeId = u32;
+
+    fn runtime_api_info(
+        &self,
+        trait_name: &str,
+        method_name: &str,
+    ) -> Result<RuntimeApiInfo<'_, Self::TypeId>, RuntimeApiInfoError<'_>> {
+        let api_trait =
+            self.apis
+                .get_by_key(trait_name)
+                .ok_or_else(|| RuntimeApiInfoError::TraitNotFound {
+                    trait_name: trait_name.to_string(),
+                })?;
+        let api_method = api_trait.methods.get_by_key(method_name).ok_or_else(|| {
+            RuntimeApiInfoError::MethodNotFound {
+                trait_name: Cow::Borrowed(&api_trait.name),
+                method_name: method_name.to_string(),
+            }
+        })?;
+
+        let info = RuntimeApiInfo {
+            inputs: Cow::Borrowed(&api_method.info.inputs),
+            output_id: api_method.info.output_id,
+        };
+
+        Ok(info)
+    }
+}
+impl frame_decode::runtime_apis::RuntimeApiEntryInfo for Metadata {
+    fn runtime_api_entries(&self) -> impl Iterator<Item = RuntimeApiEntry<'_>> {
+        self.runtime_api_traits().flat_map(|api_trait| {
+            let trait_name = api_trait.name();
+            let trait_iter = core::iter::once(RuntimeApiEntry::In(trait_name.into()));
+            let method_iter = api_trait
+                .methods()
+                .map(|method| RuntimeApiEntry::Name(method.name().into()));
+
+            trait_iter.chain(method_iter)
+        })
+    }
+}
+impl frame_decode::view_functions::ViewFunctionTypeInfo for Metadata {
+    type TypeId = u32;
+
+    fn view_function_info(
+        &self,
+        pallet_name: &str,
+        function_name: &str,
+    ) -> Result<ViewFunctionInfo<'_, Self::TypeId>, ViewFunctionInfoError<'_>> {
+        let pallet = self.pallet_by_name(pallet_name).ok_or_else(|| {
+            ViewFunctionInfoError::PalletNotFound {
+                pallet_name: pallet_name.to_string(),
+            }
+        })?;
+        let function = pallet.view_function_by_name(function_name).ok_or_else(|| {
+            ViewFunctionInfoError::FunctionNotFound {
+                pallet_name: Cow::Borrowed(pallet.name()),
+                function_name: function_name.to_string(),
+            }
+        })?;
+
+        let info = ViewFunctionInfo {
+            inputs: Cow::Borrowed(&function.inner.info.inputs),
+            output_id: function.inner.info.output_id,
+            query_id: *function.query_id(),
+        };
+
+        Ok(info)
+    }
+}
+impl frame_decode::view_functions::ViewFunctionEntryInfo for Metadata {
+    fn view_function_entries(&self) -> impl Iterator<Item = ViewFunctionEntry<'_>> {
+        self.pallets().flat_map(|pallet| {
+            let pallet_name = pallet.name();
+            let pallet_iter = core::iter::once(ViewFunctionEntry::In(pallet_name.into()));
+            let fn_iter = pallet
+                .view_functions()
+                .map(|function| ViewFunctionEntry::Name(function.name().into()));
+
+            pallet_iter.chain(fn_iter)
+        })
+    }
+}
+impl frame_decode::constants::ConstantTypeInfo for Metadata {
+    type TypeId = u32;
+
+    fn constant_info(
+        &self,
+        pallet_name: &str,
+        constant_name: &str,
+    ) -> Result<ConstantInfo<'_, Self::TypeId>, ConstantInfoError<'_>> {
+        let pallet =
+            self.pallet_by_name(pallet_name)
+                .ok_or_else(|| ConstantInfoError::PalletNotFound {
+                    pallet_name: pallet_name.to_string(),
+                })?;
+        let constant = pallet.constant_by_name(constant_name).ok_or_else(|| {
+            ConstantInfoError::ConstantNotFound {
+                pallet_name: Cow::Borrowed(pallet.name()),
+                constant_name: constant_name.to_string(),
+            }
+        })?;
+
+        let info = ConstantInfo {
+            bytes: &constant.value,
+            type_id: constant.ty,
+        };
+
+        Ok(info)
+    }
+}
+impl frame_decode::constants::ConstantEntryInfo for Metadata {
+    fn constant_entries(&self) -> impl Iterator<Item = ConstantEntry<'_>> {
+        self.pallets().flat_map(|pallet| {
+            let pallet_name = pallet.name();
+            let pallet_iter = core::iter::once(ConstantEntry::In(pallet_name.into()));
+            let constant_iter = pallet
+                .constants()
+                .map(|constant| ConstantEntry::Name(constant.name().into()));
+
+            pallet_iter.chain(constant_iter)
+        })
+    }
+}
+impl frame_decode::custom_values::CustomValueTypeInfo for Metadata {
+    type TypeId = u32;
+
+    fn custom_value_info(
+        &self,
+        name: &str,
+    ) -> Result<CustomValueInfo<'_, Self::TypeId>, CustomValueInfoError> {
+        let custom_value = self
+            .custom()
+            .get(name)
+            .ok_or_else(|| CustomValueInfoError {
+                not_found: name.to_string(),
+            })?;
+
+        let info = CustomValueInfo {
+            bytes: custom_value.data,
+            type_id: custom_value.type_id,
+        };
+
+        Ok(info)
+    }
+}
+impl frame_decode::custom_values::CustomValueEntryInfo for Metadata {
+    fn custom_values(&self) -> impl Iterator<Item = CustomValue<'_>> {
+        self.custom.map.keys().map(|name| CustomValue {
+            name: Cow::Borrowed(name),
+        })
+    }
+}

 impl Metadata {
+    /// This is essentially an alias for `<Metadata as codec::Decode>::decode(&mut bytes)`
+    pub fn decode_from(mut bytes: &[u8]) -> Result<Self, codec::Error> {
+        <Self as codec::Decode>::decode(&mut bytes)
+    }
+
+    /// Convert V16 metadata into [`Metadata`].
+    pub fn from_v16(
+        metadata: frame_metadata::v16::RuntimeMetadataV16,
+    ) -> Result<Self, TryFromError> {
+        metadata.try_into()
+    }
+
+    /// Convert V15 metadata into [`Metadata`].
+    pub fn from_v15(
+        metadata: frame_metadata::v15::RuntimeMetadataV15,
+    ) -> Result<Self, TryFromError> {
+        metadata.try_into()
+    }
+
+    /// Convert V14 metadata into [`Metadata`].
+    pub fn from_v14(
+        metadata: frame_metadata::v14::RuntimeMetadataV14,
+    ) -> Result<Self, TryFromError> {
+        metadata.try_into()
+    }
+
+    /// Convert V13 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v13(
+        metadata: &frame_metadata::v13::RuntimeMetadataV13,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v13(metadata, types, from::legacy::Opts::compat())
+    }
+
+    /// Convert V12 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v12(
+        metadata: &frame_metadata::v12::RuntimeMetadataV12,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v12(metadata, types, from::legacy::Opts::compat())
+    }
+
+    /// Convert V13 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v11(
+        metadata: &frame_metadata::v11::RuntimeMetadataV11,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v11(metadata, types, from::legacy::Opts::compat())
+    }
+
+    /// Convert V13 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v10(
+        metadata: &frame_metadata::v10::RuntimeMetadataV10,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v10(metadata, types, from::legacy::Opts::compat())
+    }
+
+    /// Convert V9 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v9(
+        metadata: &frame_metadata::v9::RuntimeMetadataV9,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v9(metadata, types, from::legacy::Opts::compat())
+    }
+
+    /// Convert V8 metadata into [`Metadata`], given the necessary extra type information.
+    #[cfg(feature = "legacy")]
+    pub fn from_v8(
+        metadata: &frame_metadata::v8::RuntimeMetadataV8,
+        types: &scale_info_legacy::TypeRegistrySet<'_>,
+    ) -> Result<Self, LegacyFromError> {
+        from::legacy::from_v8(metadata, types, from::legacy::Opts::compat())
+    }
+
    /// Access the underlying type registry.
    pub fn types(&self) -> &PortableRegistry {
        &self.types
@@ -177,10 +482,36 @@ impl Metadata {
        })
    }

-    /// Access a pallet given its encoded variant index.
-    pub fn pallet_by_index(&self, variant_index: u8) -> Option<PalletMetadata<'_>> {
+    /// Access a pallet given some call/extrinsic pallet index byte
+    pub fn pallet_by_call_index(&self, variant_index: u8) -> Option<PalletMetadata<'_>> {
        let inner = self
-            .pallets_by_index
+            .pallets_by_call_index
+            .get(&variant_index)
+            .and_then(|i| self.pallets.get_by_index(*i))?;
+
+        Some(PalletMetadata {
+            inner,
+            types: self.types(),
+        })
+    }
+
+    /// Access a pallet given some event pallet index byte
+    pub fn pallet_by_event_index(&self, variant_index: u8) -> Option<PalletMetadata<'_>> {
+        let inner = self
+            .pallets_by_event_index
+            .get(&variant_index)
+            .and_then(|i| self.pallets.get_by_index(*i))?;
+
+        Some(PalletMetadata {
+            inner,
+            types: self.types(),
+        })
+    }
+
+    /// Access a pallet given some error pallet index byte
+    pub fn pallet_by_error_index(&self, variant_index: u8) -> Option<PalletMetadata<'_>> {
+        let inner = self
+            .pallets_by_error_index
            .get(&variant_index)
            .and_then(|i| self.pallets.get_by_index(*i))?;

@@ -217,20 +548,6 @@ impl Metadata {
        })
    }

-    /// Access a view function given its query ID, if any.
-    pub fn view_function_by_query_id(
-        &'_ self,
-        query_id: &[u8; 32],
-    ) -> Option<ViewFunctionMetadata<'_>> {
-        // Dev note: currently, we only have pallet view functions, and here
-        // we just do a naive thing of iterating over the pallets to find the one
-        // we're looking for. Eventually we should construct a separate map of view
-        // functions for easy querying here.
-        self.pallets()
-            .flat_map(|p| p.view_functions())
-            .find(|vf| vf.query_id() == query_id)
-    }
-
    /// Returns custom user defined types
    pub fn custom(&self) -> CustomMetadata<'_> {
        CustomMetadata {
@@ -264,9 +581,19 @@ impl<'a> PalletMetadata<'a> {
        &self.inner.name
    }

-    /// The pallet index.
-    pub fn index(&self) -> u8 {
-        self.inner.index
+    /// The index to use for calls in this pallet.
+    pub fn call_index(&self) -> u8 {
+        self.inner.call_index
+    }
+
+    /// The index to use for events in this pallet.
+    pub fn event_index(&self) -> u8 {
+        self.inner.event_index
+    }
+
+    /// The index to use for errors in this pallet.
+    pub fn error_index(&self) -> u8 {
+        self.inner.error_index
    }

    /// The pallet docs.
@@ -418,9 +745,19 @@ impl<'a> PalletMetadata<'a> {
 #[derive(Debug, Clone)]
 struct PalletMetadataInner {
    /// Pallet name.
-    name: ArcStr,
-    /// Pallet index.
-    index: u8,
+    name: String,
+    /// The index for calls in the pallet.
+    call_index: u8,
+    /// The index for events in the pallet.
+    ///
+    /// This is the same as `call_index` for modern metadatas,
+    /// but can be different for older metadatas (pre-V12).
+    event_index: u8,
+    /// The index for errors in the pallet.
+    ///
+    /// This is the same as `call_index` for modern metadatas,
+    /// but can be different for older metadatas (pre-V12).
+    error_index: u8,
    /// Pallet storage metadata.
    storage: Option<StorageMetadata>,
    /// Type ID for the pallet Call enum.
@@ -436,9 +773,9 @@ struct PalletMetadataInner {
    /// Error variants by name/u8.
    error_variant_index: VariantIndex,
    /// Map from constant name to constant details.
-    constants: OrderedMap<ArcStr, ConstantMetadata>,
+    constants: OrderedMap<String, ConstantMetadata>,
    /// Details about each of the pallet view functions.
-    view_functions: OrderedMap<ArcStr, ViewFunctionMetadataInner>,
+    view_functions: OrderedMap<String, ViewFunctionMetadataInner>,
    /// Mapping from associated type to type ID describing its shape.
    associated_types: BTreeMap<String, u32>,
    /// Pallet documentation.
@@ -451,7 +788,7 @@ pub struct StorageMetadata {
    /// The common prefix used by all storage entries.
    prefix: String,
    /// Map from storage entry name to details.
-    entries: OrderedMap<ArcStr, StorageEntryMetadata>,
+    entries: OrderedMap<String, StorageEntryMetadata>,
 }

 impl StorageMetadata {
@@ -475,13 +812,9 @@ impl StorageMetadata {
 #[derive(Debug, Clone)]
 pub struct StorageEntryMetadata {
    /// Variable name of the storage entry.
-    name: ArcStr,
-    /// An `Option` modifier of that storage entry.
-    modifier: StorageEntryModifier,
-    /// Type of the value stored in the entry.
-    entry_type: StorageEntryType,
-    /// Default value (SCALE encoded).
-    default: Vec<u8>,
+    name: String,
+    /// Information about the storage entry.
+    info: StorageInfo<'static, u32>,
    /// Storage entry documentation.
    docs: Vec<String>,
 }
@@ -491,17 +824,18 @@ impl StorageEntryMetadata {
    pub fn name(&self) -> &str {
        &self.name
    }
-    /// Is the entry value optional or does it have a default value.
-    pub fn modifier(&self) -> StorageEntryModifier {
-        self.modifier
+    /// Keys in this storage entry.
+    pub fn keys(&self) -> impl ExactSizeIterator<Item = &StorageKeyInfo<u32>> {
+        let keys = &*self.info.keys;
+        keys.iter()
    }
-    /// Type of the storage entry.
-    pub fn entry_type(&self) -> &StorageEntryType {
-        &self.entry_type
+    /// Value type for this storage entry.
+    pub fn value_ty(&self) -> u32 {
+        self.info.value_id
    }
-    /// The SCALE encoded default value for this entry.
-    pub fn default_bytes(&self) -> &[u8] {
-        &self.default
+    /// The default value, if one exists, for this entry.
+    pub fn default_value(&self) -> Option<&[u8]> {
+        self.info.default_value.as_deref()
    }
    /// Storage entry documentation.
    pub fn docs(&self) -> &[String] {
@@ -509,101 +843,11 @@ impl StorageEntryMetadata {
    }
 }

-/// The type of a storage entry.
-#[derive(Debug, Clone)]
-pub enum StorageEntryType {
-    /// Plain storage entry (just the value).
-    Plain(u32),
-    /// A storage map.
-    Map {
-        /// One or more hashers, should be one hasher per key element.
-        hashers: Vec<StorageHasher>,
-        /// The type of the key, can be a tuple with elements for each of the hashers.
-        key_ty: u32,
-        /// The type of the value.
-        value_ty: u32,
-    },
-}
-
-impl StorageEntryType {
-    /// The type of the value.
-    pub fn value_ty(&self) -> u32 {
-        match self {
-            StorageEntryType::Map { value_ty, .. } | StorageEntryType::Plain(value_ty) => *value_ty,
-        }
-    }
-
-    /// The type of the key, can be a tuple with elements for each of the hashers. None for a Plain storage entry.
-    pub fn key_ty(&self) -> Option<u32> {
-        match self {
-            StorageEntryType::Map { key_ty, .. } => Some(*key_ty),
-            StorageEntryType::Plain(_) => None,
-        }
-    }
-}
-
-/// Hasher used by storage maps.
-#[derive(Debug, Clone, Copy)]
-pub enum StorageHasher {
-    /// 128-bit Blake2 hash.
-    Blake2_128,
-    /// 256-bit Blake2 hash.
-    Blake2_256,
-    /// Multiple 128-bit Blake2 hashes concatenated.
-    Blake2_128Concat,
-    /// 128-bit XX hash.
-    Twox128,
-    /// 256-bit XX hash.
-    Twox256,
-    /// Multiple 64-bit XX hashes concatenated.
-    Twox64Concat,
-    /// Identity hashing (no hashing).
-    Identity,
-}
-
-impl StorageHasher {
-    /// The hash produced by a [`StorageHasher`] can have these two components, in order:
-    ///
-    /// 1. A fixed size hash. (not present for [`StorageHasher::Identity`]).
-    /// 2. The SCALE encoded key that was used as an input to the hasher (only present for
-    ///    [`StorageHasher::Twox64Concat`], [`StorageHasher::Blake2_128Concat`] or [`StorageHasher::Identity`]).
-    ///
-    /// This function returns the number of bytes used to represent the first of these.
-    pub fn len_excluding_key(&self) -> usize {
-        match self {
-            StorageHasher::Blake2_128Concat => 16,
-            StorageHasher::Twox64Concat => 8,
-            StorageHasher::Blake2_128 => 16,
-            StorageHasher::Blake2_256 => 32,
-            StorageHasher::Twox128 => 16,
-            StorageHasher::Twox256 => 32,
-            StorageHasher::Identity => 0,
-        }
-    }
-
-    /// Returns true if the key used to produce the hash is appended to the hash itself.
-    pub fn ends_with_key(&self) -> bool {
-        matches!(
-            self,
-            StorageHasher::Blake2_128Concat | StorageHasher::Twox64Concat | StorageHasher::Identity
-        )
-    }
-}
-
-/// Is the storage entry optional, or does it have a default value.
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum StorageEntryModifier {
-    /// The storage entry returns an `Option<T>`, with `None` if the key is not present.
-    Optional,
-    /// The storage entry returns `T::Default` if the key is not present.
-    Default,
-}
-
 /// Metadata for a single constant.
 #[derive(Debug, Clone)]
 pub struct ConstantMetadata {
    /// Name of the pallet constant.
-    name: ArcStr,
+    name: String,
    /// Type of the pallet constant.
    ty: u32,
    /// Value stored in the constant (SCALE encoded).
@@ -816,9 +1060,9 @@ impl<'a> RuntimeApiMetadata<'a> {
 #[derive(Debug, Clone)]
 struct RuntimeApiMetadataInner {
    /// Trait name.
-    name: ArcStr,
+    name: String,
    /// Trait methods.
-    methods: OrderedMap<ArcStr, RuntimeApiMethodMetadataInner>,
+    methods: OrderedMap<String, RuntimeApiMethodMetadataInner>,
    /// Trait documentation.
    docs: Vec<String>,
 }
@@ -841,12 +1085,15 @@ impl<'a> RuntimeApiMethodMetadata<'a> {
        &self.inner.docs
    }
    /// Method inputs.
-    pub fn inputs(&self) -> impl ExactSizeIterator<Item = &'a MethodParamMetadata> + use<'a> {
-        self.inner.inputs.iter()
+    pub fn inputs(
+        &self,
+    ) -> impl ExactSizeIterator<Item = &'a RuntimeApiInput<'static, u32>> + use<'a> {
+        let inputs = &*self.inner.info.inputs;
+        inputs.iter()
    }
    /// Method return type.
    pub fn output_ty(&self) -> u32 {
-        self.inner.output_ty
+        self.inner.info.output_id
    }
    /// Return a hash for the method.
    pub fn hash(&self) -> [u8; HASH_LEN] {
@@ -857,11 +1104,9 @@ impl<'a> RuntimeApiMethodMetadata<'a> {
 #[derive(Debug, Clone)]
 struct RuntimeApiMethodMetadataInner {
    /// Method name.
-    name: ArcStr,
-    /// Method parameters.
-    inputs: Vec<MethodParamMetadata>,
-    /// Method output type.
-    output_ty: u32,
+    name: String,
+    /// Info.
+    info: RuntimeApiInfo<'static, u32>,
    /// Method documentation.
    docs: Vec<String>,
 }
@@ -882,19 +1127,22 @@ impl<'a> ViewFunctionMetadata<'a> {
    /// Query ID. This is used to query the function. Roughly, it is constructed by doing
    /// `twox_128(pallet_name) ++ twox_128("fn_name(fnarg_types) -> return_ty")` .
    pub fn query_id(&self) -> &'a [u8; 32] {
-        &self.inner.query_id
+        &self.inner.info.query_id
    }
    /// Method documentation.
    pub fn docs(&self) -> &'a [String] {
        &self.inner.docs
    }
    /// Method inputs.
-    pub fn inputs(&self) -> impl ExactSizeIterator<Item = &'a MethodParamMetadata> + use<'a> {
-        self.inner.inputs.iter()
+    pub fn inputs(
+        &self,
+    ) -> impl ExactSizeIterator<Item = &'a ViewFunctionInput<'static, u32>> + use<'a> {
+        let inputs = &*self.inner.info.inputs;
+        inputs.iter()
    }
    /// Method return type.
    pub fn output_ty(&self) -> u32 {
-        self.inner.output_ty
+        self.inner.info.output_id
    }
    /// Return a hash for the method. The query ID of a view function validates it to some
    /// degree, but only takes type _names_ into account. This hash takes into account the
@@ -907,13 +1155,9 @@ impl<'a> ViewFunctionMetadata<'a> {
 #[derive(Debug, Clone)]
 struct ViewFunctionMetadataInner {
    /// View function name.
-    name: ArcStr,
-    /// View function query ID.
-    query_id: [u8; 32],
-    /// Input types.
-    inputs: Vec<MethodParamMetadata>,
-    /// Output type.
-    output_ty: u32,
+    name: String,
+    /// Info.
+    info: ViewFunctionInfo<'static, u32>,
    /// Documentation.
    docs: Vec<String>,
 }
@@ -999,6 +1243,38 @@ impl<'a> CustomValueMetadata<'a> {
    }
 }

+/// Decode SCALE encoded metadata.
+///
+/// - The default assumption is that metadata is encoded as [`frame_metadata::RuntimeMetadataPrefixed`]. This is the
+///   expected format that metadata is encoded into.
+/// - if this fails, we also try to decode as [`frame_metadata::RuntimeMetadata`].
+/// - If this all fails, we also try to decode as [`frame_metadata::OpaqueMetadata`].
+pub fn decode_runtime_metadata(
+    input: &[u8],
+) -> Result<frame_metadata::RuntimeMetadata, codec::Error> {
+    use codec::Decode;
+
+    let err = match frame_metadata::RuntimeMetadataPrefixed::decode(&mut &*input) {
+        Ok(md) => return Ok(md.1),
+        Err(e) => e,
+    };
+
+    if let Ok(md) = frame_metadata::RuntimeMetadata::decode(&mut &*input) {
+        return Ok(md);
+    }
+
+    // frame_metadata::OpaqueMetadata is a vec of bytes. If we can decode the length, AND
+    // the length definitely corresponds to the number of remaining bytes, then we try to
+    // decode the inner bytes.
+    if let Ok(len) = codec::Compact::<u64>::decode(&mut &*input) {
+        if input.len() == len.0 as usize {
+            return decode_runtime_metadata(input);
+        }
+    }
+
+    Err(err)
+}
+
 // Support decoding metadata from the "wire" format directly into this.
 // Errors may be lost in the case that the metadata content is somehow invalid.
 impl codec::Decode for Metadata {
@@ -1008,9 +1284,11 @@ impl codec::Decode for Metadata {
            frame_metadata::RuntimeMetadata::V14(md) => md.try_into(),
            frame_metadata::RuntimeMetadata::V15(md) => md.try_into(),
            frame_metadata::RuntimeMetadata::V16(md) => md.try_into(),
-            _ => return Err("Cannot try_into() to Metadata: unsupported metadata version".into()),
+            _ => {
+                return Err("Metadata::decode failed: Cannot try_into() to Metadata: unsupported metadata version".into())
+            },
        };

-        metadata.map_err(|_e| "Cannot try_into() to Metadata.".into())
+        metadata.map_err(|_| "Metadata::decode failed: Cannot try_into() to Metadata".into())
    }
 }