diff --git a/ethcore/light/src/client/fetch.rs b/ethcore/light/src/client/fetch.rs
deleted file mode 100644
index 93a2cde11..000000000
--- a/ethcore/light/src/client/fetch.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2015-2017 Parity Technologies (UK) Ltd.
-// This file is part of Parity.
-
-// Parity is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity. If not, see .
-
-//! Trait for fetching chain data.
-
-use std::sync::Arc;
-
-use ethcore::encoded;
-use ethcore::engines::{Engine, StateDependentProof};
-use ethcore::header::Header;
-use ethcore::receipt::Receipt;
-use futures::future::IntoFuture;
-use bigint::hash::H256;
-
-/// Provides full chain data.
-pub trait ChainDataFetcher: Send + Sync + 'static {
- /// Error type when data unavailable.
- type Error: ::std::fmt::Debug;
-
- /// Future for fetching block body.
- type Body: IntoFuture- ;
- /// Future for fetching block receipts.
- type Receipts: IntoFuture
- , Error=Self::Error>;
- /// Future for fetching epoch transition
- type Transition: IntoFuture
- , Error=Self::Error>;
-
- /// Fetch a block body.
- fn block_body(&self, header: &Header) -> Self::Body;
-
- /// Fetch block receipts.
- fn block_receipts(&self, header: &Header) -> Self::Receipts;
-
- /// Fetch epoch transition proof at given header.
- fn epoch_transition(&self, hash: H256, engine: Arc, checker: Arc) -> Self::Transition;
-}
-
-/// Fetcher implementation which cannot fetch anything.
-pub struct Unavailable;
-
-/// Create a fetcher which has all data unavailable.
-pub fn unavailable() -> Unavailable { Unavailable }
-
-impl ChainDataFetcher for Unavailable {
- type Error = &'static str;
-
- type Body = Result;
- type Receipts = Result, &'static str>;
- type Transition = Result, &'static str>;
-
- fn block_body(&self, _header: &Header) -> Self::Body {
- Err("fetching block bodies unavailable")
- }
-
- fn block_receipts(&self, _header: &Header) -> Self::Receipts {
- Err("fetching block receipts unavailable")
- }
-
- fn epoch_transition(&self, _h: H256, _e: Arc, _check: Arc) -> Self::Transition {
- Err("fetching epoch transition proofs unavailable")
- }
-}
diff --git a/ethcore/light/src/client/header_chain.rs b/ethcore/light/src/client/header_chain.rs
index 7320eddb4..3828e6954 100644
--- a/ethcore/light/src/client/header_chain.rs
+++ b/ethcore/light/src/client/header_chain.rs
@@ -18,12 +18,11 @@
//!
//! Unlike a full node's `BlockChain` this doesn't store much in the database.
//! It stores candidates for the last 2048-4096 blocks as well as CHT roots for
-//! historical blocks all the way to the genesis. If the engine makes use
-//! of epoch transitions, those are stored as well.
+//! historical blocks all the way to the genesis.
//!
//! This is separate from the `BlockChain` for two reasons:
//! - It stores only headers (and a pruned subset of them)
-//! - To allow for flexibility in the database layout..
+//! - To allow for flexibility in the database layout once that's incorporated.
use std::collections::BTreeMap;
use std::sync::Arc;
@@ -31,20 +30,15 @@ use std::sync::Arc;
use cht;
use ethcore::block_status::BlockStatus;
-use ethcore::error::{BlockImportError, BlockError};
+use ethcore::error::BlockError;
use ethcore::encoded;
use ethcore::header::Header;
use ethcore::ids::BlockId;
-use ethcore::spec::Spec;
-use ethcore::engines::epoch::{
- Transition as EpochTransition,
- PendingTransition as PendingEpochTransition
-};
use rlp::{Encodable, Decodable, DecoderError, RlpStream, Rlp, UntrustedRlp};
use heapsize::HeapSizeOf;
use bigint::prelude::U256;
-use bigint::hash::{H256, H256FastMap, H264};
+use bigint::hash::H256;
use util::kvdb::{DBTransaction, KeyValueDB};
use cache::Cache;
@@ -60,9 +54,6 @@ const HISTORY: u64 = 2048;
/// The best block key. Maps to an RLP list: [best_era, last_era]
const CURRENT_KEY: &'static [u8] = &*b"best_and_latest";
-/// Key storing the last canonical epoch transition.
-const LAST_CANONICAL_TRANSITION: &'static [u8] = &*b"canonical_transition";
-
/// Information about a block.
#[derive(Debug, Clone)]
pub struct BlockDescriptor {
@@ -110,6 +101,7 @@ impl Encodable for Entry {
impl Decodable for Entry {
fn decode(rlp: &UntrustedRlp) -> Result {
+
let mut candidates = SmallVec::<[Candidate; 3]>::new();
for item in rlp.iter() {
@@ -139,42 +131,6 @@ fn era_key(number: u64) -> String {
format!("candidates_{}", number)
}
-fn pending_transition_key(block_hash: H256) -> H264 {
- const LEADING: u8 = 1;
-
- let mut key = H264::default();
-
- key[0] = LEADING;
- key.0[1..].copy_from_slice(&block_hash.0[..]);
-
- key
-}
-
-fn transition_key(block_hash: H256) -> H264 {
- const LEADING: u8 = 2;
-
- let mut key = H264::default();
-
- key[0] = LEADING;
- key.0[1..].copy_from_slice(&block_hash.0[..]);
-
- key
-}
-
-// encode last canonical transition entry: header and proof.
-fn encode_canonical_transition(header: &Header, proof: &[u8]) -> Vec {
- let mut stream = RlpStream::new_list(2);
- stream.append(header).append(&proof);
- stream.out()
-}
-
-// decode last canonical transition entry.
-fn decode_canonical_transition(t: &[u8]) -> Result<(Header, &[u8]), DecoderError> {
- let rlp = UntrustedRlp::new(t);
-
- Ok((rlp.val_at(0)?, rlp.at(1)?.data()?))
-}
-
/// Pending changes from `insert` to be applied after the database write has finished.
pub struct PendingChanges {
best_block: Option, // new best block.
@@ -185,7 +141,6 @@ pub struct HeaderChain {
genesis_header: encoded::Header, // special-case the genesis.
candidates: RwLock>,
best_block: RwLock,
- live_epoch_proofs: RwLock>,
db: Arc,
col: Option,
cache: Arc>,
@@ -193,16 +148,8 @@ pub struct HeaderChain {
impl HeaderChain {
/// Create a new header chain given this genesis block and database to read from.
- pub fn new(
- db: Arc,
- col: Option,
- spec: &Spec,
- cache: Arc>,
- ) -> Result {
- let mut live_epoch_proofs = ::std::collections::HashMap::default();
-
- let genesis = ::rlp::encode(&spec.genesis_header()).into_vec();
- let decoded_header = spec.genesis_header();
+ pub fn new(db: Arc, col: Option, genesis: &[u8], cache: Arc>) -> Result {
+ use ethcore::views::HeaderView;
let chain = if let Some(current) = db.get(col, CURRENT_KEY)? {
let (best_number, highest_number) = {
@@ -213,24 +160,12 @@ impl HeaderChain {
let mut cur_number = highest_number;
let mut candidates = BTreeMap::new();
- // load all era entries, referenced headers within them,
- // and live epoch proofs.
+ // load all era entries and referenced headers within them.
while let Some(entry) = db.get(col, era_key(cur_number).as_bytes())? {
let entry: Entry = ::rlp::decode(&entry);
trace!(target: "chain", "loaded header chain entry for era {} with {} candidates",
cur_number, entry.candidates.len());
- for c in &entry.candidates {
- let key = transition_key(c.hash);
-
- if let Some(proof) = db.get(col, &*key)? {
- live_epoch_proofs.insert(c.hash, EpochTransition {
- block_hash: c.hash,
- block_number: cur_number,
- proof: proof.into_vec(),
- });
- }
- }
candidates.insert(cur_number, entry);
cur_number -= 1;
@@ -252,42 +187,29 @@ impl HeaderChain {
};
HeaderChain {
- genesis_header: encoded::Header::new(genesis),
+ genesis_header: encoded::Header::new(genesis.to_owned()),
best_block: RwLock::new(best_block),
candidates: RwLock::new(candidates),
- live_epoch_proofs: RwLock::new(live_epoch_proofs),
db: db,
col: col,
cache: cache,
}
} else {
+ let g_view = HeaderView::new(genesis);
HeaderChain {
- genesis_header: encoded::Header::new(genesis),
+ genesis_header: encoded::Header::new(genesis.to_owned()),
best_block: RwLock::new(BlockDescriptor {
- hash: decoded_header.hash(),
+ hash: g_view.hash(),
number: 0,
- total_difficulty: *decoded_header.difficulty(),
+ total_difficulty: g_view.difficulty(),
}),
candidates: RwLock::new(BTreeMap::new()),
- live_epoch_proofs: RwLock::new(live_epoch_proofs),
db: db,
col: col,
cache: cache,
}
};
- // instantiate genesis epoch data if it doesn't exist.
- if let None = chain.db.get(col, LAST_CANONICAL_TRANSITION)? {
- let genesis_data = spec.genesis_epoch_data()?;
-
- {
- let mut batch = chain.db.transaction();
- let data = encode_canonical_transition(&decoded_header, &genesis_data);
- batch.put_vec(col, LAST_CANONICAL_TRANSITION, data);
- chain.db.write(batch)?;
- }
- }
-
Ok(chain)
}
@@ -296,24 +218,10 @@ impl HeaderChain {
/// This blindly trusts that the data given to it is sensible.
/// Returns a set of pending changes to be applied with `apply_pending`
/// before the next call to insert and after the transaction has been written.
- ///
- /// If the block is an epoch transition, provide the transition along with
- /// the header.
- pub fn insert(
- &self,
- transaction: &mut DBTransaction,
- header: Header,
- transition_proof: Option>,
- ) -> Result {
+ pub fn insert(&self, transaction: &mut DBTransaction, header: Header) -> Result {
let hash = header.hash();
let number = header.number();
let parent_hash = *header.parent_hash();
- let transition = transition_proof.map(|proof| EpochTransition {
- block_hash: hash,
- block_number: number,
- proof: proof,
- });
-
let mut pending = PendingChanges {
best_block: None,
};
@@ -329,8 +237,7 @@ impl HeaderChain {
candidates.get(&(number - 1))
.and_then(|entry| entry.candidates.iter().find(|c| c.hash == parent_hash))
.map(|c| c.total_difficulty)
- .ok_or_else(|| BlockError::UnknownParent(parent_hash))
- .map_err(BlockImportError::Block)?
+ .ok_or_else(|| BlockError::UnknownParent(parent_hash))?
};
let total_difficulty = parent_td + *header.difficulty();
@@ -355,13 +262,8 @@ impl HeaderChain {
transaction.put(self.col, era_key(number).as_bytes(), &::rlp::encode(&*cur_era))
}
- if let Some(transition) = transition {
- transaction.put(self.col, &*transition_key(hash), &transition.proof);
- self.live_epoch_proofs.write().insert(hash, transition);
- }
-
- let raw = header.encoded().into_inner();
- transaction.put_vec(self.col, &hash[..], raw);
+ let raw = ::rlp::encode(&header);
+ transaction.put(self.col, &hash[..], &*raw);
let (best_num, is_new_best) = {
let cur_best = self.best_block.read();
@@ -414,10 +316,8 @@ impl HeaderChain {
let cht_num = cht::block_to_cht_number(earliest_era)
.expect("fails only for number == 0; genesis never imported; qed");
- let mut last_canonical_transition = None;
let cht_root = {
let mut i = earliest_era;
- let mut live_epoch_proofs = self.live_epoch_proofs.write();
// iterable function which removes the candidates as it goes
// along. this will only be called until the CHT is complete.
@@ -428,25 +328,7 @@ impl HeaderChain {
i += 1;
- // prune old blocks and epoch proofs.
for ancient in &era_entry.candidates {
- let maybe_transition = live_epoch_proofs.remove(&ancient.hash);
- if let Some(epoch_transition) = maybe_transition {
- transaction.delete(self.col, &*transition_key(ancient.hash));
-
- if ancient.hash == era_entry.canonical_hash {
- last_canonical_transition = match self.db.get(self.col, &ancient.hash) {
- Err(e) => {
- warn!(target: "chain", "Error reading from DB: {}\n
- ", e);
- None
- }
- Ok(None) => panic!("stored candidates always have corresponding headers; qed"),
- Ok(Some(header)) => Some((epoch_transition, ::rlp::decode(&header))),
- };
- }
- }
-
transaction.delete(self.col, &ancient.hash);
}
@@ -460,12 +342,6 @@ impl HeaderChain {
// write the CHT root to the database.
debug!(target: "chain", "Produced CHT {} root: {:?}", cht_num, cht_root);
transaction.put(self.col, cht_key(cht_num).as_bytes(), &::rlp::encode(&cht_root));
-
- // update the last canonical transition proof
- if let Some((epoch_transition, header)) = last_canonical_transition {
- let x = encode_canonical_transition(&header, &epoch_transition.proof);
- transaction.put_vec(self.col, LAST_CANONICAL_TRANSITION, x);
- }
}
}
@@ -491,7 +367,7 @@ impl HeaderChain {
/// will be returned.
pub fn block_hash(&self, id: BlockId) -> Option {
match id {
- BlockId::Earliest | BlockId::Number(0) => Some(self.genesis_hash()),
+ BlockId::Earliest => Some(self.genesis_hash()),
BlockId::Hash(hash) => Some(hash),
BlockId::Number(num) => {
if self.best_block.read().number < num { return None }
@@ -642,56 +518,6 @@ impl HeaderChain {
false => BlockStatus::Unknown,
}
}
-
- /// Insert a pending transition.
- pub fn insert_pending_transition(&self, batch: &mut DBTransaction, hash: H256, t: PendingEpochTransition) {
- let key = pending_transition_key(hash);
- batch.put(self.col, &*key, &*::rlp::encode(&t));
- }
-
- /// Get pending transition for a specific block hash.
- pub fn pending_transition(&self, hash: H256) -> Option {
- let key = pending_transition_key(hash);
- match self.db.get(self.col, &*key) {
- Ok(val) => val.map(|x| ::rlp::decode(&x)),
- Err(e) => {
- warn!(target: "chain", "Error reading from database: {}", e);
- None
- }
- }
- }
-
- /// Get the transition to the epoch the given parent hash is part of
- /// or transitions to.
- /// This will give the epoch that any children of this parent belong to.
- ///
- /// The header corresponding the the parent hash must be stored already.
- pub fn epoch_transition_for(&self, parent_hash: H256) -> Option<(Header, Vec)> {
- // slow path: loop back block by block
- let live_proofs = self.live_epoch_proofs.read();
-
- for hdr in self.ancestry_iter(BlockId::Hash(parent_hash)) {
- if let Some(transition) = live_proofs.get(&hdr.hash()).cloned() {
- return Some((hdr.decode(), transition.proof))
- }
- }
-
- // any blocks left must be descendants of the last canonical transition block.
- match self.db.get(self.col, LAST_CANONICAL_TRANSITION) {
- Ok(x) => {
- let x = x.expect("last canonical transition always instantiated; qed");
-
- let (hdr, proof) = decode_canonical_transition(&x)
- .expect("last canonical transition always encoded correctly; qed");
-
- Some((hdr, proof.to_vec()))
- }
- Err(e) => {
- warn!("Error reading from DB: {}", e);
- None
- }
- }
- }
}
impl HeapSizeOf for HeaderChain {
@@ -744,7 +570,7 @@ mod tests {
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
- let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
let mut parent_hash = genesis_header.hash();
let mut rolling_timestamp = genesis_header.timestamp();
@@ -757,7 +583,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -777,7 +603,7 @@ mod tests {
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
- let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
let mut parent_hash = genesis_header.hash();
let mut rolling_timestamp = genesis_header.timestamp();
@@ -790,7 +616,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -809,7 +635,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -833,7 +659,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -856,10 +682,12 @@ mod tests {
#[test]
fn earliest_is_latest() {
let spec = Spec::new_test();
+ let genesis_header = spec.genesis_header();
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
- let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache).unwrap();
+
assert!(chain.block_header(BlockId::Earliest).is_some());
assert!(chain.block_header(BlockId::Latest).is_some());
@@ -874,7 +702,7 @@ mod tests {
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
{
- let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
let mut parent_hash = genesis_header.hash();
let mut rolling_timestamp = genesis_header.timestamp();
for i in 1..10000 {
@@ -886,7 +714,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -894,7 +722,7 @@ mod tests {
}
}
- let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
assert!(chain.block_header(BlockId::Number(10)).is_none());
assert!(chain.block_header(BlockId::Number(9000)).is_some());
assert!(chain.cht_root(2).is_some());
@@ -910,7 +738,7 @@ mod tests {
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
{
- let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
let mut parent_hash = genesis_header.hash();
let mut rolling_timestamp = genesis_header.timestamp();
@@ -924,7 +752,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -941,7 +769,7 @@ mod tests {
parent_hash = header.hash();
let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
+ let pending = chain.insert(&mut tx, header).unwrap();
db.write(tx).unwrap();
chain.apply_pending(pending);
@@ -952,7 +780,7 @@ mod tests {
}
// after restoration, non-canonical eras should still be loaded.
- let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
assert_eq!(chain.block_header(BlockId::Latest).unwrap().number(), 10);
assert!(chain.candidates.read().get(&100).is_some())
}
@@ -964,76 +792,10 @@ mod tests {
let db = make_db();
let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
- let chain = HeaderChain::new(db.clone(), None, &spec, cache.clone()).unwrap();
+ let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
assert!(chain.block_header(BlockId::Earliest).is_some());
assert!(chain.block_header(BlockId::Number(0)).is_some());
assert!(chain.block_header(BlockId::Hash(genesis_header.hash())).is_some());
}
-
- #[test]
- fn epoch_transitions_available_after_cht() {
- let spec = Spec::new_test();
- let genesis_header = spec.genesis_header();
- let db = make_db();
- let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
-
- let chain = HeaderChain::new(db.clone(), None, &spec, cache).unwrap();
-
- let mut parent_hash = genesis_header.hash();
- let mut rolling_timestamp = genesis_header.timestamp();
- for i in 1..6 {
- let mut header = Header::new();
- header.set_parent_hash(parent_hash);
- header.set_number(i);
- header.set_timestamp(rolling_timestamp);
- header.set_difficulty(*genesis_header.difficulty() * i.into());
- parent_hash = header.hash();
-
- let mut tx = db.transaction();
- let epoch_proof = if i == 3 {
- Some(vec![1, 2, 3, 4])
- } else {
- None
- };
-
- let pending = chain.insert(&mut tx, header, epoch_proof).unwrap();
- db.write(tx).unwrap();
- chain.apply_pending(pending);
-
- rolling_timestamp += 10;
- }
-
- // these 3 should end up falling back to the genesis epoch proof in DB
- for i in 0..3 {
- let hash = chain.block_hash(BlockId::Number(i)).unwrap();
- assert_eq!(chain.epoch_transition_for(hash).unwrap().1, Vec::::new());
- }
-
- // these are live.
- for i in 3..6 {
- let hash = chain.block_hash(BlockId::Number(i)).unwrap();
- assert_eq!(chain.epoch_transition_for(hash).unwrap().1, vec![1, 2, 3, 4]);
- }
-
- for i in 6..10000 {
- let mut header = Header::new();
- header.set_parent_hash(parent_hash);
- header.set_number(i);
- header.set_timestamp(rolling_timestamp);
- header.set_difficulty(*genesis_header.difficulty() * i.into());
- parent_hash = header.hash();
-
- let mut tx = db.transaction();
- let pending = chain.insert(&mut tx, header, None).unwrap();
- db.write(tx).unwrap();
- chain.apply_pending(pending);
-
- rolling_timestamp += 10;
- }
-
- // no live blocks have associated epoch proofs -- make sure we aren't leaking memory.
- assert!(chain.live_epoch_proofs.read().is_empty());
- assert_eq!(chain.epoch_transition_for(parent_hash).unwrap().1, vec![1, 2, 3, 4]);
- }
}
diff --git a/ethcore/light/src/client/mod.rs b/ethcore/light/src/client/mod.rs
index 2b77685bd..2067a23c2 100644
--- a/ethcore/light/src/client/mod.rs
+++ b/ethcore/light/src/client/mod.rs
@@ -19,11 +19,11 @@
use std::sync::{Weak, Arc};
use ethcore::block_status::BlockStatus;
-use ethcore::client::{TransactionImportResult, ClientReport, EnvInfo};
-use ethcore::engines::{epoch, Engine, EpochChange, EpochTransition, Proof, Unsure};
-use ethcore::error::{TransactionError, BlockImportError, Error as EthcoreError};
+use ethcore::client::{ClientReport, EnvInfo};
+use ethcore::engines::Engine;
+use ethcore::error::BlockImportError;
use ethcore::ids::BlockId;
-use ethcore::header::{BlockNumber, Header};
+use ethcore::header::Header;
use ethcore::verification::queue::{self, HeaderQueue};
use ethcore::blockchain_info::BlockChainInfo;
use ethcore::spec::Spec;
@@ -33,12 +33,9 @@ use io::IoChannel;
use parking_lot::{Mutex, RwLock};
use bigint::prelude::U256;
use bigint::hash::H256;
-use futures::{IntoFuture, Future};
-use util::Address;
use util::kvdb::{KeyValueDB, CompactionProfile};
-use self::fetch::ChainDataFetcher;
use self::header_chain::{AncestryIter, HeaderChain};
use cache::Cache;
@@ -48,8 +45,6 @@ pub use self::service::Service;
mod header_chain;
mod service;
-pub mod fetch;
-
/// Configuration for the light client.
#[derive(Debug, Clone)]
pub struct Config {
@@ -85,9 +80,6 @@ impl Default for Config {
/// Trait for interacting with the header chain abstractly.
pub trait LightChainClient: Send + Sync {
- /// Adds a new `LightChainNotify` listener.
- fn add_listener(&self, listener: Weak);
-
/// Get chain info.
fn chain_info(&self) -> BlockChainInfo;
@@ -136,7 +128,7 @@ pub trait LightChainClient: Send + Sync {
fn cht_root(&self, i: usize) -> Option;
/// Get the EIP-86 transition block number.
- fn eip86_transition(&self) -> BlockNumber;
+ fn eip86_transition(&self) -> u64;
/// Get a report of import activity since the last call.
fn report(&self) -> ClientReport;
@@ -164,7 +156,7 @@ impl AsLightClient for T {
}
/// Light client implementation.
-pub struct Client {
+pub struct Client {
queue: HeaderQueue,
engine: Arc,
chain: HeaderChain,
@@ -172,30 +164,22 @@ pub struct Client {
import_lock: Mutex<()>,
db: Arc,
listeners: RwLock>>,
- fetcher: T,
verify_full: bool,
}
-impl Client {
+impl Client {
/// Create a new `Client`.
- pub fn new(
- config: Config,
- db: Arc,
- chain_col: Option,
- spec: &Spec,
- fetcher: T,
- io_channel: IoChannel,
- cache: Arc>
- ) -> Result {
+ pub fn new(config: Config, db: Arc, chain_col: Option, spec: &Spec, io_channel: IoChannel, cache: Arc>) -> Result {
+ let gh = ::rlp::encode(&spec.genesis_header());
+
Ok(Client {
queue: HeaderQueue::new(config.queue, spec.engine.clone(), io_channel, config.check_seal),
engine: spec.engine.clone(),
- chain: HeaderChain::new(db.clone(), chain_col, &spec, cache)?,
+ chain: HeaderChain::new(db.clone(), chain_col, &gh, cache)?,
report: RwLock::new(ClientReport::default()),
import_lock: Mutex::new(()),
db: db,
listeners: RwLock::new(vec![]),
- fetcher: fetcher,
verify_full: config.verify_full,
})
}
@@ -207,24 +191,10 @@ 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,
- fetcher: T,
- io_channel: IoChannel,
- cache: Arc>
- ) -> Self {
+ pub fn in_memory(config: Config, spec: &Spec, io_channel: IoChannel, cache: Arc>) -> Self {
let db = ::util::kvdb::in_memory(0);
- Client::new(
- config,
- Arc::new(db),
- None,
- spec,
- fetcher,
- io_channel,
- cache
- ).expect("New DB creation infallible; qed")
+ Client::new(config, Arc::new(db), None, spec, io_channel, cache).expect("New DB creation infallible; qed")
}
/// Import a header to the queue for additional verification.
@@ -323,33 +293,19 @@ impl Client {
continue
}
- 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),
- };
-
- if let Err(e) = write_proof_result {
- warn!(target: "client", "Error writing pending transition proof to DB: {:?} \
- The node may not be able to synchronize further.", e);
- }
-
- let epoch_proof = self.engine.is_epoch_end(
- &verified_header,
- &|h| self.chain.block_header(BlockId::Hash(h)).map(|hdr| hdr.decode()),
- &|h| self.chain.pending_transition(h),
- );
+ // TODO: `epoch_end_signal`, `is_epoch_end`.
+ // proofs we get from the network would be _complete_, whereas we need
+ // _incomplete_ signals
let mut tx = self.db.transaction();
- let pending = match self.chain.insert(&mut tx, verified_header, epoch_proof) {
+ let pending = match self.chain.insert(&mut tx, verified_header) {
Ok(pending) => {
good.push(hash);
self.report.write().blocks_imported += 1;
pending
}
Err(e) => {
- debug!(target: "client", "Error importing header {:?}: {:?}", (num, hash), e);
+ debug!(target: "client", "Error importing header {:?}: {}", (num, hash), e);
bad.push(hash);
continue;
}
@@ -465,76 +421,9 @@ impl Client {
true
}
-
- fn check_epoch_signal(&self, verified_header: &Header) -> Result