bring snapshotting work into master

ethcore/src/client/client.rs

@@ -14,13 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::path::PathBuf;
 use std::collections::{HashSet, HashMap};
 use std::ops::Deref;
 use std::mem;
 use std::collections::VecDeque;
 use std::sync::*;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::fmt;
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
 use std::time::Instant;

ethcore/src/error.rs

@@ -230,6 +230,10 @@ pub enum Error {
 	PowInvalid,
 	/// Error concerning TrieDBs
 	Trie(TrieError),
+	/// Io error.
+	Io(::std::io::Error),
+	/// Snappy error.
+	Snappy(::util::snappy::InvalidInput),
 }
 
 impl fmt::Display for Error {
@@ -246,6 +250,8 @@ impl fmt::Display for Error {
 			Error::PowHashInvalid => f.write_str("Invalid or out of date PoW hash."),
 			Error::PowInvalid => f.write_str("Invalid nonce or mishash"),
 			Error::Trie(ref err) => f.write_fmt(format_args!("{}", err)),
+			Error::Io(ref err) => f.write_fmt(format_args!("{}", err)),
+			Error::Snappy(ref err) => f.write_fmt(format_args!("{}", err)),
 		}
 	}
 }
@@ -313,6 +319,18 @@ impl From<TrieError> for Error {
 	}
 }
 
+impl From<::std::io::Error> for Error {
+	fn from(err: ::std::io::Error) -> Error {
+		Error::Io(err)
+	}
+}
+
+impl From<::util::snappy::InvalidInput> for Error {
+	fn from(err: ::util::snappy::InvalidInput) -> Error {
+		Error::Snappy(err)
+	}
+}
+
 impl From<BlockImportError> for Error {
 	fn from(err: BlockImportError) -> Error {
 		match err {

ethcore/src/header.rs

@@ -149,6 +149,16 @@ impl Header {
 
 	/// Set the number field of the header.
 	pub fn set_parent_hash(&mut self, a: H256) { self.parent_hash = a; self.note_dirty(); }
+	/// Set the uncles hash field of the header.
+	pub fn set_uncles_hash(&mut self, a: H256) { self.uncles_hash = a; self.note_dirty(); }
+	/// Set the state root field of the header.
+	pub fn set_state_root(&mut self, a: H256) { self.state_root = a; self.note_dirty(); }
+	/// Set the transactions root field of the header.
+	pub fn set_transactions_root(&mut self, a: H256) { self.transactions_root = a; self.note_dirty() }
+	/// Set the receipts root field of the header.
+	pub fn set_receipts_root(&mut self, a: H256) { self.receipts_root = a; self.note_dirty() }
+	/// Set the log bloom field of the header.
+	pub fn set_log_bloom(&mut self, a: LogBloom) { self.log_bloom = a; self.note_dirty() }
 	/// 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.

ethcore/src/lib.rs

@@ -118,8 +118,9 @@ pub mod pod_state;
 pub mod engine;
 pub mod migrations;
 pub mod miner;
-#[macro_use] pub mod evm;
+pub mod snapshot;
 pub mod action_params;
+#[macro_use] pub mod evm;
 
 mod blooms;
 mod db;

ethcore/src/snapshot/account.rs

@@ -0,0 +1,135 @@
+// Copyright 2015, 2016 Ethcore (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 <http://www.gnu.org/licenses/>.
+
+//! Account state encoding and decoding
+
+use account_db::{AccountDB, AccountDBMut};
+use error::Error;
+
+use util::{Bytes, HashDB, SHA3_EMPTY, TrieDB};
+use util::hash::{FixedHash, H256};
+use util::numbers::U256;
+use util::rlp::{DecoderError, Rlp, RlpStream, Stream, UntrustedRlp, View};
+
+// An alternate account structure from ::account::Account.
+pub struct Account {
+	nonce: U256,
+	balance: U256,
+	storage_root: H256,
+	code_hash: H256,
+}
+
+impl Account {
+	// decode the account from rlp.
+	pub fn from_thin_rlp(rlp: &[u8]) -> Self {
+		let r: Rlp = Rlp::new(rlp);
+
+		Account {
+			nonce: r.val_at(0),
+			balance: r.val_at(1),
+			storage_root: r.val_at(2),
+			code_hash: r.val_at(3),
+		}
+	}
+
+	// encode the account to a standard rlp.
+	pub fn to_thin_rlp(&self) -> Bytes {
+		let mut stream = RlpStream::new_list(4);
+		stream
+			.append(&self.nonce)
+			.append(&self.balance)
+			.append(&self.storage_root)
+			.append(&self.code_hash);
+
+		stream.out()
+	}
+
+	// walk the account's storage trie, returning an RLP item containing the
+	// account properties and the storage.
+	pub fn to_fat_rlp(&self, acct_db: &AccountDB, addr_hash: H256) -> Result<Bytes, Error> {
+		let db = try!(TrieDB::new(acct_db, &self.storage_root));
+
+		let mut pairs = Vec::new();
+
+		for (k, v) in db.iter() {
+			pairs.push((k, v));
+		}
+
+		let mut stream = RlpStream::new_list(pairs.len());
+
+		for (k, v) in pairs {
+			stream.begin_list(2).append(&k).append(&v);
+		}
+
+		let pairs_rlp = stream.out();
+
+		let mut account_stream = RlpStream::new_list(5);
+		account_stream.append(&self.nonce)
+					  .append(&self.balance);
+
+		// [has_code, code_hash].
+		if self.code_hash == SHA3_EMPTY {
+			account_stream.append(&false).append_empty_data();
+		} else {
+			match acct_db.get(&self.code_hash) {
+				Some(c) => {
+					account_stream.append(&true).append(&c);
+				}
+				None => {
+					warn!("code lookup failed for account with address hash {}, code hash {}", addr_hash, self.code_hash);
+					account_stream.append(&false).append_empty_data();
+				}
+			}
+		}
+
+		account_stream.append_raw(&pairs_rlp, 1);
+
+		Ok(account_stream.out())
+	}
+
+	// decode a fat rlp, and rebuild the storage trie as we go.
+	pub fn from_fat_rlp(acct_db: &mut AccountDBMut, rlp: UntrustedRlp) -> Result<Self, DecoderError> {
+		use util::{TrieDBMut, TrieMut};
+
+		let nonce = try!(rlp.val_at(0));
+		let balance = try!(rlp.val_at(1));
+		let code_hash = if try!(rlp.val_at(2)) {
+			let code: Bytes = try!(rlp.val_at(3));
+			acct_db.insert(&code)
+		} else {
+			SHA3_EMPTY
+		};
+
+		let mut storage_root = H256::zero();
+
+		{
+			let mut storage_trie = TrieDBMut::new(acct_db, &mut storage_root);
+			let pairs = try!(rlp.at(4));
+			for pair_rlp in pairs.iter() {
+				let k: Bytes  = try!(pair_rlp.val_at(0));
+				let v: Bytes = try!(pair_rlp.val_at(1));
+
+				storage_trie.insert(&k, &v);
+			}
+		}
+		Ok(Account {
+			nonce: nonce,
+			balance: balance,
+			storage_root: storage_root,
+			code_hash: code_hash,
+		})
+	}
+}

ethcore/src/snapshot/block.rs

@@ -0,0 +1,123 @@
+// Copyright 2015, 2016 Ethcore (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 <http://www.gnu.org/licenses/>.
+
+//! Block RLP compression.
+
+// TODO [rob] remove when BlockRebuilder done.
+#![allow(dead_code)]
+
+use block::Block;
+use header::Header;
+
+use views::BlockView;
+use util::rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View};
+use util::{Bytes, H256};
+
+const HEADER_FIELDS: usize = 11;
+const BLOCK_FIELDS: usize = 2;
+
+pub struct AbridgedBlock {
+	rlp: Bytes,
+}
+
+impl AbridgedBlock {
+	/// Create from a vector of bytes. Does no verification.
+	pub fn from_raw(rlp: Bytes) -> Self {
+		AbridgedBlock {
+			rlp: rlp,
+		}
+	}
+
+	/// Return the inner bytes.
+	pub fn into_inner(self) -> Bytes {
+		self.rlp
+	}
+
+	/// Given a full block view, trim out the parent hash and block number,
+	/// producing new rlp.
+	pub fn from_block_view(block_view: &BlockView) -> Self {
+		let header = block_view.header_view();
+
+		let seal_fields = header.seal();
+
+		// 11 header fields, unknown amount of seal fields, and 2 block fields.
+		let mut stream = RlpStream::new_list(
+			HEADER_FIELDS +
+			seal_fields.len() +
+			BLOCK_FIELDS
+		);
+
+		// write header values.
+		stream
+			.append(&header.uncles_hash())
+			.append(&header.author())
+			.append(&header.state_root())
+			.append(&header.transactions_root())
+			.append(&header.receipts_root())
+			.append(&header.log_bloom())
+			.append(&header.difficulty())
+			.append(&header.gas_limit())
+			.append(&header.gas_used())
+			.append(&header.timestamp())
+			.append(&header.extra_data());
+
+		// write seal fields.
+		for field in seal_fields {
+			stream.append_raw(&field, 1);
+		}
+
+		// write block values.
+		stream.append(&block_view.transactions()).append(&block_view.uncles());
+
+		AbridgedBlock {
+			rlp: stream.out(),
+		}
+	}
+
+	/// Flesh out an abridged block view with the provided parent hash and block number.
+	///
+	/// Will fail if contains invalid rlp.
+	pub fn to_block(&self, parent_hash: H256, number: u64) -> Result<Block, DecoderError> {
+		let rlp = UntrustedRlp::new(&self.rlp);
+
+		let mut header = Header {
+			parent_hash: parent_hash,
+			uncles_hash: try!(rlp.val_at(0)),
+			author: try!(rlp.val_at(1)),
+			state_root: try!(rlp.val_at(2)),
+			transactions_root: try!(rlp.val_at(3)),
+			receipts_root: try!(rlp.val_at(4)),
+			log_bloom: try!(rlp.val_at(5)),
+			difficulty: try!(rlp.val_at(6)),
+			number: number,
+			gas_limit: try!(rlp.val_at(7)),
+			gas_used: try!(rlp.val_at(8)),
+			timestamp: try!(rlp.val_at(9)),
+			extra_data: try!(rlp.val_at(10)),
+			..Default::default()
+		};
+
+		let seal: Vec<Bytes> = try!(rlp.val_at(11));
+
+		header.set_seal(seal);
+
+		Ok(Block {
+			header: header,
+			transactions: try!(rlp.val_at(12)),
+			uncles: try!(rlp.val_at(13)),
+		})
+	}
+}