rework production log

Author: AmbientTea

Cargo.lock

@@ -17,7 +17,6 @@ members = [
 	"toolkit/committee-selection/pallet",
 	"toolkit/committee-selection/rpc",
 	"substrate-extensions/aura/primitives",
-	"toolkit/block-production-log/primitives",
 	"toolkit/sidechain/domain",
 	"toolkit/committee-selection/selection",
 	"toolkit/committee-selection/authority-selection-inherents",
@@ -308,7 +307,6 @@ sp-partner-chains-consensus-aura = { path = "substrate-extensions/aura/primitive
 
 # block production and rewards
 pallet-block-production-log = { path = "toolkit/block-production-log/pallet", default-features = false }
-sp-block-production-log = { path = "toolkit/block-production-log/primitives", default-features = false }
 pallet-block-participation = { path = "toolkit/block-participation/pallet", default-features = false }
 sp-block-participation = { path = "toolkit/block-participation/primitives", default-features = false }
 

Cargo.toml

@@ -52,7 +52,6 @@ sp-keyring = { workspace = true }
 authority-selection-inherents = { workspace = true }
 frame-system = { workspace = true }
 pallet-transaction-payment = { workspace = true }
-sp-block-production-log = { workspace = true }
 sidechain-domain = { workspace = true }
 sidechain-slots = { workspace = true }
 sp-sidechain = { workspace = true }

demo/node/Cargo.toml

@@ -19,7 +19,6 @@ use sp_block_participation::{
 	BlockParticipationApi,
 	inherent_data::{BlockParticipationDataSource, BlockParticipationInherentDataProvider},
 };
-use sp_block_production_log::{BlockAuthorInherentProvider, BlockProductionLogApi};
 use sp_blockchain::HeaderBackend;
 use sp_consensus_aura::{
 	Slot, inherents::InherentDataProvider as AuraIDP, sr25519::AuthorityPair as AuraPair,
@@ -54,7 +53,6 @@ where
 	T: ProvideRuntimeApi<Block> + Send + Sync + 'static,
 	T: HeaderBackend<Block>,
 	T::Api: SessionValidatorManagementApi<Block, CrossChainPublic, SessionKeys, ScEpochNumber>,
-	T::Api: BlockProductionLogApi<Block, BlockAuthor, Slot>,
 	T::Api: BlockParticipationApi<Block, BlockAuthor, Slot>,
 	T::Api: GovernedMapIDPApi<Block>,
 	T::Api: TokenBridgeIDPRuntimeApi<Block>,
@@ -64,7 +62,6 @@ where
 		TimestampIDP,
 		McHashIDP,
 		AriadneIDP,
-		BlockAuthorInherentProvider<Slot, BlockAuthor>,
 		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey, Slot>,
 		GovernedMapInherentDataProvider,
 		TokenBridgeInherentDataProvider<AccountId>,
@@ -111,8 +108,6 @@ where
 			mc_hash.mc_epoch(),
 		)
 		.await?;
-		let block_producer_id_provider =
-			BlockAuthorInherentProvider::new(client.as_ref(), parent_hash, *slot)?;
 
 		let payouts = BlockParticipationInherentDataProvider::new(
 			client.as_ref(),
@@ -140,16 +135,7 @@ where
 		)
 		.await?;
 
-		Ok((
-			slot,
-			timestamp,
-			mc_hash,
-			ariadne_data_provider,
-			block_producer_id_provider,
-			payouts,
-			governed_map,
-			bridge,
-		))
+		Ok((slot, timestamp, mc_hash, ariadne_data_provider, payouts, governed_map, bridge))
 	}
 }
 
@@ -175,15 +161,13 @@ impl<T> CreateInherentDataProviders<Block, (Slot, McBlockHash)> for VerifierCIDP
 where
 	T: ProvideRuntimeApi<Block> + Send + Sync + HeaderBackend<Block>,
 	T::Api: SessionValidatorManagementApi<Block, CrossChainPublic, SessionKeys, ScEpochNumber>,
-	T::Api: BlockProductionLogApi<Block, BlockAuthor, Slot>,
 	T::Api: BlockParticipationApi<Block, BlockAuthor, Slot>,
 	T::Api: GovernedMapIDPApi<Block>,
 	T::Api: TokenBridgeIDPRuntimeApi<Block>,
 {
 	type InherentDataProviders = (
 		TimestampIDP,
 		AriadneIDP,
-		BlockAuthorInherentProvider<Slot, BlockAuthor>,
 		BlockParticipationInherentDataProvider<BlockAuthor, DelegatorKey, Slot>,
 		GovernedMapInherentDataProvider,
 		TokenBridgeInherentDataProvider<AccountId>,
@@ -237,9 +221,6 @@ where
 		)
 		.await?;
 
-		let block_producer_id_provider =
-			BlockAuthorInherentProvider::new(client.as_ref(), parent_hash, verified_block_slot)?;
-
 		let payouts = BlockParticipationInherentDataProvider::new(
 			client.as_ref(),
 			block_participation_data_source.as_ref(),
@@ -266,14 +247,7 @@ where
 		)
 		.await?;
 
-		Ok((
-			timestamp,
-			ariadne_data_provider,
-			block_producer_id_provider,
-			payouts,
-			governed_map,
-			bridge,
-		))
+		Ok((timestamp, ariadne_data_provider, payouts, governed_map, bridge))
 	}
 }
 

demo/node/src/inherent_data.rs

@@ -7,7 +7,6 @@ use crate::tests::runtime_api_mock::{TestApi, mock_header};
 use authority_selection_inherents::{
 	AuthoritySelectionInputs, mock::MockAuthoritySelectionDataSource,
 };
-use hex_literal::hex;
 use partner_chains_demo_runtime::{AccountId, BlockAuthor};
 use partner_chains_mock_data_sources::StakeDistributionDataSourceMock;
 use partner_chains_mock_data_sources::{GovernedMapDataSourceMock, TokenBridgeDataSourceMock};
@@ -17,9 +16,7 @@ use sidechain_domain::{
 };
 use sidechain_mc_hash::mock::MockMcHashDataSource;
 use sp_block_participation::BlockProductionData;
-use sp_block_production_log::BlockProductionInherentDataV1;
 use sp_consensus_aura::Slot;
-use sp_core::ecdsa;
 use sp_inherents::CreateInherentDataProviders;
 use sp_inherents::{InherentData, InherentDataProvider};
 use sp_timestamp::Timestamp;
@@ -89,22 +86,6 @@ async fn block_proposal_cidp_should_be_created_correctly() {
 			.unwrap()
 			.is_some()
 	);
-	assert_eq!(
-		inherent_data
-			.get_data::<BlockProductionInherentDataV1<u64, BlockAuthor>>(
-				&sp_block_production_log::INHERENT_IDENTIFIER
-			)
-			.unwrap(),
-		Some(BlockProductionInherentDataV1 {
-			moment: 30,
-			block_producer_id: BlockAuthor::ProBono(
-				ecdsa::Public::from_raw(hex!(
-					"000000000000000000000000000000000000000000000000000000000000000001"
-				))
-				.into()
-			)
-		})
-	);
 	assert_eq!(
 		inherent_data
 			.get_data::<Slot>(&sp_block_participation::INHERENT_IDENTIFIER)
@@ -172,22 +153,6 @@ async fn block_verification_cidp_should_be_created_correctly() {
 			.unwrap()
 			.is_some()
 	);
-	assert_eq!(
-		inherent_data
-			.get_data::<BlockProductionInherentDataV1<u64, BlockAuthor>>(
-				&sp_block_production_log::INHERENT_IDENTIFIER
-			)
-			.unwrap(),
-		Some(BlockProductionInherentDataV1 {
-			moment: 30,
-			block_producer_id: BlockAuthor::ProBono(
-				ecdsa::Public::from_raw(hex!(
-					"000000000000000000000000000000000000000000000000000000000000000001"
-				))
-				.into()
-			)
-		})
-	);
 	assert_eq!(
 		inherent_data
 			.get_data::<Slot>(&sp_block_participation::INHERENT_IDENTIFIER)

demo/node/src/tests/inherent_data_tests.rs

@@ -1,6 +1,5 @@
 use super::mock::mock_genesis_utxo;
 use authority_selection_inherents::AuthoritySelectionInputs;
-use hex_literal::hex;
 use partner_chains_demo_runtime::opaque::SessionKeys;
 use partner_chains_demo_runtime::{BlockAuthor, CrossChainPublic};
 use sidechain_domain::*;
@@ -103,14 +102,6 @@ sp_api::mock_impl_runtime_apis! {
 		}
 	}
 
-	impl sp_block_production_log::BlockProductionLogApi<Block, BlockAuthor, Slot> for TestApi {
-		fn get_author(_slot: &Slot) -> Option<BlockAuthor> {
-			Some(BlockAuthor::ProBono(
-				ecdsa::Public::from_raw(hex!("000000000000000000000000000000000000000000000000000000000000000001")).into()
-			))
-		}
-	}
-
 	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor, Slot> for TestApi {
 		fn blocks_to_process(_slot: &Slot) -> Vec<(Slot, BlockAuthor)> {
 			self.participation_data.clone()

demo/node/src/tests/runtime_api_mock.rs

@@ -72,8 +72,7 @@ frame-benchmarking = { workspace = true, optional = true }
 frame-system-benchmarking = { workspace = true, optional = true }
 
 # Local Dependencies
-sp-block-production-log = { workspace = true }
-pallet-block-production-log = { workspace = true, features = ["block-participation"] }
+pallet-block-production-log = { workspace = true, features = ["block-participation", "aura-compat"] }
 sp-sidechain = { workspace = true }
 pallet-sidechain = { workspace = true }
 pallet-session-validator-management = { workspace = true }
@@ -161,7 +160,6 @@ std = [
 	"sidechain-slots/std",
 	"sidechain-domain/std",
 	"sp-inherents/std",
-	"sp-block-production-log/std",
 	"pallet-block-participation/std",
 	"sp-block-participation/std",
 	"pallet-governed-map/std",

demo/runtime/Cargo.toml

@@ -44,8 +44,6 @@ use sidechain_slots::Slot;
 use sp_api::impl_runtime_apis;
 use sp_block_participation::AsCardanoSPO;
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
-#[cfg(feature = "runtime-benchmarks")]
-use sp_core::ByteArray;
 use sp_core::{OpaqueMetadata, crypto::KeyTypeId};
 use sp_governed_map::MainChainScriptsV1;
 use sp_inherents::InherentIdentifier;
@@ -453,19 +451,6 @@ pub struct BlockProducerMetadataType {
 	pub hash: SizedByteString<32>,
 }
 
-#[cfg(feature = "runtime-benchmarks")]
-pub struct PalletBlockProductionLogBenchmarkHelper;
-
-#[cfg(feature = "runtime-benchmarks")]
-impl pallet_block_production_log::benchmarking::BenchmarkHelper<BlockAuthor>
-	for PalletBlockProductionLogBenchmarkHelper
-{
-	fn producer_id() -> BlockAuthor {
-		let id = sp_core::ecdsa::Public::from_slice(&[0u8; 33]).unwrap().into();
-		BlockAuthor::ProBono(id)
-	}
-}
-
 #[cfg(feature = "runtime-benchmarks")]
 pub struct PalletBlockProducerMetadataBenchmarkHelper;
 
@@ -512,12 +497,11 @@ impl
 
 impl pallet_block_production_log::Config for Runtime {
 	type BlockProducerId = BlockAuthor;
-	type WeightInfo = pallet_block_production_log::weights::SubstrateWeight<Runtime>;
 
 	type Moment = Slot;
 
-	#[cfg(feature = "runtime-benchmarks")]
-	type BenchmarkHelper = PalletBlockProductionLogBenchmarkHelper;
+	type GetMoment = Aura;
+	type GetAuthor = SessionCommitteeManagement;
 }
 
 parameter_types! {
@@ -789,7 +773,6 @@ mod benches {
 		[pallet_balances, Balances]
 		[pallet_timestamp, Timestamp]
 		[pallet_sudo, Sudo]
-		[pallet_block_production_log, BlockProductionLog]
 		[pallet_address_associations, AddressAssociations]
 		[pallet_block_producer_fees, BlockProducerFees]
 		[pallet_block_producer_metadata, BlockProducerMetadata]
@@ -1132,13 +1115,6 @@ impl_runtime_apis! {
 		}
 	}
 
-	impl sp_block_production_log::BlockProductionLogApi<Block, BlockAuthor, Slot>  for Runtime {
-		fn get_author(slot: &Slot) -> Option<BlockAuthor> {
-			SessionCommitteeManagement::get_current_authority_round_robin(u64::from(*slot) as usize)
-				.map(Into::into)
-		}
-	}
-
 	impl sp_block_participation::BlockParticipationApi<Block, BlockAuthor, Slot> for Runtime {
 		fn blocks_to_process(slot: &Slot) -> Vec<(Slot, BlockAuthor)> {
 			BlockParticipation::blocks_to_process(slot)

demo/runtime/src/lib.rs

@@ -13,7 +13,7 @@ committee and uses the Ariadne selection algorithm based on D-Param, Validator r
 and a permissioned candidate set, as provided by the `authority-selection-inherents` crate.
 
 The following components will be combined to handle block rewards:
-1. Block production log (implemented through crates `sp-block-production-log` and `pallet-block-production-log`)
+1. Block production log (implemented by `pallet-block-production-log` crate)
    to track information on the author of each block produced in the chain
 2. Address associations (implemented by the `pallet-address-associations` crate) to store and resolve
    mappings between Cardano and Partner Chain identities of SPOs and their delegators.
@@ -92,18 +92,19 @@ having no delegators). As such, this type must implement the `sp_block_participa
 to be constructable from `sidechain_domain::DelegatorKey`. To avoid any boilerplate, `sidechain_domain::DelegatorKey`
 itself can be used.
 
+#### Block production moment
+
+A `Moment` type representing the moment in time when a block was produced. This type can be a timestamp, slot or
+round number or some other monotonically rising value that can be converted to a timestamp. If it represents a time
+range, a representative timestamp, such as the start of the range should be computable from it.
+
 ### Adding the Partner Chains Toolkit components
 
 #### Block Production Log
 
-The pallet should be added to the runtime and configured to use `BlockAuthor` type as its `BlockProducerId`, and
-an inherent data provider of type `BlockAuthorInherentProvider<BlockAuthor>` should be added to both the proposal
-and verification IDP stack of the node.
-
-The runtime should implement the `BlockProductionLogApi` runtime API to expose the current block producer to the
-inherent data provider via the `get_author` method. This method's implementation depends on the consensus used by
-the partner chain. If the consensus mechanism used is Aura, the function `get_current_authority_round_robin`
-exposed by the Session Validator Management pallet should be used, which applies the same round-robin algorithm.
+The pallet should be added to the runtime and configured to use `BlockAuthor` type as its `BlockProducerId`
+and use the `Moment` type. Additionally, it must be provided a source of current block author and moment.
+These are provided out of the box for chains using Aura under feature flag `aura-compat`.
 
 #### Address Associations