subxt: Remove RootError RootEvent and RootExtrinsic traits

Signed-off-by: Alexandru Vasile <[email protected]>

codegen/src/api/mod.rs

@@ -381,58 +381,6 @@ impl RuntimeGenerator {
             })
             .collect::<Result<Vec<_>, CodegenError>>()?;
 
-        let root_event_if_arms = self.metadata.pallets().filter_map(|p| {
-            let variant_name_str = &p.name();
-            let variant_name = format_ident!("{}", variant_name_str);
-            let mod_name = format_ident!("{}", variant_name_str.to_string().to_snake_case());
-
-            p.event_ty_id().map(|_| {
-                // An 'if' arm for the RootEvent impl to match this variant name:
-                quote! {
-                    if pallet_name == #variant_name_str {
-                        return Ok(Event::#variant_name(#mod_name::Event::decode_with_metadata(
-                            &mut &*pallet_bytes,
-                            pallet_ty,
-                            metadata
-                        )?));
-                    }
-                }
-            })
-        });
-
-        let root_extrinsic_if_arms = self.metadata.pallets().filter_map(|p| {
-            let variant_name_str = p.name();
-            let variant_name = format_ident!("{}", variant_name_str);
-            let mod_name = format_ident!("{}", variant_name_str.to_string().to_snake_case());
-            p.call_ty_id().map(|_| {
-                // An 'if' arm for the RootExtrinsic impl to match this variant name:
-                quote! {
-                    if pallet_name == #variant_name_str {
-                        return Ok(Call::#variant_name(#mod_name::Call::decode_with_metadata(
-                            &mut &*pallet_bytes,
-                            pallet_ty,
-                            metadata
-                        )?));
-                    }
-                }
-            })
-        });
-
-        let root_error_if_arms = self.metadata.pallets().filter_map(|p| {
-            let variant_name_str = &p.name();
-            let variant_name = format_ident!("{}", variant_name_str);
-            let mod_name = format_ident!("{}", variant_name_str.to_string().to_snake_case());
-
-            p.error_ty_id().map(|type_id| {
-                quote! {
-                    if pallet_name == #variant_name_str {
-                        let variant_error = #mod_name::Error::decode_with_metadata(cursor, #type_id, metadata)?;
-                        return Ok(Error::#variant_name(variant_error));
-                    }
-                }
-            })
-        });
-
         let mod_ident = &item_mod_ir.ident;
         let pallets_with_constants: Vec<_> = pallets_with_mod_names
             .iter()
@@ -499,37 +447,12 @@ impl RuntimeGenerator {
                 /// The outer event enum.
                 pub type Event = #event_path;
 
-                impl #crate_path::events::RootEvent for Event {
-                    fn root_event(pallet_bytes: &[u8], pallet_name: &str, pallet_ty: u32, metadata: &#crate_path::Metadata) -> Result<Self, #crate_path::Error> {
-                        use #crate_path::metadata::DecodeWithMetadata;
-                        #( #root_event_if_arms )*
-                        Err(#crate_path::ext::scale_decode::Error::custom(format!("Pallet name '{}' not found in root Event enum", pallet_name)).into())
-                    }
-                }
-
                 /// The outer extrinsic enum.
                 pub type Call = #call_path;
 
-                impl #crate_path::blocks::RootExtrinsic for Call {
-                    fn root_extrinsic(pallet_bytes: &[u8], pallet_name: &str, pallet_ty: u32, metadata: &#crate_path::Metadata) -> Result<Self, #crate_path::Error> {
-                        use #crate_path::metadata::DecodeWithMetadata;
-                        #( #root_extrinsic_if_arms )*
-                        Err(#crate_path::ext::scale_decode::Error::custom(format!("Pallet name '{}' not found in root Call enum", pallet_name)).into())
-                    }
-                }
-
                 /// The outer error enum representing the DispatchError's Module variant.
                 pub type Error = #error_path;
 
-                impl #crate_path::error::RootError for Error {
-                    fn root_error(pallet_bytes: &[u8], pallet_name: &str, metadata: &#crate_path::Metadata) -> Result<Self, #crate_path::Error> {
-                        use #crate_path::metadata::DecodeWithMetadata;
-                        let cursor = &mut &pallet_bytes[..];
-                        #( #root_error_if_arms )*
-                        Err(#crate_path::ext::scale_decode::Error::custom(format!("Pallet name '{}' not found in root Error enum", pallet_name)).into())
-                    }
-                }
-
                 pub fn constants() -> ConstantsApi {
                     ConstantsApi
                 }

subxt/src/blocks/extrinsic_types.rs

@@ -15,7 +15,7 @@ use crate::{
 
 use codec::Decode;
 use derivative::Derivative;
-use scale_decode::DecodeAsFields;
+use scale_decode::{DecodeAsFields, DecodeAsType};
 use std::sync::Arc;
 
 /// Trait to uniquely identify the extrinsic's identity from the runtime metadata.
@@ -36,23 +36,6 @@ pub trait StaticExtrinsic: DecodeAsFields {
     }
 }
 
-/// This trait is implemented on the statically generated root extrinsic type, so that we're able
-/// to decode it properly via a pallet that impls `DecodeAsMetadata`. This is necessary
-/// because the "root extrinsic" type is generated using pallet info but doesn't actually exist in the
-/// metadata types, so we have no easy way to decode things into it via type information and need a
-/// little help via codegen.
-#[doc(hidden)]
-pub trait RootExtrinsic: Sized {
-    /// Given details of the pallet extrinsic we want to decode, and the name of the pallet, try to hand
-    /// back a "root extrinsic".
-    fn root_extrinsic(
-        pallet_bytes: &[u8],
-        pallet_name: &str,
-        pallet_extrinsic_ty: u32,
-        metadata: &Metadata,
-    ) -> Result<Self, Error>;
-}
-
 /// The body of a block.
 pub struct Extrinsics<T: Config, C> {
     client: C,
@@ -416,22 +399,17 @@ where
         }
     }
 
-    /// Attempt to decode these [`ExtrinsicDetails`] into a root extrinsic type (which includes
+    /// Attempt to decode these [`ExtrinsicDetails`] into a outer call enum type (which includes
     /// the pallet and extrinsic enum variants as well as the extrinsic fields). A compatible
     /// type for this is exposed via static codegen as a root level `Call` type.
-    pub fn as_root_extrinsic<E: RootExtrinsic>(&self) -> Result<E, Error> {
-        let md = self.extrinsic_metadata()?;
-        let pallet_extrinsic_ty = md.pallet.call_ty_id().ok_or_else(|| {
-            Error::Metadata(MetadataError::CallTypeNotFoundInPallet(md.pallet.index()))
-        })?;
-
-        // Ignore root enum index.
-        E::root_extrinsic(
-            &self.call_bytes()[1..],
-            md.pallet.name(),
-            pallet_extrinsic_ty,
-            &self.metadata,
-        )
+    pub fn as_root_extrinsic<E: DecodeAsType>(&self) -> Result<E, Error> {
+        let decoded = E::decode_as_type(
+            &mut &self.call_bytes()[..],
+            self.metadata.outer_enums().call_enum_ty(),
+            self.metadata.types(),
+        )?;
+
+        Ok(decoded)
     }
 }
 
@@ -621,27 +599,6 @@ mod tests {
         Test(Pallet),
     }
 
-    // We need this in order to be able to decode into a root extrinsic type:
-    impl RootExtrinsic for RuntimeCall {
-        fn root_extrinsic(
-            mut pallet_bytes: &[u8],
-            pallet_name: &str,
-            pallet_extrinsic_ty: u32,
-            metadata: &Metadata,
-        ) -> Result<Self, Error> {
-            if pallet_name == "Test" {
-                return Ok(RuntimeCall::Test(Pallet::decode_with_metadata(
-                    &mut pallet_bytes,
-                    pallet_extrinsic_ty,
-                    metadata,
-                )?));
-            }
-            panic!(
-                "Asked for pallet name '{pallet_name}', which isn't in our test RuntimeCall type"
-            )
-        }
-    }
-
     // The calls of the pallet.
     #[allow(unused)]
     #[derive(

subxt/src/blocks/mod.rs

@@ -10,6 +10,4 @@ mod extrinsic_types;
 
 pub use block_types::{Block, BlockBody};
 pub use blocks_client::{subscribe_to_block_headers_filling_in_gaps, BlocksClient};
-pub use extrinsic_types::{
-    ExtrinsicDetails, ExtrinsicEvents, Extrinsics, RootExtrinsic, StaticExtrinsic,
-};
+pub use extrinsic_types::{ExtrinsicDetails, ExtrinsicEvents, Extrinsics, StaticExtrinsic};

subxt/src/error/dispatch_error.rs

@@ -7,11 +7,10 @@
 
 use crate::metadata::{DecodeWithMetadata, Metadata};
 use core::fmt::Debug;
-use scale_decode::visitor::DecodeAsTypeResult;
+use scale_decode::{visitor::DecodeAsTypeResult, DecodeAsType};
 use std::borrow::Cow;
 
 use super::{Error, MetadataError};
-use crate::error::RootError;
 
 /// An error dispatching a transaction.
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]
@@ -167,14 +166,15 @@ impl ModuleError {
         self.raw
     }
 
-    /// Attempts to decode the ModuleError into a value implementing the trait `RootError`
-    /// where the actual type of value is the generated top level enum `Error`.
-    pub fn as_root_error<E: RootError>(&self) -> Result<E, Error> {
-        E::root_error(
-            &self.raw.error,
-            self.details()?.pallet.name(),
-            &self.metadata,
-        )
+    /// Attempts to decode the ModuleError into the top outer Error enum.
+    pub fn as_root_error<E: DecodeAsType>(&self) -> Result<E, Error> {
+        let decoded = E::decode_as_type(
+            &mut &self.raw.error[..],
+            self.metadata.outer_enums().error_enum_ty(),
+            self.metadata.types(),
+        )?;
+
+        Ok(decoded)
     }
 }
 

subxt/src/error/mod.rs

@@ -225,15 +225,3 @@ pub enum MetadataError {
     #[error("The generated code is not compatible with the node")]
     IncompatibleCodegen,
 }
-
-/// This trait is implemented on the statically generated root ModuleError type
-#[doc(hidden)]
-pub trait RootError: Sized {
-    /// Given details of the pallet error we want to decode
-    fn root_error(
-        // typically a [u8; 4] encodes the error of a pallet
-        pallet_bytes: &[u8],
-        pallet_name: &str,
-        metadata: &Metadata,
-    ) -> Result<Self, Error>;
-}

subxt/src/events/events_type.rs

@@ -14,6 +14,7 @@ use crate::{
 };
 use codec::{Compact, Decode};
 use derivative::Derivative;
+use scale_decode::DecodeAsType;
 use std::sync::Arc;
 
 /// A collection of events obtained from a block, bundled with the necessary
@@ -203,8 +204,6 @@ pub struct EventDetails<T: Config> {
     all_bytes: Arc<[u8]>,
     // start of the bytes (phase, pallet/variant index and then fields and then topic to follow).
     start_idx: usize,
-    // start of the event (ie pallet/variant index and then the fields and topic after).
-    event_start_idx: usize,
     // start of the fields (ie after phase and pallet/variant index).
     event_fields_start_idx: usize,
     // end of the fields.
@@ -227,8 +226,6 @@ impl<T: Config> EventDetails<T> {
 
         let phase = Phase::decode(input)?;
 
-        let event_start_idx = all_bytes.len() - input.len();
-
         let pallet_index = u8::decode(input)?;
         let variant_index = u8::decode(input)?;
 
@@ -270,7 +267,6 @@ impl<T: Config> EventDetails<T> {
             phase,
             index,
             start_idx,
-            event_start_idx,
             event_fields_start_idx,
             event_fields_end_idx,
             end_idx,
@@ -386,20 +382,16 @@ impl<T: Config> EventDetails<T> {
     /// Attempt to decode these [`EventDetails`] into a root event type (which includes
     /// the pallet and event enum variants as well as the event fields). A compatible
     /// type for this is exposed via static codegen as a root level `Event` type.
-    pub fn as_root_event<E: RootEvent>(&self) -> Result<E, Error> {
-        let ev_metadata = self.event_metadata();
-        let pallet_bytes = &self.all_bytes[self.event_start_idx + 1..self.event_fields_end_idx];
-        let pallet_event_ty = ev_metadata
-            .pallet
-            .event_ty_id()
-            .ok_or_else(|| MetadataError::EventTypeNotFoundInPallet(ev_metadata.pallet.index()))?;
-
-        E::root_event(
-            pallet_bytes,
-            self.pallet_name(),
-            pallet_event_ty,
-            &self.metadata,
-        )
+    pub fn as_root_event<E: DecodeAsType>(&self) -> Result<E, Error> {
+        let bytes = &self.all_bytes[self.start_idx + 1..self.event_fields_end_idx];
+
+        let decoded = E::decode_as_type(
+            &mut &bytes[..],
+            self.metadata.outer_enums().event_enum_ty(),
+            self.metadata.types(),
+        )?;
+
+        Ok(decoded)
     }
 
     /// Return the topics associated with this event.
@@ -414,23 +406,6 @@ pub struct EventMetadataDetails<'a> {
     pub variant: &'a scale_info::Variant<scale_info::form::PortableForm>,
 }
 
-/// This trait is implemented on the statically generated root event type, so that we're able
-/// to decode it properly via a pallet event that impls `DecodeAsMetadata`. This is necessary
-/// becasue the "root event" type is generated using pallet info but doesn't actually exist in the
-/// metadata types, so we have no easy way to decode things into it via type information and need a
-/// little help via codegen.
-#[doc(hidden)]
-pub trait RootEvent: Sized {
-    /// Given details of the pallet event we want to decode, and the name of the pallet, try to hand
-    /// back a "root event".
-    fn root_event(
-        pallet_bytes: &[u8],
-        pallet_name: &str,
-        pallet_event_ty: u32,
-        metadata: &Metadata,
-    ) -> Result<Self, Error>;
-}
-
 /// Event related test utilities used outside this module.
 #[cfg(test)]
 pub(crate) mod test_utils {
@@ -463,25 +438,6 @@ pub(crate) mod test_utils {
         Test(Ev),
     }
 
-    // We need this in order to be able to decode into a root event type:
-    impl<Ev: DecodeWithMetadata> RootEvent for AllEvents<Ev> {
-        fn root_event(
-            mut bytes: &[u8],
-            pallet_name: &str,
-            pallet_event_ty: u32,
-            metadata: &Metadata,
-        ) -> Result<Self, Error> {
-            if pallet_name == "Test" {
-                return Ok(AllEvents::Test(Ev::decode_with_metadata(
-                    &mut bytes,
-                    pallet_event_ty,
-                    metadata,
-                )?));
-            }
-            panic!("Asked for pallet name '{pallet_name}', which isn't in our test AllEvents type")
-        }
-    }
-
     /// This encodes to the same format an event is expected to encode to
     /// in node System.Events storage.
     #[derive(Encode)]

subxt/src/events/mod.rs

@@ -14,8 +14,6 @@ pub use events_client::EventsClient;
 pub use events_type::{
     EventDetails,
     Events,
-    // Used in codegen but hidden from docs:
-    RootEvent,
 };
 use scale_decode::DecodeAsFields;