A0-2097: refactor SessionBoundaries (#1028)

* refactor SessionBoundaries

Author: maciejnems

finality-aleph/src/abft/current.rs

@@ -1,8 +1,8 @@
-pub use aleph_primitives::CURRENT_FINALITY_VERSION as VERSION;
+pub use aleph_primitives::{BlockNumber, CURRENT_FINALITY_VERSION as VERSION};
 use current_aleph_bft::{default_config, Config, LocalIO, Terminator};
 use log::debug;
 use sp_blockchain::HeaderBackend;
-use sp_runtime::traits::Block;
+use sp_runtime::traits::{Block, Header};
 
 use crate::{
     abft::{common::unit_creation_delay_fn, NetworkWrapper, SpawnHandleT},
@@ -17,11 +17,7 @@ use crate::{
     CurrentNetworkData, Hasher, Keychain, NodeIndex, SessionId, SignatureSet, UnitCreationDelay,
 };
 
-pub fn run_member<
-    B: Block,
-    C: HeaderBackend<B> + Send + 'static,
-    ADN: Network<CurrentNetworkData<B>> + 'static,
->(
+pub fn run_member<B, C, ADN>(
     subtask_common: SubtaskCommon,
     multikeychain: Keychain,
     config: Config,
@@ -32,7 +28,13 @@ pub fn run_member<
     data_provider: impl current_aleph_bft::DataProvider<AlephData<B>> + Send + 'static,
     ordered_data_interpreter: OrderedDataInterpreter<B, C>,
     backup: ABFTBackup,
-) -> Task {
+) -> Task
+where
+    B: Block,
+    B::Header: Header<Number = BlockNumber>,
+    C: HeaderBackend<B> + Send + 'static,
+    ADN: Network<CurrentNetworkData<B>> + 'static,
+{
     let SubtaskCommon {
         spawn_handle,
         session_id,

finality-aleph/src/abft/legacy.rs

@@ -1,8 +1,8 @@
-pub use aleph_primitives::LEGACY_FINALITY_VERSION as VERSION;
+pub use aleph_primitives::{BlockNumber, LEGACY_FINALITY_VERSION as VERSION};
 use legacy_aleph_bft::{default_config, Config, LocalIO, Terminator};
 use log::debug;
 use sp_blockchain::HeaderBackend;
-use sp_runtime::traits::Block;
+use sp_runtime::traits::{Block, Header};
 
 use super::common::unit_creation_delay_fn;
 use crate::{
@@ -17,19 +17,21 @@ use crate::{
     Keychain, LegacyNetworkData, NodeIndex, SessionId, UnitCreationDelay,
 };
 
-pub fn run_member<
-    B: Block,
-    C: HeaderBackend<B> + Send + 'static,
-    ADN: Network<LegacyNetworkData<B>> + 'static,
->(
+pub fn run_member<B, C, ADN>(
     subtask_common: SubtaskCommon,
     multikeychain: Keychain,
     config: Config,
     network: NetworkWrapper<LegacyNetworkData<B>, ADN>,
     data_provider: impl legacy_aleph_bft::DataProvider<AlephData<B>> + Send + 'static,
     ordered_data_interpreter: OrderedDataInterpreter<B, C>,
     backup: ABFTBackup,
-) -> Task {
+) -> Task
+where
+    B: Block,
+    B::Header: Header<Number = BlockNumber>,
+    C: HeaderBackend<B> + Send + 'static,
+    ADN: Network<LegacyNetworkData<B>> + 'static,
+{
     let SubtaskCommon {
         spawn_handle,
         session_id,

finality-aleph/src/abft/traits.rs

@@ -2,10 +2,11 @@
 
 use std::{cmp::Ordering, fmt::Debug, hash::Hash as StdHash, marker::PhantomData, pin::Pin};
 
+use aleph_primitives::BlockNumber;
 use codec::{Codec, Decode, Encode};
 use futures::{channel::oneshot, Future, TryFutureExt};
 use sc_service::SpawnTaskHandle;
-use sp_api::BlockT;
+use sp_api::{BlockT, HeaderT};
 use sp_blockchain::HeaderBackend;
 use sp_runtime::traits::Hash as SpHash;
 
@@ -30,16 +31,22 @@ impl<B: BlockT> legacy_aleph_bft::DataProvider<AlephData<B>> for DataProvider<B>
     }
 }
 
-impl<B: BlockT, C: HeaderBackend<B> + Send + 'static>
-    current_aleph_bft::FinalizationHandler<AlephData<B>> for OrderedDataInterpreter<B, C>
+impl<B, C> current_aleph_bft::FinalizationHandler<AlephData<B>> for OrderedDataInterpreter<B, C>
+where
+    B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
+    C: HeaderBackend<B> + Send + 'static,
 {
     fn data_finalized(&mut self, data: AlephData<B>) {
         OrderedDataInterpreter::data_finalized(self, data)
     }
 }
 
-impl<B: BlockT, C: HeaderBackend<B> + Send + 'static>
-    legacy_aleph_bft::FinalizationHandler<AlephData<B>> for OrderedDataInterpreter<B, C>
+impl<B, C> legacy_aleph_bft::FinalizationHandler<AlephData<B>> for OrderedDataInterpreter<B, C>
+where
+    B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
+    C: HeaderBackend<B> + Send + 'static,
 {
     fn data_finalized(&mut self, data: AlephData<B>) {
         OrderedDataInterpreter::data_finalized(self, data)

finality-aleph/src/data_io/chain_info.rs

@@ -1,9 +1,10 @@
 use std::sync::Arc;
 
+use aleph_primitives::BlockNumber;
 use log::error;
 use lru::LruCache;
 use sc_client_api::HeaderBackend;
-use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor, One};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
 
 use crate::{data_io::ChainInfoCacheConfig, BlockHashNum};
 
@@ -20,6 +21,7 @@ pub trait ChainInfoProvider<B: BlockT> {
 impl<C, B> ChainInfoProvider<B> for Arc<C>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B>,
 {
     fn is_block_imported(&mut self, block: &BlockHashNum<B>) -> bool {
@@ -98,6 +100,7 @@ where
 impl<B, CIP> ChainInfoProvider<B> for CachedChainInfoProvider<B, CIP>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     CIP: ChainInfoProvider<B>,
 {
     fn is_block_imported(&mut self, block: &BlockHashNum<B>) -> bool {
@@ -179,6 +182,7 @@ where
 impl<B, CIP> ChainInfoProvider<B> for AuxFinalizationChainInfoProvider<B, CIP>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     CIP: ChainInfoProvider<B>,
 {
     fn is_block_imported(&mut self, block: &BlockHashNum<B>) -> bool {
@@ -197,7 +201,7 @@ where
         let mut curr_block = self.aux_finalized.clone();
         while curr_block.num > num {
             let parent_hash = self.chain_info_provider.get_parent_hash(&curr_block)?;
-            curr_block = (parent_hash, curr_block.num - NumberFor::<B>::one()).into();
+            curr_block = (parent_hash, curr_block.num - 1).into();
         }
         Ok(curr_block)
     }

finality-aleph/src/data_io/data_interpreter.rs

@@ -1,9 +1,10 @@
 use std::{default::Default, sync::Arc};
 
+use aleph_primitives::BlockNumber;
 use futures::channel::mpsc;
 use log::{debug, error, warn};
 use sc_client_api::HeaderBackend;
-use sp_runtime::traits::{Block as BlockT, NumberFor, One, Zero};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
 
 use crate::{
     data_io::{
@@ -21,20 +22,30 @@ type InterpretersChainInfoProvider<B, C> =
 /// Takes as input ordered `AlephData` from `AlephBFT` and pushes blocks that should be finalized
 /// to an output channel. The other end of the channel is held by the aggregator whose goal is to
 /// create multisignatures under the finalized blocks.
-pub struct OrderedDataInterpreter<B: BlockT, C: HeaderBackend<B>> {
+pub struct OrderedDataInterpreter<B, C>
+where
+    B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
+    C: HeaderBackend<B>,
+{
     blocks_to_finalize_tx: mpsc::UnboundedSender<BlockHashNum<B>>,
     chain_info_provider: InterpretersChainInfoProvider<B, C>,
     last_finalized_by_aleph: BlockHashNum<B>,
-    session_boundaries: SessionBoundaries<B>,
+    session_boundaries: SessionBoundaries,
 }
 
-fn get_last_block_prev_session<B: BlockT, C: HeaderBackend<B>>(
-    session_boundaries: SessionBoundaries<B>,
+fn get_last_block_prev_session<B, C>(
+    session_boundaries: SessionBoundaries,
     mut client: Arc<C>,
-) -> BlockHashNum<B> {
-    if session_boundaries.first_block() > NumberFor::<B>::zero() {
+) -> BlockHashNum<B>
+where
+    B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
+    C: HeaderBackend<B>,
+{
+    if session_boundaries.first_block() > 0 {
         // We are in session > 0, we take the last block of previous session.
-        let last_prev_session_num = session_boundaries.first_block() - NumberFor::<B>::one();
+        let last_prev_session_num = session_boundaries.first_block() - 1;
         client.get_finalized_at(last_prev_session_num).expect(
             "Last block of previous session must have been finalized before starting the current",
         )
@@ -46,11 +57,16 @@ fn get_last_block_prev_session<B: BlockT, C: HeaderBackend<B>>(
     }
 }
 
-impl<B: BlockT, C: HeaderBackend<B>> OrderedDataInterpreter<B, C> {
+impl<B, C> OrderedDataInterpreter<B, C>
+where
+    B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
+    C: HeaderBackend<B>,
+{
     pub fn new(
         blocks_to_finalize_tx: mpsc::UnboundedSender<BlockHashNum<B>>,
         client: Arc<C>,
-        session_boundaries: SessionBoundaries<B>,
+        session_boundaries: SessionBoundaries,
     ) -> Self {
         let last_finalized_by_aleph =
             get_last_block_prev_session(session_boundaries.clone(), client.clone());

finality-aleph/src/data_io/data_provider.rs

@@ -1,12 +1,13 @@
 use std::{sync::Arc, time::Duration};
 
+use aleph_primitives::BlockNumber;
 use futures::channel::oneshot;
 use log::{debug, warn};
 use parking_lot::Mutex;
 use sc_client_api::HeaderBackend;
 use sp_consensus::SelectChain;
 use sp_runtime::{
-    traits::{Block as BlockT, Header as HeaderT, NumberFor, One, Zero},
+    traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero},
     SaturatedConversion,
 };
 
@@ -41,13 +42,14 @@ where
 pub fn get_parent<B, C>(client: &C, block: &BlockHashNum<B>) -> Option<BlockHashNum<B>>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B>,
 {
     if block.num.is_zero() {
         return None;
     }
     if let Some(header) = client.header(block.hash).expect("client must respond") {
-        Some((*header.parent_hash(), block.num - <NumberFor<B>>::one()).into())
+        Some((*header.parent_hash(), block.num - 1).into())
     } else {
         warn!(target: "aleph-data-store", "Trying to fetch the parent of an unknown block {:?}.", block);
         None
@@ -61,6 +63,7 @@ pub fn get_proposal<B, C>(
 ) -> Result<AlephData<B>, ()>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B>,
 {
     let mut curr_block = best_block;
@@ -115,27 +118,29 @@ struct ChainInfo<B: BlockT> {
 pub struct ChainTracker<B, SC, C>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B> + 'static,
     SC: SelectChain<B> + 'static,
 {
     select_chain: SC,
     client: Arc<C>,
     data_to_propose: Arc<Mutex<Option<AlephData<B>>>>,
-    session_boundaries: SessionBoundaries<B>,
+    session_boundaries: SessionBoundaries,
     prev_chain_info: Option<ChainInfo<B>>,
     config: ChainTrackerConfig,
 }
 
 impl<B, SC, C> ChainTracker<B, SC, C>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B> + 'static,
     SC: SelectChain<B> + 'static,
 {
     pub fn new(
         select_chain: SC,
         client: Arc<C>,
-        session_boundaries: SessionBoundaries<B>,
+        session_boundaries: SessionBoundaries,
         config: ChainTrackerConfig,
         metrics: Option<Metrics<<B::Header as HeaderT>::Hash>>,
     ) -> (Self, DataProvider<B>) {
@@ -335,7 +340,7 @@ mod tests {
             client_chain_builder::ClientChainBuilder,
             mocks::{aleph_data_from_blocks, TBlock, TestClientBuilder, TestClientBuilderExt},
         },
-        SessionBoundaries, SessionId, SessionPeriod,
+        SessionBoundaryInfo, SessionId, SessionPeriod,
     };
 
     const SESSION_LEN: u32 = 100;
@@ -354,7 +359,8 @@ mod tests {
 
         let chain_builder =
             ClientChainBuilder::new(client.clone(), Arc::new(TestClientBuilder::new().build()));
-        let session_boundaries = SessionBoundaries::new(SessionId(0), SessionPeriod(SESSION_LEN));
+        let session_boundaries = SessionBoundaryInfo::new(SessionPeriod(SESSION_LEN))
+            .boundaries_for_session(SessionId(0));
 
         let config = ChainTrackerConfig {
             refresh_interval: REFRESH_INTERVAL,

finality-aleph/src/data_io/data_store.rs

@@ -6,6 +6,7 @@ use std::{
     time::{self, Duration},
 };
 
+use aleph_primitives::BlockNumber;
 use futures::{
     channel::{
         mpsc::{self, UnboundedSender},
@@ -176,6 +177,7 @@ impl Default for DataStoreConfig {
 pub struct DataStore<B, C, RB, Message, R>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B> + BlockchainEvents<B> + Send + Sync + 'static,
     RB: RequestBlocks<B> + 'static,
     Message:
@@ -192,7 +194,7 @@ where
     available_proposals_cache: LruCache<AlephProposal<B>, ProposalStatus<B>>,
     num_triggers_registered_since_last_pruning: usize,
     highest_finalized_num: NumberFor<B>,
-    session_boundaries: SessionBoundaries<B>,
+    session_boundaries: SessionBoundaries,
     client: Arc<C>,
     block_requester: RB,
     config: DataStoreConfig,
@@ -203,6 +205,7 @@ where
 impl<B, C, RB, Message, R> DataStore<B, C, RB, Message, R>
 where
     B: BlockT,
+    B::Header: HeaderT<Number = BlockNumber>,
     C: HeaderBackend<B> + BlockchainEvents<B> + Send + Sync + 'static,
     RB: RequestBlocks<B> + 'static,
     Message:
@@ -211,7 +214,7 @@ where
 {
     /// Returns a struct to be run and a network that outputs messages filtered as appropriate
     pub fn new<N: ComponentNetwork<Message, R = R>>(
-        session_boundaries: SessionBoundaries<B>,
+        session_boundaries: SessionBoundaries,
         client: Arc<C>,
         block_requester: RB,
         config: DataStoreConfig,