Merge branch 'master' into clippy-bump

Conflicts:
	dapps/Cargo.toml

Cargo.lock

@@ -287,6 +287,7 @@ dependencies = [
  "jsonrpc-core 2.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "jsonrpc-http-server 5.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mime_guess 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
  "parity-dapps-builtins 0.5.0 (git+https://github.com/ethcore/parity-dapps-builtins-rs.git)",
  "parity-dapps-dao 0.3.0 (git+https://github.com/ethcore/parity-dapps-dao-rs.git)",
@@ -883,7 +884,7 @@ dependencies = [
 [[package]]
 name = "parity-dapps-builtins"
 version = "0.5.0"
-source = "git+https://github.com/ethcore/parity-dapps-builtins-rs.git#eb86a2954f04d3aa5547a8c4bb77ae7aad09bf55"
+source = "git+https://github.com/ethcore/parity-dapps-builtins-rs.git#8bbf0421e376f9496d70adc62c1c6d7f492df817"
 dependencies = [
  "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
 ]

dapps/Cargo.toml

@@ -27,6 +27,7 @@ parity-dapps-builtins = { git = "https://github.com/ethcore/parity-dapps-builtin
 parity-dapps-wallet = { git = "https://github.com/ethcore/parity-dapps-wallet-rs.git", version = "0.5.0", optional = true }
 parity-dapps-dao = { git = "https://github.com/ethcore/parity-dapps-dao-rs.git", version = "0.3.0", optional = true }
 parity-dapps-makerotc = { git = "https://github.com/ethcore/parity-dapps-makerotc-rs.git", version = "0.2.0", optional = true }
+mime_guess = { version = "1.6.1" }
 clippy = { version = "0.0.71", optional = true}
 
 [build-dependencies]

dapps/src/api/api.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::Arc;
-use endpoint::{Endpoint, Endpoints, Handler, EndpointPath};
+use endpoint::{Endpoint, Endpoints, EndpointInfo, Handler, EndpointPath};
 
 use api::response::as_json;
 
@@ -23,8 +23,8 @@ pub struct RestApi {
 	endpoints: Arc<Endpoints>,
 }
 
-#[derive(Debug, PartialEq, Serialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct App {
+pub struct App {
 	pub id: String,
 	pub name: String,
 	pub description: String,
@@ -34,6 +34,19 @@ struct App {
 	pub icon_url: String,
 }
 
+impl App {
+	fn from_info(id: &str, info: &EndpointInfo) -> Self {
+		App {
+			id: id.to_owned(),
+			name: info.name.to_owned(),
+			description: info.description.to_owned(),
+			version: info.version.to_owned(),
+			author: info.author.to_owned(),
+			icon_url: info.icon_url.to_owned(),
+		}
+	}
+}
+
 impl RestApi {
 	pub fn new(endpoints: Arc<Endpoints>) -> Box<Endpoint> {
 		Box::new(RestApi {
@@ -43,14 +56,7 @@ impl RestApi {
 
 	fn list_apps(&self) -> Vec<App> {
 		self.endpoints.iter().filter_map(|(ref k, ref e)| {
-			e.info().map(|ref info| App {
+			e.info().map(|ref info| App::from_info(k, info))
-				id: k.to_owned().clone(),
-				name: info.name.to_owned(),
-				description: info.description.to_owned(),
-				version: info.version.to_owned(),
-				author: info.author.to_owned(),
-				icon_url: info.icon_url.to_owned(),
-			})
 		}).collect()
 	}
 }

dapps/src/api/mod.rs.in

@@ -18,3 +18,4 @@ mod api;
 mod response;
 
 pub use self::api::RestApi;
+pub use self::api::App;

dapps/src/apps/fs.rs

@@ -0,0 +1,116 @@
+// 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/>.
+
+use serde_json;
+use std::io;
+use std::io::Read;
+use std::fs;
+use std::path::PathBuf;
+use page::LocalPageEndpoint;
+use endpoint::{Endpoints, EndpointInfo};
+use api::App;
+
+struct LocalDapp {
+	id: String,
+	path: PathBuf,
+	info: EndpointInfo,
+}
+
+fn local_dapps(dapps_path: String) -> Vec<LocalDapp> {
+	let files = fs::read_dir(dapps_path.as_str());
+	if let Err(e) = files {
+		warn!(target: "dapps", "Unable to load local dapps from: {}. Reason: {:?}", dapps_path, e);
+		return vec![];
+	}
+
+	let files = files.expect("Check is done earlier");
+	files.map(|dir| {
+			let entry = try!(dir);
+			let file_type = try!(entry.file_type());
+
+			// skip files
+			if file_type.is_file() {
+				return Err(io::Error::new(io::ErrorKind::NotFound, "Not a file"));
+			}
+
+			// take directory name and path
+			entry.file_name().into_string()
+				.map(|name| (name, entry.path()))
+				.map_err(|e| {
+					info!(target: "dapps", "Unable to load dapp: {:?}. Reason: {:?}", entry.path(), e);
+					io::Error::new(io::ErrorKind::NotFound, "Invalid name")
+				})
+		})
+		.filter_map(|m| {
+			if let Err(ref e) = m {
+				debug!(target: "dapps", "Ignoring local dapp: {:?}", e);
+			}
+			m.ok()
+		})
+		.map(|(name, path)| {
+			// try to get manifest file
+			let info = read_manifest(&name, path.clone());
+			LocalDapp {
+				id: name,
+				path: path,
+				info: info,
+			}
+		})
+		.collect()
+}
+
+fn read_manifest(name: &str, mut path: PathBuf) -> EndpointInfo {
+	path.push("manifest.json");
+
+	fs::File::open(path.clone())
+		.map_err(|e| format!("{:?}", e))
+		.and_then(|mut f| {
+			// Reat file
+			let mut s = String::new();
+			try!(f.read_to_string(&mut s).map_err(|e| format!("{:?}", e)));
+			// Try to deserialize manifest
+			serde_json::from_str::<App>(&s).map_err(|e| format!("{:?}", e))
+		})
+		.map(|app| EndpointInfo {
+			name: app.name,
+			description: app.description,
+			version: app.version,
+			author: app.author,
+			icon_url: app.icon_url,
+		})
+		.unwrap_or_else(|e| {
+			warn!(target: "dapps", "Cannot read manifest file at: {:?}. Error: {:?}", path, e);
+
+			EndpointInfo {
+				name: name.into(),
+				description: name.into(),
+				version: "0.0.0".into(),
+				author: "?".into(),
+				icon_url: "icon.png".into(),
+			}
+		})
+}
+
+pub fn local_endpoints(dapps_path: String) -> Endpoints {
+	let mut pages = Endpoints::new();
+	for dapp in local_dapps(dapps_path) {
+		pages.insert(
+			dapp.id,
+			Box::new(LocalPageEndpoint::new(dapp.path, dapp.info))
+		);
+	}
+	pages
+}

dapps/src/apps/mod.rs

@@ -19,10 +19,11 @@ use page::PageEndpoint;
 use proxypac::ProxyPac;
 use parity_dapps::WebApp;
 
+mod fs;
+
 extern crate parity_dapps_status;
 extern crate parity_dapps_builtins;
 
-
 pub const DAPPS_DOMAIN : &'static str = ".parity";
 pub const RPC_PATH : &'static str =  "rpc";
 pub const API_PATH : &'static str =  "api";
@@ -36,22 +37,24 @@ pub fn utils() -> Box<Endpoint> {
 	Box::new(PageEndpoint::with_prefix(parity_dapps_builtins::App::default(), UTILS_PATH.to_owned()))
 }
 
-pub fn all_endpoints() -> Endpoints {
+pub fn all_endpoints(dapps_path: String) -> Endpoints {
-	let mut pages = Endpoints::new();
+	// fetch fs dapps at first to avoid overwriting builtins
-	pages.insert("proxy".into(), ProxyPac::boxed());
+	let mut pages = fs::local_endpoints(dapps_path);
-
 	// Home page needs to be safe embed
 	// because we use Cross-Origin LocalStorage.
 	// TODO [ToDr] Account naming should be moved to parity.
 	pages.insert("home".into(), Box::new(
 		PageEndpoint::new_safe_to_embed(parity_dapps_builtins::App::default())
 	));
+	pages.insert("proxy".into(), ProxyPac::boxed());
 	insert::<parity_dapps_status::App>(&mut pages, "status");
 	insert::<parity_dapps_status::App>(&mut pages, "parity");
 
+	// Optional dapps
 	wallet_page(&mut pages);
 	daodapp_page(&mut pages);
 	makerotc_page(&mut pages);
+
 	pages
 }
 

dapps/src/endpoint.rs

@@ -30,17 +30,17 @@ pub struct EndpointPath {
 	pub port: u16,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct EndpointInfo {
-	pub name: &'static str,
+	pub name: String,
-	pub description: &'static str,
+	pub description: String,
-	pub version: &'static str,
+	pub version: String,
-	pub author: &'static str,
+	pub author: String,
-	pub icon_url: &'static str,
+	pub icon_url: String,
 }
 
 pub trait Endpoint : Send + Sync {
-	fn info(&self) -> Option<EndpointInfo> { None }
+	fn info(&self) -> Option<&EndpointInfo> { None }
 
 	fn to_handler(&self, path: EndpointPath) -> Box<server::Handler<HttpStream>>;
 }

dapps/src/lib.rs

@@ -53,6 +53,7 @@ extern crate jsonrpc_core;
 extern crate jsonrpc_http_server;
 extern crate parity_dapps;
 extern crate ethcore_rpc;
+extern crate mime_guess;
 
 mod endpoint;
 mod apps;
@@ -73,6 +74,7 @@ static DAPPS_DOMAIN : &'static str = ".parity";
 
 /// Webapps HTTP+RPC server build.
 pub struct ServerBuilder {
+	dapps_path: String,
 	handler: Arc<IoHandler>,
 }
 
@@ -84,8 +86,9 @@ impl Extendable for ServerBuilder {
 
 impl ServerBuilder {
 	/// Construct new dapps server
-	pub fn new() -> Self {
+	pub fn new(dapps_path: String) -> Self {
 		ServerBuilder {
+			dapps_path: dapps_path,
 			handler: Arc::new(IoHandler::new())
 		}
 	}
@@ -93,13 +96,13 @@ impl ServerBuilder {
 	/// Asynchronously start server with no authentication,
 	/// returns result with `Server` handle on success or an error.
 	pub fn start_unsecure_http(&self, addr: &SocketAddr) -> Result<Server, ServerError> {
-		Server::start_http(addr, NoAuth, self.handler.clone())
+		Server::start_http(addr, NoAuth, self.handler.clone(), self.dapps_path.clone())
 	}
 
 	/// Asynchronously start server with `HTTP Basic Authentication`,
 	/// return result with `Server` handle on success or an error.
 	pub fn start_basic_auth_http(&self, addr: &SocketAddr, username: &str, password: &str) -> Result<Server, ServerError> {
-		Server::start_http(addr, HttpBasicAuth::single_user(username, password), self.handler.clone())
+		Server::start_http(addr, HttpBasicAuth::single_user(username, password), self.handler.clone(), self.dapps_path.clone())
 	}
 }
 
@@ -110,10 +113,10 @@ pub struct Server {
 }
 
 impl Server {
-	fn start_http<A: Authorization + 'static>(addr: &SocketAddr, authorization: A, handler: Arc<IoHandler>) -> Result<Server, ServerError> {
+	fn start_http<A: Authorization + 'static>(addr: &SocketAddr, authorization: A, handler: Arc<IoHandler>, dapps_path: String) -> Result<Server, ServerError> {
 		let panic_handler = Arc::new(Mutex::new(None));
 		let authorization = Arc::new(authorization);
-		let endpoints = Arc::new(apps::all_endpoints());
+		let endpoints = Arc::new(apps::all_endpoints(dapps_path));
 		let special = Arc::new({
 			let mut special = HashMap::new();
 			special.insert(router::SpecialEndpoint::Rpc, rpc::rpc(handler, panic_handler.clone()));

dapps/src/page/builtin.rs

@@ -0,0 +1,154 @@
+// 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/>.
+
+use page::handler;
+use std::sync::Arc;
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
+use parity_dapps::{WebApp, File, Info};
+
+pub struct PageEndpoint<T : WebApp + 'static> {
+	/// Content of the files
+	pub app: Arc<T>,
+	/// Prefix to strip from the path (when `None` deducted from `app_id`)
+	pub prefix: Option<String>,
+	/// Safe to be loaded in frame by other origin. (use wisely!)
+	safe_to_embed: bool,
+	info: EndpointInfo,
+}
+
+impl<T: WebApp + 'static> PageEndpoint<T> {
+	/// Creates new `PageEndpoint` for builtin (compile time) Dapp.
+	pub fn new(app: T) -> Self {
+		let info = app.info();
+		PageEndpoint {
+			app: Arc::new(app),
+			prefix: None,
+			safe_to_embed: false,
+			info: EndpointInfo::from(info),
+		}
+	}
+
+	/// Create new `PageEndpoint` and specify prefix that should be removed before looking for a file.
+	/// It's used only for special endpoints (i.e. `/parity-utils/`)
+	/// So `/parity-utils/inject.js` will be resolved to `/inject.js` is prefix is set.
+	pub fn with_prefix(app: T, prefix: String) -> Self {
+		let info = app.info();
+		PageEndpoint {
+			app: Arc::new(app),
+			prefix: Some(prefix),
+			safe_to_embed: false,
+			info: EndpointInfo::from(info),
+		}
+	}
+
+	/// Creates new `PageEndpoint` which can be safely used in iframe
+	/// even from different origin. It might be dangerous (clickjacking).
+	/// Use wisely!
+	pub fn new_safe_to_embed(app: T) -> Self {
+		let info = app.info();
+		PageEndpoint {
+			app: Arc::new(app),
+			prefix: None,
+			safe_to_embed: true,
+			info: EndpointInfo::from(info),
+		}
+	}
+}
+
+impl<T: WebApp> Endpoint for PageEndpoint<T> {
+
+	fn info(&self) -> Option<&EndpointInfo> {
+		Some(&self.info)
+	}
+
+	fn to_handler(&self, path: EndpointPath) -> Box<Handler> {
+		Box::new(handler::PageHandler {
+			app: BuiltinDapp::new(self.app.clone()),
+			prefix: self.prefix.clone(),
+			path: path,
+			file: None,
+			safe_to_embed: self.safe_to_embed,
+		})
+	}
+}
+
+impl From<Info> for EndpointInfo {
+	fn from(info: Info) -> Self {
+		EndpointInfo {
+			name: info.name.into(),
+			description: info.description.into(),
+			author: info.author.into(),
+			icon_url: info.icon_url.into(),
+			version: info.version.into(),
+		}
+	}
+}
+
+struct BuiltinDapp<T: WebApp + 'static> {
+	app: Arc<T>,
+}
+
+impl<T: WebApp + 'static> BuiltinDapp<T> {
+	fn new(app: Arc<T>) -> Self {
+		BuiltinDapp {
+			app: app,
+		}
+	}
+}
+
+impl<T: WebApp + 'static> handler::Dapp for BuiltinDapp<T> {
+	type DappFile = BuiltinDappFile<T>;
+
+	fn file(&self, path: &str) -> Option<Self::DappFile> {
+		self.app.file(path).map(|_| {
+			BuiltinDappFile {
+				app: self.app.clone(),
+				path: path.into(),
+				write_pos: 0,
+			}
+		})
+	}
+}
+
+struct BuiltinDappFile<T: WebApp + 'static> {
+	app: Arc<T>,
+	path: String,
+	write_pos: usize,
+}
+
+impl<T: WebApp + 'static> BuiltinDappFile<T> {
+	fn file(&self) -> &File {
+		self.app.file(&self.path).expect("Check is done when structure is created.")
+	}
+}
+
+impl<T: WebApp + 'static> handler::DappFile for BuiltinDappFile<T> {
+	fn content_type(&self) -> &str {
+		self.file().content_type
+	}
+
+	fn is_drained(&self) -> bool {
+		self.write_pos == self.file().content.len()
+	}
+
+	fn next_chunk(&mut self) -> &[u8] {
+		&self.file().content[self.write_pos..]
+	}
+
+	fn bytes_written(&mut self, bytes: usize) {
+		self.write_pos += bytes;
+	}
+}

dapps/src/page/handler.rs

@@ -0,0 +1,207 @@
+// 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/>.
+
+use std::io::Write;
+use hyper::header;
+use hyper::server;
+use hyper::uri::RequestUri;
+use hyper::net::HttpStream;
+use hyper::status::StatusCode;
+use hyper::{Decoder, Encoder, Next};
+use endpoint::EndpointPath;
+
+/// Represents a file that can be sent to client.
+/// Implementation should keep track of bytes already sent internally.
+pub trait DappFile: Send {
+	/// Returns a content-type of this file.
+	fn content_type(&self) -> &str;
+
+	/// Checks if all bytes from that file were written.
+	fn is_drained(&self) -> bool;
+
+	/// Fetch next chunk to write to the client.
+	fn next_chunk(&mut self) -> &[u8];
+
+	/// How many files have been written to the client.
+	fn bytes_written(&mut self, bytes: usize);
+}
+
+/// Dapp as a (dynamic) set of files.
+pub trait Dapp: Send + 'static {
+	/// File type
+	type DappFile: DappFile;
+
+	/// Returns file under given path.
+	fn file(&self, path: &str) -> Option<Self::DappFile>;
+}
+
+/// A handler for a single webapp.
+/// Resolves correct paths and serves as a plumbing code between
+/// hyper server and dapp.
+pub struct PageHandler<T: Dapp> {
+	/// A Dapp.
+	pub app: T,
+	/// File currently being served (or `None` if file does not exist).
+	pub file: Option<T::DappFile>,
+	/// Optional prefix to strip from path.
+	pub prefix: Option<String>,
+	/// Requested path.
+	pub path: EndpointPath,
+	/// Flag indicating if the file can be safely embeded (put in iframe).
+	pub safe_to_embed: bool,
+}
+
+impl<T: Dapp> PageHandler<T> {
+	fn extract_path(&self, path: &str) -> String {
+		let app_id = &self.path.app_id;
+		let prefix = "/".to_owned() + self.prefix.as_ref().unwrap_or(app_id);
+		let prefix_with_slash = prefix.clone() + "/";
+		let query_pos = path.find('?').unwrap_or_else(|| path.len());
+
+		// Index file support
+		match path == "/" || path == &prefix || path == &prefix_with_slash {
+			true => "index.html".to_owned(),
+			false => if path.starts_with(&prefix_with_slash) {
+				path[prefix_with_slash.len()..query_pos].to_owned()
+			} else if path.starts_with("/") {
+				path[1..query_pos].to_owned()
+			} else {
+				path[0..query_pos].to_owned()
+			}
+		}
+	}
+}
+
+impl<T: Dapp> server::Handler<HttpStream> for PageHandler<T> {
+	fn on_request(&mut self, req: server::Request) -> Next {
+		self.file = match *req.uri() {
+			RequestUri::AbsolutePath(ref path) => {
+				self.app.file(&self.extract_path(path))
+			},
+			RequestUri::AbsoluteUri(ref url) => {
+				self.app.file(&self.extract_path(url.path()))
+			},
+			_ => None,
+		};
+		Next::write()
+	}
+
+	fn on_request_readable(&mut self, _decoder: &mut Decoder<HttpStream>) -> Next {
+		Next::write()
+	}
+
+	fn on_response(&mut self, res: &mut server::Response) -> Next {
+		if let Some(ref f) = self.file {
+			res.set_status(StatusCode::Ok);
+			res.headers_mut().set(header::ContentType(f.content_type().parse().unwrap()));
+			if !self.safe_to_embed {
+				res.headers_mut().set_raw("X-Frame-Options", vec![b"SAMEORIGIN".to_vec()]);
+			}
+			Next::write()
+		} else {
+			res.set_status(StatusCode::NotFound);
+			Next::write()
+		}
+	}
+
+	fn on_response_writable(&mut self, encoder: &mut Encoder<HttpStream>) -> Next {
+		match self.file {
+			None => Next::end(),
+			Some(ref f) if f.is_drained() => Next::end(),
+			Some(ref mut f) => match encoder.write(f.next_chunk()) {
+				Ok(bytes) => {
+					f.bytes_written(bytes);
+					Next::write()
+				},
+				Err(e) => match e.kind() {
+					::std::io::ErrorKind::WouldBlock => Next::write(),
+					_ => Next::end(),
+				},
+			}
+		}
+	}
+}
+
+
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	pub struct TestWebAppFile;
+
+	impl DappFile for TestWebAppFile {
+		fn content_type(&self) -> &str {
+			unimplemented!()
+		}
+
+		fn is_drained(&self) -> bool {
+			unimplemented!()
+		}
+
+		fn next_chunk(&mut self) -> &[u8] {
+			unimplemented!()
+		}
+
+		fn bytes_written(&mut self, _bytes: usize) {
+			unimplemented!()
+		}
+	}
+
+	#[derive(Default)]
+	pub struct TestWebapp;
+
+	impl Dapp for TestWebapp {
+		type DappFile = TestWebAppFile;
+
+		fn file(&self, _path: &str) -> Option<Self::DappFile> {
+			None
+		}
+	}
+}
+
+#[test]
+fn should_extract_path_with_appid() {
+
+	// given
+	let path1 = "/";
+	let path2= "/test.css";
+	let path3 = "/app/myfile.txt";
+	let path4 = "/app/myfile.txt?query=123";
+	let page_handler = PageHandler {
+		app: test::TestWebapp,
+		prefix: None,
+		path: EndpointPath {
+			app_id: "app".to_owned(),
+			host: "".to_owned(),
+			port: 8080
+		},
+		file: None,
+		safe_to_embed: true,
+	};
+
+	// when
+	let res1 = page_handler.extract_path(path1);
+	let res2 = page_handler.extract_path(path2);
+	let res3 = page_handler.extract_path(path3);
+	let res4 = page_handler.extract_path(path4);
+
+	// then
+	assert_eq!(&res1, "index.html");
+	assert_eq!(&res2, "test.css");
+	assert_eq!(&res3, "myfile.txt");
+	assert_eq!(&res4, "myfile.txt");
+}

dapps/src/page/local.rs

@@ -0,0 +1,118 @@
+// 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/>.
+
+use mime_guess;
+use std::io::{Seek, Read, SeekFrom};
+use std::fs;
+use std::path::PathBuf;
+use page::handler;
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
+
+pub struct LocalPageEndpoint {
+	path: PathBuf,
+	info: EndpointInfo,
+}
+
+impl LocalPageEndpoint {
+	pub fn new(path: PathBuf, info: EndpointInfo) -> Self {
+		LocalPageEndpoint {
+			path: path,
+			info: info,
+		}
+	}
+}
+
+impl Endpoint for LocalPageEndpoint {
+	fn info(&self) -> Option<&EndpointInfo> {
+		Some(&self.info)
+	}
+
+	fn to_handler(&self, path: EndpointPath) -> Box<Handler> {
+		Box::new(handler::PageHandler {
+			app: LocalDapp::new(self.path.clone()),
+			prefix: None,
+			path: path,
+			file: None,
+			safe_to_embed: false,
+		})
+	}
+}
+
+struct LocalDapp {
+	path: PathBuf,
+}
+
+impl LocalDapp {
+	fn new(path: PathBuf) -> Self {
+		LocalDapp {
+			path: path
+		}
+	}
+}
+
+impl handler::Dapp for LocalDapp {
+	type DappFile = LocalFile;
+
+	fn file(&self, file_path: &str) -> Option<Self::DappFile> {
+		let mut path = self.path.clone();
+		for part in file_path.split('/') {
+			path.push(part);
+		}
+		// Check if file exists
+		fs::File::open(path.clone()).ok().map(|file| {
+			let content_type = mime_guess::guess_mime_type(path);
+			let len = file.metadata().ok().map_or(0, |meta| meta.len());
+			LocalFile {
+				content_type: content_type.to_string(),
+				buffer: [0; 4096],
+				file: file,
+				pos: 0,
+				len: len,
+			}
+		})
+	}
+}
+
+struct LocalFile {
+	content_type: String,
+	buffer: [u8; 4096],
+	file: fs::File,
+	len: u64,
+	pos: u64,
+}
+
+impl handler::DappFile for LocalFile {
+	fn content_type(&self) -> &str {
+		&self.content_type
+	}
+
+	fn is_drained(&self) -> bool {
+		self.pos == self.len
+	}
+
+	fn next_chunk(&mut self) -> &[u8] {
+		let _ = self.file.seek(SeekFrom::Start(self.pos));
+		if let Ok(n) = self.file.read(&mut self.buffer) {
+			&self.buffer[0..n]
+		} else {
+			&self.buffer[0..0]
+		}
+	}
+
+	fn bytes_written(&mut self, bytes: usize) {
+		self.pos += bytes as u64;
+	}
+}

dapps/src/page/mod.rs

@@ -14,216 +14,11 @@
 // 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::sync::Arc;
-use std::io::Write;
-use hyper::uri::RequestUri;
-use hyper::server;
-use hyper::header;
-use hyper::status::StatusCode;
-use hyper::net::HttpStream;
-use hyper::{Decoder, Encoder, Next};
-use endpoint::{Endpoint, EndpointInfo, EndpointPath};
-use parity_dapps::{WebApp, Info};
 
-pub struct PageEndpoint<T : WebApp + 'static> {
+mod builtin;
-	/// Content of the files
+mod local;
-	pub app: Arc<T>,
+mod handler;
-	/// Prefix to strip from the path (when `None` deducted from `app_id`)
-	pub prefix: Option<String>,
-	/// Safe to be loaded in frame by other origin. (use wisely!)
-	safe_to_embed: bool,
-}
 
-impl<T: WebApp + 'static> PageEndpoint<T> {
+pub use self::local::LocalPageEndpoint;
-	pub fn new(app: T) -> Self {
+pub use self::builtin::PageEndpoint;
-		PageEndpoint {
-			app: Arc::new(app),
-			prefix: None,
-			safe_to_embed: false,
-		}
-	}
 
-	pub fn with_prefix(app: T, prefix: String) -> Self {
-		PageEndpoint {
-			app: Arc::new(app),
-			prefix: Some(prefix),
-			safe_to_embed: false,
-		}
-	}
-
-	/// Creates new `PageEndpoint` which can be safely used in iframe
-	/// even from different origin. It might be dangerous (clickjacking).
-	/// Use wisely!
-	pub fn new_safe_to_embed(app: T) -> Self {
-		PageEndpoint {
-			app: Arc::new(app),
-			prefix: None,
-			safe_to_embed: true,
-		}
-	}
-}
-
-impl<T: WebApp> Endpoint for PageEndpoint<T> {
-
-	fn info(&self) -> Option<EndpointInfo> {
-		Some(EndpointInfo::from(self.app.info()))
-	}
-
-	fn to_handler(&self, path: EndpointPath) -> Box<server::Handler<HttpStream>> {
-		Box::new(PageHandler {
-			app: self.app.clone(),
-			prefix: self.prefix.clone(),
-			path: path,
-			file: None,
-			write_pos: 0,
-			safe_to_embed: self.safe_to_embed,
-		})
-	}
-}
-
-impl From<Info> for EndpointInfo {
-	fn from(info: Info) -> Self {
-		EndpointInfo {
-			name: info.name,
-			description: info.description,
-			author: info.author,
-			icon_url: info.icon_url,
-			version: info.version,
-		}
-	}
-}
-
-struct PageHandler<T: WebApp + 'static> {
-	app: Arc<T>,
-	prefix: Option<String>,
-	path: EndpointPath,
-	file: Option<String>,
-	write_pos: usize,
-	safe_to_embed: bool,
-}
-
-impl<T: WebApp + 'static> PageHandler<T> {
-	fn extract_path(&self, path: &str) -> String {
-		let app_id = &self.path.app_id;
-		let prefix = "/".to_owned() + self.prefix.as_ref().unwrap_or(app_id);
-		let prefix_with_slash = prefix.clone() + "/";
-		let query_pos = path.find('?').unwrap_or_else(|| path.len());
-
-		// Index file support
-		match path == "/" || path == &prefix || path == &prefix_with_slash {
-			true => "index.html".to_owned(),
-			false => if path.starts_with(&prefix_with_slash) {
-				path[prefix_with_slash.len()..query_pos].to_owned()
-			} else if path.starts_with("/") {
-				path[1..query_pos].to_owned()
-			} else {
-				path[0..query_pos].to_owned()
-			}
-		}
-	}
-}
-
-impl<T: WebApp + 'static> server::Handler<HttpStream> for PageHandler<T> {
-	fn on_request(&mut self, req: server::Request) -> Next {
-		self.file = match *req.uri() {
-			RequestUri::AbsolutePath(ref path) => {
-				Some(self.extract_path(path))
-			},
-			RequestUri::AbsoluteUri(ref url) => {
-				Some(self.extract_path(url.path()))
-			},
-			_ => None,
-		};
-		Next::write()
-	}
-
-	fn on_request_readable(&mut self, _decoder: &mut Decoder<HttpStream>) -> Next {
-		Next::write()
-	}
-
-	fn on_response(&mut self, res: &mut server::Response) -> Next {
-		if let Some(f) = self.file.as_ref().and_then(|f| self.app.file(f)) {
-			res.set_status(StatusCode::Ok);
-			res.headers_mut().set(header::ContentType(f.content_type.parse().unwrap()));
-			if !self.safe_to_embed {
-				res.headers_mut().set_raw("X-Frame-Options", vec![b"SAMEORIGIN".to_vec()]);
-			}
-			Next::write()
-		} else {
-			res.set_status(StatusCode::NotFound);
-			Next::write()
-		}
-	}
-
-	fn on_response_writable(&mut self, encoder: &mut Encoder<HttpStream>) -> Next {
-		let (wrote, res) = {
-			let file = self.file.as_ref().and_then(|f| self.app.file(f));
-			match file {
-				None => (None, Next::end()),
-				Some(f) if self.write_pos == f.content.len() => (None, Next::end()),
-				Some(f) => match encoder.write(&f.content[self.write_pos..]) {
-					Ok(bytes) => (Some(bytes), Next::write()),
-					Err(e) => match e.kind() {
-						::std::io::ErrorKind::WouldBlock => (None, Next::write()),
-						_ => (None, Next::end())
-					},
-				}
-			}
-		};
-		if let Some(bytes) = wrote {
-			self.write_pos += bytes;
-		}
-		res
-	}
-}
-
-
-#[cfg(test)]
-use parity_dapps::File;
-
-#[cfg(test)]
-#[derive(Default)]
-struct TestWebapp;
-
-#[cfg(test)]
-impl WebApp for TestWebapp {
-	fn file(&self, _path: &str) -> Option<&File> {
-		None
-	}
-	fn info(&self) -> Info {
-		unimplemented!()
-	}
-}
-
-#[test]
-fn should_extract_path_with_appid() {
-	// given
-	let path1 = "/";
-	let path2= "/test.css";
-	let path3 = "/app/myfile.txt";
-	let path4 = "/app/myfile.txt?query=123";
-	let page_handler = PageHandler {
-		app: Arc::new(TestWebapp),
-		prefix: None,
-		path: EndpointPath {
-			app_id: "app".to_owned(),
-			host: "".to_owned(),
-			port: 8080
-		},
-		file: None,
-		write_pos: 0,
-		safe_to_embed: true,
-	};
-
-	// when
-	let res1 = page_handler.extract_path(path1);
-	let res2 = page_handler.extract_path(path2);
-	let res3 = page_handler.extract_path(path3);
-	let res4 = page_handler.extract_path(path4);
-
-	// then
-	assert_eq!(&res1, "index.html");
-	assert_eq!(&res2, "test.css");
-	assert_eq!(&res3, "myfile.txt");
-	assert_eq!(&res4, "myfile.txt");
-}

ethcore/src/account.rs

@@ -51,8 +51,6 @@ impl Account {
 		}
 	}
 
-	#[cfg(test)]
-	#[cfg(feature = "json-tests")]
 	/// General constructor.
 	pub fn from_pod(pod: PodAccount) -> Account {
 		Account {

ethcore/src/client/client.rs

@@ -37,7 +37,7 @@ use filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
-use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, MiningBlockChainClient, TraceFilter};
+use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -429,14 +429,14 @@ impl<V> Client<V> where V: Verifier {
 			TransactionID::Hash(ref hash) => self.chain.transaction_address(hash),
 			TransactionID::Location(id, index) => Self::block_hash(&self.chain, id).map(|hash| TransactionAddress {
 				block_hash: hash,
-				index: index
+				index: index,
 			})
 		}
 	}
 }
 
 impl<V> BlockChainClient for Client<V> where V: Verifier {
-	fn call(&self, t: &SignedTransaction, vm_tracing: bool) -> Result<Executed, ExecutionError> {
+	fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		let header = self.block_header(BlockID::Latest).unwrap();
 		let view = HeaderView::new(&header);
 		let last_hashes = self.build_last_hashes(view.hash());
@@ -456,11 +456,21 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			ExecutionError::TransactionMalformed(message)
 		}));
 		let balance = state.balance(&sender);
-		// give the sender a decent balance
+		let needed_balance = t.value + t.gas * t.gas_price;
-		state.sub_balance(&sender, &balance);
+		if balance < needed_balance {
-		state.add_balance(&sender, &(U256::from(1) << 200));
+			// give the sender a sufficient balance
-		let options = TransactOptions { tracing: false, vm_tracing: vm_tracing, check_nonce: false };
+			state.add_balance(&sender, &(needed_balance - balance));
-		Executive::new(&mut state, &env_info, self.engine.deref().deref(), &self.vm_factory).transact(t, options)
+		}
+		let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false };
+		let mut ret = Executive::new(&mut state, &env_info, self.engine.deref().deref(), &self.vm_factory).transact(t, options);
+		
+		// TODO gav move this into Executive.
+		if analytics.state_diffing {
+			if let Ok(ref mut x) = ret {
+				x.state_diff = Some(state.diff_from(self.state()));
+			}
+		}
+		ret
 	}
 
 	fn vm_factory(&self) -> &EvmFactory {
@@ -505,7 +515,6 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 		self.state_at(id).map(|s| s.nonce(address))
 	}
 
-
 	fn block_hash(&self, id: BlockID) -> Option<H256> {
 		Self::block_hash(&self.chain, id)
 	}

ethcore/src/client/mod.rs

@@ -49,6 +49,15 @@ use evm::Factory as EvmFactory;
 use miner::{TransactionImportResult};
 use error::Error as EthError;
 
+/// Options concerning what analytics we run on the call.
+#[derive(Eq, PartialEq, Default, Clone, Copy, Debug)]
+pub struct CallAnalytics {
+	/// Make a VM trace.
+	pub vm_tracing: bool,
+	/// Make a diff.
+	pub state_diffing: bool,
+}
+
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient : Sync + Send {
 	/// Get raw block header data by block id.
@@ -158,7 +167,7 @@ pub trait BlockChainClient : Sync + Send {
 
 	/// Makes a non-persistent transaction call.
 	// TODO: should be able to accept blockchain location for call.
-	fn call(&self, t: &SignedTransaction, vm_tracing: bool) -> Result<Executed, ExecutionError>;
+	fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError>;
 
 	/// Returns EvmFactory.
 	fn vm_factory(&self) -> &EvmFactory;

ethcore/src/client/test_client.rs

@@ -20,7 +20,7 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use util::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
-use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes};
+use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics};
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
@@ -251,7 +251,7 @@ impl MiningBlockChainClient for TestBlockChainClient {
 }
 
 impl BlockChainClient for TestBlockChainClient {
-	fn call(&self, _t: &SignedTransaction, _vm_tracing: bool) -> Result<Executed, ExecutionError> {
+	fn call(&self, _t: &SignedTransaction, _analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		Ok(self.execution_result.read().unwrap().clone().unwrap())
 	}
 

ethcore/src/executive.rs

@@ -450,6 +450,7 @@ impl<'a> Executive<'a> {
 					output: output,
 					trace: trace,
 					vm_trace: vm_trace,
+					state_diff: None,
 				})
 			},
 			_ => {
@@ -463,6 +464,7 @@ impl<'a> Executive<'a> {
 					output: output,
 					trace: trace,
 					vm_trace: vm_trace,
+					state_diff: None,
 				})
 			},
 		}

ethcore/src/json_tests/state.rs

@@ -16,8 +16,7 @@
 
 use super::test_common::*;
 use tests::helpers::*;
-use pod_state::*;
+use pod_state::{self, PodState};
-use state_diff::*;
 use ethereum;
 use ethjson;
 
@@ -71,7 +70,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 					let our_post = state.to_pod();
 					println!("Got:\n{}", our_post);
 					println!("Expect:\n{}", post);
-					println!("Diff ---expect -> +++got:\n{}", StateDiff::diff_pod(&post, &our_post));
+					println!("Diff ---expect -> +++got:\n{}", pod_state::diff_pod(&post, &our_post));
 				}
 
 				if let Ok(r) = res {

ethcore/src/lib.rs

@@ -119,8 +119,6 @@ mod basic_types;
 #[macro_use] mod evm;
 mod env_info;
 mod pod_account;
-mod account_diff;
-mod state_diff;
 mod state;
 mod account;
 mod account_db;

ethcore/src/miner/miner.rs

@@ -20,10 +20,9 @@ use std::sync::atomic::AtomicBool;
 use util::*;
 use util::keys::store::{AccountProvider};
 use views::{BlockView, HeaderView};
-use client::{MiningBlockChainClient, BlockID};
+use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockChainClient, BlockID, CallAnalytics};
 use block::{ClosedBlock, IsBlock};
 use error::*;
-use client::{Executive, Executed, EnvInfo, TransactOptions};
 use transaction::SignedTransaction;
 use receipt::{Receipt};
 use spec::Spec;
@@ -251,11 +250,13 @@ impl MinerService for Miner {
 		}
 	}
 
-	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, vm_tracing: bool) -> Result<Executed, ExecutionError> {
+	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		let sealing_work = self.sealing_work.lock().unwrap();
 		match sealing_work.peek_last_ref() {
 			Some(work) => {
 				let block = work.block();
+
+				// TODO: merge this code with client.rs's fn call somwhow.
 				let header = block.header();
 				let last_hashes = chain.last_hashes();
 				let env_info = EnvInfo {
@@ -274,16 +275,24 @@ impl MinerService for Miner {
 					ExecutionError::TransactionMalformed(message)
 				}));
 				let balance = state.balance(&sender);
-				// give the sender max balance
+				let needed_balance = t.value + t.gas * t.gas_price;
-				state.sub_balance(&sender, &balance);
+				if balance < needed_balance {
-				state.add_balance(&sender, &U256::max_value());
+					// give the sender a sufficient balance
-				let options = TransactOptions { tracing: false, vm_tracing: vm_tracing, check_nonce: false };
+					state.add_balance(&sender, &(needed_balance - balance));
-
+				}
-				// TODO: use vm_trace here.
+				let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false };
-				Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options)
+				let mut ret = Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options);
+				
+				// TODO gav move this into Executive.
+				if analytics.state_diffing {
+					if let Ok(ref mut x) = ret {
+						x.state_diff = Some(state.diff_from(block.state().clone()));
+					}
+				}
+				ret
 			},
 			None => {
-				chain.call(t, vm_tracing)
+				chain.call(t, analytics)
 			}
 		}
 	}

ethcore/src/miner/mod.rs

@@ -51,7 +51,7 @@ pub use self::external::{ExternalMiner, ExternalMinerService};
 
 use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};
-use client::{MiningBlockChainClient, Executed};
+use client::{MiningBlockChainClient, Executed, CallAnalytics};
 use block::ClosedBlock;
 use receipt::Receipt;
 use error::{Error, ExecutionError};
@@ -148,7 +148,7 @@ pub trait MinerService : Send + Sync {
 	fn balance(&self, chain: &MiningBlockChainClient, address: &Address) -> U256;
 
 	/// Call into contract code using pending state.
-	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, vm_tracing: bool) -> Result<Executed, ExecutionError>;
+	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError>;
 
 	/// Get storage value in pending state.
 	fn storage_at(&self, chain: &MiningBlockChainClient, address: &Address, position: &H256) -> H256;

ethcore/src/pod_account.rs

@@ -18,6 +18,7 @@ use util::*;
 use account::*;
 use account_db::*;
 use ethjson;
+use types::account_diff::*;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 /// An account, expressed as Plain-Old-Data (hence the name).
@@ -106,17 +107,58 @@ impl fmt::Display for PodAccount {
 	}
 }
 
+/// Determine difference between two optionally existant `Account`s. Returns None
+/// if they are the same.
+pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<AccountDiff> {
+	match (pre, post) {
+		(None, Some(x)) => Some(AccountDiff {
+			balance: Diff::Born(x.balance),
+			nonce: Diff::Born(x.nonce),
+			code: Diff::Born(x.code.clone()),
+			storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Born(v.clone()))).collect(),
+		}),
+		(Some(x), None) => Some(AccountDiff {
+			balance: Diff::Died(x.balance),
+			nonce: Diff::Died(x.nonce),
+			code: Diff::Died(x.code.clone()),
+			storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Died(v.clone()))).collect(),
+		}),
+		(Some(pre), Some(post)) => {
+			let storage: Vec<_> = pre.storage.keys().merge(post.storage.keys())
+				.filter(|k| pre.storage.get(k).unwrap_or(&H256::new()) != post.storage.get(k).unwrap_or(&H256::new()))
+				.collect();
+			let r = AccountDiff {
+				balance: Diff::new(pre.balance, post.balance),
+				nonce: Diff::new(pre.nonce, post.nonce),
+				code: Diff::new(pre.code.clone(), post.code.clone()),
+				storage: storage.into_iter().map(|k|
+					(k.clone(), Diff::new(
+						pre.storage.get(&k).cloned().unwrap_or_else(H256::new),
+						post.storage.get(&k).cloned().unwrap_or_else(H256::new)
+					))).collect(),
+			};
+			if r.balance.is_same() && r.nonce.is_same() && r.code.is_same() && r.storage.is_empty() {
+				None
+			} else {
+				Some(r)
+			}
+		},
+		_ => None,
+	}
+}
+
+
 #[cfg(test)]
 mod test {
 	use common::*;
-	use account_diff::*;
+	use types::account_diff::*;
-	use super::*;
+	use super::{PodAccount, diff_pod};
 
 	#[test]
 	fn existence() {
 		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: vec![], storage: map![]};
-		assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&a)), None);
+		assert_eq!(diff_pod(Some(&a), Some(&a)), None);
-		assert_eq!(AccountDiff::diff_pod(None, Some(&a)), Some(AccountDiff{
+		assert_eq!(diff_pod(None, Some(&a)), Some(AccountDiff{
 			balance: Diff::Born(69.into()),
 			nonce: Diff::Born(0.into()),
 			code: Diff::Born(vec![]),
@@ -128,7 +170,7 @@ mod test {
 	fn basic() {
 		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: vec![], storage: map![]};
 		let b = PodAccount{balance: 42.into(), nonce: 1.into(), code: vec![], storage: map![]};
-		assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
+		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
 			balance: Diff::Changed(69.into(), 42.into()),
 			nonce: Diff::Changed(0.into(), 1.into()),
 			code: Diff::Same,
@@ -140,7 +182,7 @@ mod test {
 	fn code() {
 		let a = PodAccount{balance: 0.into(), nonce: 0.into(), code: vec![], storage: map![]};
 		let b = PodAccount{balance: 0.into(), nonce: 1.into(), code: vec![0], storage: map![]};
-		assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
+		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
 			balance: Diff::Same,
 			nonce: Diff::Changed(0.into(), 1.into()),
 			code: Diff::Changed(vec![], vec![0]),
@@ -162,7 +204,7 @@ mod test {
 			code: vec![],
 			storage: map_into![1 => 1, 2 => 3, 3 => 0, 5 => 0, 7 => 7, 8 => 0, 9 => 9]
 		};
-		assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
+		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
 			balance: Diff::Same,
 			nonce: Diff::Same,
 			code: Diff::Same,

ethcore/src/pod_state.rs

@@ -17,7 +17,8 @@
 //! State of all accounts in the system expressed in Plain Old Data.
 
 use util::*;
-use pod_account::*;
+use pod_account::{self, PodAccount};
+use types::state_diff::StateDiff;
 use ethjson;
 
 /// State of all accounts in the system expressed in Plain Old Data.
@@ -29,7 +30,6 @@ impl PodState {
 	pub fn new() -> PodState { Default::default() }
 
 	/// Contruct a new object from the `m`.
-	#[cfg(test)]
 	pub fn from(m: BTreeMap<Address, PodAccount>) -> PodState { PodState(m) }
 
 	/// Get the underlying map.
@@ -41,8 +41,6 @@ impl PodState {
 	}
 
 	/// Drain object to get the underlying map.
-	#[cfg(test)]
-	#[cfg(feature = "json-tests")]
 	pub fn drain(self) -> BTreeMap<Address, PodAccount> { self.0 }
 }
 
@@ -72,3 +70,83 @@ impl fmt::Display for PodState {
 	}
 }
 
+/// Calculate and return diff between `pre` state and `post` state.
+pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff {
+	StateDiff(pre.get().keys().merge(post.get().keys()).filter_map(|acc| pod_account::diff_pod(pre.get().get(acc), post.get().get(acc)).map(|d|(acc.clone(), d))).collect())
+}
+
+#[cfg(test)]
+mod test {
+	use common::*;
+	use types::state_diff::*;
+	use types::account_diff::*;
+	use pod_account::PodAccount;
+	use super::PodState;
+
+	#[test]
+	fn create_delete() {
+		let a = PodState::from(map![ 1.into() => PodAccount::new(69.into(), 0.into(), vec![], map![]) ]);
+		assert_eq!(super::diff_pod(&a, &PodState::new()), StateDiff(map![
+			1.into() => AccountDiff{
+				balance: Diff::Died(69.into()),
+				nonce: Diff::Died(0.into()),
+				code: Diff::Died(vec![]),
+				storage: map![],
+			}
+		]));
+		assert_eq!(super::diff_pod(&PodState::new(), &a), StateDiff(map![
+			1.into() => AccountDiff{
+				balance: Diff::Born(69.into()),
+				nonce: Diff::Born(0.into()),
+				code: Diff::Born(vec![]),
+				storage: map![],
+			}
+		]));
+	}
+
+	#[test]
+	fn create_delete_with_unchanged() {
+		let a = PodState::from(map![ 1.into() => PodAccount::new(69.into(), 0.into(), vec![], map![]) ]);
+		let b = PodState::from(map![
+			1.into() => PodAccount::new(69.into(), 0.into(), vec![], map![]),
+			2.into() => PodAccount::new(69.into(), 0.into(), vec![], map![])
+		]);
+		assert_eq!(super::diff_pod(&a, &b), StateDiff(map![
+			2.into() => AccountDiff{
+				balance: Diff::Born(69.into()),
+				nonce: Diff::Born(0.into()),
+				code: Diff::Born(vec![]),
+				storage: map![],
+			}
+		]));
+		assert_eq!(super::diff_pod(&b, &a), StateDiff(map![
+			2.into() => AccountDiff{
+				balance: Diff::Died(69.into()),
+				nonce: Diff::Died(0.into()),
+				code: Diff::Died(vec![]),
+				storage: map![],
+			}
+		]));
+	}
+
+	#[test]
+	fn change_with_unchanged() {
+		let a = PodState::from(map![
+			1.into() => PodAccount::new(69.into(), 0.into(), vec![], map![]),
+			2.into() => PodAccount::new(69.into(), 0.into(), vec![], map![])
+		]);
+		let b = PodState::from(map![
+			1.into() => PodAccount::new(69.into(), 1.into(), vec![], map![]),
+			2.into() => PodAccount::new(69.into(), 0.into(), vec![], map![])
+		]);
+		assert_eq!(super::diff_pod(&a, &b), StateDiff(map![
+			1.into() => AccountDiff{
+				balance: Diff::Same,
+				nonce: Diff::Changed(0.into(), 1.into()),
+				code: Diff::Same,
+				storage: map![],
+			}
+		]));
+	}
+
+}

ethcore/src/state.rs

@@ -20,13 +20,9 @@ use executive::{Executive, TransactOptions};
 use evm::Factory as EvmFactory;
 use account_db::*;
 use trace::Trace;
-#[cfg(test)]
-#[cfg(feature = "json-tests")]
 use pod_account::*;
-#[cfg(test)]
+use pod_state::{self, PodState};
-#[cfg(feature = "json-tests")]
+use types::state_diff::StateDiff;
-use pod_state::PodState;
-//use state_diff::*;	// TODO: uncomment once to_pod() works correctly.
 
 /// Used to return information about an `State::apply` operation.
 pub struct ApplyOutcome {
@@ -224,7 +220,7 @@ impl State {
 		let e = try!(Executive::new(self, env_info, engine, vm_factory).transact(t, options));
 
 		// TODO uncomment once to_pod() works correctly.
-//		trace!("Applied transaction. Diff:\n{}\n", StateDiff::diff_pod(&old, &self.to_pod()));
+//		trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod()));
 		self.commit();
 		let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs);
 //		trace!("Transaction receipt: {:?}", receipt);
@@ -275,12 +271,11 @@ impl State {
 		}
 	}
 
-	#[cfg(test)]
-	#[cfg(feature = "json-tests")]
 	/// Populate a PodAccount map from this state.
 	pub fn to_pod(&self) -> PodState {
 		assert!(self.snapshots.borrow().is_empty());
 		// TODO: handle database rather than just the cache.
+		// will need fat db.
 		PodState::from(self.cache.borrow().iter().fold(BTreeMap::new(), |mut m, (add, opt)| {
 			if let Some(ref acc) = *opt {
 				m.insert(add.clone(), PodAccount::from_account(acc));
@@ -289,6 +284,25 @@ impl State {
 		}))
 	}
 
+	fn query_pod(&mut self, query: &PodState) {
+		for (ref address, ref pod_account) in query.get() {
+			if self.get(address, true).is_some() {
+				for (ref key, _) in &pod_account.storage {
+					self.storage_at(address, key);
+				}
+			}
+		}
+	}
+
+	/// Returns a `StateDiff` describing the difference from `orig` to `self`.
+	/// Consumes self.
+	pub fn diff_from(&self, orig: State) -> StateDiff {
+		let pod_state_post = self.to_pod();
+		let mut state_pre = orig;
+		state_pre.query_pod(&pod_state_post);
+		pod_state::diff_pod(&state_pre.to_pod(), &pod_state_post)
+	}
+
 	/// Pull account `a` in our cache from the trie DB and return it.
 	/// `require_code` requires that the code be cached, too.
 	fn get<'a>(&'a self, a: &Address, require_code: bool) -> &'a Option<Account> {

ethcore/src/types/account_diff.rs

@@ -17,10 +17,48 @@
 //! Diff between two accounts.
 
 use util::*;
-#[cfg(test)]
-use pod_account::*;
 
-#[derive(Debug,Clone,PartialEq,Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
+/// Diff type for specifying a change (or not).
+pub enum Diff<T> where T: Eq {
+	/// Both sides are the same.
+	Same,
+	/// Left (pre, source) side doesn't include value, right side (post, destination) does.
+	Born(T),
+	/// Both sides include data; it chaged value between them.
+	Changed(T, T),
+	/// Left (pre, source) side does include value, right side (post, destination) does not.
+	Died(T),
+}
+
+impl<T> Diff<T> where T: Eq {
+	/// Construct new object with given `pre` and `post`.
+	pub fn new(pre: T, post: T) -> Self { if pre == post { Diff::Same } else { Diff::Changed(pre, post) } }
+
+	/// Get the before value, if there is one.
+	pub fn pre(&self) -> Option<&T> { match *self { Diff::Died(ref x) | Diff::Changed(ref x, _) => Some(x), _ => None } }
+
+	/// Get the after value, if there is one.
+	pub fn post(&self) -> Option<&T> { match *self { Diff::Born(ref x) | Diff::Changed(_, ref x) => Some(x), _ => None } }
+
+	/// Determine whether there was a change or not.
+	pub fn is_same(&self) -> bool { match *self { Diff::Same => true, _ => false }}
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+/// Account diff.
+pub struct AccountDiff {
+	/// Change in balance, allowed to be `Diff::Same`.
+	pub balance: Diff<U256>,
+	/// Change in nonce, allowed to be `Diff::Same`.
+	pub nonce: Diff<U256>,					// Allowed to be Same
+	/// Change in code, allowed to be `Diff::Same`.
+	pub code: Diff<Bytes>,					// Allowed to be Same
+	/// Change in storage, values are not allowed to be `Diff::Same`.
+	pub storage: BTreeMap<H256, Diff<H256>>,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
 /// Change in existance type. 
 // TODO: include other types of change.
 pub enum Existance {
@@ -43,19 +81,6 @@ impl fmt::Display for Existance {
 	}
 }
 
-#[derive(Debug,Clone,PartialEq,Eq)]
-/// Account diff.
-pub struct AccountDiff {
-	/// Change in balance, allowed to be `Diff::Same`.
-	pub balance: Diff<U256>,
-	/// Change in nonce, allowed to be `Diff::Same`.
-	pub nonce: Diff<U256>,					// Allowed to be Same
-	/// Change in code, allowed to be `Diff::Same`.
-	pub code: Diff<Bytes>,					// Allowed to be Same
-	/// Change in storage, values are not allowed to be `Diff::Same`.
-	pub storage: BTreeMap<H256, Diff<H256>>,
-}
-
 impl AccountDiff {
 	/// Get `Existance` projection.
 	pub fn existance(&self) -> Existance {
@@ -65,47 +90,6 @@ impl AccountDiff {
 			_ => Existance::Alive,
 		}
 	}
-
-	#[cfg(test)]
-	/// Determine difference between two optionally existant `Account`s. Returns None
-	/// if they are the same.
-	pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<AccountDiff> {
-		match (pre, post) {
-			(None, Some(x)) => Some(AccountDiff {
-				balance: Diff::Born(x.balance),
-				nonce: Diff::Born(x.nonce),
-				code: Diff::Born(x.code.clone()),
-				storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Born(v.clone()))).collect(),
-			}),
-			(Some(x), None) => Some(AccountDiff {
-				balance: Diff::Died(x.balance),
-				nonce: Diff::Died(x.nonce),
-				code: Diff::Died(x.code.clone()),
-				storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Died(v.clone()))).collect(),
-			}),
-			(Some(pre), Some(post)) => {
-				let storage: Vec<_> = pre.storage.keys().merge(post.storage.keys())
-					.filter(|k| pre.storage.get(k).unwrap_or(&H256::new()) != post.storage.get(k).unwrap_or(&H256::new()))
-					.collect();
-				let r = AccountDiff {
-					balance: Diff::new(pre.balance, post.balance),
-					nonce: Diff::new(pre.nonce, post.nonce),
-					code: Diff::new(pre.code.clone(), post.code.clone()),
-					storage: storage.into_iter().map(|k|
-						(k.clone(), Diff::new(
-							pre.storage.get(&k).cloned().unwrap_or_else(H256::new),
-							post.storage.get(&k).cloned().unwrap_or_else(H256::new)
-						))).collect(),
-				};
-				if r.balance.is_same() && r.nonce.is_same() && r.code.is_same() && r.storage.is_empty() {
-					None
-				} else {
-					Some(r)
-				}
-			},
-			_ => None,
-		}
-	}
 }
 
 // TODO: refactor into something nicer.

ethcore/src/types/executed.rs

@@ -20,13 +20,14 @@ use util::numbers::*;
 use util::Bytes;
 use trace::{Trace, VMTrace};
 use types::log_entry::LogEntry;
+use types::state_diff::StateDiff;
 use ipc::binary::BinaryConvertError;
 use std::fmt;
 use std::mem;
 use std::collections::VecDeque;
 
 /// Transaction execution receipt.
-#[derive(Debug, PartialEq, Clone, Binary)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct Executed {
 	/// Gas paid up front for execution of transaction.
 	pub gas: U256,
@@ -61,6 +62,8 @@ pub struct Executed {
 	pub trace: Option<Trace>,
 	/// The VM trace of this transaction.
 	pub vm_trace: Option<VMTrace>,
+	/// The state diff, if we traced it.
+	pub state_diff: Option<StateDiff>,
 }
 
 /// Result of executing the transaction.

ethcore/src/types/mod.rs.in

@@ -23,3 +23,5 @@ pub mod log_entry;
 pub mod trace_types;
 pub mod executed;
 pub mod block_status;
+pub mod account_diff;
+pub mod state_diff;

ethcore/src/types/state_diff.rs

@@ -0,0 +1,49 @@
+// 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/>.
+
+//! State diff module.
+
+use util::*;
+use account_diff::*;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+/// Expression for the delta between two system states. Encoded the
+/// delta of every altered account.
+pub struct StateDiff (pub BTreeMap<Address, AccountDiff>);
+
+impl StateDiff {
+	/// Get the actual data.
+	pub fn get(&self) -> &BTreeMap<Address, AccountDiff> {
+		&self.0
+	}
+}
+
+impl fmt::Display for StateDiff {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		for (add, acc) in &self.0 {
+			try!(write!(f, "{} {}: {}", acc.existance(), add, acc));
+		}
+		Ok(())
+	}
+}
+
+impl Deref for StateDiff {
+	type Target = BTreeMap<Address, AccountDiff>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}

parity/cli.rs

@@ -96,6 +96,8 @@ API and Console Options:
                            asked for password on startup.
   --dapps-pass PASSWORD    Specify password for Dapps server. Use only in
                            conjunction with --dapps-user.
+  --dapps-path PATH        Specify directory where dapps should be installed.
+                           [default: $HOME/.parity/dapps]
 
   --signer                 Enable Trusted Signer WebSocket endpoint used by
                            System UIs.
@@ -239,6 +241,7 @@ pub struct Args {
 	pub flag_dapps_interface: String,
 	pub flag_dapps_user: Option<String>,
 	pub flag_dapps_pass: Option<String>,
+	pub flag_dapps_path: String,
 	pub flag_signer: bool,
 	pub flag_signer_port: u16,
 	pub flag_force_sealing: bool,

parity/configuration.rs

@@ -40,6 +40,7 @@ pub struct Configuration {
 pub struct Directories {
 	pub keys: String,
 	pub db: String,
+	pub dapps: String,
 }
 
 impl Configuration {
@@ -325,11 +326,14 @@ impl Configuration {
 				&self.args.flag_keys_path
 			}
 		);
-		::std::fs::create_dir_all(&db_path).unwrap_or_else(|e| die_with_io_error("main", e));
+		::std::fs::create_dir_all(&keys_path).unwrap_or_else(|e| die_with_io_error("main", e));
+		let dapps_path = Configuration::replace_home(&self.args.flag_dapps_path);
+		::std::fs::create_dir_all(&dapps_path).unwrap_or_else(|e| die_with_io_error("main", e));
 
 		Directories {
 			keys: keys_path,
 			db: db_path,
+			dapps: dapps_path,
 		}
 	}
 

parity/dapps.rs

@@ -32,6 +32,7 @@ pub struct Configuration {
 	pub port: u16,
 	pub user: Option<String>,
 	pub pass: Option<String>,
+	pub dapps_path: String,
 }
 
 pub struct Dependencies {
@@ -63,12 +64,13 @@ pub fn new(configuration: Configuration, deps: Dependencies) -> Option<WebappSer
 		(username.to_owned(), password)
 	});
 
-	Some(setup_dapps_server(deps, &addr, auth))
+	Some(setup_dapps_server(deps, configuration.dapps_path, &addr, auth))
 }
 
 #[cfg(not(feature = "dapps"))]
 pub fn setup_dapps_server(
 	_deps: Dependencies,
+	_dapps_path: String,
 	_url: &SocketAddr,
 	_auth: Option<(String, String)>,
 ) -> ! {
@@ -78,12 +80,13 @@ pub fn setup_dapps_server(
 #[cfg(feature = "dapps")]
 pub fn setup_dapps_server(
 	deps: Dependencies,
+	dapps_path: String,
 	url: &SocketAddr,
 	auth: Option<(String, String)>
 ) -> WebappServer {
 	use ethcore_dapps as dapps;
 
-	let server = dapps::ServerBuilder::new();
+	let server = dapps::ServerBuilder::new(dapps_path);
 	let server = rpc_apis::setup_rpc(server, deps.apis.clone(), rpc_apis::ApiSet::UnsafeContext);
 	let start_result = match auth {
 		None => {

parity/main.rs

@@ -231,6 +231,7 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 		port: conf.args.flag_dapps_port,
 		user: conf.args.flag_dapps_user.clone(),
 		pass: conf.args.flag_dapps_pass.clone(),
+		dapps_path: conf.directories().dapps,
 	}, dapps::Dependencies {
 		panic_handler: panic_handler.clone(),
 		apis: deps_for_rpc_apis.clone(),

rpc/src/v1/impls/eth.rs

@@ -511,8 +511,8 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 			.and_then(|(request, block_number,)| {
 				let signed = try!(self.sign_call(request));
 				let r = match block_number {
-					BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, false),
+					BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, Default::default()),
-					BlockNumber::Latest => take_weak!(self.client).call(&signed, false),
+					BlockNumber::Latest => take_weak!(self.client).call(&signed, Default::default()),
 					_ => panic!("{:?}", block_number),
 				};
 				to_value(&r.map(|e| Bytes(e.output)).unwrap_or(Bytes::new(vec![])))
@@ -524,8 +524,8 @@ impl<C, S, A, M, EM> Eth for EthClient<C, S, A, M, EM> where
 			.and_then(|(request, block_number,)| {
 				let signed = try!(self.sign_call(request));
 				let r = match block_number {
-					BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, false),
+					BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, Default::default()),
-					BlockNumber::Latest => take_weak!(self.client).call(&signed, false),
+					BlockNumber::Latest => take_weak!(self.client).call(&signed, Default::default()),
 					_ => return Err(Error::invalid_params()),
 				};
 				to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0)))

rpc/src/v1/impls/ethcore.rs

@@ -22,9 +22,12 @@ use std::sync::{Arc, Weak};
 use std::ops::Deref;
 use std::collections::BTreeMap;
 use jsonrpc_core::*;
+use serde;
 use ethcore::miner::MinerService;
+use ethcore::state_diff::StateDiff;
+use ethcore::account_diff::{Diff, Existance};
 use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action};
-use ethcore::client::BlockChainClient;
+use ethcore::client::{BlockChainClient, CallAnalytics};
 use ethcore::trace::VMTrace;
 use v1::traits::Ethcore;
 use v1::types::{Bytes, CallRequest};
@@ -115,6 +118,47 @@ fn vm_trace_to_object(t: &VMTrace) -> Value {
 	Value::Object(ret)
 }
 
+fn diff_to_object<T>(d: &Diff<T>) -> Value where T: serde::Serialize + Eq {
+	let mut ret = BTreeMap::new();
+	match *d {
+		Diff::Same => {
+			ret.insert("diff".to_owned(), Value::String("=".to_owned()));
+		}
+		Diff::Born(ref x) => {
+			ret.insert("diff".to_owned(), Value::String("+".to_owned()));
+			ret.insert("+".to_owned(), to_value(x).unwrap());
+		}
+		Diff::Died(ref x) => {
+			ret.insert("diff".to_owned(), Value::String("-".to_owned()));
+			ret.insert("-".to_owned(), to_value(x).unwrap());
+		}
+		Diff::Changed(ref from, ref to) => {
+			ret.insert("diff".to_owned(), Value::String("*".to_owned()));
+			ret.insert("-".to_owned(), to_value(from).unwrap());
+			ret.insert("+".to_owned(), to_value(to).unwrap());
+		}
+	};
+	Value::Object(ret)
+}
+
+fn state_diff_to_object(t: &StateDiff) -> Value {
+	Value::Object(t.iter().map(|(address, account)| {
+		(address.hex(), Value::Object(map![
+			"existance".to_owned() => Value::String(match account.existance() {
+				Existance::Born => "+",
+				Existance::Alive => ".",
+				Existance::Died => "-",
+			}.to_owned()),
+			"balance".to_owned() => diff_to_object(&account.balance),
+			"nonce".to_owned() => diff_to_object(&account.nonce),
+			"code".to_owned() => diff_to_object(&account.code),
+			"storage".to_owned() => Value::Object(account.storage.iter().map(|(key, val)| {
+				(key.hex(), diff_to_object(&val))
+			}).collect::<BTreeMap<_, _>>())
+		]))
+	}).collect::<BTreeMap<_, _>>())
+}
+
 impl<C, M> Ethcore for EthcoreClient<C, M> where C: BlockChainClient + 'static, M: MinerService + 'static {
 
 	fn set_min_gas_price(&self, params: Params) -> Result<Value, Error> {
@@ -211,7 +255,7 @@ impl<C, M> Ethcore for EthcoreClient<C, M> where C: BlockChainClient + 'static,
 		from_params(params)
 			.and_then(|(request,)| {
 				let signed = try!(self.sign_call(request));
-				let r = take_weak!(self.client).call(&signed, true);
+				let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: true, state_diffing: false });
 				if let Ok(executed) = r {
 					if let Some(vm_trace) = executed.vm_trace {
 						return Ok(vm_trace_to_object(&vm_trace));
@@ -220,4 +264,19 @@ impl<C, M> Ethcore for EthcoreClient<C, M> where C: BlockChainClient + 'static,
 				Ok(Value::Null)
 			})
 	}
+
+	fn state_diff_call(&self, params: Params) -> Result<Value, Error> {
+		trace!(target: "jsonrpc", "state_diff_call: {:?}", params);
+		from_params(params)
+			.and_then(|(request,)| {
+				let signed = try!(self.sign_call(request));
+				let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: false, state_diffing: true });
+				if let Ok(executed) = r {
+					if let Some(state_diff) = executed.state_diff {
+						return Ok(state_diff_to_object(&state_diff));
+					}
+				}
+				Ok(Value::Null)
+			})
+	}
 }

rpc/src/v1/tests/helpers/miner_service.rs

@@ -19,7 +19,7 @@
 use util::{Address, H256, Bytes, U256, FixedHash, Uint};
 use util::standard::*;
 use ethcore::error::{Error, ExecutionError};
-use ethcore::client::{MiningBlockChainClient, Executed};
+use ethcore::client::{MiningBlockChainClient, Executed, CallAnalytics};
 use ethcore::block::{ClosedBlock, IsBlock};
 use ethcore::transaction::SignedTransaction;
 use ethcore::receipt::Receipt;
@@ -202,7 +202,7 @@ impl MinerService for TestMinerService {
 		self.latest_closed_block.lock().unwrap().as_ref().map_or_else(U256::zero, |b| b.block().fields().state.balance(address).clone())
 	}
 
-	fn call(&self, _chain: &MiningBlockChainClient, _t: &SignedTransaction, _vm_tracing: bool) -> Result<Executed, ExecutionError> {
+	fn call(&self, _chain: &MiningBlockChainClient, _t: &SignedTransaction, _analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		unimplemented!();
 	}
 

rpc/src/v1/tests/mocked/eth.rs

@@ -431,6 +431,7 @@ fn rpc_eth_call() {
 		output: vec![0x12, 0x34, 0xff],
 		trace: None,
 		vm_trace: None,
+		state_diff: None,
 	});
 
 	let request = r#"{
@@ -465,6 +466,7 @@ fn rpc_eth_call_default_block() {
 		output: vec![0x12, 0x34, 0xff],
 		trace: None,
 		vm_trace: None,
+		state_diff: None,
 	});
 
 	let request = r#"{
@@ -498,6 +500,7 @@ fn rpc_eth_estimate_gas() {
 		output: vec![0x12, 0x34, 0xff],
 		trace: None,
 		vm_trace: None,
+		state_diff: None,
 	});
 
 	let request = r#"{
@@ -532,6 +535,7 @@ fn rpc_eth_estimate_gas_default_block() {
 		output: vec![0x12, 0x34, 0xff],
 		trace: None,
 		vm_trace: None,
+		state_diff: None,
 	});
 
 	let request = r#"{

rpc/src/v1/traits/ethcore.rs

@@ -75,6 +75,9 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 	/// Executes the given call and returns the VM trace for it.
 	fn vm_trace_call(&self, _: Params) -> Result<Value, Error>;
 
+	/// Executes the given call and returns the diff for it.
+	fn state_diff_call(&self, params: Params) -> Result<Value, Error>;
+
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
@@ -98,6 +101,7 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 		delegate.add_method("ethcore_defaultExtraData", Ethcore::default_extra_data);
 
 		delegate.add_method("ethcore_vmTraceCall", Ethcore::vm_trace_call);
+		delegate.add_method("ethcore_stateDiffCall", Ethcore::state_diff_call);
 
 		delegate
 	}

util/src/misc.rs

@@ -24,33 +24,6 @@ use target_info::Target;
 include!(concat!(env!("OUT_DIR"), "/version.rs"));
 include!(concat!(env!("OUT_DIR"), "/rustc_version.rs"));
 
-#[derive(Debug,Clone,PartialEq,Eq)]
-/// Diff type for specifying a change (or not).
-pub enum Diff<T> where T: Eq {
-	/// Both sides are the same.
-	Same,
-	/// Left (pre, source) side doesn't include value, right side (post, destination) does.
-	Born(T),
-	/// Both sides include data; it chaged value between them.
-	Changed(T, T),
-	/// Left (pre, source) side does include value, right side (post, destination) does not.
-	Died(T),
-}
-
-impl<T> Diff<T> where T: Eq {
-	/// Construct new object with given `pre` and `post`.
-	pub fn new(pre: T, post: T) -> Self { if pre == post { Diff::Same } else { Diff::Changed(pre, post) } }
-
-	/// Get the before value, if there is one.
-	pub fn pre(&self) -> Option<&T> { match *self { Diff::Died(ref x) | Diff::Changed(ref x, _) => Some(x), _ => None } }
-
-	/// Get the after value, if there is one.
-	pub fn post(&self) -> Option<&T> { match *self { Diff::Born(ref x) | Diff::Changed(_, ref x) => Some(x), _ => None } }
-
-	/// Determine whether there was a change or not.
-	pub fn is_same(&self) -> bool { match *self { Diff::Same => true, _ => false }}
-}
-
 #[derive(PartialEq,Eq,Clone,Copy)]
 /// Boolean type for clean/dirty status.
 pub enum Filth {