update to polkadot-stable2509, without backporting AURA authorities tracker (#1046)

Author: LGLO

Cargo.lock

@@ -2,7 +2,7 @@
 
 :chains: Toolkit for maintaining and securing [Substrate](https://polkadot.com/) based blockchains with the Cardano ecosystem
 
-![polkadot-sdk](https://img.shields.io/badge/polkadot--sdk-stable2506-blue)
+![polkadot-sdk](https://img.shields.io/badge/polkadot--sdk-stable2509-blue)
 [![language](https://img.shields.io/badge/language-Rust-239120)]()
 [![OS](https://img.shields.io/badge/OS-linux%2C%20macOS-0078D4)]()
 [![CPU](https://img.shields.io/badge/CPU-x64%2C%20ARM64-FF8C00)]()

Cargo.toml

@@ -6,6 +6,9 @@ This changelog is based on [Keep A Changelog](https://keepachangelog.com/en/1.1.
 
 ## Changed
 
+* Updated polkadot-sdk dependency to polkadot-stable2509.
+Partner Chains Aura modification follows changes regarding checking inherents that are also present in the new polkadot-sdk release.
+Pallet Session new parameters should be: `type KeyDeposit = ();` and `type Currency = Balances;`.
 * Updated partner-chains-smart-contracts (raw-scripts) dependency to v8.2.0. Not breaking.
 * `SessionManager` and `ShouldEndSession` implementations of `pallet-session-validator-management` rotate one additional
 session in order to make `pallet_session` use authorities with less delay.

README.md

@@ -314,6 +314,8 @@ impl pallet_session::Config for Runtime {
 	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
 	type Keys = SessionKeys;
 	type DisablingStrategy = pallet_session::disabling::UpToLimitWithReEnablingDisablingStrategy;
+	type Currency = Balances;
+	type KeyDeposit = ();
 
 	type WeightInfo = pallet_session::weights::SubstrateWeight<Runtime>;
 }

changelog.md

@@ -98,7 +98,7 @@ impl pallet_balances::Config for Test {
 	type WeightInfo = pallet_balances::weights::SubstrateWeight<Test>;
 	type FreezeIdentifier = ();
 	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
 	type RuntimeFreezeReason = RuntimeFreezeReason;
 	type DoneSlashHandler = ();
 }
@@ -149,6 +149,8 @@ impl pallet_session::Config for Test {
 	type Keys = TestSessionKeys;
 	type DisablingStrategy = pallet_session::disabling::UpToLimitWithReEnablingDisablingStrategy;
 	type WeightInfo = pallet_session::weights::SubstrateWeight<Test>;
+	type Currency = Balances;
+	type KeyDeposit = ();
 }
 
 impl pallet_sidechain::Config for Test {

demo/runtime/src/lib.rs

@@ -18,8 +18,10 @@ workspace = true
 [dependencies]
 async-trait = { workspace = true }
 parity-scale-codec = { workspace = true, default-features = true }
+fork-tree = { workspace = true, default-features = true }
 futures = { workspace = true }
 log = { workspace = true, default-features = true }
+parking_lot = { workspace = true, default-features = true }
 sc-client-api = { workspace = true, default-features = true }
 sc-consensus = { workspace = true, default-features = true }
 sc-consensus-aura = { workspace = true, default-features = true }

demo/runtime/src/mock.rs

@@ -35,7 +35,7 @@ use sc_consensus_slots::{CheckedHeader, check_equivocation};
 use sc_telemetry::{CONSENSUS_DEBUG, CONSENSUS_TRACE, TelemetryHandle, telemetry};
 use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
-use sp_blockchain::HeaderBackend;
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
 use sp_consensus::Error as ConsensusError;
 use sp_consensus_aura::AuraApi;
 use sp_consensus_slots::Slot;
@@ -107,25 +107,25 @@ where
 }
 
 /// A verifier for Aura blocks, with added ID phantom type.
-pub struct AuraVerifier<C, P, CIDP, N, ID> {
+pub struct AuraVerifier<C, P: Pair, CIDP, B: BlockT, ID> {
 	client: Arc<C>,
 	create_inherent_data_providers: CIDP,
 	check_for_equivocation: CheckForEquivocation,
 	telemetry: Option<TelemetryHandle>,
-	compatibility_mode: CompatibilityMode<N>,
+	compatibility_mode: CompatibilityMode<NumberFor<B>>,
 	_phantom: PhantomData<(fn() -> P, ID)>,
 }
 
-impl<C, P, CIDP, N, ID> AuraVerifier<C, P, CIDP, N, ID> {
+impl<C, P: Pair, CIDP, B: BlockT, ID> AuraVerifier<C, P, CIDP, B, ID> {
 	pub(crate) fn new(
 		client: Arc<C>,
 		create_inherent_data_providers: CIDP,
 		check_for_equivocation: CheckForEquivocation,
 		telemetry: Option<TelemetryHandle>,
-		compatibility_mode: CompatibilityMode<N>,
+		compatibility_mode: CompatibilityMode<NumberFor<B>>,
 	) -> Self {
 		Self {
-			client,
+			client: client.clone(),
 			create_inherent_data_providers,
 			check_for_equivocation,
 			telemetry,
@@ -135,47 +135,16 @@ impl<C, P, CIDP, N, ID> AuraVerifier<C, P, CIDP, N, ID> {
 	}
 }
 
-impl<C, P, CIDP, N, ID> AuraVerifier<C, P, CIDP, N, ID>
-where
-	CIDP: Send,
-{
-	async fn check_inherents<B: BlockT>(
-		&self,
-		block: B,
-		at_hash: B::Hash,
-		inherent_data_providers: CIDP::InherentDataProviders,
-	) -> Result<(), Error<B>>
-	where
-		C: ProvideRuntimeApi<B>,
-		C::Api: BlockBuilderApi<B>,
-		CIDP: CreateInherentDataProviders<B, (Slot, <ID as InherentDigest>::Value)>,
-		ID: InherentDigest,
-	{
-		let inherent_data = create_inherent_data::<B>(&inherent_data_providers).await?;
-
-		let inherent_res = self
-			.client
-			.runtime_api()
-			.check_inherents(at_hash, block, inherent_data)
-			.map_err(|e| Error::Client(e.into()))?;
-
-		if !inherent_res.ok() {
-			for (i, e) in inherent_res.into_errors() {
-				match inherent_data_providers.try_handle_error(&i, &e).await {
-					Some(res) => res.map_err(Error::Inherent)?,
-					None => return Err(Error::UnknownInherentError(i)),
-				}
-			}
-		}
-
-		Ok(())
-	}
-}
-
 #[async_trait::async_trait]
-impl<B: BlockT, C, P, CIDP, ID> Verifier<B> for AuraVerifier<C, P, CIDP, NumberFor<B>, ID>
+impl<B, C, P, CIDP, ID> Verifier<B> for AuraVerifier<C, P, CIDP, B, ID>
 where
-	C: ProvideRuntimeApi<B> + Send + Sync + AuxStore,
+	B: BlockT,
+	C: HeaderBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProvideRuntimeApi<B>
+		+ Send
+		+ Sync
+		+ sc_client_api::backend::AuxStore,
 	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B>,
 	P: Pair,
 	P::Public: Codec + Debug,
@@ -255,13 +224,17 @@ where
 						.has_api_with::<dyn BlockBuilderApi<B>, _>(parent_hash, |v| v >= 2)
 						.map_err(|e| e.to_string())?
 					{
-						self.check_inherents(
-							new_block.clone(),
+						let inherent_data =
+							create_inherent_data::<B>(&inherent_data_providers).await?;
+						sp_block_builder::check_inherents_with_data(
+							self.client.clone(),
 							parent_hash,
-							inherent_data_providers,
+							new_block.clone(),
+							&inherent_data_providers,
+							inherent_data,
 						)
 						.await
-						.map_err(|e| e.to_string())?;
+						.map_err(|e| format!("Error checking block inherents {:?}", e))?;
 					}
 
 					let (_, inner_body) = new_block.deconstruct();
@@ -323,7 +296,8 @@ where
 		+ Sync
 		+ AuxStore
 		+ UsageProvider<Block>
-		+ HeaderBackend<Block>,
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>,
 	I: BlockImport<Block, Error = ConsensusError> + Send + Sync + 'static,
 	P: Pair + 'static,
 	P::Public: Codec + Debug,

substrate-extensions/aura/consensus/Cargo.toml

@@ -449,7 +449,7 @@ mod tests {
 	}
 
 	type AuraVerifier =
-		import_queue::AuraVerifier<PeersFullClient, AuthorityPair, TestCIDP, u64, ()>;
+		import_queue::AuraVerifier<PeersFullClient, AuthorityPair, TestCIDP, TestBlock, ()>;
 	type AuraPeer = Peer<(), PeersClient>;
 
 	#[derive(Default)]

substrate-extensions/aura/consensus/src/import_queue.rs

@@ -33,6 +33,7 @@ frame-benchmarking = { workspace = true, optional = true }
 
 [dev-dependencies]
 sp-io = { workspace = true }
+pallet-balances = { workspace = true }
 
 [features]
 default = ["std"]