decouple block participation from slots

Author: AmbientTea

Cargo.lock

@@ -61,7 +61,7 @@ where
 			ScEpochNumber,
 		>,
 	T::Api: BlockProductionLogApi<Block, BlockAuthor, Slot>,
-	T::Api: BlockParticipationApi<Block, BlockAuthor>,
+	T::Api: BlockParticipationApi<Block, BlockAuthor, Slot>,
 	T::Api: GovernedMapIDPApi<Block>,
 	T::Api: TokenBridgeIDPRuntimeApi<Block>,
 {
@@ -71,7 +71,7 @@ where
 		McHashIDP,
 		AriadneIDP,
 		BlockAuthorInherentProvider<Slot, BlockAuthor>,
-		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey>,
+		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey, Slot>,
 		GovernedMapInherentDataProvider,
 		TokenBridgeInherentDataProvider<AccountId>,
 	);
@@ -122,7 +122,6 @@ where
 			parent_hash,
 			*slot,
 			mc_epoch_config,
-			config.sc_slot_config.slot_duration,
 		)
 		.await?;
 
@@ -184,15 +183,15 @@ where
 			ScEpochNumber,
 		>,
 	T::Api: BlockProductionLogApi<Block, BlockAuthor, Slot>,
-	T::Api: BlockParticipationApi<Block, BlockAuthor>,
+	T::Api: BlockParticipationApi<Block, BlockAuthor, Slot>,
 	T::Api: GovernedMapIDPApi<Block>,
 	T::Api: TokenBridgeIDPRuntimeApi<Block>,
 {
 	type InherentDataProviders = (
 		TimestampIDP,
 		AriadneIDP,
 		BlockAuthorInherentProvider<Slot, BlockAuthor>,
-		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey>,
+		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey, Slot>,
 		GovernedMapInherentDataProvider,
 		TokenBridgeInherentDataProvider<AccountId>,
 	);
@@ -248,7 +247,6 @@ where
 			parent_hash,
 			verified_block_slot,
 			mc_epoch_config,
-			config.sc_slot_config.slot_duration,
 		)
 		.await?;
 

demo/node/src/inherent_data.rs

@@ -1,5 +1,7 @@
 use crate::inherent_data::{ProposalCIDP, VerifierCIDP};
-use crate::tests::mock::{test_client, test_create_inherent_data_config};
+use crate::tests::mock::{
+	block_participation_data, past_block_author, past_block_slot, test_create_inherent_data_config,
+};
 use crate::tests::runtime_api_mock;
 use crate::tests::runtime_api_mock::{TestApi, mock_header};
 use authority_selection_inherents::{
@@ -46,6 +48,7 @@ async fn block_proposal_cidp_should_be_created_correctly() {
 		test_create_inherent_data_config(),
 		TestApi::new(ScEpochNumber(2))
 			.with_headers([(mock_header().hash(), mock_header())])
+			.with_pariticipation_data(vec![(past_block_slot(), past_block_author())])
 			.into(),
 		Arc::new(mc_hash_data_source),
 		Arc::new(MockAuthoritySelectionDataSource::default()),
@@ -114,7 +117,7 @@ async fn block_proposal_cidp_should_be_created_correctly() {
 				&runtime_api_mock::TEST_TARGET_INHERENT_ID
 			)
 			.unwrap(),
-		Some(BlockProductionData::new(Slot::from(30), vec![]))
+		Some(block_participation_data())
 	);
 }
 
@@ -140,7 +143,9 @@ async fn block_verification_cidp_should_be_created_correctly() {
 
 	let verifier_cidp = VerifierCIDP::new(
 		create_inherent_data_config.clone(),
-		test_client(),
+		TestApi::new(ScEpochNumber(2))
+			.with_pariticipation_data(vec![(past_block_slot(), past_block_author())])
+			.into(),
 		Arc::new(mc_hash_data_source),
 		Arc::new(MockAuthoritySelectionDataSource::default()),
 		Arc::new(StakeDistributionDataSourceMock::new()),
@@ -195,6 +200,6 @@ async fn block_verification_cidp_should_be_created_correctly() {
 				&runtime_api_mock::TEST_TARGET_INHERENT_ID
 			)
 			.unwrap(),
-		Some(BlockProductionData::new(Slot::from(30), vec![]))
+		Some(block_participation_data())
 	);
 }

demo/node/src/tests/inherent_data_tests.rs

@@ -1,13 +1,17 @@
 #![allow(clippy::type_complexity)]
 
 use crate::inherent_data::CreateInherentDataConfig;
-use crate::tests::runtime_api_mock::TestApi;
 use hex_literal::hex;
+use partner_chains_demo_runtime::{BlockAuthor, CrossChainPublic};
 use sc_consensus_aura::SlotDuration;
 use sidechain_domain::mainchain_epoch::MainchainEpochConfig;
 use sidechain_domain::*;
-use sidechain_slots::{ScSlotConfig, SlotsPerEpoch};
-use sp_core::offchain::{Duration, Timestamp};
+use sidechain_slots::{ScSlotConfig, Slot, SlotsPerEpoch};
+use sp_block_participation::{BlockProducerParticipationData, BlockProductionData};
+use sp_core::{
+	ecdsa,
+	offchain::{Duration, Timestamp},
+};
 use std::sync::Arc;
 
 pub fn mock_genesis_utxo() -> UtxoId {
@@ -39,8 +43,20 @@ pub fn test_epoch_config() -> MainchainEpochConfig {
 	}
 }
 
-pub fn test_client() -> Arc<TestApi> {
-	Arc::new(TestApi::new(ScEpochNumber(2)))
+pub fn past_block_author() -> BlockAuthor {
+	BlockAuthor::ProBono(CrossChainPublic::from(ecdsa::Public::default()))
+}
+pub fn past_block_slot() -> Slot {
+	Slot::from(420)
+}
+
+pub fn block_participation_data() -> BlockProductionData<BlockAuthor, DelegatorKey> {
+	BlockProductionData::new(vec![BlockProducerParticipationData {
+		block_producer: past_block_author(),
+		block_count: 1,
+		delegator_total_shares: 0,
+		delegators: vec![],
+	}])
 }
 
 pub fn test_create_inherent_data_config() -> CreateInherentDataConfig {

demo/node/src/tests/mock.rs

@@ -24,19 +24,24 @@ type Header = <Block as BlockT>::Header;
 pub struct TestApi {
 	pub next_unset_epoch_number: ScEpochNumber,
 	pub headers: HashMap<Hash, Header>,
+	pub participation_data: Vec<(Slot, BlockAuthor)>,
 }
 
 impl TestApi {
 	pub fn new(next_unset_epoch_number: ScEpochNumber) -> Self {
 		let header = mock_header();
 		let mut headers = HashMap::new();
 		headers.insert(header.hash(), header);
-		Self { next_unset_epoch_number, headers }
+		Self { next_unset_epoch_number, headers, participation_data: Default::default() }
 	}
 
 	pub fn with_headers<Hs: Into<HashMap<Hash, Header>>>(self, headers: Hs) -> Self {
 		Self { headers: headers.into(), ..self }
 	}
+
+	pub fn with_pariticipation_data(self, participation_data: Vec<(Slot, BlockAuthor)>) -> Self {
+		Self { participation_data, ..self }
+	}
 }
 
 impl Default for TestApi {
@@ -105,16 +110,16 @@ sp_api::mock_impl_runtime_apis! {
 		}
 	}
 
-	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor> for TestApi {
-		fn should_release_data(slot: Slot) -> Option<Slot> {
-			Some(slot)
-		}
-		fn blocks_produced_up_to_slot(_slot: Slot) -> Vec<(Slot, BlockAuthor)> {
-			vec![]
+	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor, Slot> for TestApi {
+		fn blocks_to_process(_slot: &Slot) -> Vec<(Slot, BlockAuthor)> {
+			self.participation_data.clone()
 		}
 		fn target_inherent_id() -> InherentIdentifier {
 			TEST_TARGET_INHERENT_ID
 		}
+		fn moment_to_timestamp_millis(slot: Slot) -> u64 {
+			1000 * (*slot)
+		}
 	}
 
 	impl sp_governed_map::GovernedMapIDPApi<Block> for TestApi {

demo/node/src/tests/runtime_api_mock.rs

@@ -73,7 +73,7 @@ frame-system-benchmarking = { workspace = true, optional = true }
 
 # Local Dependencies
 sp-block-production-log = { workspace = true }
-pallet-block-production-log = { workspace = true }
+pallet-block-production-log = { workspace = true, features = ["block-participation"] }
 sp-sidechain = { workspace = true }
 pallet-sidechain = { workspace = true }
 pallet-session-validator-management = { workspace = true }

demo/runtime/Cargo.toml

@@ -593,20 +593,12 @@ impl pallet_block_producer_metadata::Config for Runtime {
 
 impl pallet_block_participation::Config for Runtime {
 	type WeightInfo = pallet_block_participation::weights::SubstrateWeight<Runtime>;
-	type BlockAuthor = BlockAuthor;
 	type DelegatorId = DelegatorKey;
+	type BlockAuthor = BlockAuthor;
 
-	fn should_release_data(slot: sidechain_slots::Slot) -> Option<sidechain_slots::Slot> {
-		TestHelperPallet::should_release_participation_data(slot)
-	}
-
-	fn blocks_produced_up_to_slot(slot: Slot) -> impl Iterator<Item = (Slot, BlockAuthor)> {
-		BlockProductionLog::peek_prefix(slot)
-	}
+	type Moment = Slot;
 
-	fn discard_blocks_produced_up_to_slot(slot: Slot) {
-		BlockProductionLog::drop_prefix(&slot)
-	}
+	type BlockParticipationProvider = BlockProductionLog;
 
 	const TARGET_INHERENT_ID: InherentIdentifier = TestHelperPallet::INHERENT_IDENTIFIER;
 }
@@ -1139,15 +1131,16 @@ impl_runtime_apis! {
 		}
 	}
 
-	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor> for Runtime {
-		fn should_release_data(slot: Slot) -> Option<Slot> {
-			BlockParticipation::should_release_data(slot)
-		}
-		fn blocks_produced_up_to_slot(slot: Slot) -> Vec<(Slot, BlockAuthor)> {
-			<Runtime as pallet_block_participation::Config>::blocks_produced_up_to_slot(slot).collect()
+	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor, Slot> for Runtime {
+		fn blocks_to_process(slot: &Slot) -> Vec<(Slot, BlockAuthor)> {
+			BlockParticipation::blocks_to_process(slot)
 		}
 		fn target_inherent_id() -> InherentIdentifier {
-			<Runtime as pallet_block_participation::Config>::TARGET_INHERENT_ID
+			BlockParticipation::target_inherent_id()
+		}
+		fn moment_to_timestamp_millis(moment: Slot) -> u64 {
+			let slot_duration_millis = <Self as sp_consensus_aura::runtime_decl_for_aura_api::AuraApi<Block, AuraId>>::slot_duration().as_millis();
+			*moment * slot_duration_millis
 		}
 	}
 

demo/runtime/src/lib.rs

@@ -64,18 +64,6 @@ pub mod pallet {
 		}
 	}
 
-	impl<T: Config> Pallet<T> {
-		pub fn should_release_participation_data(
-			slot: sidechain_slots::Slot,
-		) -> Option<sidechain_slots::Slot> {
-			if (*slot).is_multiple_of(ParticipationDataReleasePeriod::<T>::get()) {
-				Some(slot)
-			} else {
-				None
-			}
-		}
-	}
-
 	impl<T: Config> sp_sidechain::OnNewEpoch for Pallet<T> {
 		fn on_new_epoch(
 			_old_epoch: ScEpochNumber,

demo/runtime/src/test_helper_pallet.rs

@@ -49,10 +49,10 @@ def block_production_log(block_to_query_storage, api: BlockchainApi):
 
 @fixture(scope="module")
 def pc_epochs(block_participation, config: ApiConfig, initial_pc_epoch):
-    up_to_slot = block_participation["up_to_slot"]
-    logging.info(f"Participation data up to slot: {up_to_slot}")
-    start_pc_epoch = (up_to_slot - PARTICIPATION_DATA_SLOT_RANGE) // config.nodes_config.slots_in_epoch
-    stop_pc_epoch = up_to_slot // config.nodes_config.slots_in_epoch
+    up_to_moment = block_participation["up_to_moment"]
+    logging.info(f"Participation data up to slot: {up_to_moment}")
+    start_pc_epoch = (up_to_moment - PARTICIPATION_DATA_SLOT_RANGE) // config.nodes_config.slots_in_epoch
+    stop_pc_epoch = up_to_moment // config.nodes_config.slots_in_epoch
     epochs = range(start_pc_epoch, stop_pc_epoch)
     logging.info(f"Participation data spans PC epochs: {epochs}")
     if initial_pc_epoch in epochs:
@@ -114,7 +114,7 @@ def _count_blocks(mc_epoch, producer):
 @mark.xdist_group("block_participation")
 def test_block_participation_data_is_not_empty(block_participation):
     assert block_participation
-    assert block_participation["up_to_slot"]
+    assert block_participation["up_to_moment"]
     assert block_participation["producer_participation"]
 
 

e2e-tests/tests/delegator_rewards/test_spo_journey.py

@@ -5,15 +5,15 @@ use crate::Pallet as BlockParticipation;
 use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 
-#[benchmarks]
+#[benchmarks(where <T as crate::Config>::Moment: From<u64>)]
 mod benchmarks {
 	use super::*;
 
 	#[benchmark]
 	fn note_processing() -> Result<(), BenchmarkError> {
 		#[block]
 		{
-			BlockParticipation::<T>::note_processing(RawOrigin::None.into(), Slot::from(42))?;
+			BlockParticipation::<T>::note_processing(RawOrigin::None.into(), 42u64.into())?;
 		}
 		Ok(())
 	}