clean up custom idps

core/src/commands/fast_forward.rs

@@ -16,7 +16,7 @@
 // limitations under the License.
 
 use std::{fmt::Debug, str::FromStr};
-
+use crate::inherents::providers::pre_apply_inherents;
 use parity_scale_codec::{Decode, Encode};
 use sc_cli::Result;
 use sc_executor::{sp_wasm_interface::HostFunctions, WasmExecutor};
@@ -31,7 +31,7 @@ use sp_state_machine::TestExternalities;
 
 use crate::{
     build_executor, full_extensions,
-    inherents::providers::{pre_apply_inherents, ChainVariant, InherentProvider},
+    inherents::providers::{ChainVariant, InherentProvider},
     state::{RuntimeChecks, State},
     state_machine_call, state_machine_call_with_proof, BlockT, SharedParams,
 };

core/src/inherents/custom_idps/mod.rs

@@ -0,0 +1,3 @@
+pub mod para_parachain;
+pub mod relay_parachains;
+pub mod timestamp;

core/src/inherents/custom_idps/para_parachain.rs

@@ -0,0 +1,106 @@
+use parity_scale_codec::{Decode, Encode};
+use polkadot_primitives::{BlockNumber, HeadData};
+use sp_consensus_babe::SlotDuration;
+use sp_core::twox_128;
+use sp_inherents::InherentIdentifier;
+use sp_runtime::traits::{Block as BlockT, HashingFor, NumberFor};
+use sp_state_machine::TestExternalities;
+
+/// ext cannot be part of the InherentDataProvider (thread safety), so we need to make storage
+/// queries seperately
+pub fn get_para_id<B: BlockT>(ext: &mut TestExternalities<HashingFor<B>>) -> u32 {
+    let para_id_key = [twox_128(b"ParachainInfo"), twox_128(b"ParachainId")].concat();
+
+    ext.execute_with(|| sp_io::storage::get(&para_id_key))
+        .map(|b| -> u32 { Decode::decode(&mut &b[..]).unwrap() })
+        .expect("Parachain must have an ID")
+}
+
+/// ext cannot be part of the InherentDataProvider (thread safety), so we need to make storage
+/// queries seperately
+pub fn get_last_relay_chain_block_number<B: BlockT>(
+    ext: &mut TestExternalities<HashingFor<B>>,
+) -> BlockNumber {
+    let last_relay_chain_block_number_key = [
+        twox_128(b"ParachainSystem"),
+        twox_128(b"LastRelayChainBlockNumber"),
+    ]
+    .concat();
+
+    match ext
+        .execute_with(|| sp_io::storage::get(&last_relay_chain_block_number_key))
+        .map(|b| -> Option<NumberFor<B>> { Decode::decode(&mut &b[..]).ok() })
+        .unwrap()
+        .expect("Parachain must provide last relay chain block number")
+        .try_into()
+    {
+        Ok(block_number) => block_number,
+        Err(_) => {
+            panic!("Failed to convert relay chain block number")
+        }
+    }
+}
+
+pub struct InherentDataProvider<B: BlockT> {
+    pub timestamp: sp_timestamp::Timestamp,
+    pub blocktime_millis: u64,
+    pub last_relay_chain_block_number: BlockNumber,
+    pub para_id: u32,
+    pub parent_header: B::Header,
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT> sp_inherents::InherentDataProvider for InherentDataProvider<B> {
+    async fn provide_inherent_data(
+        &self,
+        inherent_data: &mut sp_inherents::InherentData,
+    ) -> Result<(), sp_inherents::Error> {
+        let relay_chain_slot = cumulus_primitives_core::relay_chain::Slot::from_timestamp(
+            self.timestamp,
+            SlotDuration::from_millis(self.blocktime_millis),
+        )
+        .encode();
+
+        let additional_key_values: Vec<(Vec<u8>, Vec<u8>)> = vec![
+            // Insert relay chain slot to pass Aura check
+            // https://github.com/paritytech/polkadot-sdk/blob/ef114a422291b44f8973739ab7858a29a523e6a2/cumulus/pallets/aura-ext/src/consensus_hook.rs#L69
+            (
+                cumulus_primitives_core::relay_chain::well_known_keys::CURRENT_SLOT.to_vec(),
+                relay_chain_slot,
+            ),
+            // Insert para header info to pass para inherent check
+            // https://github.com/paritytech/polkadot-sdk/blob/17b56fae2d976a3df87f34076875de8c26da0355/cumulus/pallets/parachain-system/src/lib.rs#L1296
+            (
+                cumulus_primitives_core::relay_chain::well_known_keys::para_head(
+                    self.para_id.into(),
+                ),
+                HeadData(self.parent_header.encode()).encode(),
+            ),
+        ];
+
+        cumulus_client_parachain_inherent::MockValidationDataInherentDataProvider {
+            current_para_block: Default::default(),
+            relay_offset: self.last_relay_chain_block_number,
+            relay_blocks_per_para_block: Default::default(),
+            para_blocks_per_relay_epoch: Default::default(),
+            relay_randomness_config: (),
+            xcm_config: cumulus_client_parachain_inherent::MockXcmConfig::default(),
+            raw_downward_messages: Default::default(),
+            raw_horizontal_messages: Default::default(),
+            additional_key_values: Some(additional_key_values),
+        }
+        .provide_inherent_data(inherent_data)
+        .await
+        .expect("Failed to provide Para Parachain inherent data.");
+
+        Ok(())
+    }
+
+    async fn try_handle_error(
+        &self,
+        _: &InherentIdentifier,
+        _: &[u8],
+    ) -> Option<Result<(), sp_inherents::Error>> {
+        None
+    }
+}

core/src/inherents/custom_idps.rs → core/src/inherents/custom_idps/relay_parachains.rs

@@ -15,38 +15,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Custom InherentDataProviders.
-//!
-//! Useful to create custom inherent data providers for testing, when the one provided by
-//! Substrate is unnecessarily too complex for try-runtime-cli purposes.
+//! Relay chain parachains inherent.
 
 use sp_inherents::InherentIdentifier;
 use sp_runtime::traits::Block as BlockT;
 
-pub struct ParaInherentDataProvider<B: BlockT> {
+pub struct InherentDataProvider<B: BlockT> {
     parent_header: B::Header,
 }
 
-impl<B: BlockT> ParaInherentDataProvider<B> {
+impl<B: BlockT> InherentDataProvider<B> {
     pub fn new(parent_header: B::Header) -> Self {
         Self { parent_header }
     }
 }
 
-/// Auxiliary trait to extract para inherent data.
-pub trait ParaInherentData<B: BlockT> {
-    /// Get para inherent data.
-    fn para_inherent_data(&self) -> Result<Option<B::Header>, sp_inherents::Error>;
-}
-
-impl<B: BlockT> ParaInherentData<B> for sp_inherents::InherentData {
-    fn para_inherent_data(&self) -> Result<Option<B::Header>, sp_inherents::Error> {
-        self.get_data(&polkadot_primitives::PARACHAINS_INHERENT_IDENTIFIER)
-    }
-}
-
 #[async_trait::async_trait]
-impl<B: BlockT> sp_inherents::InherentDataProvider for ParaInherentDataProvider<B> {
+impl<B: BlockT> sp_inherents::InherentDataProvider for InherentDataProvider<B> {
     async fn provide_inherent_data(
         &self,
         inherent_data: &mut sp_inherents::InherentData,

core/src/inherents/custom_idps/timestamp.rs

@@ -0,0 +1,66 @@
+use sp_inherents::{InherentData, InherentIdentifier};
+use sp_runtime::Digest;
+use sp_timestamp::{Timestamp, TimestampInherentData};
+
+pub struct InherentDataProvider {
+    pub blocktime_millis: u64,
+    pub maybe_parent_info: Option<(InherentData, Digest)>,
+}
+
+impl InherentDataProvider {
+    pub fn timestamp(&self) -> Timestamp {
+        match &self.maybe_parent_info {
+            Some((prev_inherent_data, _)) => sp_timestamp::InherentDataProvider::new(
+                prev_inherent_data
+                    .timestamp_inherent_data()
+                    .unwrap()
+                    .unwrap()
+                    + self.blocktime_millis,
+            )
+            .timestamp()
+            .into(),
+            None => sp_timestamp::InherentDataProvider::from_system_time()
+                .timestamp()
+                .into(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl sp_inherents::InherentDataProvider for InherentDataProvider {
+    async fn provide_inherent_data(
+        &self,
+        inherent_data: &mut sp_inherents::InherentData,
+    ) -> Result<(), sp_inherents::Error> {
+        match &self.maybe_parent_info {
+            Some((prev_inherent_data, _)) => {
+                let idp = sp_timestamp::InherentDataProvider::new(
+                    prev_inherent_data
+                        .timestamp_inherent_data()
+                        .unwrap()
+                        .unwrap()
+                        + self.blocktime_millis,
+                );
+                idp.provide_inherent_data(inherent_data)
+                    .await
+                    .expect("Failed to provide timestamp inherent");
+            }
+            None => {
+                let idp = sp_timestamp::InherentDataProvider::from_system_time();
+                idp.provide_inherent_data(inherent_data)
+                    .await
+                    .expect("Failed to provide timestamp inherent");
+            }
+        };
+
+        Ok(())
+    }
+
+    async fn try_handle_error(
+        &self,
+        _: &InherentIdentifier,
+        _: &[u8],
+    ) -> Option<Result<(), sp_inherents::Error>> {
+        None
+    }
+}