block builder logic for polkadot

polkadot/api/src/lib.rs

@@ -32,8 +32,10 @@ use client::Client;
 use polkadot_runtime::runtime;
 use polkadot_executor::Executor as LocalDispatch;
 use substrate_executor::{NativeExecutionDispatch, NativeExecutor};
+use state_machine::OverlayedChanges;
 use primitives::{AccountId, SessionKey, Timestamp};
-use primitives::block::{Id as BlockId, Block};
+use primitives::block::{Id as BlockId, Block, Header, Body};
+use primitives::transaction::UncheckedTransaction;
 use primitives::parachain::DutyRoster;
 
 error_chain! {
@@ -43,10 +45,21 @@ error_chain! {
 			description("Unknown runtime code")
 			display("Unknown runtime code")
 		}
+		/// Unknown block ID.
 		UnknownBlock(b: BlockId) {
 			description("Unknown block")
 			display("Unknown block")
 		}
+		/// Attempted to push an inherent transaction manually.
+		PushedInherentTransaction(tx: UncheckedTransaction) {
+			description("Attempted to push an inherent transaction to a block."),
+			display("Pushed inherent transaction to a block: {:?}", tx),
+		}
+		/// Badly-formed transaction.
+		BadlyFormedTransaction(tx: UncheckedTransaction) {
+			description("Attempted to push a badly-formed transaction to a block."),
+			display("Pushed badly-formed transaction to a block: {:?}", tx),
+		}
 		/// Some other error.
 		// TODO: allow to be specified as associated type of PolkadotApi
 		Other(e: Box<::std::error::Error + Send>) {
@@ -60,10 +73,29 @@ error_chain! {
 	}
 }
 
+impl From<client::error::Error> for Error {
+	fn from(e: client::error::Error) -> Error {
+		match e {
+			client::error::Error(client::error::ErrorKind::UnknownBlock(b), _) => Error::from_kind(ErrorKind::UnknownBlock(b)),
+			other => Error::from_kind(ErrorKind::Other(Box::new(other) as Box<_>)),
+		}
+	}
+}
+
+pub trait BlockBuilder: Sized {
+	/// Push a non-inherent transaction.
+	fn push_transaction(&mut self, transaction: UncheckedTransaction) -> Result<()>;
+
+	/// Finalise the block.
+	fn bake(self) -> Block;
+}
+
 /// Trait encapsulating the Polkadot API.
 ///
 /// All calls should fail when the exact runtime is unknown.
 pub trait PolkadotApi {
+	type BlockBuilder: BlockBuilder;
+
 	/// Get session keys at a given block.
 	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>>;
 
@@ -78,24 +110,20 @@ pub trait PolkadotApi {
 
 	/// Evaluate a block and see if it gives an error.
 	fn evaluate_block(&self, at: &BlockId, block: Block) -> Result<()>;
-}
 
-fn convert_client_error(e: client::error::Error) -> Error {
-	match e {
-		client::error::Error(client::error::ErrorKind::UnknownBlock(b), _) => Error::from_kind(ErrorKind::UnknownBlock(b)),
-		other => Error::from_kind(ErrorKind::Other(Box::new(other) as Box<_>)),
-	}
+	/// Create a block builder on top of the parent block.
+	fn build_block(&self, parent: &BlockId, timestamp: u64) -> Result<Self::BlockBuilder>;
 }
 
 // set up the necessary scaffolding to execute the runtime.
 macro_rules! with_runtime {
 	($client: ident, $at: expr, $exec: expr) => {{
 		// bail if the code is not the same as the natively linked.
-		if $client.code_at($at).map_err(convert_client_error)? != LocalDispatch::native_equivalent() {
+		if $client.code_at($at)? != LocalDispatch::native_equivalent() {
 			bail!(ErrorKind::UnknownRuntime);
 		}
 
-		$client.state_at($at).map_err(convert_client_error).and_then(|state| {
+		$client.state_at($at).map_err(Error::from).and_then(|state| {
 			let mut changes = Default::default();
 			let mut ext = state_machine::Ext {
 				overlay: &mut changes,
@@ -110,6 +138,8 @@ macro_rules! with_runtime {
 impl<B: Backend> PolkadotApi for Client<B, NativeExecutor<LocalDispatch>>
 	where ::client::error::Error: From<<<B as Backend>::State as state_machine::backend::Backend>::Error>
 {
+	type BlockBuilder = ClientBlockBuilder<B::State>;
+
 	fn session_keys(&self, at: &BlockId) -> Result<Vec<SessionKey>> {
 		with_runtime!(self, at, ::runtime::consensus::authorities)
 	}
@@ -129,4 +159,119 @@ impl<B: Backend> PolkadotApi for Client<B, NativeExecutor<LocalDispatch>>
 	fn evaluate_block(&self, at: &BlockId, block: Block) -> Result<()> {
 		with_runtime!(self, at, || ::runtime::system::internal::execute_block(block))
 	}
+
+	fn build_block(&self, parent: &BlockId, timestamp: Timestamp) -> Result<Self::BlockBuilder> {
+		if self.code_at(parent)? != LocalDispatch::native_equivalent() {
+			bail!(ErrorKind::UnknownRuntime);
+		}
+
+		let header = Header {
+			parent_hash: self.block_hash_from_id(parent)?.ok_or(ErrorKind::UnknownBlock(*parent))?,
+			number: self.block_number_from_id(parent)?.ok_or(ErrorKind::UnknownBlock(*parent))? + 1,
+			state_root: Default::default(),
+			transaction_root: Default::default(),
+			digest: Default::default(),
+		};
+
+		let body = Body {
+			timestamp: timestamp,
+			transactions: Vec::new(),
+		};
+
+		let mut builder = ClientBlockBuilder {
+			parent: *parent,
+			changes: OverlayedChanges::default(),
+			state: self.state_at(parent)?,
+			header,
+			timestamp,
+			transactions: Vec::new(),
+		};
+
+		for inherent in body.inherent_transactions() {
+			builder.execute_transaction(inherent)?;
+		}
+
+		Ok(builder)
+	}
+}
+
+/// A polkadot block builder.
+#[derive(Debug, Clone)]
+pub struct ClientBlockBuilder<S> {
+	parent: BlockId,
+	changes: OverlayedChanges,
+	state: S,
+	header: Header,
+	timestamp: Timestamp,
+	transactions: Vec<UncheckedTransaction>,
+}
+
+impl<S: state_machine::Backend> ClientBlockBuilder<S>
+	where S::Error: Into<client::error::Error>
+{
+	// executes a transaction, inherent or otherwise, without appending to the list
+	fn execute_transaction(&mut self, transaction: UncheckedTransaction) -> Result<()> {
+		if !transaction.is_well_formed() {
+			bail!(ErrorKind::BadlyFormedTransaction(transaction));
+		}
+
+		let mut ext = state_machine::Ext {
+			overlay: &mut self.changes,
+			backend: &self.state,
+		};
+
+		// TODO: avoid clone
+		let header = self.header.clone();
+		let result = ::substrate_executor::with_native_environment(
+			&mut ext,
+			move || runtime::system::internal::execute_transaction(transaction, header),
+		).map_err(Into::into);
+
+		match result {
+			Ok(header) => {
+				ext.overlay.commit_prospective();
+				self.header = header;
+				Ok(())
+			}
+			Err(e) => {
+				ext.overlay.discard_prospective();
+				Err(e)
+			}
+		}
+	}
+}
+
+impl<S: state_machine::Backend> BlockBuilder for ClientBlockBuilder<S>
+	where S::Error: Into<client::error::Error>
+{
+	fn push_transaction(&mut self, transaction: UncheckedTransaction) -> Result<()> {
+		if transaction.transaction.function.is_inherent() {
+			bail!(ErrorKind::PushedInherentTransaction(transaction));
+		} else {
+			self.execute_transaction(transaction.clone())?;
+			self.transactions.push(transaction);
+			Ok(())
+		}
+	}
+
+	fn bake(mut self) -> Block {
+		let mut ext = state_machine::Ext {
+			overlay: &mut self.changes,
+			backend: &self.state,
+		};
+
+		let old_header = self.header;
+		let final_header = ::substrate_executor::with_native_environment(
+			&mut ext,
+			move || runtime::system::internal::finalise_block(old_header)
+		).expect("all inherent transactions pushed; all other transactions executed correctly; qed");
+
+		Block {
+			header: final_header,
+			body: Body {
+				timestamp: self.timestamp,
+				transactions: self.transactions,
+			}
+		}
+	}
 }

polkadot/consensus/src/error.rs

@@ -16,8 +16,7 @@
 
 //! Errors that can occur during the consensus process.
 
-use polkadot_primitives::Timestamp;
-use primitives::block::{Number as BlockNumber, HeaderHash};
+use primitives::block::HeaderHash;
 
 error_chain! {
 	links {

polkadot/consensus/src/lib.rs

@@ -50,8 +50,8 @@ use std::sync::Arc;
 use codec::Slicable;
 use table::{Table, Context as TableContextTrait};
 use table::generic::Statement as GenericStatement;
-use polkadot_api::PolkadotApi;
-use polkadot_primitives::Hash;
+use polkadot_api::{PolkadotApi, BlockBuilder};
+use polkadot_primitives::{Hash, Timestamp};
 use polkadot_primitives::block::Block as PolkadotBlock;
 use polkadot_primitives::parachain::{Id as ParaId, DutyRoster, BlockData, Extrinsic, CandidateReceipt};
 use primitives::block::{Block as SubstrateBlock, Header as SubstrateHeader, HeaderHash, Id as BlockId};
@@ -474,15 +474,14 @@ impl<C: PolkadotApi, N: Network> bft::ProposerFactory for ProposerFactory<C, N>
 		// TODO [PoC-2]: kick off collation process.
 		Ok(Proposer {
 			parent_hash,
-			parent_header: parent_header.clone(),
 			_table: table,
 			_router: router,
 			client: self.client.clone(),
 		})
 	}
 }
 
-fn current_timestamp() -> ::polkadot_primitives::Timestamp {
+fn current_timestamp() -> Timestamp {
 	use std::time;
 
 	time::SystemTime::now().duration_since(time::UNIX_EPOCH)
@@ -493,7 +492,6 @@ fn current_timestamp() -> ::polkadot_primitives::Timestamp {
 /// The Polkadot proposer logic.
 pub struct Proposer<C, R> {
 	parent_hash: HeaderHash,
-	parent_header: SubstrateHeader,
 	client: Arc<C>,
 	_table: Arc<SharedTable>,
 	_router: R,
@@ -505,30 +503,18 @@ impl<C: PolkadotApi, R: TableRouter> bft::Proposer for Proposer<C, R> {
 	type Evaluate = Result<bool, Error>;
 
 	fn propose(&self) -> Result<SubstrateBlock, Error> {
-		use polkadot_primitives::{Header as PolkadotHeader, Body as PolkadotBody};
-
-		let header = PolkadotHeader {
-			parent_hash: self.parent_hash,
-			number: self.parent_header.number + 1,
-			state_root: Default::default(),
-			transaction_root: Default::default(),
-			digest: Default::default(),
-		};
-
-		let body = PolkadotBody {
-			// TODO: compare against parent block's and schedule proposal for then.
-			timestamp: current_timestamp(),
-			transactions: Vec::new(),
-		};
+		// TODO: handle case when current timestamp behind that in state.
+		let polkadot_block = self.client.build_block(
+			&BlockId::Hash(self.parent_hash),
+			current_timestamp()
+		)?.bake();
 
-		for tx in body.inherent_transactions() {
-			// import these TXs first.
-		}
+		// TODO: integrate transaction queue and `push_transaction`s.
 
-		// get transactions out of the queue.
+		let substrate_block = Slicable::decode(&mut polkadot_block.encode().as_slice())
+			.expect("polkadot blocks defined to serialize to substrate blocks correctly; qed");
 
-		// finalise block and get new header.
-		unimplemented!()
+		Ok(substrate_block)
 	}
 
 	// TODO: certain kinds of errors here should lead to a misbehavior report.
@@ -540,10 +526,10 @@ impl<C: PolkadotApi, R: TableRouter> bft::Proposer for Proposer<C, R> {
 fn evaluate_proposal<C: PolkadotApi>(
 	proposal: &SubstrateBlock,
 	client: &C,
-	now: ::polkadot_primitives::Timestamp,
+	now: Timestamp,
 	parent_hash: &HeaderHash,
 ) -> Result<bool, Error> {
-	const MAX_TIMESTAMP_DRIFT: ::polkadot_primitives::Timestamp = 4;
+	const MAX_TIMESTAMP_DRIFT: Timestamp = 4;
 
 	let encoded = Slicable::encode(proposal);
 	let proposal = PolkadotBlock::decode(&mut &encoded[..])

substrate/primitives/src/block.rs

@@ -179,7 +179,7 @@ impl Slicable for Header {
 }
 
 /// Block indentification.
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Debug))]
 pub enum Id {
 	/// Identify by block header hash.

substrate/state-machine/src/lib.rs

@@ -47,7 +47,7 @@ pub use backend::Backend;
 ///
 /// A transaction shares all prospective changes within an inner overlay
 /// that can be cleared.
-#[derive(Default)]
+#[derive(Debug, Default, Clone)]
 pub struct OverlayedChanges {
 	prospective: HashMap<Vec<u8>, Option<Vec<u8>>>,
 	committed: HashMap<Vec<u8>, Option<Vec<u8>>>,