Initial refactor and block closing.

ethcore/src/block.rs

@@ -155,9 +155,9 @@ pub struct OpenBlock<'x> {
 /// Just like OpenBlock, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
 /// and collected the uncles.
 ///
-/// There is no function available to push a transaction. If you want that you'll need to `reopen()` it.
-pub struct ClosedBlock<'x> {
-	open_block: OpenBlock<'x>,
+/// There is no function available to push a transaction.
+pub struct ClosedBlock {
+	block: ExecutedBlock,
 	uncle_bytes: Bytes,
 }
 
@@ -181,7 +181,7 @@ impl<'x> OpenBlock<'x> {
 		r.block.base.header.set_number(parent.number() + 1);
 		r.block.base.header.set_author(author);
 		r.block.base.header.set_extra_data(extra_data);
-		r.block.base.header.set_timestamp_now();
+		r.block.base.header.set_timestamp_now(parent.timestamp());
 
 		engine.populate_from_parent(&mut r.block.base.header, parent);
 		engine.on_new_block(&mut r.block);
@@ -259,7 +259,7 @@ impl<'x> OpenBlock<'x> {
 	}
 
 	/// Turn this into a `ClosedBlock`. A BlockChain must be provided in order to figure out the uncles.
-	pub fn close(self) -> ClosedBlock<'x> {
+	pub fn close(self) -> ClosedBlock {
 		let mut s = self;
 		s.engine.on_close_block(&mut s.block);
 		s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
@@ -271,7 +271,10 @@ impl<'x> OpenBlock<'x> {
 		s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
 		s.block.base.header.note_dirty();
 
-		ClosedBlock::new(s, uncle_bytes)
+		ClosedBlock {
+			block: s.block, 
+			uncle_bytes: uncle_bytes,
+		}
 	}
 }
 
@@ -279,38 +282,28 @@ impl<'x> IsBlock for OpenBlock<'x> {
 	fn block(&self) -> &ExecutedBlock { &self.block }
 }
 
-impl<'x> IsBlock for ClosedBlock<'x> {
-	fn block(&self) -> &ExecutedBlock { &self.open_block.block }
+impl<'x> IsBlock for ClosedBlock {
+	fn block(&self) -> &ExecutedBlock { &self.block }
 }
 
-impl<'x> ClosedBlock<'x> {
-	fn new(open_block: OpenBlock<'x>, uncle_bytes: Bytes) -> Self {
-		ClosedBlock {
-			open_block: open_block,
-			uncle_bytes: uncle_bytes,
-		}
-	}
-
+impl ClosedBlock {
 	/// Get the hash of the header without seal arguments.
 	pub fn hash(&self) -> H256 { self.header().rlp_sha3(Seal::Without) }
 
 	/// Provide a valid seal in order to turn this into a `SealedBlock`.
 	///
 	/// NOTE: This does not check the validity of `seal` with the engine.
-	pub fn seal(self, seal: Vec<Bytes>) -> Result<SealedBlock, BlockError> {
+	pub fn seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, BlockError> {
 		let mut s = self;
-		if seal.len() != s.open_block.engine.seal_fields() {
-			return Err(BlockError::InvalidSealArity(Mismatch{expected: s.open_block.engine.seal_fields(), found: seal.len()}));
+		if seal.len() != engine.seal_fields() {
+			return Err(BlockError::InvalidSealArity(Mismatch{expected: engine.seal_fields(), found: seal.len()}));
 		}
-		s.open_block.block.base.header.set_seal(seal);
-		Ok(SealedBlock { block: s.open_block.block, uncle_bytes: s.uncle_bytes })
+		s.block.base.header.set_seal(seal);
+		Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes })
 	}
 
-	/// Turn this back into an `OpenBlock`.
-	pub fn reopen(self) -> OpenBlock<'x> { self.open_block }
-
 	/// Drop this object and return the underlieing database.
-	pub fn drain(self) -> JournalDB { self.open_block.block.state.drop().1 }
+	pub fn drain(self) -> JournalDB { self.block.state.drop().1 }
 }
 
 impl SealedBlock {
@@ -332,7 +325,7 @@ impl IsBlock for SealedBlock {
 }
 
 /// Enact the block given by block header, transactions and uncles
-pub fn enact<'x>(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	{
 		if ::log::max_log_level() >= ::log::LogLevel::Trace {
 			let s = State::from_existing(db.clone(), parent.state_root().clone(), engine.account_start_nonce());
@@ -350,14 +343,14 @@ pub fn enact<'x>(header: &Header, transactions: &[SignedTransaction], uncles: &[
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_bytes<'x>(block_bytes: &[u8], engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	let block = BlockView::new(block_bytes);
 	let header = block.header();
 	enact(&header, &block.transactions(), &block.uncles(), engine, db, parent, last_hashes)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_verified<'x>(block: &PreVerifiedBlock, engine: &'x Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock<'x>, Error> {
+pub fn enact_verified(block: &PreVerifiedBlock, engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
 	enact(&block.header, &block.transactions, &view.uncles(), engine, db, parent, last_hashes)
 }
@@ -365,7 +358,7 @@ pub fn enact_verified<'x>(block: &PreVerifiedBlock, engine: &'x Engine, db: Jour
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
 pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, db: JournalDB, parent: &Header, last_hashes: LastHashes) -> Result<SealedBlock, Error> {
 	let header = BlockView::new(block_bytes).header_view();
-	Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(header.seal())))
+	Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(engine, header.seal())))
 }
 
 #[cfg(test)]
@@ -386,7 +379,7 @@ mod tests {
 		let last_hashes = vec![genesis_header.hash()];
 		let b = OpenBlock::new(engine.deref(), db, &genesis_header, last_hashes, Address::zero(), vec![]);
 		let b = b.close();
-		let _ = b.seal(vec![]);
+		let _ = b.seal(engine.deref(), vec![]);
 	}
 
 	#[test]

ethcore/src/client.rs

@@ -193,6 +193,9 @@ pub struct Client {
 	report: RwLock<ClientReport>,
 	import_lock: Mutex<()>,
 	panic_handler: Arc<PanicHandler>,
+
+	// for sealing...
+	_sealing_block: Mutex<Option<ClosedBlock>>,
 }
 
 const HISTORY: u64 = 1000;
@@ -228,7 +231,8 @@ impl Client {
 			block_queue: RwLock::new(block_queue),
 			report: RwLock::new(Default::default()),
 			import_lock: Mutex::new(()),
-			panic_handler: panic_handler
+			panic_handler: panic_handler,
+			_sealing_block: Mutex::new(None),
 		}))
 	}
 
@@ -237,10 +241,10 @@ impl Client {
 		self.block_queue.write().unwrap().flush();
 	}
 
-	fn build_last_hashes(&self, header: &Header) -> LastHashes {
+	fn build_last_hashes(&self, parent_hash: H256) -> LastHashes {
 		let mut last_hashes = LastHashes::new();
 		last_hashes.resize(256, H256::new());
-		last_hashes[0] = header.parent_hash.clone();
+		last_hashes[0] = parent_hash;
 		let chain = self.chain.read().unwrap();
 		for i in 0..255 {
 			match chain.block_details(&last_hashes[i]) {
@@ -273,7 +277,7 @@ impl Client {
 
 		// Enact Verified Block
 		let parent = chain_has_parent.unwrap();
-		let last_hashes = self.build_last_hashes(header);
+		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().clone();
 
 		let enact_result = enact_verified(&block, engine, db, &parent, last_hashes);
@@ -302,6 +306,8 @@ impl Client {
 		let _import_lock = self.import_lock.lock();
 		let blocks = self.block_queue.write().unwrap().drain(max_blocks_to_import);
 
+		let original_best = self.chain_info().best_block_hash;
+
 		for block in blocks {
 			let header = &block.header;
 
@@ -357,6 +363,10 @@ impl Client {
 			}
 		}
 
+		if self.chain_info().best_block_hash != original_best {
+			self.new_chain_head();
+		}
+
 		imported
 	}
 
@@ -403,8 +413,29 @@ impl Client {
 			BlockId::Latest => Some(self.chain.read().unwrap().best_block_number())
 		}
 	}
+
+	/// New chain head event.
+	pub fn new_chain_head(&self) {
+		let h = self.chain.read().unwrap().best_block_hash();
+		info!("NEW CHAIN HEAD: #{}: {}", self.chain.read().unwrap().best_block_number(), h);
+
+		info!("Preparing to seal.");
+		let b = OpenBlock::new(
+			&self.engine,
+			self.state_db.lock(),
+			self.chain.read().unwrap().block_header(&h).unwrap_or_else(|| {return;}),
+			self.build_last_hashes(h.clone()),
+			x!("0037a6b811ffeb6e072da21179d11b1406371c63"),
+			b"Parity".to_owned()
+		);
+		let b = b.close();
+		info!("Sealed: hash={}, diff={}, number={}", b.hash(), b.block().difficulty(), b.block().number());
+		*self._sealing_block.lock().unwrap() = Some(b);
+	}
 }
 
+// TODO: need MinerService MinerIoHandler
+
 impl BlockChainClient for Client {
 	fn block_header(&self, id: BlockId) -> Option<Bytes> {
 		let chain = self.chain.read().unwrap();

ethcore/src/header.rs

@@ -131,7 +131,7 @@ impl Header {
 	/// Set the timestamp field of the header.
 	pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
 	/// Set the timestamp field of the header to the current time.
-	pub fn set_timestamp_now(&mut self) { self.timestamp = now_utc().to_timespec().sec as u64; self.note_dirty(); }
+	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(now_utc().to_timespec().sec as u64, but_later_than + 1); self.note_dirty(); }
 	/// Set the author field of the header.
 	pub fn set_author(&mut self, a: Address) { if a != self.author { self.author = a; self.note_dirty(); } }
 

parity/main.rs

@@ -354,7 +354,6 @@ impl Default for Informant {
 }
 
 impl Informant {
-
 	fn format_bytes(b: usize) -> String {
 		match binary_prefix(b as f64) {
 			Standalone(bytes)   => format!("{} bytes", bytes),