wip/included head not present in relay storage proof

Author: jimjbrettj

crates/anvil-polkadot/Cargo.toml

@@ -67,7 +67,21 @@ polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch
 	"substrate-frame-rpc-system",
 	"substrate-rpc-client",
 	"substrate-wasm-builder",
+
+	"sc-consensus-aura",
+	"polkadot-primitives",
+	"cumulus-client-parachain-inherent",
+	"sp-arithmetic",
+	"cumulus-client-service",
+	"cumulus-primitives-aura",
+
+	"cumulus-primitives-core",
+	"sp-inherents",
 ] }
+hex = "0.4"
+indicatif.workspace = true
+
+
 anvil.workspace = true
 anvil-core.workspace = true
 anvil-server = { workspace = true, features = ["clap"] }

crates/anvil-polkadot/src/cmd.rs

@@ -98,6 +98,9 @@ pub struct NodeArgs {
 
     #[command(flatten)]
     pub server_config: ServerConfig,
+
+        #[command(flatten)]
+    pub fork: ForkArgs,
 }
 
 /// The default IPC endpoint
@@ -148,6 +151,8 @@ impl NodeArgs {
             .with_eth_rpc_url(self.evm.fork_url.map(|fork| fork.url))
             .fork_request_timeout(self.evm.fork_request_timeout.map(Duration::from_millis))
             .fork_request_retries(self.evm.fork_request_retries);
+            // for my testing
+            .with_fork_block_hash(self.fork.fork_block_hash);
 
         let substrate_node_config = SubstrateNodeConfig::new(&anvil_config);
 
@@ -357,6 +362,22 @@ fn duration_from_secs_f64(s: &str) -> Result<Duration, String> {
     Duration::try_from_secs_f64(s).map_err(|e| e.to_string())
 }
 
+#[derive(Clone, Debug, Parser)]
+#[command(next_help_heading = "Fork options")]
+pub struct ForkArgs {
+    /// Fetch state over a remote endpoint instead of starting from an empty state.
+    #[arg(
+        long = "fork-url",
+        short = 'f',
+        value_name = "URL",
+    )]
+    pub fork_url: Option<String>,
+
+    /// Fetch state from a specific block hash over a remote endpoint.
+    #[arg(long, value_name = "BLOCK")]
+    pub fork_block_hash: Option<String>,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/anvil-polkadot/src/config.rs

@@ -332,6 +332,8 @@ pub struct AnvilNodeConfig {
     pub fork_request_timeout: Duration,
     /// Number of request retries for spurious networks
     pub fork_request_retries: u32,
+    /// Fetch state from a specific block hash over a remote endpoint.
+    pub fork_block_hash: Option<String>,
 }
 
 impl AnvilNodeConfig {
@@ -557,6 +559,7 @@ impl Default for AnvilNodeConfig {
             fork_choice: None,
             fork_request_timeout: REQUEST_TIMEOUT,
             fork_request_retries: 5,
+            fork_block_hash: None,
         }
     }
 }
@@ -901,6 +904,13 @@ impl AnvilNodeConfig {
         }
         self
     }
+
+    // For my own testing
+    #[must_use]
+    pub fn with_fork_block_hash(mut self, fork_block_hash: Option<String>) -> Self {
+        self.fork_block_hash = fork_block_hash;
+        self
+    }
 }
 
 /// Fork delimiter used to specify which block or transaction to fork from.

crates/anvil-polkadot/src/substrate_node/service/consensus.rs

@@ -1,13 +1,22 @@
+
+use crate::{
+    substrate_node::{
+       service::{AuxStore, ProvideRuntimeApi, UsageProvider, AuraApi, AuthorityId, TIMESTAMP}
+    },
+};
 use polkadot_sdk::{
     sc_consensus::BlockImportParams,
-    sc_consensus_aura::CompatibleDigestItem,
+    sc_consensus_aura::{self,CompatibleDigestItem},
     sc_consensus_manual_seal::{ConsensusDataProvider, Error},
     sp_consensus_aura::ed25519::AuthoritySignature,
     sp_consensus_babe::Slot,
     sp_inherents::InherentData,
     sp_runtime::{Digest, DigestItem, traits::Block as BlockT},
+	sp_timestamp::TimestampInherentData,
 };
 use std::marker::PhantomData;
+use std::sync::atomic::{ Ordering};
+use std::sync::Arc;
 
 /// Consensus data provider for Aura. This will always use slot 0 (used to determine the
 /// index of the AURA authority from the authorities set by AURA runtimes) for the aura
@@ -55,3 +64,74 @@ where
         Ok(())
     }
 }
+
+// Mine /// Consensus data provider for Aura. This allows to use manual-seal driven nodes to author valid
+/// AURA blocks. It will inspect incoming [`InherentData`] and look for included timestamps. Based
+/// on these timestamps, the [`AuraConsensusDataProvider`] will emit fitting digest items.
+pub struct AuraConsensusDataProvider<B, P> {
+	// slot duration
+	slot_duration: sc_consensus_aura::SlotDuration,
+	// phantom data for required generics
+	_phantom: PhantomData<(B, P)>,
+}
+
+impl<B, P> AuraConsensusDataProvider<B, P>
+where
+	B: BlockT,
+{
+	/// Creates a new instance of the [`AuraConsensusDataProvider`], requires that `client`
+	/// implements [`sp_consensus_aura::AuraApi`]
+	pub fn new<C>(client: Arc<C>) -> Self
+	where
+		C: AuxStore + ProvideRuntimeApi<B> + UsageProvider<B>,
+		C::Api: AuraApi<B, AuthorityId>,
+	{
+		let slot_duration = sc_consensus_aura::slot_duration(&*client)
+			.expect("slot_duration is always present; qed.");
+
+		Self { slot_duration, _phantom: PhantomData }
+	}
+
+	/// Creates a new instance of the [`AuraConsensusDataProvider`]
+	pub fn new_with_slot_duration(slot_duration: sc_consensus_aura::SlotDuration) -> Self {
+		Self { slot_duration, _phantom: PhantomData }
+	}
+}
+
+impl<B, P> ConsensusDataProvider<B> for AuraConsensusDataProvider<B, P>
+where
+	B: BlockT,
+	P: Send + Sync,
+{
+	type Proof = P;
+
+	fn create_digest(
+        &self,
+        _parent: &B::Header,
+        inherents: &InherentData,
+    ) -> Result<Digest, Error> {
+        let timestamp =
+            inherents.timestamp_inherent_data()?.expect("Timestamp is always present; qed");
+
+        print!("time da {}", timestamp);
+        print!("time db {}", TIMESTAMP.load(Ordering::SeqCst));
+
+        // we always calculate the new slot number based on the current time-stamp and the slot
+        // duration.
+        let digest_item = <DigestItem as CompatibleDigestItem<AuthoritySignature>>::aura_pre_digest(
+            Slot::from_timestamp(timestamp, self.slot_duration),
+        );
+
+        Ok(Digest { logs: vec![digest_item] })
+    }
+
+	fn append_block_import(
+		&self,
+		_parent: &B::Header,
+		_params: &mut BlockImportParams<B>,
+		_inherents: &InherentData,
+		_proof: Self::Proof,
+	) -> Result<(), Error> {
+		Ok(())
+	}
+}

crates/anvil-polkadot/src/substrate_node/service/executor.rs

@@ -16,13 +16,14 @@ use polkadot_sdk::{
     sp_storage::ChildInfo,
     sp_version,
     sp_wasm_interface::ExtendedHostFunctions,
+    cumulus_client_service::ParachainHostFunctions, 
 };
 use std::{cell::RefCell, sync::Arc};
 
 /// Wasm executor which overrides the signature checking host functions for impersonation.
 pub type WasmExecutor = sc_executor::WasmExecutor<
     ExtendedHostFunctions<
-        ExtendedHostFunctions<sp_io::SubstrateHostFunctions, SenderAddressRecoveryOverride>,
+        ExtendedHostFunctions<ParachainHostFunctions, SenderAddressRecoveryOverride>,
         PublicKeyToHashOverride,
     >,
 >;