From 7214da1b8369d1b7ff24e5d67c661113cb4a3d9f Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 1 Oct 2024 11:03:11 -0400
Subject: [PATCH 1/2] update tag in update.sh to v1.16.0-rc1

---
 support/procedural-fork/update.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/support/procedural-fork/update.sh b/support/procedural-fork/update.sh
index a8793b261..0cb933b33 100755
--- a/support/procedural-fork/update.sh
+++ b/support/procedural-fork/update.sh
@@ -5,7 +5,7 @@ set -e
 
 # Set the repository and tag
 REPO_URL="git@github.com:paritytech/polkadot-sdk.git"
-POLKADOT_SDK_TAG="v1.10.0-rc3"
+POLKADOT_SDK_TAG="v1.16.0-rc1"
 
 # Create a temporary directory for cloning
 TMP_DIR=$(mktemp -d)

From ac6e87d2c2328a5cf6f127ed3d4e45c72c622065 Mon Sep 17 00:00:00 2001
From: Sam Johnson <sam@durosoft.com>
Date: Tue, 1 Oct 2024 11:03:55 -0400
Subject: [PATCH 2/2] update procedural-fork to v1.16.0-rc1

---
 support/procedural-fork/src/benchmark.rs      | 103 +++++-----
 .../src/construct_runtime/expand/call.rs      |   1 +
 .../src/construct_runtime/expand/inherent.rs  |   6 +-
 .../src/construct_runtime/expand/metadata.rs  |   4 +-
 .../src/construct_runtime/expand/origin.rs    |  34 ++--
 .../src/construct_runtime/mod.rs              |  24 +--
 .../src/construct_runtime/parse.rs            |  37 ++--
 support/procedural-fork/src/dynamic_params.rs |   4 +-
 .../src/pallet/expand/constants.rs            |   9 +-
 .../src/pallet/expand/documentation.rs        |   4 +-
 .../src/pallet/expand/error.rs                |  44 +++--
 .../src/pallet/expand/hooks.rs                |  81 ++++----
 .../src/pallet/expand/pallet_struct.rs        |  14 +-
 .../src/pallet/expand/storage.rs              |  67 +++----
 .../src/pallet/expand/tasks.rs                |   7 +-
 .../src/pallet/expand/tt_default_parts.rs     |   4 +-
 .../src/pallet/parse/composite.rs             |   4 -
 .../src/pallet/parse/config.rs                | 187 ++++++++++--------
 .../procedural-fork/src/pallet/parse/error.rs |   4 -
 .../src/pallet/parse/extra_constants.rs       |   5 +-
 .../src/pallet/parse/genesis_build.rs         |   9 +-
 .../src/pallet/parse/helper.rs                |  18 +-
 .../procedural-fork/src/pallet/parse/hooks.rs |   9 +-
 .../src/pallet/parse/inherent.rs              |   6 +-
 .../procedural-fork/src/pallet/parse/mod.rs   |  19 +-
 .../src/pallet/parse/origin.rs                |   8 +-
 .../src/pallet/parse/storage.rs               |   6 +-
 .../procedural-fork/src/pallet/parse/tasks.rs |   8 +-
 .../src/pallet/parse/tests/tasks.rs           |   4 +-
 .../src/pallet/parse/type_value.rs            |  12 +-
 .../src/pallet/parse/validate_unsigned.rs     |  17 +-
 .../procedural-fork/src/runtime/expand/mod.rs |  21 +-
 support/procedural-fork/src/runtime/mod.rs    |   2 -
 .../procedural-fork/src/runtime/parse/mod.rs  |  64 +++---
 .../src/runtime/parse/pallet.rs               | 154 ++++++++++++---
 .../src/runtime/parse/pallet_decl.rs          | 145 ++++++++++++--
 .../src/runtime/parse/runtime_struct.rs       |   4 +-
 37 files changed, 679 insertions(+), 470 deletions(-)

diff --git a/support/procedural-fork/src/benchmark.rs b/support/procedural-fork/src/benchmark.rs
index 376200d6e..0eb3c330a 100644
--- a/support/procedural-fork/src/benchmark.rs
+++ b/support/procedural-fork/src/benchmark.rs
@@ -323,6 +323,24 @@ fn ensure_valid_return_type(item_fn: &ItemFn) -> Result<()> {
     Ok(())
 }
 
+/// Ensure that the passed statements do not contain any forbidden variable names
+fn ensure_no_forbidden_variable_names(stmts: &[Stmt]) -> Result<()> {
+    const FORBIDDEN_VAR_NAMES: [&str; 2] = ["recording", "verify"];
+    for stmt in stmts {
+        let Stmt::Local(l) = stmt else { continue };
+        let Pat::Ident(ident) = &l.pat else { continue };
+        if FORBIDDEN_VAR_NAMES.contains(&ident.ident.to_string().as_str()) {
+            return Err(Error::new(
+                ident.span(),
+                format!(
+                    "Variables {FORBIDDEN_VAR_NAMES:?} are reserved for benchmarking internals.",
+                ),
+            ));
+        }
+    }
+    Ok(())
+}
+
 /// Parses params such as `x: Linear<0, 1>`
 fn parse_params(item_fn: &ItemFn) -> Result<Vec<ParamDef>> {
     let mut params: Vec<ParamDef> = Vec::new();
@@ -481,9 +499,12 @@ impl BenchmarkDef {
             }
         };
 
+        let setup_stmts = Vec::from(&item_fn.block.stmts[0..i]);
+        ensure_no_forbidden_variable_names(&setup_stmts)?;
+
         Ok(BenchmarkDef {
             params,
-            setup_stmts: Vec::from(&item_fn.block.stmts[0..i]),
+            setup_stmts,
             call_def,
             verify_stmts,
             last_stmt,
@@ -692,18 +713,16 @@ pub fn benchmarks(
 
                 fn instance(
                     &self,
+                    recording: &mut impl #krate::Recording,
                     components: &[(#krate::BenchmarkParameter, u32)],
                     verify: bool,
-                ) -> Result<
-                    #krate::__private::Box<dyn FnOnce() -> Result<(), #krate::BenchmarkError>>,
-                    #krate::BenchmarkError,
-                > {
+                ) -> Result<(), #krate::BenchmarkError> {
                     match self {
                         #(
                             Self::#benchmark_names => {
                                 <#benchmark_names as #krate::BenchmarkingSetup<
                                     #type_use_generics
-                                >>::instance(&#benchmark_names, components, verify)
+                                >>::instance(&#benchmark_names, recording, components, verify)
                             }
                         )
                         *
@@ -794,17 +813,7 @@ pub fn benchmarks(
                     #krate::benchmarking::set_whitelist(whitelist.clone());
                     let mut results: #krate::__private::Vec<#krate::BenchmarkResult> = #krate::__private::Vec::new();
 
-                    // Always do at least one internal repeat...
-                    for _ in 0 .. internal_repeats.max(1) {
-                        // Always reset the state after the benchmark.
-                        #krate::__private::defer!(#krate::benchmarking::wipe_db());
-
-                        // Set up the externalities environment for the setup we want to
-                        // benchmark.
-                        let closure_to_benchmark = <
-                            SelectedBenchmark as #krate::BenchmarkingSetup<#type_use_generics>
-                        >::instance(&selected_benchmark, c, verify)?;
-
+                    let on_before_start = || {
                         // Set the block number to at least 1 so events are deposited.
                         if #krate::__private::Zero::is_zero(&#frame_system::Pallet::<T>::block_number()) {
                             #frame_system::Pallet::<T>::set_block_number(1u32.into());
@@ -822,6 +831,12 @@ pub fn benchmarks(
 
                         // Reset the read/write counter so we don't count operations in the setup process.
                         #krate::benchmarking::reset_read_write_count();
+                    };
+
+                    // Always do at least one internal repeat...
+                    for _ in 0 .. internal_repeats.max(1) {
+                        // Always reset the state after the benchmark.
+                        #krate::__private::defer!(#krate::benchmarking::wipe_db());
 
                         // Time the extrinsic logic.
                         #krate::__private::log::trace!(
@@ -831,20 +846,12 @@ pub fn benchmarks(
                             c
                         );
 
-                        let start_pov = #krate::benchmarking::proof_size();
-                        let start_extrinsic = #krate::benchmarking::current_time();
-
-                        closure_to_benchmark()?;
-
-                        let finish_extrinsic = #krate::benchmarking::current_time();
-                        let end_pov = #krate::benchmarking::proof_size();
+                        let mut recording = #krate::BenchmarkRecording::new(&on_before_start);
+                        <SelectedBenchmark as #krate::BenchmarkingSetup<#type_use_generics>>::instance(&selected_benchmark, &mut recording, c, verify)?;
 
                         // Calculate the diff caused by the benchmark.
-                        let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
-                        let diff_pov = match (start_pov, end_pov) {
-                            (Some(start), Some(end)) => end.saturating_sub(start),
-                            _ => Default::default(),
-                        };
+                        let elapsed_extrinsic = recording.elapsed_extrinsic().expect("elapsed time should be recorded");
+                        let diff_pov = recording.diff_pov().unwrap_or_default();
 
                         // Commit the changes to get proper write count
                         #krate::benchmarking::commit_db();
@@ -1163,9 +1170,10 @@ fn expand_benchmark(
 
             fn instance(
                 &self,
+                recording: &mut impl #krate::Recording,
                 components: &[(#krate::BenchmarkParameter, u32)],
                 verify: bool
-            ) -> Result<#krate::__private::Box<dyn FnOnce() -> Result<(), #krate::BenchmarkError>>, #krate::BenchmarkError> {
+            ) -> Result<(), #krate::BenchmarkError> {
                 #(
                     // prepare instance #param_names
                     let #param_names = components.iter()
@@ -1179,15 +1187,15 @@ fn expand_benchmark(
                     #setup_stmts
                 )*
                 #pre_call
-                Ok(#krate::__private::Box::new(move || -> Result<(), #krate::BenchmarkError> {
-                    #post_call
-                    if verify {
-                        #(
-                            #verify_stmts
-                        )*
-                    }
-                    #impl_last_stmt
-                }))
+                recording.start();
+                #post_call
+                recording.stop();
+                if verify {
+                    #(
+                        #verify_stmts
+                    )*
+                }
+                #impl_last_stmt
             }
         }
 
@@ -1205,18 +1213,15 @@ fn expand_benchmark(
                     // Always reset the state after the benchmark.
                     #krate::__private::defer!(#krate::benchmarking::wipe_db());
 
-                    // Set up the benchmark, return execution + verification function.
-                    let closure_to_verify = <
-                        SelectedBenchmark as #krate::BenchmarkingSetup<T, _>
-                    >::instance(&selected_benchmark, &c, true)?;
-
-                    // Set the block number to at least 1 so events are deposited.
-                    if #krate::__private::Zero::is_zero(&#frame_system::Pallet::<T>::block_number()) {
-                        #frame_system::Pallet::<T>::set_block_number(1u32.into());
-                    }
+                    let on_before_start = || {
+                        // Set the block number to at least 1 so events are deposited.
+                        if #krate::__private::Zero::is_zero(&#frame_system::Pallet::<T>::block_number()) {
+                            #frame_system::Pallet::<T>::set_block_number(1u32.into());
+                        }
+                    };
 
                     // Run execution + verification
-                    closure_to_verify()
+                    <SelectedBenchmark as #krate::BenchmarkingSetup<T, _>>::test_instance(&selected_benchmark,  &c, &on_before_start)
                 };
 
                 if components.is_empty() {
diff --git a/support/procedural-fork/src/construct_runtime/expand/call.rs b/support/procedural-fork/src/construct_runtime/expand/call.rs
index 7e8c2e856..cc467c31d 100644
--- a/support/procedural-fork/src/construct_runtime/expand/call.rs
+++ b/support/procedural-fork/src/construct_runtime/expand/call.rs
@@ -69,6 +69,7 @@ pub fn expand_outer_dispatch(
     quote! {
         #( #query_call_part_macros )*
 
+        /// The aggregated runtime call type.
         #[derive(
             Clone, PartialEq, Eq,
             #scrate::__private::codec::Encode,
diff --git a/support/procedural-fork/src/construct_runtime/expand/inherent.rs b/support/procedural-fork/src/construct_runtime/expand/inherent.rs
index b58d540fe..9705f9703 100644
--- a/support/procedural-fork/src/construct_runtime/expand/inherent.rs
+++ b/support/procedural-fork/src/construct_runtime/expand/inherent.rs
@@ -61,17 +61,17 @@ pub fn expand_outer_inherent(
 
         trait InherentDataExt {
             fn create_extrinsics(&self) ->
-                #scrate::__private::sp_std::vec::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>;
+                #scrate::__private::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>;
             fn check_extrinsics(&self, block: &#block) -> #scrate::inherent::CheckInherentsResult;
         }
 
         impl InherentDataExt for #scrate::inherent::InherentData {
             fn create_extrinsics(&self) ->
-                #scrate::__private::sp_std::vec::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>
+                #scrate::__private::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>
             {
                 use #scrate::inherent::ProvideInherent;
 
-                let mut inherents = #scrate::__private::sp_std::vec::Vec::new();
+                let mut inherents = #scrate::__private::Vec::new();
 
                 #(
                     #pallet_attrs
diff --git a/support/procedural-fork/src/construct_runtime/expand/metadata.rs b/support/procedural-fork/src/construct_runtime/expand/metadata.rs
index f98c719ca..9f3d9cd4a 100644
--- a/support/procedural-fork/src/construct_runtime/expand/metadata.rs
+++ b/support/procedural-fork/src/construct_runtime/expand/metadata.rs
@@ -114,7 +114,7 @@ pub fn expand_runtime_metadata(
                     >();
 
                 #scrate::__private::metadata_ir::MetadataIR {
-                    pallets: #scrate::__private::sp_std::vec![ #(#pallets),* ],
+                    pallets: #scrate::__private::vec![ #(#pallets),* ],
                     extrinsic: #scrate::__private::metadata_ir::ExtrinsicMetadataIR {
                         ty,
                         version: <#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata>::VERSION,
@@ -159,7 +159,7 @@ pub fn expand_runtime_metadata(
                 })
             }
 
-            pub fn metadata_versions() -> #scrate::__private::sp_std::vec::Vec<u32> {
+            pub fn metadata_versions() -> #scrate::__private::Vec<u32> {
                 #scrate::__private::metadata_ir::supported_versions()
             }
         }
diff --git a/support/procedural-fork/src/construct_runtime/expand/origin.rs b/support/procedural-fork/src/construct_runtime/expand/origin.rs
index 2d50777bf..58c8adec5 100644
--- a/support/procedural-fork/src/construct_runtime/expand/origin.rs
+++ b/support/procedural-fork/src/construct_runtime/expand/origin.rs
@@ -110,25 +110,25 @@ pub fn expand_outer_origin(
         #[derive(Clone)]
         pub struct RuntimeOrigin {
             pub caller: OriginCaller,
-            filter: #scrate::__private::sp_std::rc::Rc<Box<dyn Fn(&<#runtime as #system_path::Config>::RuntimeCall) -> bool>>,
+            filter: #scrate::__private::Rc<#scrate::__private::Box<dyn Fn(&<#runtime as #system_path::Config>::RuntimeCall) -> bool>>,
         }
 
         #[cfg(not(feature = "std"))]
-        impl #scrate::__private::sp_std::fmt::Debug for RuntimeOrigin {
+        impl core::fmt::Debug for RuntimeOrigin {
             fn fmt(
                 &self,
-                fmt: &mut #scrate::__private::sp_std::fmt::Formatter,
-            ) -> #scrate::__private::sp_std::result::Result<(), #scrate::__private::sp_std::fmt::Error> {
+                fmt: &mut core::fmt::Formatter,
+            ) -> core::result::Result<(), core::fmt::Error> {
                 fmt.write_str("<wasm:stripped>")
             }
         }
 
         #[cfg(feature = "std")]
-        impl #scrate::__private::sp_std::fmt::Debug for RuntimeOrigin {
+        impl core::fmt::Debug for RuntimeOrigin {
             fn fmt(
                 &self,
-                fmt: &mut #scrate::__private::sp_std::fmt::Formatter,
-            ) -> #scrate::__private::sp_std::result::Result<(), #scrate::__private::sp_std::fmt::Error> {
+                fmt: &mut core::fmt::Formatter,
+            ) -> core::result::Result<(), core::fmt::Error> {
                 fmt.debug_struct("Origin")
                     .field("caller", &self.caller)
                     .field("filter", &"[function ptr]")
@@ -144,7 +144,7 @@ pub fn expand_outer_origin(
             fn add_filter(&mut self, filter: impl Fn(&Self::Call) -> bool + 'static) {
                 let f = self.filter.clone();
 
-                self.filter = #scrate::__private::sp_std::rc::Rc::new(Box::new(move |call| {
+                self.filter = #scrate::__private::Rc::new(#scrate::__private::Box::new(move |call| {
                     f(call) && filter(call)
                 }));
             }
@@ -155,7 +155,7 @@ pub fn expand_outer_origin(
                     as #scrate::traits::Contains<<#runtime as #system_path::Config>::RuntimeCall>
                 >::contains;
 
-                self.filter = #scrate::__private::sp_std::rc::Rc::new(Box::new(filter));
+                self.filter = #scrate::__private::Rc::new(#scrate::__private::Box::new(filter));
             }
 
             fn set_caller_from(&mut self, other: impl Into<Self>) {
@@ -257,7 +257,7 @@ pub fn expand_outer_origin(
         impl TryFrom<OriginCaller> for #system_path::Origin<#runtime> {
             type Error = OriginCaller;
             fn try_from(x: OriginCaller)
-                -> #scrate::__private::sp_std::result::Result<#system_path::Origin<#runtime>, OriginCaller>
+                -> core::result::Result<#system_path::Origin<#runtime>, OriginCaller>
             {
                 if let OriginCaller::system(l) = x {
                     Ok(l)
@@ -280,7 +280,7 @@ pub fn expand_outer_origin(
             fn from(x: OriginCaller) -> Self {
                 let mut o = RuntimeOrigin {
                     caller: x,
-                    filter: #scrate::__private::sp_std::rc::Rc::new(Box::new(|_| true)),
+                    filter: #scrate::__private::Rc::new(#scrate::__private::Box::new(|_| true)),
                 };
 
                 #scrate::traits::OriginTrait::reset_filter(&mut o);
@@ -289,7 +289,7 @@ pub fn expand_outer_origin(
             }
         }
 
-        impl From<RuntimeOrigin> for #scrate::__private::sp_std::result::Result<#system_path::Origin<#runtime>, RuntimeOrigin> {
+        impl From<RuntimeOrigin> for core::result::Result<#system_path::Origin<#runtime>, RuntimeOrigin> {
             /// NOTE: converting to pallet origin loses the origin filter information.
             fn from(val: RuntimeOrigin) -> Self {
                 if let OriginCaller::system(l) = val.caller {
@@ -357,7 +357,7 @@ fn expand_origin_caller_variant(
 }
 
 fn expand_origin_pallet_conversions(
-    scrate: &TokenStream,
+    _scrate: &TokenStream,
     runtime: &Ident,
     pallet: &Pallet,
     instance: Option<&Ident>,
@@ -405,7 +405,7 @@ fn expand_origin_pallet_conversions(
         }
 
         #attr
-        impl From<RuntimeOrigin> for #scrate::__private::sp_std::result::Result<#pallet_origin, RuntimeOrigin> {
+        impl From<RuntimeOrigin> for core::result::Result<#pallet_origin, RuntimeOrigin> {
             /// NOTE: converting to pallet origin loses the origin filter information.
             fn from(val: RuntimeOrigin) -> Self {
                 if let OriginCaller::#variant_name(l) = val.caller {
@@ -421,7 +421,7 @@ fn expand_origin_pallet_conversions(
             type Error = OriginCaller;
             fn try_from(
                 x: OriginCaller,
-            ) -> #scrate::__private::sp_std::result::Result<#pallet_origin, OriginCaller> {
+            ) -> core::result::Result<#pallet_origin, OriginCaller> {
                 if let OriginCaller::#variant_name(l) = x {
                     Ok(l)
                 } else {
@@ -435,7 +435,7 @@ fn expand_origin_pallet_conversions(
             type Error = ();
             fn try_from(
                 x: &'a OriginCaller,
-            ) -> #scrate::__private::sp_std::result::Result<&'a #pallet_origin, ()> {
+            ) -> core::result::Result<&'a #pallet_origin, ()> {
                 if let OriginCaller::#variant_name(l) = x {
                     Ok(&l)
                 } else {
@@ -449,7 +449,7 @@ fn expand_origin_pallet_conversions(
             type Error = ();
             fn try_from(
                 x: &'a RuntimeOrigin,
-            ) -> #scrate::__private::sp_std::result::Result<&'a #pallet_origin, ()> {
+            ) -> core::result::Result<&'a #pallet_origin, ()> {
                 if let OriginCaller::#variant_name(l) = &x.caller {
                     Ok(&l)
                 } else {
diff --git a/support/procedural-fork/src/construct_runtime/mod.rs b/support/procedural-fork/src/construct_runtime/mod.rs
index de688b3d6..9bc271fdc 100644
--- a/support/procedural-fork/src/construct_runtime/mod.rs
+++ b/support/procedural-fork/src/construct_runtime/mod.rs
@@ -491,7 +491,7 @@ fn construct_runtime_final_expansion(
         #[doc(hidden)]
         trait InternalConstructRuntime {
             #[inline(always)]
-            fn runtime_metadata(&self) -> #scrate::__private::sp_std::vec::Vec<#scrate::__private::metadata_ir::RuntimeApiMetadataIR> {
+            fn runtime_metadata(&self) -> #scrate::__private::Vec<#scrate::__private::metadata_ir::RuntimeApiMetadataIR> {
                 Default::default()
             }
         }
@@ -554,6 +554,7 @@ pub(crate) fn decl_all_pallets<'a>(
     for pallet_declaration in pallet_declarations {
         let type_name = &pallet_declaration.name;
         let pallet = &pallet_declaration.path;
+        let docs = &pallet_declaration.docs;
         let mut generics = vec![quote!(#runtime)];
         generics.extend(
             pallet_declaration
@@ -567,6 +568,7 @@ pub(crate) fn decl_all_pallets<'a>(
             attrs.extend(TokenStream2::from_str(&feat).expect("was parsed successfully; qed"));
         }
         let type_decl = quote!(
+            #( #[doc = #docs] )*
             #(#attrs)*
             pub type #type_name = #pallet::Pallet <#(#generics),*>;
         );
@@ -703,10 +705,10 @@ pub(crate) fn decl_pallet_runtime_setup(
         impl #scrate::traits::PalletInfo for PalletInfo {
 
             fn index<P: 'static>() -> Option<usize> {
-                let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+                let type_id = core::any::TypeId::of::<P>();
                 #(
                     #pallet_attrs
-                    if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+                    if type_id == core::any::TypeId::of::<#names>() {
                         return Some(#indices)
                     }
                 )*
@@ -715,10 +717,10 @@ pub(crate) fn decl_pallet_runtime_setup(
             }
 
             fn name<P: 'static>() -> Option<&'static str> {
-                let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+                let type_id = core::any::TypeId::of::<P>();
                 #(
                     #pallet_attrs
-                    if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+                    if type_id == core::any::TypeId::of::<#names>() {
                         return Some(#name_strings)
                     }
                 )*
@@ -727,10 +729,10 @@ pub(crate) fn decl_pallet_runtime_setup(
             }
 
             fn name_hash<P: 'static>() -> Option<[u8; 16]> {
-                let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+                let type_id = core::any::TypeId::of::<P>();
                 #(
                     #pallet_attrs
-                    if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+                    if type_id == core::any::TypeId::of::<#names>() {
                         return Some(#name_hashes)
                     }
                 )*
@@ -739,10 +741,10 @@ pub(crate) fn decl_pallet_runtime_setup(
             }
 
             fn module_name<P: 'static>() -> Option<&'static str> {
-                let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+                let type_id = core::any::TypeId::of::<P>();
                 #(
                     #pallet_attrs
-                    if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+                    if type_id == core::any::TypeId::of::<#names>() {
                         return Some(#module_names)
                     }
                 )*
@@ -751,10 +753,10 @@ pub(crate) fn decl_pallet_runtime_setup(
             }
 
             fn crate_version<P: 'static>() -> Option<#scrate::traits::CrateVersion> {
-                let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+                let type_id = core::any::TypeId::of::<P>();
                 #(
                     #pallet_attrs
-                    if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+                    if type_id == core::any::TypeId::of::<#names>() {
                         return Some(
                             <#pallet_structs as #scrate::traits::PalletInfoAccess>::crate_version()
                         )
diff --git a/support/procedural-fork/src/construct_runtime/parse.rs b/support/procedural-fork/src/construct_runtime/parse.rs
index 173a8dd12..e5e60b3ff 100644
--- a/support/procedural-fork/src/construct_runtime/parse.rs
+++ b/support/procedural-fork/src/construct_runtime/parse.rs
@@ -65,8 +65,6 @@ pub enum RuntimeDeclaration {
 /// Declaration of a runtime with some pallet with implicit declaration of parts.
 #[derive(Debug)]
 pub struct ImplicitRuntimeDeclaration {
-    pub name: Ident,
-    pub where_section: Option<WhereSection>,
     pub pallets: Vec<PalletDeclaration>,
 }
 
@@ -103,8 +101,6 @@ impl Parse for RuntimeDeclaration {
         match convert_pallets(pallets.content.inner.into_iter().collect())? {
             PalletsConversion::Implicit(pallets) => {
                 Ok(RuntimeDeclaration::Implicit(ImplicitRuntimeDeclaration {
-                    name,
-                    where_section,
                     pallets,
                 }))
             }
@@ -131,9 +127,6 @@ impl Parse for RuntimeDeclaration {
 #[derive(Debug)]
 pub struct WhereSection {
     pub span: Span,
-    pub block: syn::TypePath,
-    pub node_block: syn::TypePath,
-    pub unchecked_extrinsic: syn::TypePath,
 }
 
 impl Parse for WhereSection {
@@ -152,10 +145,9 @@ impl Parse for WhereSection {
             }
             input.parse::<Token![,]>()?;
         }
-        let block = remove_kind(input, WhereKind::Block, &mut definitions)?.value;
-        let node_block = remove_kind(input, WhereKind::NodeBlock, &mut definitions)?.value;
-        let unchecked_extrinsic =
-            remove_kind(input, WhereKind::UncheckedExtrinsic, &mut definitions)?.value;
+        remove_kind(input, WhereKind::Block, &mut definitions)?;
+        remove_kind(input, WhereKind::NodeBlock, &mut definitions)?;
+        remove_kind(input, WhereKind::UncheckedExtrinsic, &mut definitions)?;
         if let Some(WhereDefinition {
             ref kind_span,
             ref kind,
@@ -168,12 +160,7 @@ impl Parse for WhereSection {
             );
             return Err(Error::new(*kind_span, msg));
         }
-        Ok(Self {
-            span: input.span(),
-            block,
-            node_block,
-            unchecked_extrinsic,
-        })
+        Ok(Self { span: input.span() })
     }
 }
 
@@ -188,7 +175,6 @@ pub enum WhereKind {
 pub struct WhereDefinition {
     pub kind_span: Span,
     pub kind: WhereKind,
-    pub value: syn::TypePath,
 }
 
 impl Parse for WhereDefinition {
@@ -210,14 +196,10 @@ impl Parse for WhereDefinition {
             return Err(lookahead.error());
         };
 
-        Ok(Self {
-            kind_span,
-            kind,
-            value: {
-                let _: Token![=] = input.parse()?;
-                input.parse()?
-            },
-        })
+        let _: Token![=] = input.parse()?;
+        let _: syn::TypePath = input.parse()?;
+
+        Ok(Self { kind_span, kind })
     }
 }
 
@@ -646,6 +628,8 @@ pub struct Pallet {
     pub pallet_parts: Vec<PalletPart>,
     /// Expressions specified inside of a #[cfg] attribute.
     pub cfg_pattern: Vec<cfg_expr::Expression>,
+    /// The doc literals
+    pub docs: Vec<syn::Expr>,
 }
 
 impl Pallet {
@@ -827,6 +811,7 @@ fn convert_pallets(pallets: Vec<PalletDeclaration>) -> syn::Result<PalletsConver
                 instance: pallet.instance,
                 cfg_pattern,
                 pallet_parts,
+                docs: vec![],
             })
         })
         .collect::<Result<Vec<_>>>()?;
diff --git a/support/procedural-fork/src/dynamic_params.rs b/support/procedural-fork/src/dynamic_params.rs
index 70a18bf34..e1f9f626c 100644
--- a/support/procedural-fork/src/dynamic_params.rs
+++ b/support/procedural-fork/src/dynamic_params.rs
@@ -94,7 +94,7 @@ impl ToTokens for DynamicParamModAttr {
         let mut quoted_enum = quote! {};
         for m in self.inner_mods() {
             let aggregate_name =
-                syn::Ident::new(&m.ident.to_string().to_class_case(), m.ident.span());
+                syn::Ident::new(&m.ident.to_string().to_pascal_case(), m.ident.span());
             let mod_name = &m.ident;
 
             let mut attrs = m.attrs.clone();
@@ -245,7 +245,7 @@ impl ToTokens for DynamicPalletParamAttr {
         );
 
         let aggregate_name = syn::Ident::new(
-            &params_mod.ident.to_string().to_class_case(),
+            &params_mod.ident.to_string().to_pascal_case(),
             params_mod.ident.span(),
         );
         let (mod_name, vis) = (&params_mod.ident, &params_mod.vis);
diff --git a/support/procedural-fork/src/pallet/expand/constants.rs b/support/procedural-fork/src/pallet/expand/constants.rs
index 5153ccf49..19862a8a6 100644
--- a/support/procedural-fork/src/pallet/expand/constants.rs
+++ b/support/procedural-fork/src/pallet/expand/constants.rs
@@ -30,8 +30,7 @@ struct ConstDef {
     pub metadata_name: Option<syn::Ident>,
 }
 
-///
-/// * Impl fn module_constant_metadata for pallet.
+/// Implement the `pallet_constants_metadata` function for the pallet.
 pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
     let frame_support = &def.frame_support;
     let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
@@ -97,7 +96,7 @@ pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
                 name: #ident_str,
                 ty: #frame_support::__private::scale_info::meta_type::<#const_type>(),
                 value: { #default_byte_impl },
-                docs: #frame_support::__private::sp_std::vec![ #( #doc ),* ],
+                docs: #frame_support::__private::vec![ #( #doc ),* ],
             }
         })
     });
@@ -107,9 +106,9 @@ pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 
             #[doc(hidden)]
             pub fn pallet_constants_metadata()
-                -> #frame_support::__private::sp_std::vec::Vec<#frame_support::__private::metadata_ir::PalletConstantMetadataIR>
+                -> #frame_support::__private::Vec<#frame_support::__private::metadata_ir::PalletConstantMetadataIR>
             {
-                #frame_support::__private::sp_std::vec![ #( #consts ),* ]
+                #frame_support::__private::vec![ #( #consts ),* ]
             }
         }
     )
diff --git a/support/procedural-fork/src/pallet/expand/documentation.rs b/support/procedural-fork/src/pallet/expand/documentation.rs
index adc4f7ce9..62b2e8b8b 100644
--- a/support/procedural-fork/src/pallet/expand/documentation.rs
+++ b/support/procedural-fork/src/pallet/expand/documentation.rs
@@ -166,9 +166,9 @@ pub fn expand_documentation(def: &mut Def) -> proc_macro2::TokenStream {
 
             #[doc(hidden)]
             pub fn pallet_documentation_metadata()
-                -> #frame_support::__private::sp_std::vec::Vec<&'static str>
+                -> #frame_support::__private::Vec<&'static str>
             {
-                #frame_support::__private::sp_std::vec![ #( #docs ),* ]
+                #frame_support::__private::vec![ #( #docs ),* ]
             }
         }
     )
diff --git a/support/procedural-fork/src/pallet/expand/error.rs b/support/procedural-fork/src/pallet/expand/error.rs
index e2c3f680c..1b76034ef 100644
--- a/support/procedural-fork/src/pallet/expand/error.rs
+++ b/support/procedural-fork/src/pallet/expand/error.rs
@@ -66,28 +66,30 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
         #[doc(hidden)]
         #[codec(skip)]
         __Ignore(
-            #frame_support::__private::sp_std::marker::PhantomData<(#type_use_gen)>,
+            core::marker::PhantomData<(#type_use_gen)>,
             #frame_support::Never,
         )
     );
 
-    let as_str_matches = error.variants.iter().map(
-		|VariantDef { ident: variant, field: field_ty, docs: _, cfg_attrs }| {
-			let variant_str = variant.to_string();
-			let cfg_attrs = cfg_attrs.iter().map(|attr| attr.to_token_stream());
-			match field_ty {
-				Some(VariantField { is_named: true }) => {
-					quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant { .. } => #variant_str,)
-				},
-				Some(VariantField { is_named: false }) => {
-					quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant(..) => #variant_str,)
-				},
-				None => {
-					quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant => #variant_str,)
-				},
-			}
-		},
-	);
+    let as_str_matches =
+		error
+			.variants
+			.iter()
+			.map(|VariantDef { ident: variant, field: field_ty, cfg_attrs }| {
+				let variant_str = variant.to_string();
+				let cfg_attrs = cfg_attrs.iter().map(|attr| attr.to_token_stream());
+				match field_ty {
+					Some(VariantField { is_named: true }) => {
+						quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant { .. } => #variant_str,)
+					},
+					Some(VariantField { is_named: false }) => {
+						quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant(..) => #variant_str,)
+					},
+					None => {
+						quote::quote_spanned!(error.attr_span => #( #cfg_attrs )* Self::#variant => #variant_str,)
+					},
+				}
+			});
 
     let error_item = {
         let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[error.index];
@@ -126,11 +128,11 @@ pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
     }
 
     quote::quote_spanned!(error.attr_span =>
-        impl<#type_impl_gen> #frame_support::__private::sp_std::fmt::Debug for #error_ident<#type_use_gen>
+        impl<#type_impl_gen> core::fmt::Debug for #error_ident<#type_use_gen>
             #config_where_clause
         {
-            fn fmt(&self, f: &mut #frame_support::__private::sp_std::fmt::Formatter<'_>)
-                -> #frame_support::__private::sp_std::fmt::Result
+            fn fmt(&self, f: &mut core::fmt::Formatter<'_>)
+                -> core::fmt::Result
             {
                 f.write_str(self.as_str())
             }
diff --git a/support/procedural-fork/src/pallet/expand/hooks.rs b/support/procedural-fork/src/pallet/expand/hooks.rs
index 6967f4c08..8ff0e8f30 100644
--- a/support/procedural-fork/src/pallet/expand/hooks.rs
+++ b/support/procedural-fork/src/pallet/expand/hooks.rs
@@ -258,24 +258,24 @@ pub fn expand_hooks(def: &mut Def) -> proc_macro2::TokenStream {
                 >::on_runtime_upgrade()
             }
 
-            #[cfg(feature = "try-runtime")]
-            fn pre_upgrade() -> Result<#frame_support::__private::sp_std::vec::Vec<u8>, #frame_support::sp_runtime::TryRuntimeError> {
-                <
-                    Self
-                    as
-                    #frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
-                >::pre_upgrade()
-            }
+            #frame_support::try_runtime_enabled! {
+                fn pre_upgrade() -> Result<#frame_support::__private::Vec<u8>, #frame_support::sp_runtime::TryRuntimeError> {
+                    <
+                        Self
+                        as
+                        #frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+                    >::pre_upgrade()
+                }
 
-            #[cfg(feature = "try-runtime")]
-            fn post_upgrade(state: #frame_support::__private::sp_std::vec::Vec<u8>) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
-                #post_storage_version_check
+                fn post_upgrade(state: #frame_support::__private::Vec<u8>) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
+                    #post_storage_version_check
 
-                <
-                    Self
-                    as
-                    #frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
-                >::post_upgrade(state)
+                    <
+                        Self
+                        as
+                        #frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+                    >::post_upgrade(state)
+                }
             }
         }
 
@@ -310,34 +310,35 @@ pub fn expand_hooks(def: &mut Def) -> proc_macro2::TokenStream {
             }
         }
 
-        #[cfg(feature = "try-runtime")]
-        impl<#type_impl_gen>
-            #frame_support::traits::TryState<#frame_system::pallet_prelude::BlockNumberFor::<T>>
-            for #pallet_ident<#type_use_gen> #where_clause
-        {
-            fn try_state(
-                n: #frame_system::pallet_prelude::BlockNumberFor::<T>,
-                _s: #frame_support::traits::TryStateSelect
-            ) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
-                #frame_support::__private::log::info!(
-                    target: #frame_support::LOG_TARGET,
-                    "🩺 Running {:?} try-state checks",
-                    #pallet_name,
-                );
-                <
-                    Self as #frame_support::traits::Hooks<
-                        #frame_system::pallet_prelude::BlockNumberFor::<T>
-                    >
-                >::try_state(n).map_err(|err| {
-                    #frame_support::__private::log::error!(
+        #frame_support::try_runtime_enabled! {
+            impl<#type_impl_gen>
+                #frame_support::traits::TryState<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+                for #pallet_ident<#type_use_gen> #where_clause
+            {
+                fn try_state(
+                    n: #frame_system::pallet_prelude::BlockNumberFor::<T>,
+                    _s: #frame_support::traits::TryStateSelect
+                ) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
+                    #frame_support::__private::log::info!(
                         target: #frame_support::LOG_TARGET,
-                        "❌ {:?} try_state checks failed: {:?}",
+                        "🩺 Running {:?} try-state checks",
                         #pallet_name,
-                        err
                     );
+                    <
+                        Self as #frame_support::traits::Hooks<
+                            #frame_system::pallet_prelude::BlockNumberFor::<T>
+                        >
+                    >::try_state(n).map_err(|err| {
+                        #frame_support::__private::log::error!(
+                            target: #frame_support::LOG_TARGET,
+                            "❌ {:?} try_state checks failed: {:?}",
+                            #pallet_name,
+                            err
+                        );
 
-                    err
-                })
+                        err
+                    })
+                }
             }
         }
     )
diff --git a/support/procedural-fork/src/pallet/expand/pallet_struct.rs b/support/procedural-fork/src/pallet/expand/pallet_struct.rs
index c5def65ed..64e5d533c 100644
--- a/support/procedural-fork/src/pallet/expand/pallet_struct.rs
+++ b/support/procedural-fork/src/pallet/expand/pallet_struct.rs
@@ -54,7 +54,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
     if let Some(field) = pallet_item.fields.iter_mut().next() {
         if field.ty == syn::parse_quote!(_) {
             field.ty = syn::parse_quote!(
-                #frame_support::__private::sp_std::marker::PhantomData<(#type_use_gen)>
+                core::marker::PhantomData<(#type_use_gen)>
             );
         }
     }
@@ -148,10 +148,10 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
             #storages_where_clauses
         {
             fn storage_info()
-                -> #frame_support::__private::sp_std::vec::Vec<#frame_support::traits::StorageInfo>
+                -> #frame_support::__private::Vec<#frame_support::traits::StorageInfo>
             {
                 #[allow(unused_mut)]
-                let mut res = #frame_support::__private::sp_std::vec![];
+                let mut res = #frame_support::__private::vec![];
 
                 #(
                     #(#storage_cfg_attrs)*
@@ -191,8 +191,8 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
     let whitelisted_storage_keys_impl = quote::quote![
         use #frame_support::traits::{StorageInfoTrait, TrackedStorageKey, WhitelistedStorageKeys};
         impl<#type_impl_gen> WhitelistedStorageKeys for #pallet_ident<#type_use_gen> #storages_where_clauses {
-            fn whitelisted_storage_keys() -> #frame_support::__private::sp_std::vec::Vec<TrackedStorageKey> {
-                use #frame_support::__private::sp_std::vec;
+            fn whitelisted_storage_keys() -> #frame_support::__private::Vec<TrackedStorageKey> {
+                use #frame_support::__private::vec;
                 vec![#(
                     TrackedStorageKey::new(#whitelisted_storage_idents::<#type_use_gen>::hashed_key().to_vec())
                 ),*]
@@ -284,7 +284,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
             #config_where_clause
         {
             fn count() -> usize { 1 }
-            fn infos() -> #frame_support::__private::sp_std::vec::Vec<#frame_support::traits::PalletInfoData> {
+            fn infos() -> #frame_support::__private::Vec<#frame_support::traits::PalletInfoData> {
                 use #frame_support::traits::PalletInfoAccess;
                 let item = #frame_support::traits::PalletInfoData {
                     index: Self::index(),
@@ -292,7 +292,7 @@ pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
                     module_name: Self::module_name(),
                     crate_version: Self::crate_version(),
                 };
-                #frame_support::__private::sp_std::vec![item]
+                #frame_support::__private::vec![item]
             }
         }
 
diff --git a/support/procedural-fork/src/pallet/expand/storage.rs b/support/procedural-fork/src/pallet/expand/storage.rs
index b77e9846b..95b046670 100644
--- a/support/procedural-fork/src/pallet/expand/storage.rs
+++ b/support/procedural-fork/src/pallet/expand/storage.rs
@@ -454,7 +454,7 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
 			#(#cfg_attrs)*
 			{
 				<#full_ident as #frame_support::storage::StorageEntryMetadataBuilder>::build_metadata(
-					#frame_support::__private::sp_std::vec![
+					#frame_support::__private::vec![
 						#( #docs, )*
 					],
 					&mut entries,
@@ -886,39 +886,40 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
         storage_names.sort_by_cached_key(|ident| ident.to_string());
 
         quote::quote!(
-            #[cfg(feature = "try-runtime")]
-            impl<#type_impl_gen> #frame_support::traits::TryDecodeEntireStorage
-            for #pallet_ident<#type_use_gen> #completed_where_clause
-            {
-                fn try_decode_entire_state() -> Result<usize, #frame_support::__private::sp_std::vec::Vec<#frame_support::traits::TryDecodeEntireStorageError>> {
-                    let pallet_name = <<T as #frame_system::Config>::PalletInfo	as frame_support::traits::PalletInfo>
-                        ::name::<#pallet_ident<#type_use_gen>>()
-                        .expect("Every active pallet has a name in the runtime; qed");
-
-                    #frame_support::__private::log::debug!(target: "runtime::try-decode-state", "trying to decode pallet: {pallet_name}");
-
-                    // NOTE: for now, we have to exclude storage items that are feature gated.
-                    let mut errors = #frame_support::__private::sp_std::vec::Vec::new();
-                    let mut decoded = 0usize;
-
-                    #(
-                        #frame_support::__private::log::debug!(target: "runtime::try-decode-state", "trying to decode storage: \
-                        {pallet_name}::{}", stringify!(#storage_names));
+            #frame_support::try_runtime_enabled! {
+                impl<#type_impl_gen> #frame_support::traits::TryDecodeEntireStorage
+                for #pallet_ident<#type_use_gen> #completed_where_clause
+                {
+                    fn try_decode_entire_state() -> Result<usize, #frame_support::__private::Vec<#frame_support::traits::TryDecodeEntireStorageError>> {
+                        let pallet_name = <<T as #frame_system::Config>::PalletInfo	as #frame_support::traits::PalletInfo>
+                            ::name::<#pallet_ident<#type_use_gen>>()
+                            .expect("Every active pallet has a name in the runtime; qed");
+
+                        #frame_support::__private::log::debug!(target: "runtime::try-decode-state", "trying to decode pallet: {pallet_name}");
+
+                        // NOTE: for now, we have to exclude storage items that are feature gated.
+                        let mut errors = #frame_support::__private::Vec::new();
+                        let mut decoded = 0usize;
+
+                        #(
+                            #frame_support::__private::log::debug!(target: "runtime::try-decode-state", "trying to decode storage: \
+                            {pallet_name}::{}", stringify!(#storage_names));
+
+                            match <#storage_names as #frame_support::traits::TryDecodeEntireStorage>::try_decode_entire_state() {
+                                Ok(count) => {
+                                    decoded += count;
+                                },
+                                Err(err) => {
+                                    errors.extend(err);
+                                },
+                            }
+                        )*
 
-                        match <#storage_names as #frame_support::traits::TryDecodeEntireStorage>::try_decode_entire_state() {
-                            Ok(count) => {
-                                decoded += count;
-                            },
-                            Err(err) => {
-                                errors.extend(err);
-                            },
+                        if errors.is_empty() {
+                            Ok(decoded)
+                        } else {
+                            Err(errors)
                         }
-                    )*
-
-                    if errors.is_empty() {
-                        Ok(decoded)
-                    } else {
-                        Err(errors)
                     }
                 }
             }
@@ -939,7 +940,7 @@ pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
                         .expect("No name found for the pallet in the runtime! This usually means that the pallet wasn't added to `construct_runtime!`."),
                     entries: {
                         #[allow(unused_mut)]
-                        let mut entries = #frame_support::__private::sp_std::vec![];
+                        let mut entries = #frame_support::__private::vec![];
                         #( #entries_builder )*
                         entries
                     },
diff --git a/support/procedural-fork/src/pallet/expand/tasks.rs b/support/procedural-fork/src/pallet/expand/tasks.rs
index 8c4dfb54f..8a0bd2252 100644
--- a/support/procedural-fork/src/pallet/expand/tasks.rs
+++ b/support/procedural-fork/src/pallet/expand/tasks.rs
@@ -163,7 +163,6 @@ impl ToTokens for TasksDef {
             .map(|task| &task.arg_names)
             .collect::<Vec<_>>();
 
-        let sp_std = quote!(#scrate::__private::sp_std);
         let impl_generics = &self.item_impl.generics;
         tokens.extend(quote! {
 			impl #impl_generics #enum_use
@@ -173,13 +172,13 @@ impl ToTokens for TasksDef {
 
 			impl #impl_generics #scrate::traits::Task for #enum_use
 			{
-				type Enumeration = #sp_std::vec::IntoIter<#enum_use>;
+				type Enumeration = #scrate::__private::IntoIter<#enum_use>;
 
 				fn iter() -> Self::Enumeration {
-					let mut all_tasks = #sp_std::vec![];
+					let mut all_tasks = #scrate::__private::vec![];
 					#(all_tasks
 						.extend(#task_iters.map(|(#(#task_arg_names),*)| #enum_ident::#task_fn_idents { #(#task_arg_names: #task_arg_names.clone()),* })
-						.collect::<#sp_std::vec::Vec<_>>());
+						.collect::<#scrate::__private::Vec<_>>());
 					)*
 					all_tasks.into_iter()
 				}
diff --git a/support/procedural-fork/src/pallet/expand/tt_default_parts.rs b/support/procedural-fork/src/pallet/expand/tt_default_parts.rs
index 57b78339a..8e7dc39d8 100644
--- a/support/procedural-fork/src/pallet/expand/tt_default_parts.rs
+++ b/support/procedural-fork/src/pallet/expand/tt_default_parts.rs
@@ -208,9 +208,9 @@ pub fn expand_tt_default_parts(def: &mut Def) -> proc_macro2::TokenStream {
         macro_rules! #default_parts_unique_id_v2 {
             {
                 $caller:tt
-                frame_support = [{ $($frame_support:ident)::* }]
+                your_tt_return = [{ $my_tt_return:path }]
             } => {
-                $($frame_support)*::__private::tt_return! {
+                $my_tt_return! {
                     $caller
                     tokens = [{
                         + Pallet #call_part_v2 #storage_part_v2 #event_part_v2 #error_part_v2 #origin_part_v2 #config_part_v2
diff --git a/support/procedural-fork/src/pallet/parse/composite.rs b/support/procedural-fork/src/pallet/parse/composite.rs
index 38da1f205..239b4fd4b 100644
--- a/support/procedural-fork/src/pallet/parse/composite.rs
+++ b/support/procedural-fork/src/pallet/parse/composite.rs
@@ -87,8 +87,6 @@ pub mod keyword {
 }
 
 pub struct CompositeDef {
-    /// The index of the CompositeDef item in the pallet module.
-    pub index: usize,
     /// The composite keyword used (contains span).
     pub composite_keyword: keyword::CompositeKeyword,
     /// Name of the associated type.
@@ -104,7 +102,6 @@ pub struct CompositeDef {
 impl CompositeDef {
     pub fn try_from(
         attr_span: proc_macro2::Span,
-        index: usize,
         scrate: &syn::Path,
         item: &mut syn::Item,
     ) -> syn::Result<Self> {
@@ -186,7 +183,6 @@ impl CompositeDef {
             syn::parse2::<keyword::CompositeKeyword>(item.ident.to_token_stream())?;
 
         Ok(CompositeDef {
-            index,
             composite_keyword,
             attr_span,
             generics: item.generics.clone(),
diff --git a/support/procedural-fork/src/pallet/parse/config.rs b/support/procedural-fork/src/pallet/parse/config.rs
index cde565245..95b4143b6 100644
--- a/support/procedural-fork/src/pallet/parse/config.rs
+++ b/support/procedural-fork/src/pallet/parse/config.rs
@@ -62,8 +62,6 @@ pub struct ConfigDef {
     pub has_event_type: bool,
     /// The where clause on trait definition but modified so `Self` is `T`.
     pub where_clause: Option<syn::WhereClause>,
-    /// The span of the pallet::config attribute.
-    pub attr_span: proc_macro2::Span,
     /// Whether a default sub-trait should be generated.
     ///
     /// Contains default sub-trait items (instantiated by `#[pallet::config(with_default)]`).
@@ -97,30 +95,32 @@ impl TryFrom<&syn::TraitItemType> for ConstMetadataDef {
         let bound = trait_ty
             .bounds
             .iter()
-            .find_map(|b| {
-                if let syn::TypeParamBound::Trait(tb) = b {
-                    tb.path
-                        .segments
-                        .last()
-                        .and_then(|s| if s.ident == "Get" { Some(s) } else { None })
-                } else {
-                    None
-                }
+            .find_map(|param_bound| {
+                let syn::TypeParamBound::Trait(trait_bound) = param_bound else {
+                    return None;
+                };
+
+                trait_bound
+                    .path
+                    .segments
+                    .last()
+                    .and_then(|s| (s.ident == "Get").then(|| s))
             })
             .ok_or_else(|| err(trait_ty.span(), "`Get<T>` trait bound not found"))?;
-        let type_arg = if let syn::PathArguments::AngleBracketed(ref ab) = bound.arguments {
-            if ab.args.len() == 1 {
-                if let syn::GenericArgument::Type(ref ty) = ab.args[0] {
-                    Ok(ty)
-                } else {
-                    Err(err(ab.args[0].span(), "Expected a type argument"))
-                }
-            } else {
-                Err(err(bound.span(), "Expected a single type argument"))
-            }
-        } else {
-            Err(err(bound.span(), "Expected trait generic args"))
-        }?;
+
+        let syn::PathArguments::AngleBracketed(ref ab) = bound.arguments else {
+            return Err(err(bound.span(), "Expected trait generic args"));
+        };
+
+        // Only one type argument is expected.
+        if ab.args.len() != 1 {
+            return Err(err(bound.span(), "Expected a single type argument"));
+        }
+
+        let syn::GenericArgument::Type(ref type_arg) = ab.args[0] else {
+            return Err(err(ab.args[0].span(), "Expected a type argument"));
+        };
+
         let type_ = syn::parse2::<syn::Type>(replace_self_by_t(type_arg.to_token_stream()))
             .expect("Internal error: replacing `Self` by `T` should result in valid type");
 
@@ -229,59 +229,62 @@ fn check_event_type(
     trait_item: &syn::TraitItem,
     trait_has_instance: bool,
 ) -> syn::Result<bool> {
-    if let syn::TraitItem::Type(type_) = trait_item {
-        if type_.ident == "RuntimeEvent" {
-            // Check event has no generics
-            if !type_.generics.params.is_empty() || type_.generics.where_clause.is_some() {
-                let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must have\
-					no generics nor where_clause";
-                return Err(syn::Error::new(trait_item.span(), msg));
-            }
+    let syn::TraitItem::Type(type_) = trait_item else {
+        return Ok(false);
+    };
 
-            // Check bound contains IsType and From
-            let has_is_type_bound = type_.bounds.iter().any(|s| {
-                syn::parse2::<IsTypeBoundEventParse>(s.to_token_stream())
-                    .map_or(false, |b| has_expected_system_config(b.0, frame_system))
-            });
+    if type_.ident != "RuntimeEvent" {
+        return Ok(false);
+    }
 
-            if !has_is_type_bound {
-                let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
-					bound: `IsType<<Self as frame_system::Config>::RuntimeEvent>`".to_string();
-                return Err(syn::Error::new(type_.span(), msg));
-            }
+    // Check event has no generics
+    if !type_.generics.params.is_empty() || type_.generics.where_clause.is_some() {
+        let msg =
+            "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must have\
+					no generics nor where_clause";
+        return Err(syn::Error::new(trait_item.span(), msg));
+    }
 
-            let from_event_bound = type_
-                .bounds
-                .iter()
-                .find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
+    // Check bound contains IsType and From
+    let has_is_type_bound = type_.bounds.iter().any(|s| {
+        syn::parse2::<IsTypeBoundEventParse>(s.to_token_stream())
+            .map_or(false, |b| has_expected_system_config(b.0, frame_system))
+    });
+
+    if !has_is_type_bound {
+        let msg =
+            "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
+					bound: `IsType<<Self as frame_system::Config>::RuntimeEvent>`"
+                .to_string();
+        return Err(syn::Error::new(type_.span(), msg));
+    }
 
-            let from_event_bound = if let Some(b) = from_event_bound {
-                b
-            } else {
-                let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
-					bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`";
-                return Err(syn::Error::new(type_.span(), msg));
-            };
+    let from_event_bound = type_
+        .bounds
+        .iter()
+        .find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
 
-            if from_event_bound.is_generic && (from_event_bound.has_instance != trait_has_instance)
-            {
-                let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` bounds inconsistent \
+    let Some(from_event_bound) = from_event_bound else {
+        let msg =
+            "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
+				bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`";
+        return Err(syn::Error::new(type_.span(), msg));
+    };
+
+    if from_event_bound.is_generic && (from_event_bound.has_instance != trait_has_instance) {
+        let msg =
+            "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` bounds inconsistent \
 					`From<Event..>`. Config and generic Event must be both with instance or \
 					without instance";
-                return Err(syn::Error::new(type_.span(), msg));
-            }
-
-            Ok(true)
-        } else {
-            Ok(false)
-        }
-    } else {
-        Ok(false)
+        return Err(syn::Error::new(type_.span(), msg));
     }
+
+    Ok(true)
 }
 
 /// Check that the path to `frame_system::Config` is valid, this is that the path is just
-/// `frame_system::Config` or when using the `frame` crate it is `frame::xyz::frame_system::Config`.
+/// `frame_system::Config` or when using the `frame` crate it is
+/// `polkadot_sdk_frame::xyz::frame_system::Config`.
 fn has_expected_system_config(path: syn::Path, frame_system: &syn::Path) -> bool {
     // Check if `frame_system` is actually 'frame_system'.
     if path.segments.iter().all(|s| s.ident != "frame_system") {
@@ -305,7 +308,7 @@ fn has_expected_system_config(path: syn::Path, frame_system: &syn::Path) -> bool
             syn::parse2::<syn::Path>(quote::quote!(frame_system)).expect("is a valid path; qed")
         }
         (_, _) =>
-        // They are either both `frame_system` or both `frame::xyz::frame_system`.
+        // They are either both `frame_system` or both `polkadot_sdk_frame::xyz::frame_system`.
         {
             frame_system.clone()
         }
@@ -351,14 +354,11 @@ pub fn replace_self_by_t(input: proc_macro2::TokenStream) -> proc_macro2::TokenS
 impl ConfigDef {
     pub fn try_from(
         frame_system: &syn::Path,
-        attr_span: proc_macro2::Span,
         index: usize,
         item: &mut syn::Item,
         enable_default: bool,
     ) -> syn::Result<Self> {
-        let item = if let syn::Item::Trait(item) = item {
-            item
-        } else {
+        let syn::Item::Trait(item) = item else {
             let msg = "Invalid pallet::config, expected trait definition";
             return Err(syn::Error::new(item.span(), msg));
         };
@@ -512,7 +512,6 @@ impl ConfigDef {
             consts_metadata,
             has_event_type,
             where_clause,
-            attr_span,
             default_sub_trait,
         })
     }
@@ -539,14 +538,29 @@ mod tests {
 
     #[test]
     fn has_expected_system_config_works_with_frame() {
+        let path = syn::parse2::<syn::Path>(quote::quote!(frame_system::Config)).unwrap();
+
+        let frame_system =
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::deps::frame_system))
+                .unwrap();
+        assert!(has_expected_system_config(path.clone(), &frame_system));
+
         let frame_system =
             syn::parse2::<syn::Path>(quote::quote!(frame::deps::frame_system)).unwrap();
-        let path = syn::parse2::<syn::Path>(quote::quote!(frame_system::Config)).unwrap();
         assert!(has_expected_system_config(path, &frame_system));
     }
 
     #[test]
     fn has_expected_system_config_works_with_frame_full_path() {
+        let frame_system =
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::deps::frame_system))
+                .unwrap();
+        let path = syn::parse2::<syn::Path>(quote::quote!(
+            polkadot_sdk_frame::deps::frame_system::Config
+        ))
+        .unwrap();
+        assert!(has_expected_system_config(path, &frame_system));
+
         let frame_system =
             syn::parse2::<syn::Path>(quote::quote!(frame::deps::frame_system)).unwrap();
         let path =
@@ -556,6 +570,13 @@ mod tests {
 
     #[test]
     fn has_expected_system_config_works_with_other_frame_full_path() {
+        let frame_system =
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::xyz::frame_system)).unwrap();
+        let path =
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::xyz::frame_system::Config))
+                .unwrap();
+        assert!(has_expected_system_config(path, &frame_system));
+
         let frame_system =
             syn::parse2::<syn::Path>(quote::quote!(frame::xyz::frame_system)).unwrap();
         let path =
@@ -566,26 +587,32 @@ mod tests {
     #[test]
     fn has_expected_system_config_does_not_works_with_mixed_frame_full_path() {
         let frame_system =
-            syn::parse2::<syn::Path>(quote::quote!(frame::xyz::frame_system)).unwrap();
-        let path =
-            syn::parse2::<syn::Path>(quote::quote!(frame::deps::frame_system::Config)).unwrap();
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::xyz::frame_system)).unwrap();
+        let path = syn::parse2::<syn::Path>(quote::quote!(
+            polkadot_sdk_frame::deps::frame_system::Config
+        ))
+        .unwrap();
         assert!(!has_expected_system_config(path, &frame_system));
     }
 
     #[test]
     fn has_expected_system_config_does_not_works_with_other_mixed_frame_full_path() {
         let frame_system =
-            syn::parse2::<syn::Path>(quote::quote!(frame::deps::frame_system)).unwrap();
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::deps::frame_system))
+                .unwrap();
         let path =
-            syn::parse2::<syn::Path>(quote::quote!(frame::xyz::frame_system::Config)).unwrap();
+            syn::parse2::<syn::Path>(quote::quote!(polkadot_sdk_frame::xyz::frame_system::Config))
+                .unwrap();
         assert!(!has_expected_system_config(path, &frame_system));
     }
 
     #[test]
     fn has_expected_system_config_does_not_work_with_frame_full_path_if_not_frame_crate() {
         let frame_system = syn::parse2::<syn::Path>(quote::quote!(frame_system)).unwrap();
-        let path =
-            syn::parse2::<syn::Path>(quote::quote!(frame::deps::frame_system::Config)).unwrap();
+        let path = syn::parse2::<syn::Path>(quote::quote!(
+            polkadot_sdk_frame::deps::frame_system::Config
+        ))
+        .unwrap();
         assert!(!has_expected_system_config(path, &frame_system));
     }
 
diff --git a/support/procedural-fork/src/pallet/parse/error.rs b/support/procedural-fork/src/pallet/parse/error.rs
index e93e2113f..7aab5732b 100644
--- a/support/procedural-fork/src/pallet/parse/error.rs
+++ b/support/procedural-fork/src/pallet/parse/error.rs
@@ -16,7 +16,6 @@
 // limitations under the License.
 
 use super::helper;
-use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
 use syn::{spanned::Spanned, Fields};
 
@@ -37,8 +36,6 @@ pub struct VariantDef {
     pub ident: syn::Ident,
     /// The variant field, if any.
     pub field: Option<VariantField>,
-    /// The variant doc literals.
-    pub docs: Vec<syn::Expr>,
     /// The `cfg` attributes.
     pub cfg_attrs: Vec<syn::Attribute>,
 }
@@ -112,7 +109,6 @@ impl ErrorDef {
                 Ok(VariantDef {
                     ident: variant.ident.clone(),
                     field: field_ty,
-                    docs: get_doc_literals(&variant.attrs),
                     cfg_attrs,
                 })
             })
diff --git a/support/procedural-fork/src/pallet/parse/extra_constants.rs b/support/procedural-fork/src/pallet/parse/extra_constants.rs
index 38acea21a..431fcf677 100644
--- a/support/procedural-fork/src/pallet/parse/extra_constants.rs
+++ b/support/procedural-fork/src/pallet/parse/extra_constants.rs
@@ -37,8 +37,6 @@ pub struct ExtraConstantsDef {
     pub where_clause: Option<syn::WhereClause>,
     /// A set of usage of instance, must be check for consistency with trait.
     pub instances: Vec<helper::InstanceUsage>,
-    /// The index of call item in pallet module.
-    pub index: usize,
     /// The extra constant defined.
     pub extra_constants: Vec<ExtraConstantDef>,
 }
@@ -79,7 +77,7 @@ impl syn::parse::Parse for ExtraConstAttr {
 }
 
 impl ExtraConstantsDef {
-    pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+    pub fn try_from(item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Impl(item) = item {
             item
         } else {
@@ -159,7 +157,6 @@ impl ExtraConstantsDef {
         }
 
         Ok(Self {
-            index,
             instances,
             where_clause: item.generics.where_clause.clone(),
             extra_constants,
diff --git a/support/procedural-fork/src/pallet/parse/genesis_build.rs b/support/procedural-fork/src/pallet/parse/genesis_build.rs
index 670d4d5ef..936c929af 100644
--- a/support/procedural-fork/src/pallet/parse/genesis_build.rs
+++ b/support/procedural-fork/src/pallet/parse/genesis_build.rs
@@ -20,8 +20,6 @@ use syn::spanned::Spanned;
 
 /// Definition for pallet genesis build implementation.
 pub struct GenesisBuildDef {
-    /// The index of item in pallet module.
-    pub index: usize,
     /// A set of usage of instance, must be check for consistency with trait.
     pub instances: Option<Vec<helper::InstanceUsage>>,
     /// The where_clause used.
@@ -31,11 +29,7 @@ pub struct GenesisBuildDef {
 }
 
 impl GenesisBuildDef {
-    pub fn try_from(
-        attr_span: proc_macro2::Span,
-        index: usize,
-        item: &mut syn::Item,
-    ) -> syn::Result<Self> {
+    pub fn try_from(attr_span: proc_macro2::Span, item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Impl(item) = item {
             item
         } else {
@@ -58,7 +52,6 @@ impl GenesisBuildDef {
 
         Ok(Self {
             attr_span,
-            index,
             instances,
             where_clause: item.generics.where_clause.clone(),
         })
diff --git a/support/procedural-fork/src/pallet/parse/helper.rs b/support/procedural-fork/src/pallet/parse/helper.rs
index f58c8d81c..1105046c2 100644
--- a/support/procedural-fork/src/pallet/parse/helper.rs
+++ b/support/procedural-fork/src/pallet/parse/helper.rs
@@ -55,23 +55,21 @@ pub(crate) fn take_first_item_pallet_attr<Attr>(
 where
     Attr: syn::parse::Parse,
 {
-    let attrs = if let Some(attrs) = item.mut_item_attrs() {
-        attrs
-    } else {
+    let Some(attrs) = item.mut_item_attrs() else {
         return Ok(None);
     };
 
-    if let Some(index) = attrs.iter().position(|attr| {
+    let Some(index) = attrs.iter().position(|attr| {
         attr.path()
             .segments
             .first()
             .map_or(false, |segment| segment.ident == "pallet")
-    }) {
-        let pallet_attr = attrs.remove(index);
-        Ok(Some(syn::parse2(pallet_attr.into_token_stream())?))
-    } else {
-        Ok(None)
-    }
+    }) else {
+        return Ok(None);
+    };
+
+    let pallet_attr = attrs.remove(index);
+    Ok(Some(syn::parse2(pallet_attr.into_token_stream())?))
 }
 
 /// Take all the pallet attributes (e.g. attribute like `#[pallet..]`) and decode them to `Attr`
diff --git a/support/procedural-fork/src/pallet/parse/hooks.rs b/support/procedural-fork/src/pallet/parse/hooks.rs
index 1cf5c72cc..bca1a3383 100644
--- a/support/procedural-fork/src/pallet/parse/hooks.rs
+++ b/support/procedural-fork/src/pallet/parse/hooks.rs
@@ -20,8 +20,6 @@ use syn::spanned::Spanned;
 
 /// Implementation of the pallet hooks.
 pub struct HooksDef {
-    /// The index of item in pallet.
-    pub index: usize,
     /// A set of usage of instance, must be check for consistency with trait.
     pub instances: Vec<helper::InstanceUsage>,
     /// The where_clause used.
@@ -33,11 +31,7 @@ pub struct HooksDef {
 }
 
 impl HooksDef {
-    pub fn try_from(
-        attr_span: proc_macro2::Span,
-        index: usize,
-        item: &mut syn::Item,
-    ) -> syn::Result<Self> {
+    pub fn try_from(attr_span: proc_macro2::Span, item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Impl(item) = item {
             item
         } else {
@@ -77,7 +71,6 @@ impl HooksDef {
 
         Ok(Self {
             attr_span,
-            index,
             instances,
             has_runtime_upgrade,
             where_clause: item.generics.where_clause.clone(),
diff --git a/support/procedural-fork/src/pallet/parse/inherent.rs b/support/procedural-fork/src/pallet/parse/inherent.rs
index 4eb04e914..911de2ffe 100644
--- a/support/procedural-fork/src/pallet/parse/inherent.rs
+++ b/support/procedural-fork/src/pallet/parse/inherent.rs
@@ -20,14 +20,12 @@ use syn::spanned::Spanned;
 
 /// The definition of the pallet inherent implementation.
 pub struct InherentDef {
-    /// The index of inherent item in pallet module.
-    pub index: usize,
     /// A set of usage of instance, must be check for consistency with trait.
     pub instances: Vec<helper::InstanceUsage>,
 }
 
 impl InherentDef {
-    pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+    pub fn try_from(item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Impl(item) = item {
             item
         } else {
@@ -55,6 +53,6 @@ impl InherentDef {
             helper::check_impl_gen(&item.generics, item.impl_token.span())?,
         ];
 
-        Ok(InherentDef { index, instances })
+        Ok(InherentDef { instances })
     }
 }
diff --git a/support/procedural-fork/src/pallet/parse/mod.rs b/support/procedural-fork/src/pallet/parse/mod.rs
index 57c252473..69f921733 100644
--- a/support/procedural-fork/src/pallet/parse/mod.rs
+++ b/support/procedural-fork/src/pallet/parse/mod.rs
@@ -109,10 +109,9 @@ impl Def {
             let pallet_attr: Option<PalletAttr> = helper::take_first_item_pallet_attr(item)?;
 
             match pallet_attr {
-				Some(PalletAttr::Config(span, with_default)) if config.is_none() =>
+				Some(PalletAttr::Config(_, with_default)) if config.is_none() =>
 					config = Some(config::ConfigDef::try_from(
 						&frame_system,
-						span,
 						index,
 						item,
 						with_default,
@@ -122,7 +121,7 @@ impl Def {
 					pallet_struct = Some(p);
 				},
 				Some(PalletAttr::Hooks(span)) if hooks.is_none() => {
-					let m = hooks::HooksDef::try_from(span, index, item)?;
+					let m = hooks::HooksDef::try_from(span, item)?;
 					hooks = Some(m);
 				},
 				Some(PalletAttr::RuntimeCall(cw, span)) if call.is_none() =>
@@ -162,27 +161,27 @@ impl Def {
 					genesis_config = Some(g);
 				},
 				Some(PalletAttr::GenesisBuild(span)) if genesis_build.is_none() => {
-					let g = genesis_build::GenesisBuildDef::try_from(span, index, item)?;
+					let g = genesis_build::GenesisBuildDef::try_from(span, item)?;
 					genesis_build = Some(g);
 				},
 				Some(PalletAttr::RuntimeOrigin(_)) if origin.is_none() =>
-					origin = Some(origin::OriginDef::try_from(index, item)?),
+					origin = Some(origin::OriginDef::try_from(item)?),
 				Some(PalletAttr::Inherent(_)) if inherent.is_none() =>
-					inherent = Some(inherent::InherentDef::try_from(index, item)?),
+					inherent = Some(inherent::InherentDef::try_from(item)?),
 				Some(PalletAttr::Storage(span)) =>
 					storages.push(storage::StorageDef::try_from(span, index, item, dev_mode)?),
 				Some(PalletAttr::ValidateUnsigned(_)) if validate_unsigned.is_none() => {
-					let v = validate_unsigned::ValidateUnsignedDef::try_from(index, item)?;
+					let v = validate_unsigned::ValidateUnsignedDef::try_from(item)?;
 					validate_unsigned = Some(v);
 				},
 				Some(PalletAttr::TypeValue(span)) =>
 					type_values.push(type_value::TypeValueDef::try_from(span, index, item)?),
 				Some(PalletAttr::ExtraConstants(_)) =>
 					extra_constants =
-						Some(extra_constants::ExtraConstantsDef::try_from(index, item)?),
+						Some(extra_constants::ExtraConstantsDef::try_from(item)?),
 				Some(PalletAttr::Composite(span)) => {
 					let composite =
-						composite::CompositeDef::try_from(span, index, &frame_support, item)?;
+						composite::CompositeDef::try_from(span, &frame_support, item)?;
 					if composites.iter().any(|def| {
 						match (&def.composite_keyword, &composite.composite_keyword) {
 							(
@@ -777,7 +776,6 @@ impl syn::parse::Parse for PalletAttr {
 #[derive(Clone)]
 pub struct InheritedCallWeightAttr {
     pub typename: syn::Type,
-    pub span: proc_macro2::Span,
 }
 
 impl syn::parse::Parse for InheritedCallWeightAttr {
@@ -801,7 +799,6 @@ impl syn::parse::Parse for InheritedCallWeightAttr {
 
         Ok(Self {
             typename: buffer.parse()?,
-            span: input.span(),
         })
     }
 }
diff --git a/support/procedural-fork/src/pallet/parse/origin.rs b/support/procedural-fork/src/pallet/parse/origin.rs
index 2dd84c40d..8232719d6 100644
--- a/support/procedural-fork/src/pallet/parse/origin.rs
+++ b/support/procedural-fork/src/pallet/parse/origin.rs
@@ -25,16 +25,13 @@ use syn::spanned::Spanned;
 /// * `struct Origin`
 /// * `enum Origin`
 pub struct OriginDef {
-    /// The index of item in pallet module.
-    pub index: usize,
-    pub has_instance: bool,
     pub is_generic: bool,
     /// A set of usage of instance, must be check for consistency with trait.
     pub instances: Vec<helper::InstanceUsage>,
 }
 
 impl OriginDef {
-    pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+    pub fn try_from(item: &mut syn::Item) -> syn::Result<Self> {
         let item_span = item.span();
         let (vis, ident, generics) = match &item {
             syn::Item::Enum(item) => (&item.vis, &item.ident, &item.generics),
@@ -46,7 +43,6 @@ impl OriginDef {
             }
         };
 
-        let has_instance = generics.params.len() == 2;
         let is_generic = !generics.params.is_empty();
 
         let mut instances = vec![];
@@ -71,8 +67,6 @@ impl OriginDef {
         }
 
         Ok(OriginDef {
-            index,
-            has_instance,
             is_generic,
             instances,
         })
diff --git a/support/procedural-fork/src/pallet/parse/storage.rs b/support/procedural-fork/src/pallet/parse/storage.rs
index 64a5e685b..811832427 100644
--- a/support/procedural-fork/src/pallet/parse/storage.rs
+++ b/support/procedural-fork/src/pallet/parse/storage.rs
@@ -718,11 +718,11 @@ fn process_generics(
         "CountedStorageNMap" => StorageKind::CountedNMap,
         found => {
             let msg = format!(
-                "Invalid pallet::storage, expected ident: `StorageValue` or \
+				"Invalid pallet::storage, expected ident: `StorageValue` or \
 				`StorageMap` or `CountedStorageMap` or `StorageDoubleMap` or `StorageNMap` or `CountedStorageNMap` \
 				in order to expand metadata, found `{}`.",
-                found,
-            );
+				found,
+			);
             return Err(syn::Error::new(segment.ident.span(), msg));
         }
     };
diff --git a/support/procedural-fork/src/pallet/parse/tasks.rs b/support/procedural-fork/src/pallet/parse/tasks.rs
index 50633fbd0..2a8d14826 100644
--- a/support/procedural-fork/src/pallet/parse/tasks.rs
+++ b/support/procedural-fork/src/pallet/parse/tasks.rs
@@ -34,8 +34,8 @@ use syn::{
     parse2,
     spanned::Spanned,
     token::{Bracket, Paren, PathSep, Pound},
-    Attribute, Error, Expr, Ident, ImplItem, ImplItemFn, ItemEnum, ItemImpl, LitInt, Path,
-    PathArguments, Result, TypePath,
+    Error, Expr, Ident, ImplItem, ImplItemFn, ItemEnum, ItemImpl, LitInt, Path, PathArguments,
+    Result, TypePath,
 };
 
 pub mod keywords {
@@ -192,7 +192,6 @@ pub struct TaskDef {
     pub condition_attr: TaskConditionAttr,
     pub list_attr: TaskListAttr,
     pub weight_attr: TaskWeightAttr,
-    pub normal_attrs: Vec<Attribute>,
     pub item: ImplItemFn,
     pub arg_names: Vec<Ident>,
 }
@@ -202,7 +201,7 @@ impl syn::parse::Parse for TaskDef {
         let item = input.parse::<ImplItemFn>()?;
         // we only want to activate TaskAttrType parsing errors for tasks-related attributes,
         // so we filter them here
-        let (task_attrs, normal_attrs) = partition_task_attrs(&item);
+        let task_attrs = partition_task_attrs(&item).0;
 
         let task_attrs: Vec<TaskAttr> = task_attrs
             .into_iter()
@@ -319,7 +318,6 @@ impl syn::parse::Parse for TaskDef {
             condition_attr,
             list_attr,
             weight_attr,
-            normal_attrs,
             item,
             arg_names,
         })
diff --git a/support/procedural-fork/src/pallet/parse/tests/tasks.rs b/support/procedural-fork/src/pallet/parse/tests/tasks.rs
index 6cd4d13bb..0097ed047 100644
--- a/support/procedural-fork/src/pallet/parse/tests/tasks.rs
+++ b/support/procedural-fork/src/pallet/parse/tests/tasks.rs
@@ -124,10 +124,10 @@ fn test_parse_pallet_manual_tasks_impl_without_manual_tasks_enum() {
             where
                 T: TypeInfo,
             {
-                type Enumeration = sp_std::vec::IntoIter<Task<T>>;
+                type Enumeration = alloc::vec::IntoIter<Task<T>>;
 
                 fn iter() -> Self::Enumeration {
-                    sp_std::vec![Task::increment, Task::decrement].into_iter()
+                    alloc::vec![Task::increment, Task::decrement].into_iter()
                 }
             }
 
diff --git a/support/procedural-fork/src/pallet/parse/type_value.rs b/support/procedural-fork/src/pallet/parse/type_value.rs
index d5c85248f..1054fd74c 100644
--- a/support/procedural-fork/src/pallet/parse/type_value.rs
+++ b/support/procedural-fork/src/pallet/parse/type_value.rs
@@ -28,12 +28,8 @@ pub struct TypeValueDef {
     pub ident: syn::Ident,
     /// The type return by Get.
     pub type_: Box<syn::Type>,
-    /// The block returning the value to get
-    pub block: Box<syn::Block>,
     /// If type value is generic over `T` (or `T` and `I` for instantiable pallet)
     pub is_generic: bool,
-    /// A set of usage of instance, must be check for consistency with config.
-    pub instances: Vec<helper::InstanceUsage>,
     /// The where clause of the function.
     pub where_clause: Option<syn::WhereClause>,
     /// The span of the pallet::type_value attribute.
@@ -90,7 +86,6 @@ impl TypeValueDef {
 
         let vis = item.vis.clone();
         let ident = item.sig.ident.clone();
-        let block = item.block.clone();
         let type_ = match item.sig.output.clone() {
             syn::ReturnType::Type(_, type_) => type_,
             syn::ReturnType::Default => {
@@ -99,10 +94,7 @@ impl TypeValueDef {
             }
         };
 
-        let mut instances = vec![];
-        if let Some(usage) = helper::check_type_value_gen(&item.sig.generics, item.sig.span())? {
-            instances.push(usage);
-        }
+        helper::check_type_value_gen(&item.sig.generics, item.sig.span())?;
 
         let is_generic = item.sig.generics.type_params().count() > 0;
         let where_clause = item.sig.generics.where_clause.clone();
@@ -113,9 +105,7 @@ impl TypeValueDef {
             is_generic,
             vis,
             ident,
-            block,
             type_,
-            instances,
             where_clause,
             docs,
         })
diff --git a/support/procedural-fork/src/pallet/parse/validate_unsigned.rs b/support/procedural-fork/src/pallet/parse/validate_unsigned.rs
index 6e5109a74..3fcbe09e8 100644
--- a/support/procedural-fork/src/pallet/parse/validate_unsigned.rs
+++ b/support/procedural-fork/src/pallet/parse/validate_unsigned.rs
@@ -19,15 +19,10 @@ use super::helper;
 use syn::spanned::Spanned;
 
 /// The definition of the pallet validate unsigned implementation.
-pub struct ValidateUnsignedDef {
-    /// The index of validate unsigned item in pallet module.
-    pub index: usize,
-    /// A set of usage of instance, must be check for consistency with config.
-    pub instances: Vec<helper::InstanceUsage>,
-}
+pub struct ValidateUnsignedDef {}
 
 impl ValidateUnsignedDef {
-    pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+    pub fn try_from(item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Impl(item) = item {
             item
         } else {
@@ -52,11 +47,9 @@ impl ValidateUnsignedDef {
             return Err(syn::Error::new(item.span(), msg));
         }
 
-        let instances = vec![
-            helper::check_pallet_struct_usage(&item.self_ty)?,
-            helper::check_impl_gen(&item.generics, item.impl_token.span())?,
-        ];
+        helper::check_pallet_struct_usage(&item.self_ty)?;
+        helper::check_impl_gen(&item.generics, item.impl_token.span())?;
 
-        Ok(ValidateUnsignedDef { index, instances })
+        Ok(ValidateUnsignedDef {})
     }
 }
diff --git a/support/procedural-fork/src/runtime/expand/mod.rs b/support/procedural-fork/src/runtime/expand/mod.rs
index c26cbccb7..a1a6d4d07 100644
--- a/support/procedural-fork/src/runtime/expand/mod.rs
+++ b/support/procedural-fork/src/runtime/expand/mod.rs
@@ -97,23 +97,26 @@ fn construct_runtime_implicit_to_explicit(
         quote!()
     };
     let mut expansion = quote::quote!(
-        #[frame_support::runtime #attr]
+        #[#frame_support::runtime #attr]
         #input
     );
     for pallet in definition.pallet_decls.iter() {
         let pallet_path = &pallet.path;
         let pallet_name = &pallet.name;
-        let pallet_instance = pallet
-            .instance
-            .as_ref()
-            .map(|instance| quote::quote!(<#instance>));
+        let runtime_param = &pallet.runtime_param;
+        let pallet_segment_and_instance = match (&pallet.pallet_segment, &pallet.instance) {
+            (Some(segment), Some(instance)) => quote::quote!(::#segment<#runtime_param, #instance>),
+            (Some(segment), None) => quote::quote!(::#segment<#runtime_param>),
+            (None, Some(instance)) => quote::quote!(<#instance>),
+            (None, None) => quote::quote!(),
+        };
         expansion = quote::quote!(
             #frame_support::__private::tt_call! {
                 macro = [{ #pallet_path::tt_default_parts_v2 }]
-                frame_support = [{ #frame_support }]
+                your_tt_return = [{ #frame_support::__private::tt_return }]
                 ~~> #frame_support::match_and_insert! {
                     target = [{ #expansion }]
-                    pattern = [{ #pallet_name = #pallet_path #pallet_instance  }]
+                    pattern = [{ #pallet_name = #pallet_path #pallet_segment_and_instance }]
                 }
             }
         );
@@ -264,7 +267,7 @@ fn construct_runtime_final_expansion(
         // Prevent UncheckedExtrinsic to print unused warning.
         const _: () = {
             #[allow(unused)]
-            type __hidden_use_of_unchecked_extrinsic = #unchecked_extrinsic;
+            type __HiddenUseOfUncheckedExtrinsic = #unchecked_extrinsic;
         };
 
         #[derive(
@@ -294,7 +297,7 @@ fn construct_runtime_final_expansion(
         #[doc(hidden)]
         trait InternalConstructRuntime {
             #[inline(always)]
-            fn runtime_metadata(&self) -> #scrate::__private::sp_std::vec::Vec<#scrate::__private::metadata_ir::RuntimeApiMetadataIR> {
+            fn runtime_metadata(&self) -> #scrate::__private::Vec<#scrate::__private::metadata_ir::RuntimeApiMetadataIR> {
                 Default::default()
             }
         }
diff --git a/support/procedural-fork/src/runtime/mod.rs b/support/procedural-fork/src/runtime/mod.rs
index 589acff6c..a96b21cd1 100644
--- a/support/procedural-fork/src/runtime/mod.rs
+++ b/support/procedural-fork/src/runtime/mod.rs
@@ -200,8 +200,6 @@
 //!     +----------------------+
 //! ```
 
-#![cfg(feature = "experimental")]
-
 pub use parse::Def;
 use proc_macro::TokenStream;
 use syn::spanned::Spanned;
diff --git a/support/procedural-fork/src/runtime/parse/mod.rs b/support/procedural-fork/src/runtime/parse/mod.rs
index 79cf894e8..a6a49e814 100644
--- a/support/procedural-fork/src/runtime/parse/mod.rs
+++ b/support/procedural-fork/src/runtime/parse/mod.rs
@@ -118,7 +118,6 @@ pub enum AllPalletsDeclaration {
 /// Declaration of a runtime with some pallet with implicit declaration of parts.
 #[derive(Debug, Clone)]
 pub struct ImplicitAllPalletsDeclaration {
-    pub name: Ident,
     pub pallet_decls: Vec<PalletDeclaration>,
     pub pallet_count: usize,
 }
@@ -132,7 +131,6 @@ pub struct ExplicitAllPalletsDeclaration {
 
 pub struct Def {
     pub input: TokenStream2,
-    pub item: syn::ItemMod,
     pub runtime_struct: runtime_struct::RuntimeStructDef,
     pub pallets: AllPalletsDeclaration,
     pub runtime_types: Vec<RuntimeType>,
@@ -161,8 +159,7 @@ impl Def {
         let mut pallets = vec![];
 
         for item in items.iter_mut() {
-            let mut pallet_item = None;
-            let mut pallet_index = 0;
+            let mut pallet_index_and_item = None;
 
             let mut disable_call = false;
             let mut disable_unsigned = false;
@@ -171,17 +168,16 @@ impl Def {
                 helper::take_first_item_runtime_attr::<RuntimeAttr>(item)?
             {
                 match runtime_attr {
-                    RuntimeAttr::Runtime(span) if runtime_struct.is_none() => {
-                        let p = runtime_struct::RuntimeStructDef::try_from(span, item)?;
+                    RuntimeAttr::Runtime(_) if runtime_struct.is_none() => {
+                        let p = runtime_struct::RuntimeStructDef::try_from(item)?;
                         runtime_struct = Some(p);
                     }
                     RuntimeAttr::Derive(_, types) if runtime_types.is_none() => {
                         runtime_types = Some(types);
                     }
                     RuntimeAttr::PalletIndex(span, index) => {
-                        pallet_index = index;
-                        pallet_item = if let syn::Item::Type(item) = item {
-                            Some(item.clone())
+                        pallet_index_and_item = if let syn::Item::Type(item) = item {
+                            Some((index, item.clone()))
                         } else {
                             let msg = "Invalid runtime::pallet_index, expected type definition";
                             return Err(syn::Error::new(span, msg));
@@ -196,11 +192,11 @@ impl Def {
                 }
             }
 
-            if let Some(pallet_item) = pallet_item {
+            if let Some((pallet_index, pallet_item)) = pallet_index_and_item {
                 match *pallet_item.ty.clone() {
                     syn::Type::Path(ref path) => {
                         let pallet_decl =
-                            PalletDeclaration::try_from(item.span(), &pallet_item, path)?;
+                            PalletDeclaration::try_from(item.span(), &pallet_item, &path.path)?;
 
                         if let Some(used_pallet) =
                             names.insert(pallet_decl.name.clone(), pallet_decl.name.span())
@@ -239,6 +235,11 @@ impl Def {
                     }
                     _ => continue,
                 }
+            } else {
+                if let syn::Item::Type(item) = item {
+                    let msg = "Missing pallet index for pallet declaration. Please add `#[runtime::pallet_index(...)]`";
+                    return Err(syn::Error::new(item.span(), &msg));
+                }
             }
         }
 
@@ -246,7 +247,6 @@ impl Def {
         let decl_count = pallet_decls.len();
         let pallets = if decl_count > 0 {
             AllPalletsDeclaration::Implicit(ImplicitAllPalletsDeclaration {
-                name,
                 pallet_decls,
                 pallet_count: decl_count.saturating_add(pallets.len()),
             })
@@ -255,21 +255,41 @@ impl Def {
         };
 
         let def = Def {
-            input,
-            item,
-            runtime_struct: runtime_struct.ok_or_else(|| {
-                syn::Error::new(item_span,
+			input,
+			runtime_struct: runtime_struct.ok_or_else(|| {
+				syn::Error::new(item_span,
 					"Missing Runtime. Please add a struct inside the module and annotate it with `#[runtime::runtime]`"
 				)
-            })?,
-            pallets,
-            runtime_types: runtime_types.ok_or_else(|| {
-                syn::Error::new(item_span,
+			})?,
+			pallets,
+			runtime_types: runtime_types.ok_or_else(|| {
+				syn::Error::new(item_span,
 					"Missing Runtime Types. Please annotate the runtime struct with `#[runtime::derive]`"
 				)
-            })?,
-        };
+			})?,
+		};
 
         Ok(def)
     }
 }
+
+#[test]
+fn runtime_parsing_works() {
+    let def = Def::try_from(syn::parse_quote! {
+        #[runtime::runtime]
+        mod runtime {
+            #[runtime::derive(RuntimeCall, RuntimeEvent)]
+            #[runtime::runtime]
+            pub struct Runtime;
+
+            #[runtime::pallet_index(0)]
+            pub type System = frame_system::Pallet<Runtime>;
+
+            #[runtime::pallet_index(1)]
+            pub type Pallet1 = pallet1<Instance1>;
+        }
+    })
+    .expect("Failed to parse runtime definition");
+
+    assert_eq!(def.runtime_struct.ident, "Runtime");
+}
diff --git a/support/procedural-fork/src/runtime/parse/pallet.rs b/support/procedural-fork/src/runtime/parse/pallet.rs
index 039e2631b..591c05930 100644
--- a/support/procedural-fork/src/runtime/parse/pallet.rs
+++ b/support/procedural-fork/src/runtime/parse/pallet.rs
@@ -15,9 +15,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::construct_runtime::parse::{Pallet, PalletPart, PalletPartKeyword, PalletPath};
+use crate::{
+    construct_runtime::parse::{Pallet, PalletPart, PalletPartKeyword, PalletPath},
+    runtime::parse::PalletDeclaration,
+};
+use frame_support_procedural_tools::get_doc_literals;
 use quote::ToTokens;
-use syn::{punctuated::Punctuated, spanned::Spanned, token, Error, Ident, PathArguments};
+use syn::{punctuated::Punctuated, token, Error};
 
 impl Pallet {
     pub fn try_from(
@@ -56,26 +60,13 @@ impl Pallet {
             "Invalid pallet declaration, expected a path or a trait object",
         ))?;
 
-        let mut instance = None;
-        if let Some(segment) = path
-            .inner
-            .segments
-            .iter_mut()
-            .find(|seg| !seg.arguments.is_empty())
-        {
-            if let PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
-                args, ..
-            }) = segment.arguments.clone()
-            {
-                if let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) = args.first() {
-                    instance = Some(Ident::new(
-                        &arg_path.to_token_stream().to_string(),
-                        arg_path.span(),
-                    ));
-                    segment.arguments = PathArguments::None;
-                }
-            }
-        }
+        let PalletDeclaration {
+            path: inner,
+            instance,
+            ..
+        } = PalletDeclaration::try_from(attr_span, item, &path.inner)?;
+
+        path = PalletPath { inner };
 
         pallet_parts = pallet_parts
             .into_iter()
@@ -94,6 +85,8 @@ impl Pallet {
 
         let cfg_pattern = vec![];
 
+        let docs = get_doc_literals(&item.attrs);
+
         Ok(Pallet {
             is_expanded: true,
             name,
@@ -102,6 +95,123 @@ impl Pallet {
             instance,
             cfg_pattern,
             pallet_parts,
+            docs,
         })
     }
 }
+
+#[test]
+fn pallet_parsing_works() {
+    use syn::{parse_quote, ItemType};
+
+    let item: ItemType = parse_quote! {
+        pub type System = frame_system + Call;
+    };
+    let ItemType { ty, .. } = item.clone();
+    let syn::Type::TraitObject(syn::TypeTraitObject { bounds, .. }) = *ty else {
+        panic!("Expected a trait object");
+    };
+
+    let index = 0;
+    let pallet = Pallet::try_from(
+        proc_macro2::Span::call_site(),
+        &item,
+        index,
+        false,
+        false,
+        &bounds,
+    )
+    .unwrap();
+
+    assert_eq!(pallet.name.to_string(), "System");
+    assert_eq!(pallet.index, index);
+    assert_eq!(pallet.path.to_token_stream().to_string(), "frame_system");
+    assert_eq!(pallet.instance, None);
+}
+
+#[test]
+fn pallet_parsing_works_with_instance() {
+    use syn::{parse_quote, ItemType};
+
+    let item: ItemType = parse_quote! {
+        pub type System = frame_system<Instance1> + Call;
+    };
+    let ItemType { ty, .. } = item.clone();
+    let syn::Type::TraitObject(syn::TypeTraitObject { bounds, .. }) = *ty else {
+        panic!("Expected a trait object");
+    };
+
+    let index = 0;
+    let pallet = Pallet::try_from(
+        proc_macro2::Span::call_site(),
+        &item,
+        index,
+        false,
+        false,
+        &bounds,
+    )
+    .unwrap();
+
+    assert_eq!(pallet.name.to_string(), "System");
+    assert_eq!(pallet.index, index);
+    assert_eq!(pallet.path.to_token_stream().to_string(), "frame_system");
+    assert_eq!(pallet.instance, Some(parse_quote! { Instance1 }));
+}
+
+#[test]
+fn pallet_parsing_works_with_pallet() {
+    use syn::{parse_quote, ItemType};
+
+    let item: ItemType = parse_quote! {
+        pub type System = frame_system::Pallet<Runtime> + Call;
+    };
+    let ItemType { ty, .. } = item.clone();
+    let syn::Type::TraitObject(syn::TypeTraitObject { bounds, .. }) = *ty else {
+        panic!("Expected a trait object");
+    };
+
+    let index = 0;
+    let pallet = Pallet::try_from(
+        proc_macro2::Span::call_site(),
+        &item,
+        index,
+        false,
+        false,
+        &bounds,
+    )
+    .unwrap();
+
+    assert_eq!(pallet.name.to_string(), "System");
+    assert_eq!(pallet.index, index);
+    assert_eq!(pallet.path.to_token_stream().to_string(), "frame_system");
+    assert_eq!(pallet.instance, None);
+}
+
+#[test]
+fn pallet_parsing_works_with_instance_and_pallet() {
+    use syn::{parse_quote, ItemType};
+
+    let item: ItemType = parse_quote! {
+        pub type System = frame_system::Pallet<Runtime, Instance1> + Call;
+    };
+    let ItemType { ty, .. } = item.clone();
+    let syn::Type::TraitObject(syn::TypeTraitObject { bounds, .. }) = *ty else {
+        panic!("Expected a trait object");
+    };
+
+    let index = 0;
+    let pallet = Pallet::try_from(
+        proc_macro2::Span::call_site(),
+        &item,
+        index,
+        false,
+        false,
+        &bounds,
+    )
+    .unwrap();
+
+    assert_eq!(pallet.name.to_string(), "System");
+    assert_eq!(pallet.index, index);
+    assert_eq!(pallet.path.to_token_stream().to_string(), "frame_system");
+    assert_eq!(pallet.instance, Some(parse_quote! { Instance1 }));
+}
diff --git a/support/procedural-fork/src/runtime/parse/pallet_decl.rs b/support/procedural-fork/src/runtime/parse/pallet_decl.rs
index bb1246606..fab826eee 100644
--- a/support/procedural-fork/src/runtime/parse/pallet_decl.rs
+++ b/support/procedural-fork/src/runtime/parse/pallet_decl.rs
@@ -15,19 +15,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use quote::ToTokens;
-use syn::{spanned::Spanned, Attribute, Ident, PathArguments};
+use syn::{Ident, PathArguments};
 
 /// The declaration of a pallet.
 #[derive(Debug, Clone)]
 pub struct PalletDeclaration {
-    /// The name of the pallet, e.g.`System` in `System: frame_system`.
+    /// The name of the pallet, e.g.`System` in `pub type System = frame_system`.
     pub name: Ident,
-    /// Optional attributes tagged right above a pallet declaration.
-    pub attrs: Vec<Attribute>,
-    /// The path of the pallet, e.g. `frame_system` in `System: frame_system`.
+    /// The path of the pallet, e.g. `frame_system` in `pub type System = frame_system`.
     pub path: syn::Path,
-    /// The instance of the pallet, e.g. `Instance1` in `Council: pallet_collective::<Instance1>`.
+    /// The segment of the pallet, e.g. `Pallet` in `pub type System = frame_system::Pallet`.
+    pub pallet_segment: Option<syn::PathSegment>,
+    /// The runtime parameter of the pallet, e.g. `Runtime` in
+    /// `pub type System = frame_system::Pallet<Runtime>`.
+    pub runtime_param: Option<Ident>,
+    /// The instance of the pallet, e.g. `Instance1` in `pub type Council =
+    /// pallet_collective<Instance1>`.
     pub instance: Option<Ident>,
 }
 
@@ -35,12 +38,14 @@ impl PalletDeclaration {
     pub fn try_from(
         _attr_span: proc_macro2::Span,
         item: &syn::ItemType,
-        path: &syn::TypePath,
+        path: &syn::Path,
     ) -> syn::Result<Self> {
         let name = item.ident.clone();
 
-        let mut path = path.path.clone();
+        let mut path = path.clone();
 
+        let mut pallet_segment = None;
+        let mut runtime_param = None;
         let mut instance = None;
         if let Some(segment) = path
             .segments
@@ -51,21 +56,131 @@ impl PalletDeclaration {
                 args, ..
             }) = segment.arguments.clone()
             {
-                if let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) = args.first() {
-                    instance = Some(Ident::new(
-                        &arg_path.to_token_stream().to_string(),
-                        arg_path.span(),
-                    ));
+                if segment.ident == "Pallet" {
+                    let mut segment = segment.clone();
                     segment.arguments = PathArguments::None;
+                    pallet_segment = Some(segment.clone());
+                }
+                let mut args_iter = args.iter();
+                if let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) =
+                    args_iter.next()
+                {
+                    let ident = arg_path.path.require_ident()?.clone();
+                    if segment.ident == "Pallet" {
+                        runtime_param = Some(ident);
+                        if let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) =
+                            args_iter.next()
+                        {
+                            instance = Some(arg_path.path.require_ident()?.clone());
+                        }
+                    } else {
+                        instance = Some(ident);
+                        segment.arguments = PathArguments::None;
+                    }
                 }
             }
         }
 
+        if pallet_segment.is_some() {
+            path = syn::Path {
+                leading_colon: None,
+                segments: path
+                    .segments
+                    .iter()
+                    .filter(|seg| seg.arguments.is_empty())
+                    .cloned()
+                    .collect(),
+            };
+        }
+
         Ok(Self {
             name,
             path,
+            pallet_segment,
+            runtime_param,
             instance,
-            attrs: item.attrs.clone(),
         })
     }
 }
+
+#[test]
+fn declaration_works() {
+    use syn::parse_quote;
+
+    let decl: PalletDeclaration = PalletDeclaration::try_from(
+        proc_macro2::Span::call_site(),
+        &parse_quote! { pub type System = frame_system; },
+        &parse_quote! { frame_system },
+    )
+    .expect("Failed to parse pallet declaration");
+
+    assert_eq!(decl.name, "System");
+    assert_eq!(decl.path, parse_quote! { frame_system });
+    assert_eq!(decl.pallet_segment, None);
+    assert_eq!(decl.runtime_param, None);
+    assert_eq!(decl.instance, None);
+}
+
+#[test]
+fn declaration_works_with_instance() {
+    use syn::parse_quote;
+
+    let decl: PalletDeclaration = PalletDeclaration::try_from(
+        proc_macro2::Span::call_site(),
+        &parse_quote! { pub type System = frame_system<Instance1>; },
+        &parse_quote! { frame_system<Instance1> },
+    )
+    .expect("Failed to parse pallet declaration");
+
+    assert_eq!(decl.name, "System");
+    assert_eq!(decl.path, parse_quote! { frame_system });
+    assert_eq!(decl.pallet_segment, None);
+    assert_eq!(decl.runtime_param, None);
+    assert_eq!(decl.instance, Some(parse_quote! { Instance1 }));
+}
+
+#[test]
+fn declaration_works_with_pallet() {
+    use syn::parse_quote;
+
+    let decl: PalletDeclaration = PalletDeclaration::try_from(
+        proc_macro2::Span::call_site(),
+        &parse_quote! { pub type System = frame_system::Pallet<Runtime>; },
+        &parse_quote! { frame_system::Pallet<Runtime> },
+    )
+    .expect("Failed to parse pallet declaration");
+
+    assert_eq!(decl.name, "System");
+    assert_eq!(decl.path, parse_quote! { frame_system });
+
+    let segment: syn::PathSegment = syn::PathSegment {
+        ident: parse_quote! { Pallet },
+        arguments: PathArguments::None,
+    };
+    assert_eq!(decl.pallet_segment, Some(segment));
+    assert_eq!(decl.runtime_param, Some(parse_quote! { Runtime }));
+    assert_eq!(decl.instance, None);
+}
+
+#[test]
+fn declaration_works_with_pallet_and_instance() {
+    use syn::parse_quote;
+
+    let decl: PalletDeclaration = PalletDeclaration::try_from(
+        proc_macro2::Span::call_site(),
+        &parse_quote! { pub type System = frame_system::Pallet<Runtime, Instance1>; },
+        &parse_quote! { frame_system::Pallet<Runtime, Instance1> },
+    )
+    .expect("Failed to parse pallet declaration");
+
+    assert_eq!(decl.name, "System");
+    assert_eq!(decl.path, parse_quote! { frame_system });
+
+    let segment: syn::PathSegment = syn::PathSegment {
+        ident: parse_quote! { Pallet },
+        arguments: PathArguments::None,
+    };
+    assert_eq!(decl.pallet_segment, Some(segment));
+    assert_eq!(decl.runtime_param, Some(parse_quote! { Runtime }));
+    assert_eq!(decl.instance, Some(parse_quote! { Instance1 }));
+}
diff --git a/support/procedural-fork/src/runtime/parse/runtime_struct.rs b/support/procedural-fork/src/runtime/parse/runtime_struct.rs
index 7ddbdcfeb..82c6470d7 100644
--- a/support/procedural-fork/src/runtime/parse/runtime_struct.rs
+++ b/support/procedural-fork/src/runtime/parse/runtime_struct.rs
@@ -18,11 +18,10 @@
 use syn::spanned::Spanned;
 pub struct RuntimeStructDef {
     pub ident: syn::Ident,
-    pub attr_span: proc_macro2::Span,
 }
 
 impl RuntimeStructDef {
-    pub fn try_from(attr_span: proc_macro2::Span, item: &mut syn::Item) -> syn::Result<Self> {
+    pub fn try_from(item: &mut syn::Item) -> syn::Result<Self> {
         let item = if let syn::Item::Struct(item) = item {
             item
         } else {
@@ -32,7 +31,6 @@ impl RuntimeStructDef {
 
         Ok(Self {
             ident: item.ident.clone(),
-            attr_span,
         })
     }
 }