Timestamp Inherent

Cargo.toml

@@ -12,13 +12,15 @@ members = [
 	"wardrobe/amoeba",
 	"wardrobe/money",
 	"wardrobe/poe",
+	"wardrobe/timestamp",
 	"wardrobe/kitties",
 	"wardrobe/runtime_upgrade",
 ]
 resolver = "2"
 
 [workspace.dependencies]
 # Generic dependencies
+async-trait = "0.1.73"
 clap = "4.3.0"
 hex-literal = "0.4.1"
 jsonrpsee = "0.16.2"

node/Cargo.toml

@@ -45,6 +45,7 @@ sp-blockchain = { workspace = true }
 
 # Local Dependencies
 node-template-runtime = { package = "tuxedo-template-runtime", path = "../tuxedo-template-runtime" }
+tuxedo-core = { path = "../tuxedo-core" }
 
 [[bin]]
 name = "node-template"

node/src/service.rs

@@ -234,6 +234,7 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
         );
 
         let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
+        let client_for_cidp = client.clone();
 
         let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _, _>(
             StartAuraParams {
@@ -242,16 +243,27 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
                 select_chain,
                 block_import,
                 proposer_factory,
-                create_inherent_data_providers: move |_, ()| async move {
-                    let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
-
-                    let slot =
-						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
-							*timestamp,
-							slot_duration,
-						);
-
-                    Ok((slot, timestamp))
+                create_inherent_data_providers: move |parent_hash, ()| {
+                    let parent_block = client_for_cidp
+                        .clone()
+                        .block(parent_hash)
+                        .expect("a")
+                        .expect("b")
+                        .block;
+
+                    async move {
+                        let parent_idp =
+                            tuxedo_core::inherents::ParentBlockInherentDataProvider(parent_block);
+                        let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+
+                        let slot =
+                            sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
+                                *timestamp,
+                                slot_duration,
+                            );
+
+                        Ok((slot, parent_idp, timestamp))
+                    }
                 },
                 force_authoring,
                 backoff_authoring_blocks,

tuxedo-core/Cargo.toml

@@ -7,6 +7,7 @@ repository = "https://github.com/Off-Narrative-Labs/Tuxedo"
 version = "1.0.0-dev"
 
 [dependencies]
+async-trait = { optional = true, workspace = true }
 log = { workspace = true }
 parity-scale-codec = { features = [ "derive" ], workspace = true }
 parity-util-mem = { optional = true, workspace = true }
@@ -19,6 +20,7 @@ derive-no-bound = { path = "no_bound" }
 sp-api = { default_features = false, workspace = true }
 sp-core = { default_features = false, workspace = true }
 sp-debug-derive = { features = [ "force-debug" ], default_features = false, workspace = true }
+sp-inherents = { default_features = false, workspace = true }
 sp-io = { features = [ "with-tracing" ], default_features = false, workspace = true }
 sp-runtime = { default_features = false, workspace = true }
 sp-std = { default_features = false, workspace = true }
@@ -30,12 +32,14 @@ array-bytes = { workspace = true }
 [features]
 default = [ "std" ]
 std = [
+	"async-trait",
 	"sp-debug-derive/std",
 	"parity-scale-codec/std",
 	"sp-core/std",
 	"sp-std/std",
 	"serde",
 	"sp-api/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-runtime/std",
 	"parity-util-mem",

tuxedo-core/aggregator/src/lib.rs

@@ -32,20 +32,35 @@ pub fn aggregate(_: TokenStream, body: TokenStream) -> TokenStream {
         )
     });
     let variants = variant_type_pairs.clone().map(|(v, _t)| v);
+    let variants2 = variants.clone();
     let inner_types = variant_type_pairs.map(|(_v, t)| t);
+    let inner_types2 = inner_types.clone();
 
     let output = quote! {
         // First keep the original code in tact
         #original_code
 
-        // Now write all the From impls
+        // Now write all the wrapping From impls
         #(
             impl From<#inner_types> for #outer_type {
                 fn from(b: #inner_types) -> Self {
                     Self::#variants(b)
                 }
             }
         )*
+
+        // Finally write all the un-wrapping From impls
+        #(
+            impl From<#outer_type> for #inner_types2 {
+                fn from(a: #outer_type) -> Self {
+                    if let #outer_type::#variants2(b) = a {
+                        b
+                    } else {
+                        panic!("wrong type or something...")
+                    }
+                }
+            }
+        )*
     };
 
     output.into()
@@ -115,12 +130,28 @@ pub fn tuxedo_constraint_checker(attrs: TokenStream, body: TokenStream) -> Token
     let variants = variant_type_pairs.clone().map(|(v, _t)| v);
     let inner_types = variant_type_pairs.map(|(_v, t)| t);
 
-    let vis = ast.vis;
+    // Set up the names of the new associated types.
     let mut error_type_name = outer_type.to_string();
     error_type_name.push_str("Error");
     let error_type = Ident::new(&error_type_name, outer_type.span());
-    let inner_types = inner_types.clone();
+
+    let mut inherent_hooks_name = outer_type.to_string();
+    inherent_hooks_name.push_str("InherentHooks");
+    let inherent_hooks = Ident::new(&inherent_hooks_name, outer_type.span());
+
+    let vis = ast.vis;
+
+    // TODO there must be a better way to do this, right?
+    let inner_types2 = inner_types.clone();
+    let inner_types3 = inner_types.clone();
+    let inner_types4 = inner_types.clone();
+    let inner_types6 = inner_types.clone();
     let variants2 = variants.clone();
+    let variants3 = variants.clone();
+    let variants4 = variants.clone();
+    let variants5 = variants.clone();
+    let variants6 = variants.clone();
+
     let output = quote! {
         // Preserve the original enum, and write the From impls
         #[tuxedo_core::aggregate]
@@ -138,9 +169,84 @@ pub fn tuxedo_constraint_checker(attrs: TokenStream, body: TokenStream) -> Token
             )*
         }
 
+        /// This type is generated by the `#[tuxedo_constraint_checker]` macro.
+        /// It is a combined set of inherent hooks for the inherent hooks of each individual checker.
+        ///
+        /// This type is accessible downstream as `<OuterConstraintChecker as ConstraintChecker>::InherentHooks`
+        #[derive(Debug, scale_info::TypeInfo)]
+        #vis enum #inherent_hooks {
+            #(
+                #variants2(<#inner_types2 as tuxedo_core::ConstraintChecker<#verifier>>::InherentHooks),
+            )*
+        }
+
+        impl tuxedo_core::inherents::InherentInternal<#verifier, #outer_type> for #inherent_hooks {
+
+            fn create_inherents(
+                authoring_inherent_data: &InherentData,
+                previous_inherents: Vec<(tuxedo_core::types::Transaction<#verifier, #outer_type>, sp_core::H256)>,
+            ) -> Vec<tuxedo_core::types::Transaction<#verifier, #outer_type>>  {
+
+                let mut all_inherents = Vec::new();
+
+                #(
+                    {
+                        // Filter the previous inherents down to just the ones that came from this piece
+                        let previous_inherents = previous_inherents
+                            .iter()
+                            .filter_map(|(tx, hash)| {
+                                match tx.checker {
+                                    #outer_type::#variants3(ref inner_checker) => Some((tx.transform::<#inner_types3>(), *hash )),
+                                    _ => None,
+                                }
+                            })
+                            .collect();
+
+                        let inherents = <#inner_types3 as tuxedo_core::ConstraintChecker<#verifier>>::InherentHooks::create_inherents(authoring_inherent_data, previous_inherents)
+                            .iter()
+                            .map(|tx| tx.transform::<#outer_type>())
+                            .collect::<Vec<_>>();
+                        all_inherents.extend(inherents);
+                    }
+                )*
+
+                // Return the aggregate of all inherent extrinsics from all constituent constraint checkers.
+                all_inherents
+            }
+
+            fn check_inherents(
+                importing_inherent_data: &sp_inherents::InherentData,
+                inherents: Vec<tuxedo_core::types::Transaction<#verifier, #outer_type>>,
+                result: &mut sp_inherents::CheckInherentsResult,
+            ) {
+                #(
+                    let relevant_inherents: Vec<tuxedo_core::types::Transaction<#verifier, #inner_types4>> = inherents
+                        .iter()
+                        .filter_map(|tx| {
+                            match tx.checker {
+                                #outer_type::#variants4(ref inner_checker) => Some(tx.transform::<#inner_types4>()),
+                                _ => None,
+                            }
+                        })
+                        .collect();
+
+                    <#inner_types4 as tuxedo_core::ConstraintChecker<#verifier>>::InherentHooks::check_inherents(importing_inherent_data, relevant_inherents, result);
+
+                    // According to https://paritytech.github.io/polkadot-sdk/master/sp_inherents/struct.CheckInherentsResult.html
+                    // "When a fatal error occurs, all other errors are removed and the implementation needs to abort checking inherents."
+                    if result.fatal_error() {
+                        return;
+                    }
+                )*
+            }
+
+        }
+
         impl tuxedo_core::ConstraintChecker<#verifier> for #outer_type {
             type Error = #error_type;
 
+            type InherentHooks = #inherent_hooks;
+
             fn check (
                 &self,
                 inputs: &[tuxedo_core::types::Output<#verifier>],
@@ -149,10 +255,20 @@ pub fn tuxedo_constraint_checker(attrs: TokenStream, body: TokenStream) -> Token
             ) -> Result<TransactionPriority, Self::Error> {
                 match self {
                     #(
-                        Self::#variants2(inner) => inner.check(inputs, peeks, outputs).map_err(|e| Self::Error::#variants2(e)),
+                        Self::#variants5(inner) => inner.check(inputs, peeks, outputs).map_err(|e| Self::Error::#variants5(e)),
+                    )*
+                }
+            }
+
+            fn is_inherent(&self) -> bool {
+                match self {
+                    #(
+                        Self::#variants6(inner) => <#inner_types6 as tuxedo_core::ConstraintChecker<#verifier>>::is_inherent(inner),
                     )*
                 }
+
             }
+
         }
     };