fatp: maintenance on every block imported

This should reduce the number of empty blocks, which are built when
block builder is building upon blocks that are unknown to transaction
pool.

The ligh-maintain fallback will also be implemented.

substrate/client/api/src/client.rs

@@ -410,7 +410,7 @@ impl<B: BlockT> TryFrom<BlockImportNotification<B>> for ChainEvent<B> {
 		if n.is_new_best {
 			Ok(Self::NewBestBlock { hash: n.hash, tree_route: n.tree_route })
 		} else {
-			Err(())
+			Ok(Self::NewBlock { hash: n.hash })
 		}
 	}
 }

substrate/client/transaction-pool/api/src/lib.rs

@@ -350,6 +350,11 @@ impl<T> ReadyTransactions for std::iter::Empty<T> {
 /// Events that the transaction pool listens for.
 #[derive(Debug)]
 pub enum ChainEvent<B: BlockT> {
+	/// New block have been added to the chain.
+	NewBlock {
+		/// Hash of the block.
+		hash: B::Hash,
+	},
 	/// New best block have been added to the chain.
 	NewBestBlock {
 		/// Hash of the block.
@@ -372,7 +377,9 @@ impl<B: BlockT> ChainEvent<B> {
 	/// Returns the block hash associated to the event.
 	pub fn hash(&self) -> B::Hash {
 		match self {
-			Self::NewBestBlock { hash, .. } | Self::Finalized { hash, .. } => *hash,
+			Self::NewBlock { hash, .. } |
+			Self::NewBestBlock { hash, .. } |
+			Self::Finalized { hash, .. } => *hash,
 		}
 	}
 

substrate/client/transaction-pool/src/common/enactment_state.rs

@@ -177,7 +177,8 @@ where
 	/// fallback when tree_route cannot be computed.
 	pub fn force_update(&mut self, event: &ChainEvent<Block>) {
 		match event {
-			ChainEvent::NewBestBlock { hash, .. } => self.recent_best_block = *hash,
+			ChainEvent::NewBlock { hash, .. } | ChainEvent::NewBestBlock { hash, .. } =>
+				self.recent_best_block = *hash,
 			ChainEvent::Finalized { hash, .. } => self.recent_finalized_block = *hash,
 		};
 		log::debug!(

substrate/client/transaction-pool/src/fork_aware_txpool/fork_aware_txpool.rs

@@ -1124,7 +1124,7 @@ where
 		};
 
 		match event {
-			ChainEvent::NewBestBlock { .. } => {},
+			ChainEvent::NewBestBlock { .. } | ChainEvent::NewBlock { .. }=> {},
 			ChainEvent::Finalized { hash, ref tree_route } => {
 				self.handle_finalized(hash, tree_route).await;
 

substrate/client/transaction-pool/src/single_state_txpool/single_state_txpool.rs

@@ -718,6 +718,10 @@ where
 	PoolApi: 'static + graph::ChainApi<Block = Block>,
 {
 	async fn maintain(&self, event: ChainEvent<Self::Block>) {
+		if matches!(event, ChainEvent::NewBlock{..}) {
+			return
+		}
+
 		let prev_finalized_block = self.enactment_state.lock().recent_finalized_block();
 		let compute_tree_route = |from, to| -> Result<TreeRoute<Block>, String> {
 			match self.api.tree_route(from, to) {