partial implementation of propose fn

Doesn't actually compile yet; need to bring in some other
commits to ensure ProvisionerMessage is a thing, and also
figure out how to get the block hash given the current
context.

node/core/proposer/Cargo.toml

@@ -9,6 +9,7 @@ futures = "0.3.4"
 futures-timer = "3.0.1"
 log = "0.4.8"
 parity-scale-codec = "1.3.0"
+polkadot-node-messages = { path = "../../messages" }
 polkadot-overseer = { path = "../../overseer" }
 polkadot-primitives = { path = "../../../primitives" }
 sc-basic-authorship = { git = "https://github.com/paritytech/substrate", branch = "master" }

node/core/proposer/src/lib.rs

@@ -1,14 +1,15 @@
-use futures::future;
+use futures::prelude::*;
 use polkadot_overseer::OverseerHandler;
-use polkadot_primitives::{parachain::ParachainHost, Block, Header};
+use polkadot_node_messages::{AllMessages, ProvisionableData, ProvisionerMessage};
+use polkadot_primitives::{inclusion_inherent, parachain::ParachainHost, Block, Header};
 use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
 use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_blockchain::HeaderBackend;
 use sp_consensus::{Proposal, RecordProof};
 use sp_inherents::InherentData;
 use sp_runtime::traits::{DigestFor, HashFor};
 use sp_transaction_pool::TransactionPool;
-use std::{sync::Arc, time};
+use std::{pin::Pin, sync::Arc, time};
 
 /// Custom Proposer factory for Polkadot
 pub struct ProposerFactory<TxPool, Backend, Client> {
@@ -46,7 +47,9 @@ where
 	// Rust bug: https://github.com/rust-lang/rust/issues/24159
 	sp_api::StateBackendFor<Client, Block>: sp_api::StateBackend<HashFor<Block>> + Send,
 {
-	type CreateProposer = future::Ready<Result<Self::Proposer, Self::Error>>;
+	type CreateProposer = Pin<Box<
+		dyn Future<Output = Result<Self::Proposer, Self::Error>> + Send + 'static
+	>>;
 	type Proposer = Proposer<TxPool, Backend, Client>;
 	type Error = sp_blockchain::Error;
 
@@ -57,6 +60,7 @@ where
 
 pub struct Proposer<TxPool: TransactionPool<Block = Block>, Backend, Client> {
 	inner: sc_basic_authorship::Proposer<Backend, Block, Client, TxPool>,
+	overseer: OverseerHandler,
 }
 
 impl<TxPool, Backend, Client> sp_consensus::Proposer<Block> for Proposer<TxPool, Backend, Client>
@@ -76,17 +80,54 @@ where
 	sp_api::StateBackendFor<Client, Block>: sp_api::StateBackend<HashFor<Block>> + Send,
 {
 	type Transaction = sc_client_api::TransactionFor<Backend, Block>;
-	type Proposal =
-		tokio_executor::blocking::Blocking<Result<Proposal<Block, Self::Transaction>, Self::Error>>;
-	type Error = sp_blockchain::Error;
+	type Proposal = Pin<Box<dyn Future<Output = Result<Proposal<Block, sp_api::TransactionFor<Client, Block>>, Error>> + Send>>;
+	type Error = Error;
 
 	fn propose(
 		self,
-		inherent_data: InherentData,
+		mut inherent_data: InherentData,
 		inherent_digests: DigestFor<Block>,
 		max_duration: time::Duration,
 		record_proof: RecordProof,
 	) -> Self::Proposal {
-		unimplemented!()
+		// REVIEW: per the guide, block authors must re-send a new request for block authorship data
+		// for each block. I'm assuming that this function gets called once per block, but it is not
+		// obvious from the documentation that that assumption is in fact true.
+		let (sender, receiver) = futures::channel::mpsc::channel(1);
+		let mut bitfields = Vec::new();
+		let mut candidates = Vec::new();
+
+		async move {
+			self.overseer.send_msg(AllMessages::ProvisionerMessage(ProvisionerMessage::RequestBlockAuthorshipData(unimplemented!(), sender)));
+			receiver.for_each_concurrent(None, |item| {
+				match item {
+					ProvisionableData::Bitfield(_, signed_bitfield) => bitfields.push(signed_bitfield),
+					ProvisionableData::BackedCandidate(candidate) => candidates.push(candidate),
+					_ => {},
+				}
+			});
+			inherent_data.put_data(inclusion_inherent::INHERENT_IDENTIFIER, &(bitfields, candidates))
+				.map_err(Error::Inherent)?;
+			self.inner.propose(inherent_data, inherent_digests, max_duration, record_proof).await.map_err(Into::into)
+		}.boxed()
+	}
+}
+
+#[derive(Debug)]
+pub enum Error {
+	Consensus(sp_consensus::Error),
+	Blockchain(sp_blockchain::Error),
+	Inherent(sp_inherents::Error),
+}
+
+impl From<sp_consensus::Error> for Error {
+	fn from(e: sp_consensus::Error) -> Error {
+		Error::Consensus(e)
+	}
+}
+
+impl From<sp_blockchain::Error> for Error {
+	fn from(e: sp_blockchain::Error) -> Error {
+		Error::Blockchain(e)
 	}
 }