checking for signals in the light client

ethcore/light/src/client/mod.rs

@@ -20,7 +20,7 @@ use std::sync::{Weak, Arc};
 
 use ethcore::block_status::BlockStatus;
 use ethcore::client::{ClientReport, EnvInfo};
-use ethcore::engines::Engine;
+use ethcore::engines::{Engine, EpochChange, Proof, Unsure};
 use ethcore::error::BlockImportError;
 use ethcore::ids::BlockId;
 use ethcore::header::Header;
@@ -31,9 +31,12 @@ use ethcore::service::ClientIoMessage;
 use ethcore::encoded;
 use io::IoChannel;
 
+use futures::{IntoFuture, Future};
+
 use util::{H256, U256, Mutex, RwLock};
 use util::kvdb::{KeyValueDB, CompactionProfile};
 
+use self::fetch::ChainDataFetcher;
 use self::header_chain::{AncestryIter, HeaderChain};
 
 use cache::Cache;
@@ -43,6 +46,8 @@ pub use self::service::Service;
 mod header_chain;
 mod service;
 
+pub mod fetch;
+
 /// Configuration for the light client.
 #[derive(Debug, Clone)]
 pub struct Config {
@@ -154,7 +159,7 @@ impl<T: LightChainClient> AsLightClient for T {
 }
 
 /// Light client implementation.
-pub struct Client {
+pub struct Client<T> {
 	queue: HeaderQueue,
 	engine: Arc<Engine>,
 	chain: HeaderChain,
@@ -162,12 +167,21 @@ pub struct Client {
 	import_lock: Mutex<()>,
 	db: Arc<KeyValueDB>,
 	listeners: RwLock<Vec<Weak<LightChainNotify>>>,
+	fetcher: T,
 	verify_full: bool,
 }
 
-impl Client {
+impl<T: ChainDataFetcher> Client<T> {
 	/// Create a new `Client`.
-	pub fn new(config: Config, db: Arc<KeyValueDB>, chain_col: Option<u32>, spec: &Spec, io_channel: IoChannel<ClientIoMessage>, cache: Arc<Mutex<Cache>>) -> Result<Self, String> {
+	pub fn new(
+		config: Config,
+		db: Arc<KeyValueDB>,
+		chain_col: Option<u32>,
+		spec: &Spec,
+		fetcher: T,
+		io_channel: IoChannel<ClientIoMessage>,
+		cache: Arc<Mutex<Cache>>
+	) -> Result<Self, String> {
 		let gh = ::rlp::encode(&spec.genesis_header());
 
 		Ok(Client {
@@ -178,6 +192,7 @@ impl Client {
 			import_lock: Mutex::new(()),
 			db: db,
 			listeners: RwLock::new(vec![]),
+			fetcher: fetcher,
 			verify_full: config.verify_full,
 		})
 	}
@@ -189,10 +204,24 @@ impl Client {
 
 	/// Create a new `Client` backed purely in-memory.
 	/// This will ignore all database options in the configuration.
-	pub fn in_memory(config: Config, spec: &Spec, io_channel: IoChannel<ClientIoMessage>, cache: Arc<Mutex<Cache>>) -> Self {
+	pub fn in_memory(
+		config: Config,
+		spec: &Spec,
+		fetcher: T,
+		io_channel: IoChannel<ClientIoMessage>,
+		cache: Arc<Mutex<Cache>>
+	) -> Self {
 		let db = ::util::kvdb::in_memory(0);
 
-		Client::new(config, Arc::new(db), None, spec, io_channel, cache).expect("New DB creation infallible; qed")
+		Client::new(
+			config,
+			Arc::new(db),
+			None,
+			spec,
+			fetcher,
+			io_channel,
+			cache
+		).expect("New DB creation infallible; qed")
 	}
 
 	/// Import a header to the queue for additional verification.
@@ -291,9 +320,14 @@ impl Client {
 				continue
 			}
 
-			// TODO: `epoch_end_signal`, `is_epoch_end`.
-			// proofs we get from the network would be _complete_, whereas we need
-			// _incomplete_ signals
+			let _write_proof_result = match self.check_epoch_signal(&verified_header) {
+				Ok(Some(proof)) => self.write_pending_proof(&verified_header, proof),
+				Ok(None) => Ok(()),
+				Err(e) =>
+					panic!("Unable to fetch epoch transition proof: {:?}", e),
+			};
+
+			// TODO: check epoch end.
 
 			let mut tx = self.db.transaction();
 			let pending = match self.chain.insert(&mut tx, verified_header) {
@@ -419,9 +453,71 @@ impl Client {
 
 		true
 	}
+
+	fn check_epoch_signal(&self, verified_header: &Header) -> Result<Option<Proof>, T::Error> {
+		let (mut block, mut receipts) = (None, None);
+
+		// First, check without providing auxiliary data.
+		match self.engine.signals_epoch_end(verified_header, None, None) {
+			EpochChange::No => return Ok(None),
+			EpochChange::Yes(proof) => return Ok(Some(proof)),
+			EpochChange::Unsure(unsure) => {
+				let (b, r) = match unsure {
+					Unsure::NeedsBody =>
+						(Some(self.fetcher.block_body(verified_header)), None),
+					Unsure::NeedsReceipts =>
+						(None, Some(self.fetcher.block_receipts(verified_header))),
+					Unsure::NeedsBoth => (
+						Some(self.fetcher.block_body(verified_header)),
+						Some(self.fetcher.block_receipts(verified_header)),
+					),
+				};
+
+				if let Some(b) = b {
+					block = Some(b.into_future().wait()?);
+				}
+
+				if let Some(r) = r {
+					receipts = Some(r.into_future().wait()?);
+				}
+			}
+		}
+
+		let block = block.as_ref().map(|x| &x[..]);
+		let receipts = receipts.as_ref().map(|x| &x[..]);
+
+		// Check again now that required data has been fetched.
+		match self.engine.signals_epoch_end(verified_header, block, receipts) {
+			EpochChange::No => return Ok(None),
+			EpochChange::Yes(proof) => return Ok(Some(proof)),
+			EpochChange::Unsure(_) =>
+				panic!("Detected faulty engine implementation: requests additional \
+					data to check epoch end signal when everything necessary provided"),
+		}
+	}
+
+	// attempts to fetch the epoch proof from the network until successful.
+	fn write_pending_proof(&self, header: &Header, proof: Proof) -> Result<(), T::Error> {
+		let _proof = match proof {
+			Proof::Known(known) => known,
+			Proof::WithState(state_dependent) => {
+				loop {
+					let proof = self.fetcher.epoch_transition(header).into_future().wait()?;
+					match state_dependent.check_proof(&*self.engine, &proof) {
+						Ok(()) => break proof,
+						Err(e) =>
+							debug!(target: "client", "Fetched bad epoch transition proof from network: {}", e),
+					}
+				}
+			}
+		};
+
+		// TODO: actually write it
+		unimplemented!()
+	}
 }
 
-impl LightChainClient for Client {
+impl<T: ChainDataFetcher> LightChainClient for Client<T> {
 	fn chain_info(&self) -> BlockChainInfo { Client::chain_info(self) }
 
 	fn queue_header(&self, header: Header) -> Result<H256, BlockImportError> {