Remove code from previous approach

client/api/src/backend.rs

@@ -69,17 +69,6 @@ pub struct ImportSummary<Block: BlockT> {
 	pub retracted: Vec<Block::Hash>,
 }
 
-/// Summary of a Justification event.
-///
-/// Contains the most recently finalized block as well
-/// as a justification for its finalization.
-pub struct JustificationSummary<Block: BlockT> {
-	/// Most recently finalized header.
-	pub header: Block::Header,
-	/// A justification proving that the given block was finalized.
-	pub justification: Justification,
-}
-
 /// Import operation wrapper
 pub struct ClientImportOperation<Block: BlockT, B: Backend<Block>> {
 	/// DB Operation.
@@ -88,8 +77,6 @@ pub struct ClientImportOperation<Block: BlockT, B: Backend<Block>> {
 	pub notify_imported: Option<ImportSummary<Block>>,
 	/// A list of hashes of blocks that got finalized.
 	pub notify_finalized: Vec<Block::Hash>,
-	/// Best finalized block and accompanying justification.
-	pub notify_justified: Option<JustificationSummary<Block>>,
 }
 
 /// State of a new block.

client/api/src/client.rs

@@ -36,9 +36,6 @@ pub type ImportNotifications<Block> = TracingUnboundedReceiver<BlockImportNotifi
 /// A stream of block finality notifications.
 pub type FinalityNotifications<Block> = TracingUnboundedReceiver<FinalityNotification<Block>>;
 
-/// A stream of Grandpa Justification notifications.
-pub type JustificationNotifications<Block> = TracingUnboundedReceiver<JustificationNotification<Block>>;
-
 /// Expected hashes of blocks at given heights.
 ///
 /// This may be used as chain spec extension to set trusted checkpoints, i.e.
@@ -67,12 +64,6 @@ pub trait BlockchainEvents<Block: BlockT> {
 	/// finalized block.
 	fn finality_notification_stream(&self) -> FinalityNotifications<Block>;
 
-	/// Get a stream of Grandpa justifications alongside the best block that's
-	/// been finalized with that justification.
-	///
-	/// Idk about the guarantees around the frequency of this yet
-	fn justification_notification_stream(&self) -> JustificationNotifications<Block>;
-
 	/// Get storage changes event stream.
 	///
 	/// Passing `None` as `filter_keys` subscribes to all storage changes.
@@ -255,12 +246,3 @@ pub struct FinalityNotification<Block: BlockT> {
 	/// Imported block header.
 	pub header: Block::Header,
 }
-
-/// Justification for a finalized block.
-#[derive(Clone, Debug)]
-pub struct JustificationNotification<Block: BlockT> {
-	/// Highest finalized block header
-	pub header: Block::Header,
-	/// A justification that the given header has been finalized
-	pub justification: Justification,
-}

client/src/client.rs

@@ -64,13 +64,12 @@ use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
 pub use sc_client_api::{
 	backend::{
 		self, BlockImportOperation, PrunableStateChangesTrieStorage,
-		ClientImportOperation, Finalizer, ImportSummary, JustificationSummary, NewBlockState,
+		ClientImportOperation, Finalizer, ImportSummary, NewBlockState,
 		changes_tries_state_at_block, StorageProvider,
 		LockImportRun,
 	},
 	client::{
 		ImportNotifications, FinalityNotification, FinalityNotifications, BlockImportNotification,
-		JustificationNotification, JustificationNotifications,
 		ClientInfo, BlockchainEvents, BlockBackend, ProvideUncles, BadBlocks, ForkBlocks,
 		BlockOf,
 	},
@@ -96,7 +95,6 @@ pub struct Client<B, E, Block, RA> where Block: BlockT {
 	storage_notifications: Mutex<StorageNotifications<Block>>,
 	import_notification_sinks: Mutex<Vec<TracingUnboundedSender<BlockImportNotification<Block>>>>,
 	finality_notification_sinks: Mutex<Vec<TracingUnboundedSender<FinalityNotification<Block>>>>,
-	justification_notification_sinks: Mutex<Vec<TracingUnboundedSender<JustificationNotification<Block>>>>,
 	// holds the block hash currently being imported. TODO: replace this with block queue
 	importing_block: RwLock<Option<Block::Hash>>,
 	block_rules: BlockRules<Block>,
@@ -206,7 +204,6 @@ impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA>
 				op: self.backend.begin_operation()?,
 				notify_imported: None,
 				notify_finalized: Vec::new(),
-				notify_justified: None,
 			};
 
 			let r = f(&mut op)?;
@@ -215,14 +212,11 @@ impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA>
 				op,
 				notify_imported,
 				notify_finalized,
-				notify_justified,
 			} = op;
 			self.backend.commit_operation(op)?;
 
-			// Q: Does the order of these matter?
 			self.notify_finalized(notify_finalized)?;
 			self.notify_imported(notify_imported)?;
-			self.notify_justified(notify_justified)?;
 
 			Ok(r)
 		};
@@ -289,7 +283,6 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 			storage_notifications: Default::default(),
 			import_notification_sinks: Default::default(),
 			finality_notification_sinks: Default::default(),
-			justification_notification_sinks: Default::default(),
 			importing_block: Default::default(),
 			block_rules: BlockRules::new(fork_blocks, bad_blocks),
 			execution_extensions,
@@ -625,7 +618,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		if let Ok(ImportResult::Imported(ref aux)) = result {
 			if aux.is_new_best {
 				use rand::Rng;
-				
+
 				// don't send telemetry block import events during initial sync for every
 				// block to avoid spamming the telemetry server, these events will be randomly
 				// sent at a rate of 1/10.
@@ -906,19 +899,6 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 			for finalized in &enacted[start..] {
 				operation.notify_finalized.push(finalized.hash);
 			}
-
-			// Only want to notify if a block was "explicitly" finalized
-			// instead of one that was implicitly finlized
-			if let Some(justification) = justification {
-				// TODO: Check that this expect() holds true
-				let header = self.header(&BlockId::Hash(block))?
-					.expect("header already known to exist in DB because it is indicated in the tree route; qed");
-				operation.notify_justified = Some(JustificationSummary {
-					header,
-					justification,
-				});
-			}
-
 		}
 
 		Ok(())
@@ -1004,34 +984,6 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		Ok(())
 	}
 
-	fn notify_justified(
-		&self,
-		notify_justified: Option<JustificationSummary<Block>>,
-	) -> sp_blockchain::Result<()> {
-		let notify_justified = match notify_justified {
-			Some(notify_justified) => notify_justified,
-			None => {
-				// Clean up unused justification notification
-				// Is this neccesary though?
-				self.justification_notification_sinks
-					.lock()
-					.retain(|sink| !sink.is_closed());
-
-				return Ok(());
-			}
-		};
-
-		let notification = JustificationNotification::<Block> {
-			header: notify_justified.header,
-			justification: notify_justified.justification,
-		};
-
-		self.justification_notification_sinks.lock()
-			.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
-
-		Ok(())
-	}
-
 	/// Attempts to revert the chain by `n` blocks guaranteeing that no block is
 	/// reverted past the last finalized block. Returns the number of blocks
 	/// that were successfully reverted.
@@ -1829,12 +1781,6 @@ where
 		stream
 	}
 
-	fn justification_notification_stream(&self) -> JustificationNotifications<Block> {
-		let (sink, stream) = tracing_unbounded("mpsc_justification_notification_stream");
-		self.justification_notification_sinks.lock().push(sink);
-		stream
-	}
-
 	/// Get storage changes event stream.
 	fn storage_changes_notification_stream(
 		&self,