Core tracedb functionality.

ethcore/Cargo.toml

@@ -22,6 +22,7 @@ crossbeam = "0.1.5"
 lazy_static = "0.1"
 ethcore-devtools = { path = "../devtools" }
 ethjson = { path = "../json" }
+bloomchain = "0.1"
 
 [features]
 jit = ["evmjit"]

ethcore/src/block.rs

@@ -22,6 +22,7 @@ use common::*;
 use engine::*;
 use state::*;
 use verification::PreverifiedBlock;
+use trace::Trace;
 
 /// A block, encoded as it is on the block chain.
 #[derive(Default, Debug, Clone)]

ethcore/src/blockchain/blockchain.rs

@@ -55,9 +55,6 @@ impl Default for BlockChainConfig {
 
 /// Interface for querying blocks by hash and by number.
 pub trait BlockProvider {
-	/// True if we store full tracing information for transactions.
-	fn have_tracing(&self) -> bool;
-
 	/// Returns true if the given block is known
 	/// (though not necessarily a part of the canon chain).
 	fn is_known(&self, hash: &H256) -> bool;
@@ -186,9 +183,6 @@ impl BlockProvider for BlockChain {
 		self.extras_db.exists_with_cache(&self.block_details, hash)
 	}
 
-	/// We do not store tracing information.
-	fn have_tracing(&self) -> bool { false }
-
 	/// Get raw block data
 	fn block(&self, hash: &H256) -> Option<Bytes> {
 		{
@@ -734,9 +728,10 @@ impl BlockChain {
 		self.query_extras(hash, &self.blocks_blooms)
 	}
 
-	fn query_extras<K, T>(&self, hash: &K, cache: &RwLock<HashMap<K, T>>) -> Option<T> where
+	fn query_extras<K, T, R>(&self, hash: &K, cache: &RwLock<HashMap<K, T>>) -> Option<T> where
 		T: ExtrasIndexable + Clone + Decodable,
-		K: Key<T> + Eq + Hash + Clone,
+		K: Key<T, Target = R> + Eq + Hash + Clone,
+		R: Deref<Target = [u8]>,
 		H256: From<K> {
 		self.note_used(CacheID::Extras(T::index(), H256::from(hash.clone())));
 		self.extras_db.read_with_cache(cache, hash)

ethcore/src/client/client.rs

@@ -42,6 +42,7 @@ use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
 use receipt::LocalizedReceipt;
 pub use blockchain::CacheSize as BlockChainCacheSize;
+use trace::{TraceDB, Database as TraceDatabase};
 
 /// General block status
 #[derive(Debug, Eq, PartialEq)]
@@ -103,6 +104,7 @@ impl ClientReport {
 /// Call `import_block()` to import a block asynchronously; `flush_queue()` flushes the queue.
 pub struct Client<V = CanonVerifier> where V: Verifier {
 	chain: Arc<BlockChain>,
+	tracedb: Arc<TraceDB<BlockChain>>,
 	engine: Arc<Box<Engine>>,
 	state_db: Mutex<Box<JournalDB>>,
 	block_queue: BlockQueue,
@@ -150,6 +152,7 @@ impl<V> Client<V> where V: Verifier {
 		let path = get_db_path(path, config.pruning, spec.genesis_header().hash());
 		let gb = spec.genesis_block();
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, &path));
+		let tracedb = Arc::new(TraceDB::new(config.tracing, &path, chain.clone()));
 
 		let mut state_db = journaldb::new(&append_path(&path, "state"), config.pruning);
 
@@ -165,6 +168,7 @@ impl<V> Client<V> where V: Verifier {
 
 		Arc::new(Client {
 			chain: chain,
+			tracedb: tracedb,
 			engine: engine,
 			state_db: Mutex::new(state_db),
 			block_queue: block_queue,
@@ -225,7 +229,7 @@ impl<V> Client<V> where V: Verifier {
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, self.chain.have_tracing(), db, &parent, last_hashes);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());

ethcore/src/client/config.rs

@@ -16,6 +16,7 @@
 
 pub use block_queue::BlockQueueConfig;
 pub use blockchain::BlockChainConfig;
+pub use trace::{Config as TraceConfig, Switch};
 use util::journaldb;
 
 /// Client configuration. Includes configs for all sub-systems.
@@ -25,6 +26,8 @@ pub struct ClientConfig {
 	pub queue: BlockQueueConfig,
 	/// Blockchain configuration.
 	pub blockchain: BlockChainConfig,
+	/// Trace configuration.
+	pub tracing: TraceConfig,
 	/// The JournalDB ("pruning") algorithm to use.
 	pub pruning: journaldb::Algorithm,
 	/// The name of the client instance.

ethcore/src/client/mod.rs

@@ -20,6 +20,7 @@ mod client;
 mod config;
 mod ids;
 mod test_client;
+mod trace;
 
 pub use self::client::*;
 pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig};

ethcore/src/client/trace.rs

@@ -0,0 +1,38 @@
+
+//! Bridge between Tracedb and Blockchain.
+
+use std::ops::Range;
+use util::{Address, H256};
+use header::BlockNumber;
+use trace::DatabaseExtras as TraceDatabaseExtras;
+use blockchain::{BlockChain, BlockProvider};
+use extras::TransactionAddress;
+use super::BlockId;
+
+impl TraceDatabaseExtras for BlockChain {
+	fn block_hash(&self, block_number: BlockNumber) -> Option<H256> {
+		(self as &BlockProvider).block_hash(block_number)
+	}
+
+	fn transaction_hash(&self, block_number: BlockNumber, tx_position: usize) -> Option<H256> {
+		(self as &BlockProvider).block_hash(block_number)
+			.and_then(|block_hash| {
+				let tx_address = TransactionAddress {
+					block_hash: block_hash,
+					index: tx_position
+				};
+				self.transaction(&tx_address)
+			})
+			.map(|tx| tx.hash())
+	}
+}
+
+/// Easy to use trace filter.
+pub struct Filter {
+	/// Range of filtering.
+	pub range: Range<BlockId>,
+	/// From address.
+	pub from_address: Vec<Address>,
+	/// To address.
+	pub to_address: Vec<Address>,
+}

ethcore/src/common.rs

@@ -26,4 +26,3 @@ pub use transaction::*;
 pub use log_entry::*;
 pub use receipt::*;
 pub use action_params::*;
-pub use trace::*;

ethcore/src/db.rs

@@ -16,10 +16,11 @@
 
 //! Extras db utils.
 
+use std::ops::Deref;
 use std::hash::Hash;
 use std::sync::RwLock;
 use std::collections::HashMap;
-use util::{H264, DBTransaction, Database};
+use util::{DBTransaction, Database};
 use util::rlp::{encode, Encodable, decode, Decodable};
 
 #[derive(Clone, Copy)]
@@ -30,19 +31,22 @@ pub enum CacheUpdatePolicy {
 
 /// Should be used to get database key associated with given value.
 pub trait Key<T> {
+	type Target: Deref<Target = [u8]>;
+
 	/// Returns db key.
-	fn key(&self) -> H264;
+	fn key(&self) -> Self::Target;
 }
 
 /// Should be used to write value into database.
 pub trait Writable {
 	/// Writes the value into the database.
-	fn write<T>(&self, key: &Key<T>, value: &T) where T: Encodable;
+	fn write<T, R>(&self, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]>;
 
 	/// Writes the value into the database and updates the cache.
-	fn write_with_cache<K, T>(&self, cache: &mut HashMap<K, T>, key: K, value: T, policy: CacheUpdatePolicy) where
-	K: Key<T> + Hash + Eq,
-	T: Encodable {
+	fn write_with_cache<K, T, R>(&self, cache: &mut HashMap<K, T>, key: K, value: T, policy: CacheUpdatePolicy) where
+	K: Key<T, Target = R> + Hash + Eq,
+	T: Encodable,
+	R: Deref<Target = [u8]> {
 		self.write(&key, &value);
 		match policy {
 			CacheUpdatePolicy::Overwrite => {
@@ -55,8 +59,10 @@ pub trait Writable {
 	}
 
 	/// Writes the values into the database and updates the cache.
-	fn extend_with_cache<K, T>(&self, cache: &mut HashMap<K, T>, values: HashMap<K, T>, policy: CacheUpdatePolicy)
-	where K: Key<T> + Hash + Eq, T: Encodable {
+	fn extend_with_cache<K, T, R>(&self, cache: &mut HashMap<K, T>, values: HashMap<K, T>, policy: CacheUpdatePolicy) where
+	K: Key<T, Target = R> + Hash + Eq,
+	T: Encodable,
+	R: Deref<Target = [u8]> {
 		match policy {
 			CacheUpdatePolicy::Overwrite => {
 				for (key, value) in values.into_iter() {
@@ -77,7 +83,9 @@ pub trait Writable {
 /// Should be used to read values from database.
 pub trait Readable {
 	/// Returns value for given key.
-	fn read<T>(&self, key: &Key<T>) -> Option<T> where T: Decodable;
+	fn read<T, R>(&self, key: &Key<T, Target = R>) -> Option<T> where
+	T: Decodable,
+	R: Deref<Target = [u8]>;
 
 	/// Returns value for given key either in cache or in database.
 	fn read_with_cache<K, T>(&self, cache: &RwLock<HashMap<K, T>>,  key: &K) -> Option<T> where
@@ -98,50 +106,51 @@ pub trait Readable {
 	}
 
 	/// Returns true if given value exists.
-	fn exists<T>(&self, key: &Key<T>) -> bool;
+	fn exists<T, R>(&self, key: &Key<T, Target = R>) -> bool where R: Deref<Target= [u8]>;
 
 	/// Returns true if given value exists either in cache or in database.
-	fn exists_with_cache<K, T>(&self, cache: &RwLock<HashMap<K, T>>, key: &K) -> bool where
-		K: Eq + Hash + Key<T> {
+	fn exists_with_cache<K, T, R>(&self, cache: &RwLock<HashMap<K, T>>, key: &K) -> bool where
+	K: Eq + Hash + Key<T, Target = R>,
+	R: Deref<Target = [u8]> {
 		{
 			let read = cache.read().unwrap();
 			if read.get(key).is_some() {
 				return true;
 			}
 		}
 
-		self.exists::<T>(key)
+		self.exists::<T, R>(key)
 	}
 }
 
 impl Writable for DBTransaction {
-	fn write<T>(&self, key: &Key<T>, value: &T) where T: Encodable {
+	fn write<T, R>(&self, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]> {
 		let result = self.put(&key.key(), &encode(value));
 		if let Err(err) = result {
-			panic!("db put failed, key: {:?}, err: {:?}", key.key(), err);
+			panic!("db put failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
 		}
 	}
 }
 
 impl Readable for Database {
-	fn read<T>(&self, key: &Key<T>) -> Option<T> where T: Decodable {
+	fn read<T, R>(&self, key: &Key<T, Target = R>) -> Option<T> where T: Decodable, R: Deref<Target = [u8]> {
 		let result = self.get(&key.key());
 
 		match result {
 			Ok(option) => option.map(|v| decode(&v)),
 			Err(err) => {
-				panic!("db get failed, key: {:?}, err: {:?}", key.key(), err);
+				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
 			}
 		}
 	}
 
-	fn exists<T>(&self, key: &Key<T>) -> bool {
+	fn exists<T, R>(&self, key: &Key<T, Target = R>) -> bool where R: Deref<Target = [u8]> {
 		let result = self.get(&key.key());
 
 		match result {
 			Ok(v) => v.is_some(),
 			Err(err) => {
-				panic!("db get failed, key: {:?}, err: {:?}", key.key(), err);
+				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
 			}
 		}
 	}