sc-block-builder: Remove BlockBuilderProvider (#2099)

The `BlockBuilderProvider` was a trait that was defined in
`sc-block-builder`. The trait was implemented for `Client`. This
basically meant that you needed to import `sc-block-builder` any way to
have access to the block builder. So, this trait was not providing any
real value. This pull request is removing the said trait. Instead of the
trait it introduces a builder for creating a `BlockBuilder`. The builder
currently has the quite fabulous name `BlockBuilderBuilder` (I'm open to
any better name 😅). The rest of the pull request is about
replacing the old trait with the new builder.

# Downstream code changes

If you used `new_block` or `new_block_at` before you now need to switch
it over to the new `BlockBuilderBuilder` pattern:

```rust
// `new` requires a type that implements `CallApiAt`. 
let mut block_builder = BlockBuilderBuilder::new(client)
                // Then you need to specify the hash of the parent block the block will be build on top of
		.on_parent_block(at)
                // The block builder also needs the block number of the parent block. 
                // Here it is fetched from the given `client` using the `HeaderBackend`
                // However, there also exists `with_parent_block_number` for directly passing the number
		.fetch_parent_block_number(client)
		.unwrap()
                // Enable proof recording if required. This call is optional.
		.enable_proof_recording()
                // Pass the digests. This call is optional.
                .with_inherent_digests(digests)
		.build()
		.expect("Creates new block builder");
```

---------

Co-authored-by: Sebastian Kunert <skunert49@gmail.com>
Co-authored-by: command-bot <>

substrate/client/consensus/aura/src/lib.rs

@@ -548,7 +548,7 @@ where
 mod tests {
 	use super::*;
 	use parking_lot::Mutex;
-	use sc_block_builder::BlockBuilderProvider;
+	use sc_block_builder::BlockBuilderBuilder;
 	use sc_client_api::BlockchainEvents;
 	use sc_consensus::BoxJustificationImport;
 	use sc_consensus_slots::{BackoffAuthoringOnFinalizedHeadLagging, SimpleSlotWorker};
@@ -604,7 +604,14 @@ mod tests {
 			_: Duration,
 			_: Option<usize>,
 		) -> Self::Proposal {
-			let r = self.1.new_block(digests).unwrap().build().map_err(|e| e.into());
+			let r = BlockBuilderBuilder::new(&*self.1)
+				.on_parent_block(self.1.chain_info().best_hash)
+				.fetch_parent_block_number(&*self.1)
+				.unwrap()
+				.with_inherent_digests(digests)
+				.build()
+				.unwrap()
+				.build();
 
 			future::ready(r.map(|b| Proposal {
 				block: b.block,

substrate/client/consensus/babe/src/tests.rs

@@ -20,7 +20,7 @@
 
 use super::*;
 use authorship::claim_slot;
-use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
+use sc_block_builder::{BlockBuilder, BlockBuilderBuilder};
 use sc_client_api::{BlockchainEvents, Finalizer};
 use sc_consensus::{BoxBlockImport, BoxJustificationImport};
 use sc_consensus_epochs::{EpochIdentifier, EpochIdentifierPosition};
@@ -98,8 +98,13 @@ impl DummyProposer {
 		&mut self,
 		pre_digests: Digest,
 	) -> future::Ready<Result<Proposal<TestBlock, ()>, Error>> {
-		let block_builder =
-			self.factory.client.new_block_at(self.parent_hash, pre_digests, false).unwrap();
+		let block_builder = BlockBuilderBuilder::new(&*self.factory.client)
+			.on_parent_block(self.parent_hash)
+			.fetch_parent_block_number(&*self.factory.client)
+			.unwrap()
+			.with_inherent_digests(pre_digests)
+			.build()
+			.unwrap();
 
 		let mut block = match block_builder.build().map_err(|e| e.into()) {
 			Ok(b) => b.block,
@@ -297,7 +302,7 @@ impl TestNetFactory for BabeTestNet {
 async fn rejects_empty_block() {
 	sp_tracing::try_init_simple();
 	let mut net = BabeTestNet::new(3);
-	let block_builder = |builder: BlockBuilder<_, _, _>| builder.build().unwrap().block;
+	let block_builder = |builder: BlockBuilder<_, _>| builder.build().unwrap().block;
 	net.mut_peers(|peer| {
 		peer[0].generate_blocks(1, BlockOrigin::NetworkInitialSync, block_builder);
 	})

substrate/client/consensus/beefy/src/tests.rs

@@ -35,6 +35,7 @@ use crate::{
 };
 use futures::{future, stream::FuturesUnordered, Future, FutureExt, StreamExt};
 use parking_lot::Mutex;
+use sc_block_builder::BlockBuilderBuilder;
 use sc_client_api::{Backend as BackendT, BlockchainEvents, FinalityNotifications, HeaderBackend};
 use sc_consensus::{
 	BlockImport, BlockImportParams, BoxJustificationImport, ForkChoiceStrategy, ImportResult,
@@ -741,7 +742,6 @@ async fn correct_beefy_payload() {
 #[tokio::test]
 async fn beefy_importing_justifications() {
 	use futures::{future::poll_fn, task::Poll};
-	use sc_block_builder::BlockBuilderProvider;
 	use sc_client_api::BlockBackend;
 
 	sp_tracing::try_init_simple();
@@ -774,8 +774,10 @@ async fn beefy_importing_justifications() {
 			.and_then(|j| j.get(BEEFY_ENGINE_ID).cloned())
 	};
 
-	let builder = full_client
-		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+	let builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(full_client.genesis_hash())
+		.with_parent_block_number(0)
+		.build()
 		.unwrap();
 	let block = builder.build().unwrap().block;
 	let hashof1 = block.header.hash();
@@ -792,7 +794,11 @@ async fn beefy_importing_justifications() {
 
 	// Import block 2 with "valid" justification (beefy pallet genesis block not yet reached).
 	let block_num = 2;
-	let builder = full_client.new_block_at(hashof1, Default::default(), false).unwrap();
+	let builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(hashof1)
+		.with_parent_block_number(1)
+		.build()
+		.unwrap();
 	let block = builder.build().unwrap().block;
 	let hashof2 = block.header.hash();
 
@@ -824,7 +830,11 @@ async fn beefy_importing_justifications() {
 
 	// Import block 3 with valid justification.
 	let block_num = 3;
-	let builder = full_client.new_block_at(hashof2, Default::default(), false).unwrap();
+	let builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(hashof2)
+		.with_parent_block_number(2)
+		.build()
+		.unwrap();
 	let block = builder.build().unwrap().block;
 	let hashof3 = block.header.hash();
 	let proof = crate::justification::tests::new_finality_proof(block_num, &good_set, keys);
@@ -858,7 +868,11 @@ async fn beefy_importing_justifications() {
 
 	// Import block 4 with invalid justification (incorrect validator set).
 	let block_num = 4;
-	let builder = full_client.new_block_at(hashof3, Default::default(), false).unwrap();
+	let builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(hashof3)
+		.with_parent_block_number(3)
+		.build()
+		.unwrap();
 	let block = builder.build().unwrap().block;
 	let hashof4 = block.header.hash();
 	let keys = &[BeefyKeyring::Alice];

substrate/client/consensus/grandpa/rpc/src/lib.rs

@@ -142,7 +142,7 @@ mod tests {
 		RpcModule,
 	};
 	use parity_scale_codec::{Decode, Encode};
-	use sc_block_builder::{BlockBuilder, RecordProof};
+	use sc_block_builder::BlockBuilderBuilder;
 	use sc_consensus_grandpa::{
 		report, AuthorityId, FinalityProof, GrandpaJustification, GrandpaJustificationSender,
 	};
@@ -335,21 +335,16 @@ mod tests {
 		let peers = &[Ed25519Keyring::Alice];
 
 		let builder = TestClientBuilder::new();
-		let backend = builder.backend();
 		let client = builder.build();
 		let client = Arc::new(client);
 
-		let built_block = BlockBuilder::new(
-			&*client,
-			client.info().best_hash,
-			client.info().best_number,
-			RecordProof::No,
-			Default::default(),
-			&*backend,
-		)
-		.unwrap()
-		.build()
-		.unwrap();
+		let built_block = BlockBuilderBuilder::new(&*client)
+			.on_parent_block(client.info().best_hash)
+			.with_parent_block_number(client.info().best_number)
+			.build()
+			.unwrap()
+			.build()
+			.unwrap();
 
 		let block = built_block.block;
 		let block_hash = block.hash();

substrate/client/consensus/grandpa/src/finality_proof.rs

@@ -261,7 +261,7 @@ mod tests {
 	use super::*;
 	use crate::{authorities::AuthoritySetChanges, BlockNumberOps, ClientError, SetId};
 	use futures::executor::block_on;
-	use sc_block_builder::BlockBuilderProvider;
+	use sc_block_builder::BlockBuilderBuilder;
 	use sc_client_api::{apply_aux, LockImportRun};
 	use sp_consensus::BlockOrigin;
 	use sp_consensus_grandpa::GRANDPA_ENGINE_ID as ID;
@@ -323,7 +323,14 @@ mod tests {
 
 		let mut blocks = Vec::new();
 		for _ in 0..number_of_blocks {
-			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			let block = BlockBuilderBuilder::new(&*client)
+				.on_parent_block(client.chain_info().best_hash)
+				.with_parent_block_number(client.chain_info().best_number)
+				.build()
+				.unwrap()
+				.build()
+				.unwrap()
+				.block;
 			block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
 			blocks.push(block);
 		}

substrate/client/consensus/grandpa/src/tests.rs

@@ -54,7 +54,7 @@ use tokio::runtime::Handle;
 
 use authorities::AuthoritySet;
 use communication::grandpa_protocol_name;
-use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
+use sc_block_builder::{BlockBuilder, BlockBuilderBuilder};
 use sc_consensus::LongestChain;
 use sp_application_crypto::key_types::GRANDPA;
 
@@ -897,8 +897,11 @@ async fn allows_reimporting_change_blocks() {
 	let (mut block_import, ..) = net.make_block_import(client.clone());
 
 	let full_client = client.as_client();
-	let mut builder = full_client
-		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+	let mut builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(full_client.chain_info().best_hash)
+		.fetch_parent_block_number(&*full_client)
+		.unwrap()
+		.build()
 		.unwrap();
 
 	add_scheduled_change(
@@ -942,8 +945,11 @@ async fn test_bad_justification() {
 	let (mut block_import, ..) = net.make_block_import(client.clone());
 
 	let full_client = client.as_client();
-	let mut builder = full_client
-		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+	let mut builder = BlockBuilderBuilder::new(&*full_client)
+		.on_parent_block(full_client.chain_info().best_hash)
+		.fetch_parent_block_number(&*full_client)
+		.unwrap()
+		.build()
 		.unwrap();
 
 	add_scheduled_change(
@@ -1913,7 +1919,12 @@ async fn imports_justification_for_regular_blocks_on_import() {
 
 	// create a new block (without importing it)
 	let generate_block = |parent| {
-		let builder = full_client.new_block_at(parent, Default::default(), false).unwrap();
+		let builder = BlockBuilderBuilder::new(&*full_client)
+			.on_parent_block(parent)
+			.fetch_parent_block_number(&*full_client)
+			.unwrap()
+			.build()
+			.unwrap();
 		builder.build().unwrap().block
 	};
 
@@ -2042,8 +2053,7 @@ async fn revert_prunes_authority_changes() {
 
 	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
 
-	type TestBlockBuilder<'a> =
-		BlockBuilder<'a, Block, PeersFullClient, substrate_test_runtime_client::Backend>;
+	type TestBlockBuilder<'a> = BlockBuilder<'a, Block, PeersFullClient>;
 	let edit_block = |mut builder: TestBlockBuilder| {
 		add_scheduled_change(
 			&mut builder,

substrate/client/consensus/grandpa/src/voting_rule.rs

@@ -330,7 +330,7 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sc_block_builder::BlockBuilderProvider;
+	use sc_block_builder::BlockBuilderBuilder;
 	use sp_consensus::BlockOrigin;
 	use sp_runtime::traits::Header as _;
 
@@ -371,7 +371,14 @@ mod tests {
 		let mut hashes = Vec::with_capacity(200);
 
 		for _ in 0..200 {
-			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			let block = BlockBuilderBuilder::new(&*client)
+				.on_parent_block(client.chain_info().best_hash)
+				.with_parent_block_number(client.chain_info().best_number)
+				.build()
+				.unwrap()
+				.build()
+				.unwrap()
+				.block;
 			hashes.push(block.hash());
 
 			futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
@@ -414,7 +421,14 @@ mod tests {
 		let n = 5;
 		let mut hashes = Vec::with_capacity(n);
 		for _ in 0..n {
-			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			let block = BlockBuilderBuilder::new(&*client)
+				.on_parent_block(client.chain_info().best_hash)
+				.with_parent_block_number(client.chain_info().best_number)
+				.build()
+				.unwrap()
+				.build()
+				.unwrap()
+				.block;
 			hashes.push(block.hash());
 
 			futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();

substrate/client/consensus/grandpa/src/warp_proof.rs

@@ -322,7 +322,7 @@ mod tests {
 	use crate::{AuthoritySetChanges, GrandpaJustification};
 	use parity_scale_codec::Encode;
 	use rand::prelude::*;
-	use sc_block_builder::BlockBuilderProvider;
+	use sc_block_builder::BlockBuilderBuilder;
 	use sp_blockchain::HeaderBackend;
 	use sp_consensus::BlockOrigin;
 	use sp_consensus_grandpa::GRANDPA_ENGINE_ID;
@@ -348,7 +348,11 @@ mod tests {
 		let mut authority_set_changes = Vec::new();
 
 		for n in 1..=100 {
-			let mut builder = client.new_block(Default::default()).unwrap();
+			let mut builder = BlockBuilderBuilder::new(&*client)
+				.on_parent_block(client.chain_info().best_hash)
+				.with_parent_block_number(client.chain_info().best_number)
+				.build()
+				.unwrap();
 			let mut new_authorities = None;
 
 			// we will trigger an authority set change every 10 blocks