Merge branch 'master' into dev-chain

Cargo.lock

@@ -1249,7 +1249,7 @@ dependencies = [
 [[package]]
 name = "parity-ui-precompiled"
 version = "1.4.0"
-source = "git+https://github.com/ethcore/js-precompiled.git#c6691c86121806988c73d1847b3a0b77ee5b546e"
+source = "git+https://github.com/ethcore/js-precompiled.git#afaeb08a0f41ed41add35d86db4c751c5593e292"
 dependencies = [
  "parity-dapps-glue 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

dapps/src/router/mod.rs

@@ -131,7 +131,7 @@ impl<A: Authorization + 'static> server::Handler<HttpStream> for Router<A> {
 						StatusCode::NotFound,
 						"404 Not Found",
 						"Your homepage is not available when Trusted Signer is disabled.",
-						Some("You can still access dapps by writing a correct address, though. Re-enabled Signer to get your homepage back."),
+						Some("You can still access dapps by writing a correct address, though. Re-enable Signer to get your homepage back."),
 						self.signer_address.clone(),
 					))
 				}

ethcore/light/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+description = "Parity LES primitives"
+homepage = "https://ethcore.io"
+license = "GPL-3.0"
+name = "ethcore-light"
+version = "1.5.0"
+authors = ["Ethcore <admin@ethcore.io>"]
+
+[dependencies]
+log = "0.3"
+ethcore = { path = ".." }
+ethcore-util = { path = "../../util" }
+ethcore-network = { path = "../../util/network" }
+ethcore-io = { path = "../../util/io" }
+rlp = { path = "../../util/rlp" }
+time = "0.1"

ethcore/light/src/client.rs

@@ -0,0 +1,115 @@
+// 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/>.
+
+//! Light client implementation. Used for raw data queries as well as the header
+//! sync.
+
+use std::sync::Arc;
+
+use ethcore::engines::Engine;
+use ethcore::ids::BlockID;
+use ethcore::service::ClientIoMessage;
+use ethcore::block_import_error::BlockImportError;
+use ethcore::block_status::BlockStatus;
+use ethcore::verification::queue::{HeaderQueue, QueueInfo};
+use ethcore::transaction::SignedTransaction;
+use ethcore::blockchain_info::BlockChainInfo;
+
+use io::IoChannel;
+use util::hash::H256;
+use util::{Bytes, Mutex};
+
+use provider::Provider;
+use request;
+
+/// Light client implementation.
+pub struct Client {
+	engine: Arc<Engine>,
+	header_queue: HeaderQueue,
+	message_channel: Mutex<IoChannel<ClientIoMessage>>,
+}
+
+impl Client {
+	/// Import a header as rlp-encoded bytes.
+	pub fn import_header(&self, bytes: Bytes) -> Result<H256, BlockImportError> {
+		let header = ::rlp::decode(&bytes);
+
+		self.header_queue.import(header).map_err(Into::into)
+	}
+
+	/// Whether the block is already known (but not necessarily part of the canonical chain)
+	pub fn is_known(&self, _id: BlockID) -> bool {
+		false
+	}
+
+	/// Fetch a vector of all pending transactions.
+	pub fn pending_transactions(&self) -> Vec<SignedTransaction> {
+		vec![]
+	}
+
+	/// Inquire about the status of a given block.
+	pub fn status(&self, _id: BlockID) -> BlockStatus {
+		BlockStatus::Unknown
+	}
+
+	/// Get the header queue info.
+	pub fn queue_info(&self) -> QueueInfo {
+		self.header_queue.queue_info()
+	}
+}
+
+// dummy implementation -- may draw from canonical cache further on.
+impl Provider for Client {
+	fn chain_info(&self) -> BlockChainInfo {
+		unimplemented!()
+	}
+
+	fn reorg_depth(&self, _a: &H256, _b: &H256) -> Option<u64> {
+		None
+	}
+
+	fn earliest_state(&self) -> Option<u64> {
+		None
+	}
+
+	fn block_headers(&self, _req: request::Headers) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn block_bodies(&self, _req: request::Bodies) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn receipts(&self, _req: request::Receipts) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn proofs(&self, _req: request::StateProofs) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn code(&self, _req: request::ContractCodes) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn header_proofs(&self, _req: request::HeaderProofs) -> Vec<Bytes> {
+		Vec::new()
+	}
+
+	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+		Vec::new()
+	}
+}

ethcore/light/src/lib.rs

@@ -0,0 +1,47 @@
+// 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/>.
+
+//! Light client logic and implementation.
+//!
+//! A "light" client stores very little chain-related data locally
+//! unlike a full node, which stores all blocks, headers, receipts, and more.
+//!
+//! This enables the client to have a much lower resource footprint in
+//! exchange for the cost of having to ask the network for state data
+//! while responding to queries. This makes a light client unsuitable for
+//! low-latency applications, but perfectly suitable for simple everyday
+//! use-cases like sending transactions from a personal account.
+//!
+//! It starts by performing a header-only sync, verifying random samples
+//! of members of the chain to varying degrees.
+
+// TODO: remove when integrating with parity.
+#![allow(dead_code)]
+
+pub mod client;
+pub mod net;
+pub mod provider;
+pub mod request;
+
+extern crate ethcore_util as util;
+extern crate ethcore_network as network;
+extern crate ethcore_io as io;
+extern crate ethcore;
+extern crate rlp;
+extern crate time;
+
+#[macro_use]
+extern crate log;

ethcore/light/src/net/buffer_flow.rs

@@ -0,0 +1,264 @@
+// 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/>.
+
+//! LES buffer flow management.
+//!
+//! Every request in the LES protocol leads to a reduction
+//! of the requester's buffer value as a rate-limiting mechanism.
+//! This buffer value will recharge at a set rate.
+//!
+//! This module provides an interface for configuration of buffer
+//! flow costs and recharge rates.
+
+use request;
+use super::packet;
+use super::error::Error;
+
+use rlp::*;
+use util::U256;
+use time::{Duration, SteadyTime};
+
+/// A request cost specification.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Cost(pub U256, pub U256);
+
+/// Buffer value.
+///
+/// Produced and recharged using `FlowParams`.
+/// Definitive updates can be made as well -- these will reset the recharge
+/// point to the time of the update.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Buffer {
+	estimate: U256,
+	recharge_point: SteadyTime,
+}
+
+impl Buffer {
+	/// Get the current buffer value.
+	pub fn current(&self) -> U256 { self.estimate.clone() }
+
+	/// Make a definitive update.
+	/// This will be the value obtained after receiving
+	/// a response to a request.
+	pub fn update_to(&mut self, value: U256) {
+		self.estimate = value;
+		self.recharge_point = SteadyTime::now();
+	}
+
+	/// Attempt to apply the given cost to the buffer.
+	///
+	/// If successful, the cost will be deducted successfully.
+	///
+	/// If unsuccessful, the structure will be unaltered an an
+	/// error will be produced.
+	pub fn deduct_cost(&mut self, cost: U256) -> Result<(), Error> {
+		match cost > self.estimate {
+			true => Err(Error::BufferEmpty),
+			false => {
+				self.estimate = self.estimate - cost;
+				Ok(())
+			}
+		}
+	}
+}
+
+/// A cost table, mapping requests to base and per-request costs.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CostTable {
+	headers: Cost,
+	bodies: Cost,
+	receipts: Cost,
+	state_proofs: Cost,
+	contract_codes: Cost,
+	header_proofs: Cost,
+}
+
+impl Default for CostTable {
+	fn default() -> Self {
+		// arbitrarily chosen constants.
+		CostTable {
+			headers: Cost(100000.into(), 10000.into()),
+			bodies: Cost(150000.into(), 15000.into()),
+			receipts: Cost(50000.into(), 5000.into()),
+			state_proofs: Cost(250000.into(), 25000.into()),
+			contract_codes: Cost(200000.into(), 20000.into()),
+			header_proofs: Cost(150000.into(), 15000.into()),
+		}
+	}
+}
+
+impl RlpEncodable for CostTable {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		fn append_cost(s: &mut RlpStream, msg_id: u8, cost: &Cost) {
+			s.begin_list(3)
+				.append(&msg_id)
+				.append(&cost.0)
+				.append(&cost.1);
+		}
+
+		s.begin_list(6);
+
+		append_cost(s, packet::GET_BLOCK_HEADERS, &self.headers);
+		append_cost(s, packet::GET_BLOCK_BODIES, &self.bodies);
+		append_cost(s, packet::GET_RECEIPTS, &self.receipts);
+		append_cost(s, packet::GET_PROOFS, &self.state_proofs);
+		append_cost(s, packet::GET_CONTRACT_CODES, &self.contract_codes);
+		append_cost(s, packet::GET_HEADER_PROOFS, &self.header_proofs);
+	}
+}
+
+impl RlpDecodable for CostTable {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let rlp = decoder.as_rlp();
+
+		let mut headers = None;
+		let mut bodies = None;
+		let mut receipts = None;
+		let mut state_proofs = None;
+		let mut contract_codes = None;
+		let mut header_proofs = None;
+
+		for row in rlp.iter() {
+			let msg_id: u8 = try!(row.val_at(0));
+			let cost = {
+				let base = try!(row.val_at(1));
+				let per = try!(row.val_at(2));
+
+				Cost(base, per)
+			};
+
+			match msg_id {
+				packet::GET_BLOCK_HEADERS => headers = Some(cost),
+				packet::GET_BLOCK_BODIES => bodies = Some(cost),
+				packet::GET_RECEIPTS => receipts = Some(cost),
+				packet::GET_PROOFS => state_proofs = Some(cost),
+				packet::GET_CONTRACT_CODES => contract_codes = Some(cost),
+				packet::GET_HEADER_PROOFS => header_proofs = Some(cost),
+				_ => return Err(DecoderError::Custom("Unrecognized message in cost table")),
+			}
+		}
+
+		Ok(CostTable {
+			headers: try!(headers.ok_or(DecoderError::Custom("No headers cost specified"))),
+			bodies: try!(bodies.ok_or(DecoderError::Custom("No bodies cost specified"))),
+			receipts: try!(receipts.ok_or(DecoderError::Custom("No receipts cost specified"))),
+			state_proofs: try!(state_proofs.ok_or(DecoderError::Custom("No proofs cost specified"))),
+			contract_codes: try!(contract_codes.ok_or(DecoderError::Custom("No contract codes specified"))),
+			header_proofs: try!(header_proofs.ok_or(DecoderError::Custom("No header proofs cost specified"))),
+		})
+	}
+}
+
+/// A buffer-flow manager handles costs, recharge, limits
+#[derive(Debug, Clone, PartialEq)]
+pub struct FlowParams {
+	costs: CostTable,
+	limit: U256,
+	recharge: U256,
+}
+
+impl FlowParams {
+	/// Create new flow parameters from a request cost table,
+	/// buffer limit, and (minimum) rate of recharge.
+	pub fn new(limit: U256, costs: CostTable, recharge: U256) -> Self {
+		FlowParams {
+			costs: costs,
+			limit: limit,
+			recharge: recharge,
+		}
+	}
+
+	/// Get a reference to the buffer limit.
+	pub fn limit(&self) -> &U256 { &self.limit }
+
+	/// Get a reference to the cost table.
+	pub fn cost_table(&self) -> &CostTable { &self.costs }
+
+	/// Get a reference to the recharge rate.
+	pub fn recharge_rate(&self) -> &U256 { &self.recharge }
+
+	/// Compute the actual cost of a request, given the kind of request
+	/// and number of requests made.
+	pub fn compute_cost(&self, kind: request::Kind, amount: usize) -> U256 {
+		let cost = match kind {
+			request::Kind::Headers => &self.costs.headers,
+			request::Kind::Bodies => &self.costs.bodies,
+			request::Kind::Receipts => &self.costs.receipts,
+			request::Kind::StateProofs => &self.costs.state_proofs,
+			request::Kind::Codes => &self.costs.contract_codes,
+			request::Kind::HeaderProofs => &self.costs.header_proofs,
+		};
+
+		let amount: U256 = amount.into();
+		cost.0 + (amount * cost.1)
+	}
+
+	/// Create initial buffer parameter.
+	pub fn create_buffer(&self) -> Buffer {
+		Buffer {
+			estimate: self.limit,
+			recharge_point: SteadyTime::now(),
+		}
+	}
+
+	/// Recharge the buffer based on time passed since last
+	/// update.
+	pub fn recharge(&self, buf: &mut Buffer) {
+		let now = SteadyTime::now();
+
+		// recompute and update only in terms of full seconds elapsed
+		// in order to keep the estimate as an underestimate.
+		let elapsed = (now - buf.recharge_point).num_seconds();
+		buf.recharge_point = buf.recharge_point + Duration::seconds(elapsed);
+
+		let elapsed: U256 = elapsed.into();
+
+		buf.estimate = ::std::cmp::min(self.limit, buf.estimate + (elapsed * self.recharge));
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_serialize_cost_table() {
+		let costs = CostTable::default();
+		let serialized = ::rlp::encode(&costs);
+
+		let new_costs: CostTable = ::rlp::decode(&*serialized);
+
+		assert_eq!(costs, new_costs);
+	}
+
+	#[test]
+	fn buffer_mechanism() {
+		use std::thread;
+		use std::time::Duration;
+
+		let flow_params = FlowParams::new(100.into(), Default::default(), 20.into());
+		let mut buffer =  flow_params.create_buffer();
+
+		assert!(buffer.deduct_cost(101.into()).is_err());
+		assert!(buffer.deduct_cost(10.into()).is_ok());
+
+		thread::sleep(Duration::from_secs(1));
+
+		flow_params.recharge(&mut buffer);
+
+		assert_eq!(buffer.estimate, 100.into());
+	}
+}

ethcore/light/src/net/error.rs

@@ -0,0 +1,94 @@
+// 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/>.
+
+//! Defines error types and levels of punishment to use upon
+//! encountering.
+
+use rlp::DecoderError;
+use network::NetworkError;
+
+use std::fmt;
+
+/// Levels of punishment.
+///
+/// Currently just encompasses two different kinds of disconnect and
+/// no punishment, but this is where reputation systems might come into play.
+// In ascending order
+#[derive(Debug, PartialEq, Eq)]
+pub enum Punishment {
+	/// Perform no punishment.
+	None,
+	/// Disconnect the peer, but don't prevent them from reconnecting.
+	Disconnect,
+	/// Disconnect the peer and prevent them from reconnecting.
+	Disable,
+}
+
+/// Kinds of errors which can be encountered in the course of LES.
+#[derive(Debug)]
+pub enum Error {
+	/// An RLP decoding error.
+	Rlp(DecoderError),
+	/// A network error.
+	Network(NetworkError),
+	/// Out of buffer.
+	BufferEmpty,
+	/// Unrecognized packet code.
+	UnrecognizedPacket(u8),
+	/// Unexpected handshake.
+	UnexpectedHandshake,
+	/// Peer on wrong network (wrong NetworkId or genesis hash)
+	WrongNetwork,
+}
+
+impl Error {
+	/// What level of punishment does this error warrant?
+	pub fn punishment(&self) -> Punishment {
+		match *self {
+			Error::Rlp(_) => Punishment::Disable,
+			Error::Network(_) => Punishment::None,
+			Error::BufferEmpty => Punishment::Disable,
+			Error::UnrecognizedPacket(_) => Punishment::Disconnect,
+			Error::UnexpectedHandshake => Punishment::Disconnect,
+			Error::WrongNetwork => Punishment::Disable,
+		}
+	}
+}
+
+impl From<DecoderError> for Error {
+	fn from(err: DecoderError) -> Self {
+		Error::Rlp(err)
+	}
+}
+
+impl From<NetworkError> for Error {
+	fn from(err: NetworkError) -> Self {
+		Error::Network(err)
+	}
+}
+
+impl fmt::Display for Error {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match *self {
+			Error::Rlp(ref err) => err.fmt(f),
+			Error::Network(ref err) => err.fmt(f),
+			Error::BufferEmpty => write!(f, "Out of buffer"),
+			Error::UnrecognizedPacket(code) => write!(f, "Unrecognized packet: 0x{:x}", code),
+			Error::UnexpectedHandshake => write!(f, "Unexpected handshake"),
+			Error::WrongNetwork => write!(f, "Wrong network"),
+		}
+	}
+}

ethcore/light/src/net/mod.rs

@@ -0,0 +1,506 @@
+// 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/>.
+
+//! LES Protocol Version 1 implementation.
+//!
+//! This uses a "Provider" to answer requests.
+//! See https://github.com/ethcore/parity/wiki/Light-Ethereum-Subprotocol-(LES)
+
+use io::TimerToken;
+use network::{NetworkProtocolHandler, NetworkContext, NetworkError, PeerId};
+use rlp::{RlpStream, Stream, UntrustedRlp, View};
+use util::hash::H256;
+use util::RwLock;
+
+use std::collections::{HashMap, HashSet};
+use std::sync::atomic::AtomicUsize;
+
+use provider::Provider;
+use request::{self, Request};
+
+use self::buffer_flow::{Buffer, FlowParams};
+use self::error::{Error, Punishment};
+use self::status::{Status, Capabilities};
+
+mod buffer_flow;
+mod error;
+mod status;
+
+pub use self::status::Announcement;
+
+const TIMEOUT: TimerToken = 0;
+const TIMEOUT_INTERVAL_MS: u64 = 1000;
+
+// LPV1
+const PROTOCOL_VERSION: u32 = 1;
+
+// TODO [rob] make configurable.
+const PROTOCOL_ID: [u8; 3] = *b"les";
+
+// packet ID definitions.
+mod packet {
+	// the status packet.
+	pub const STATUS: u8 = 0x00;
+
+	// announcement of new block hashes or capabilities.
+	pub const ANNOUNCE: u8 = 0x01;
+
+	// request and response for block headers
+	pub const GET_BLOCK_HEADERS: u8 = 0x02;
+	pub const BLOCK_HEADERS: u8 = 0x03;
+
+	// request and response for block bodies
+	pub const GET_BLOCK_BODIES: u8 = 0x04;
+	pub const BLOCK_BODIES: u8 = 0x05;
+
+	// request and response for transaction receipts.
+	pub const GET_RECEIPTS: u8 = 0x06;
+	pub const RECEIPTS: u8 = 0x07;
+
+	// request and response for merkle proofs.
+	pub const GET_PROOFS: u8 = 0x08;
+	pub const PROOFS: u8 = 0x09;
+
+	// request and response for contract code.
+	pub const GET_CONTRACT_CODES: u8 = 0x0a;
+	pub const CONTRACT_CODES: u8 = 0x0b;
+
+	// relay transactions to peers.
+	pub const SEND_TRANSACTIONS: u8 = 0x0c;
+
+	// request and response for header proofs in a CHT.
+	pub const GET_HEADER_PROOFS: u8 = 0x0d;
+	pub const HEADER_PROOFS: u8 = 0x0e;
+}
+
+// A pending peer: one we've sent our status to but
+// may not have received one for.
+struct PendingPeer {
+	sent_head: H256,
+}
+
+// data about each peer.
+struct Peer {
+	local_buffer: Buffer, // their buffer relative to us
+	remote_buffer: Buffer, // our buffer relative to them
+	current_asking: HashSet<usize>, // pending request ids.
+	status: Status,
+	capabilities: Capabilities,
+	remote_flow: FlowParams,
+	sent_head: H256, // last head we've given them.
+}
+
+/// This is an implementation of the light ethereum network protocol, abstracted
+/// over a `Provider` of data and a p2p network.
+///
+/// This is simply designed for request-response purposes. Higher level uses
+/// of the protocol, such as synchronization, will function as wrappers around
+/// this system.
+pub struct LightProtocol {
+	provider: Box<Provider>,
+	genesis_hash: H256,
+	network_id: status::NetworkId,
+	pending_peers: RwLock<HashMap<PeerId, PendingPeer>>,
+	peers: RwLock<HashMap<PeerId, Peer>>,
+	pending_requests: RwLock<HashMap<usize, Request>>,
+	capabilities: RwLock<Capabilities>,
+	flow_params: FlowParams, // assumed static and same for every peer.
+	req_id: AtomicUsize,
+}
+
+impl LightProtocol {
+	/// Make an announcement of new chain head and capabilities to all peers.
+	/// The announcement is expected to be valid.
+	pub fn make_announcement(&self, mut announcement: Announcement, io: &NetworkContext) {
+		let mut reorgs_map = HashMap::new();
+
+		// calculate reorg info and send packets
+		for (peer_id, peer_info) in self.peers.write().iter_mut() {
+			let reorg_depth = reorgs_map.entry(peer_info.sent_head)
+				.or_insert_with(|| {
+					match self.provider.reorg_depth(&announcement.head_hash, &peer_info.sent_head) {
+						Some(depth) => depth,
+						None => {
+							// both values will always originate locally -- this means something
+							// has gone really wrong
+							debug!(target: "les", "couldn't compute reorganization depth between {:?} and {:?}",
+								&announcement.head_hash, &peer_info.sent_head);
+							0
+						}
+					}
+				});
+
+			peer_info.sent_head = announcement.head_hash;
+			announcement.reorg_depth = *reorg_depth;
+
+			if let Err(e) = io.send(*peer_id, packet::ANNOUNCE, status::write_announcement(&announcement)) {
+				debug!(target: "les", "Error sending to peer {}: {}", peer_id, e);
+			}
+		}
+	}
+}
+
+impl LightProtocol {
+	// called when a peer connects.
+	fn on_connect(&self, peer: &PeerId, io: &NetworkContext) {
+		let peer = *peer;
+
+		match self.send_status(peer, io) {
+			Ok(pending_peer) => {
+				self.pending_peers.write().insert(peer, pending_peer);
+			}
+			Err(e) => {
+				trace!(target: "les", "Error while sending status: {}", e);
+				io.disconnect_peer(peer);
+			}
+		}
+	}
+
+	// called when a peer disconnects.
+	fn on_disconnect(&self, peer: PeerId) {
+		// TODO: reassign all requests assigned to this peer.
+		self.pending_peers.write().remove(&peer);
+		self.peers.write().remove(&peer);
+	}
+
+	// send status to a peer.
+	fn send_status(&self, peer: PeerId, io: &NetworkContext) -> Result<PendingPeer, NetworkError> {
+		let chain_info = self.provider.chain_info();
+
+		// TODO: could update capabilities here.
+
+		let status = Status {
+			head_td: chain_info.total_difficulty,
+			head_hash: chain_info.best_block_hash,
+			head_num: chain_info.best_block_number,
+			genesis_hash: chain_info.genesis_hash,
+			protocol_version: PROTOCOL_VERSION,
+			network_id: self.network_id,
+			last_head: None,
+		};
+
+		let capabilities = self.capabilities.read().clone();
+		let status_packet = status::write_handshake(&status, &capabilities, &self.flow_params);
+
+		try!(io.send(peer, packet::STATUS, status_packet));
+
+		Ok(PendingPeer {
+			sent_head: chain_info.best_block_hash,
+		})
+	}
+
+	// Handle status message from peer.
+	fn status(&self, peer: &PeerId, data: UntrustedRlp) -> Result<(), Error> {
+		let pending = match self.pending_peers.write().remove(peer) {
+			Some(pending) => pending,
+			None => {
+				return Err(Error::UnexpectedHandshake);
+			}
+		};
+
+		let (status, capabilities, flow_params) = try!(status::parse_handshake(data));
+
+		trace!(target: "les", "Connected peer with chain head {:?}", (status.head_hash, status.head_num));
+
+		if (status.network_id, status.genesis_hash) != (self.network_id, self.genesis_hash) {
+			return Err(Error::WrongNetwork);
+		}
+
+		self.peers.write().insert(*peer, Peer {
+			local_buffer: self.flow_params.create_buffer(),
+			remote_buffer: flow_params.create_buffer(),
+			current_asking: HashSet::new(),
+			status: status,
+			capabilities: capabilities,
+			remote_flow: flow_params,
+			sent_head: pending.sent_head,
+		});
+
+		Ok(())
+	}
+
+	// Handle an announcement.
+	fn announcement(&self, peer: &PeerId, data: UntrustedRlp) -> Result<(), Error> {
+		if !self.peers.read().contains_key(peer) {
+			debug!(target: "les", "Ignoring announcement from unknown peer");
+			return Ok(())
+		}
+
+		let announcement = try!(status::parse_announcement(data));
+		let mut peers = self.peers.write();
+
+		let peer_info = match peers.get_mut(peer) {
+			Some(info) => info,
+			None => return Ok(()),
+		};
+
+		// update status.
+		{
+			// TODO: punish peer if they've moved backwards.
+			let status = &mut peer_info.status;
+			let last_head = status.head_hash;
+			status.head_hash = announcement.head_hash;
+			status.head_td = announcement.head_td;
+			status.head_num = announcement.head_num;
+			status.last_head = Some((last_head, announcement.reorg_depth));
+		}
+
+		// update capabilities.
+		{
+			let caps = &mut peer_info.capabilities;
+			caps.serve_headers = caps.serve_headers || announcement.serve_headers;
+			caps.serve_state_since = caps.serve_state_since.or(announcement.serve_state_since);
+			caps.serve_chain_since = caps.serve_chain_since.or(announcement.serve_chain_since);
+			caps.tx_relay = caps.tx_relay || announcement.tx_relay;
+		}
+
+		// TODO: notify listeners if new best block.
+
+		Ok(())
+	}
+
+	// Handle a request for block headers.
+	fn get_block_headers(&self, peer: &PeerId, io: &NetworkContext, data: UntrustedRlp) -> Result<(), Error> {
+		const MAX_HEADERS: usize = 512;
+
+		let mut present_buffer = match self.peers.read().get(peer) {
+			Some(peer) => peer.local_buffer.clone(),
+			None => {
+				debug!(target: "les", "Ignoring announcement from unknown peer");
+				return Ok(())
+			}
+		};
+
+		self.flow_params.recharge(&mut present_buffer);
+		let req_id: u64 = try!(data.val_at(0));
+
+		let req = request::Headers {
+			block: {
+				let rlp = try!(data.at(1));
+				(try!(rlp.val_at(0)), try!(rlp.val_at(1)))
+			},
+			max: ::std::cmp::min(MAX_HEADERS, try!(data.val_at(2))),
+			skip: try!(data.val_at(3)),
+			reverse: try!(data.val_at(4)),
+		};
+
+		let max_cost = self.flow_params.compute_cost(request::Kind::Headers, req.max);
+		try!(present_buffer.deduct_cost(max_cost));
+
+		let response = self.provider.block_headers(req);
+		let actual_cost = self.flow_params.compute_cost(request::Kind::Headers, response.len());
+
+		let cur_buffer = match self.peers.write().get_mut(peer) {
+			Some(peer) => {
+				self.flow_params.recharge(&mut peer.local_buffer);
+				try!(peer.local_buffer.deduct_cost(actual_cost));
+				peer.local_buffer.current()
+			}
+			None => {
+				debug!(target: "les", "peer disconnected during serving of request.");
+				return Ok(())
+			}
+		};
+
+		io.respond(packet::BLOCK_HEADERS, {
+			let mut stream = RlpStream::new_list(response.len() + 2);
+			stream.append(&req_id).append(&cur_buffer);
+
+			for header in response {
+				stream.append_raw(&header, 1);
+			}
+
+			stream.out()
+		}).map_err(Into::into)
+	}
+
+	// Receive a response for block headers.
+	fn block_headers(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Handle a request for block bodies.
+	fn get_block_bodies(&self, peer: &PeerId, io: &NetworkContext, data: UntrustedRlp) -> Result<(), Error> {
+		const MAX_BODIES: usize = 256;
+
+		let mut present_buffer = match self.peers.read().get(peer) {
+			Some(peer) => peer.local_buffer.clone(),
+			None => {
+				debug!(target: "les", "Ignoring announcement from unknown peer");
+				return Ok(())
+			}
+		};
+
+		self.flow_params.recharge(&mut present_buffer);
+		let req_id: u64 = try!(data.val_at(0));
+
+		let req = request::Bodies {
+			block_hashes: try!(data.iter().skip(1).take(MAX_BODIES).map(|x| x.as_val()).collect())
+		};
+
+		let max_cost = self.flow_params.compute_cost(request::Kind::Bodies, req.block_hashes.len());
+		try!(present_buffer.deduct_cost(max_cost));
+
+		let response = self.provider.block_bodies(req);
+		let response_len = response.iter().filter(|x| &x[..] != &::rlp::EMPTY_LIST_RLP).count();
+		let actual_cost = self.flow_params.compute_cost(request::Kind::Bodies, response_len);
+
+		let cur_buffer = match self.peers.write().get_mut(peer) {
+			Some(peer) => {
+				self.flow_params.recharge(&mut peer.local_buffer);
+				try!(peer.local_buffer.deduct_cost(actual_cost));
+				peer.local_buffer.current()
+			}
+			None => {
+				debug!(target: "les", "peer disconnected during serving of request.");
+				return Ok(())
+			}
+		};
+
+		io.respond(packet::BLOCK_BODIES, {
+			let mut stream = RlpStream::new_list(response.len() + 2);
+			stream.append(&req_id).append(&cur_buffer);
+
+			for body in response {
+				stream.append_raw(&body, 1);
+			}
+
+			stream.out()
+		}).map_err(Into::into)
+	}
+
+	// Receive a response for block bodies.
+	fn block_bodies(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Handle a request for receipts.
+	fn get_receipts(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Receive a response for receipts.
+	fn receipts(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Handle a request for proofs.
+	fn get_proofs(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Receive a response for proofs.
+	fn proofs(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Handle a request for contract code.
+	fn get_contract_code(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Receive a response for contract code.
+	fn contract_code(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Handle a request for header proofs
+	fn get_header_proofs(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Receive a response for header proofs
+	fn header_proofs(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+
+	// Receive a set of transactions to relay.
+	fn relay_transactions(&self, _: &PeerId, _: &NetworkContext, _: UntrustedRlp) -> Result<(), Error> {
+		unimplemented!()
+	}
+}
+
+impl NetworkProtocolHandler for LightProtocol {
+	fn initialize(&self, io: &NetworkContext) {
+		io.register_timer(TIMEOUT, TIMEOUT_INTERVAL_MS).expect("Error registering sync timer.");
+	}
+
+	fn read(&self, io: &NetworkContext, peer: &PeerId, packet_id: u8, data: &[u8]) {
+		let rlp = UntrustedRlp::new(data);
+
+		// handle the packet
+		let res = match packet_id {
+			packet::STATUS => self.status(peer, rlp),
+			packet::ANNOUNCE => self.announcement(peer, rlp),
+
+			packet::GET_BLOCK_HEADERS => self.get_block_headers(peer, io, rlp),
+			packet::BLOCK_HEADERS => self.block_headers(peer, io, rlp),
+
+			packet::GET_BLOCK_BODIES => self.get_block_bodies(peer, io, rlp),
+			packet::BLOCK_BODIES => self.block_bodies(peer, io, rlp),
+
+			packet::GET_RECEIPTS => self.get_receipts(peer, io, rlp),
+			packet::RECEIPTS => self.receipts(peer, io, rlp),
+
+			packet::GET_PROOFS => self.get_proofs(peer, io, rlp),
+			packet::PROOFS => self.proofs(peer, io, rlp),
+
+			packet::GET_CONTRACT_CODES => self.get_contract_code(peer, io, rlp),
+			packet::CONTRACT_CODES => self.contract_code(peer, io, rlp),
+
+			packet::GET_HEADER_PROOFS => self.get_header_proofs(peer, io, rlp),
+			packet::HEADER_PROOFS => self.header_proofs(peer, io, rlp),
+
+			packet::SEND_TRANSACTIONS => self.relay_transactions(peer, io, rlp),
+
+			other => {
+				Err(Error::UnrecognizedPacket(other))
+			}
+		};
+
+		// if something went wrong, figure out how much to punish the peer.
+		if let Err(e) = res {
+			match e.punishment() {
+				Punishment::None => {}
+				Punishment::Disconnect => {
+					debug!(target: "les", "Disconnecting peer {}: {}", peer, e);
+					io.disconnect_peer(*peer)
+				}
+				Punishment::Disable => {
+					debug!(target: "les", "Disabling peer {}: {}", peer, e);
+					io.disable_peer(*peer)
+				}
+			}
+		}
+	}
+
+	fn connected(&self, io: &NetworkContext, peer: &PeerId) {
+		self.on_connect(peer, io);
+	}
+
+	fn disconnected(&self, _io: &NetworkContext, peer: &PeerId) {
+		self.on_disconnect(*peer);
+	}
+
+	fn timeout(&self, _io: &NetworkContext, timer: TimerToken) {
+		match timer {
+			TIMEOUT => {
+				// broadcast transactions to peers.
+			}
+			_ => warn!(target: "les", "received timeout on unknown token {}", timer),
+		}
+	}
+}

ethcore/light/src/net/status.rs

@@ -0,0 +1,539 @@
+// 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/>.
+
+//! Peer status and capabilities.
+
+use rlp::{DecoderError, RlpDecodable, RlpEncodable, RlpStream, Stream, UntrustedRlp, View};
+use util::{H256, U256};
+
+use super::buffer_flow::FlowParams;
+
+// recognized handshake/announcement keys.
+// unknown keys are to be skipped, known keys have a defined order.
+// their string values are defined in the LES spec.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
+enum Key {
+	ProtocolVersion,
+	NetworkId,
+	HeadTD,
+	HeadHash,
+	HeadNum,
+	GenesisHash,
+	ServeHeaders,
+	ServeChainSince,
+	ServeStateSince,
+	TxRelay,
+	BufferLimit,
+	BufferCostTable,
+	BufferRechargeRate,
+}
+
+impl Key {
+	// get the string value of this key.
+	fn as_str(&self) -> &'static str {
+		match *self {
+			Key::ProtocolVersion => "protocolVersion",
+			Key::NetworkId => "networkId",
+			Key::HeadTD => "headTd",
+			Key::HeadHash => "headHash",
+			Key::HeadNum => "headNum",
+			Key::GenesisHash => "genesisHash",
+			Key::ServeHeaders => "serveHeaders",
+			Key::ServeChainSince => "serveChainSince",
+			Key::ServeStateSince => "serveStateSince",
+			Key::TxRelay => "txRelay",
+			Key::BufferLimit => "flowControl/BL",
+			Key::BufferCostTable => "flowControl/MRC",
+			Key::BufferRechargeRate => "flowControl/MRR",
+		}
+	}
+
+	// try to parse the key value from a string.
+	fn from_str(s: &str) -> Option<Self> {
+		match s {
+			"protocolVersion" => Some(Key::ProtocolVersion),
+			"networkId" => Some(Key::NetworkId),
+			"headTd" => Some(Key::HeadTD),
+			"headHash" => Some(Key::HeadHash),
+			"headNum" => Some(Key::HeadNum),
+			"genesisHash" => Some(Key::GenesisHash),
+			"serveHeaders" => Some(Key::ServeHeaders),
+			"serveChainSince" => Some(Key::ServeChainSince),
+			"serveStateSince" => Some(Key::ServeStateSince),
+			"txRelay" => Some(Key::TxRelay),
+			"flowControl/BL" => Some(Key::BufferLimit),
+			"flowControl/MRC" => Some(Key::BufferCostTable),
+			"flowControl/MRR" => Some(Key::BufferRechargeRate),
+			_ => None
+		}
+	}
+}
+
+/// Network ID structure.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum NetworkId {
+	/// ID for the mainnet
+	Mainnet = 1,
+	/// ID for the testnet
+	Testnet = 0,
+}
+
+impl NetworkId {
+	fn from_raw(raw: u32) -> Option<Self> {
+		match raw {
+			0 => Some(NetworkId::Testnet),
+			1 => Some(NetworkId::Mainnet),
+			_ => None,
+		}
+	}
+}
+
+// helper for decoding key-value pairs in the handshake or an announcement.
+struct Parser<'a> {
+	pos: usize,
+	rlp: UntrustedRlp<'a>,
+}
+
+impl<'a> Parser<'a> {
+	// expect a specific next key, and decode the value.
+	// error on unexpected key or invalid value.
+	fn expect<T: RlpDecodable>(&mut self, key: Key) -> Result<T, DecoderError> {
+		self.expect_raw(key).and_then(|item| item.as_val())
+	}
+
+	// expect a specific next key, and get the value's RLP.
+	// if the key isn't found, the position isn't advanced.
+	fn expect_raw(&mut self, key: Key) -> Result<UntrustedRlp<'a>, DecoderError> {
+		let pre_pos = self.pos;
+		if let Some((k, val)) = try!(self.get_next()) {
+			if k == key { return Ok(val) }
+		}
+
+		self.pos = pre_pos;
+		Err(DecoderError::Custom("Missing expected key"))
+	}
+
+	// get the next key and value RLP.
+	fn get_next(&mut self) -> Result<Option<(Key, UntrustedRlp<'a>)>, DecoderError> {
+		while self.pos < self.rlp.item_count() {
+			let pair = try!(self.rlp.at(self.pos));
+			let k: String = try!(pair.val_at(0));
+
+			self.pos += 1;
+			match Key::from_str(&k) {
+				Some(key) => return Ok(Some((key , try!(pair.at(1))))),
+				None => continue,
+			}
+		}
+
+		Ok(None)
+	}
+}
+
+// Helper for encoding a key-value pair
+fn encode_pair<T: RlpEncodable>(key: Key, val: &T) -> Vec<u8> {
+	let mut s = RlpStream::new_list(2);
+	s.append(&key.as_str()).append(val);
+	s.out()
+}
+
+// Helper for encoding a flag.
+fn encode_flag(key: Key) -> Vec<u8> {
+	let mut s = RlpStream::new_list(2);
+	s.append(&key.as_str()).append_empty_data();
+	s.out()
+}
+
+/// A peer status message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Status {
+	/// Protocol version.
+	pub protocol_version: u32,
+	/// Network id of this peer.
+	pub network_id: NetworkId,
+	/// Total difficulty of the head of the chain.
+	pub head_td: U256,
+	/// Hash of the best block.
+	pub head_hash: H256,
+	/// Number of the best block.
+	pub head_num: u64,
+	/// Genesis hash
+	pub genesis_hash: H256,
+	/// Last announced chain head and reorg depth to common ancestor.
+	pub last_head: Option<(H256, u64)>,
+}
+
+/// Peer capabilities.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Capabilities {
+	/// Whether this peer can serve headers
+	pub serve_headers: bool,
+	/// Earliest block number it can serve block/receipt requests for.
+	pub serve_chain_since: Option<u64>,
+	/// Earliest block number it can serve state requests for.
+	pub serve_state_since: Option<u64>,
+	/// Whether it can relay transactions to the eth network.
+	pub tx_relay: bool,
+}
+
+impl Default for Capabilities {
+	fn default() -> Self {
+		Capabilities {
+			serve_headers: true,
+			serve_chain_since: None,
+			serve_state_since: None,
+			tx_relay: false,
+		}
+	}
+}
+
+/// Attempt to parse a handshake message into its three parts:
+///   - chain status
+///   - serving capabilities
+///   - buffer flow parameters
+pub fn parse_handshake(rlp: UntrustedRlp) -> Result<(Status, Capabilities, FlowParams), DecoderError> {
+	let mut parser = Parser {
+		pos: 0,
+		rlp: rlp,
+	};
+
+	let status = Status {
+		protocol_version: try!(parser.expect(Key::ProtocolVersion)),
+		network_id: try!(parser.expect(Key::NetworkId)
+			.and_then(|id: u32| NetworkId::from_raw(id).ok_or(DecoderError::Custom("Invalid network ID")))),
+		head_td: try!(parser.expect(Key::HeadTD)),
+		head_hash: try!(parser.expect(Key::HeadHash)),
+		head_num: try!(parser.expect(Key::HeadNum)),
+		genesis_hash: try!(parser.expect(Key::GenesisHash)),
+		last_head: None,
+	};
+
+	let capabilities = Capabilities {
+		serve_headers: parser.expect_raw(Key::ServeHeaders).is_ok(),
+		serve_chain_since: parser.expect(Key::ServeChainSince).ok(),
+		serve_state_since: parser.expect(Key::ServeStateSince).ok(),
+		tx_relay: parser.expect_raw(Key::TxRelay).is_ok(),
+	};
+
+	let flow_params = FlowParams::new(
+		try!(parser.expect(Key::BufferLimit)),
+		try!(parser.expect(Key::BufferCostTable)),
+		try!(parser.expect(Key::BufferRechargeRate)),
+	);
+
+	Ok((status, capabilities, flow_params))
+}
+
+/// Write a handshake, given status, capabilities, and flow parameters.
+pub fn write_handshake(status: &Status, capabilities: &Capabilities, flow_params: &FlowParams) -> Vec<u8> {
+	let mut pairs = Vec::new();
+	pairs.push(encode_pair(Key::ProtocolVersion, &status.protocol_version));
+	pairs.push(encode_pair(Key::NetworkId, &(status.network_id as u32)));
+	pairs.push(encode_pair(Key::HeadTD, &status.head_td));
+	pairs.push(encode_pair(Key::HeadHash, &status.head_hash));
+	pairs.push(encode_pair(Key::HeadNum, &status.head_num));
+	pairs.push(encode_pair(Key::GenesisHash, &status.genesis_hash));
+
+	if capabilities.serve_headers {
+		pairs.push(encode_flag(Key::ServeHeaders));
+	}
+	if let Some(ref serve_chain_since) = capabilities.serve_chain_since {
+		pairs.push(encode_pair(Key::ServeChainSince, serve_chain_since));
+	}
+	if let Some(ref serve_state_since) = capabilities.serve_state_since {
+		pairs.push(encode_pair(Key::ServeStateSince, serve_state_since));
+	}
+	if capabilities.tx_relay {
+		pairs.push(encode_flag(Key::TxRelay));
+	}
+
+	pairs.push(encode_pair(Key::BufferLimit, flow_params.limit()));
+	pairs.push(encode_pair(Key::BufferCostTable, flow_params.cost_table()));
+	pairs.push(encode_pair(Key::BufferRechargeRate, flow_params.recharge_rate()));
+
+	let mut stream = RlpStream::new_list(pairs.len());
+
+	for pair in pairs {
+		stream.append_raw(&pair, 1);
+	}
+
+	stream.out()
+}
+
+/// An announcement of new chain head or capabilities made by a peer.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Announcement {
+	/// Hash of the best block.
+	pub head_hash: H256,
+	/// Number of the best block.
+	pub head_num: u64,
+	/// Head total difficulty
+	pub head_td: U256,
+	/// reorg depth to common ancestor of last announced head.
+	pub reorg_depth: u64,
+	/// optional new header-serving capability. false means "no change"
+	pub serve_headers: bool,
+	/// optional new state-serving capability
+	pub serve_state_since: Option<u64>,
+	/// optional new chain-serving capability
+	pub serve_chain_since: Option<u64>,
+	/// optional new transaction-relay capability. false means "no change"
+	pub tx_relay: bool,
+	// TODO: changes in buffer flow?
+}
+
+/// Parse an announcement.
+pub fn parse_announcement(rlp: UntrustedRlp) -> Result<Announcement, DecoderError> {
+	let mut last_key = None;
+
+	let mut announcement = Announcement {
+		head_hash: try!(rlp.val_at(0)),
+		head_num: try!(rlp.val_at(1)),
+		head_td: try!(rlp.val_at(2)),
+		reorg_depth: try!(rlp.val_at(3)),
+		serve_headers: false,
+		serve_state_since: None,
+		serve_chain_since: None,
+		tx_relay: false,
+	};
+
+	let mut parser = Parser {
+		pos: 4,
+		rlp: rlp,
+	};
+
+	while let Some((key, item)) = try!(parser.get_next()) {
+		if Some(key) <= last_key { return Err(DecoderError::Custom("Invalid announcement key ordering")) }
+		last_key = Some(key);
+
+		match key {
+			Key::ServeHeaders => announcement.serve_headers = true,
+			Key::ServeStateSince => announcement.serve_state_since = Some(try!(item.as_val())),
+			Key::ServeChainSince => announcement.serve_chain_since = Some(try!(item.as_val())),
+			Key::TxRelay => announcement.tx_relay = true,
+			_ => return Err(DecoderError::Custom("Nonsensical key in announcement")),
+		}
+	}
+
+	Ok(announcement)
+}
+
+/// Write an announcement out.
+pub fn write_announcement(announcement: &Announcement) -> Vec<u8> {
+	let mut pairs = Vec::new();
+	if announcement.serve_headers {
+		pairs.push(encode_flag(Key::ServeHeaders));
+	}
+	if let Some(ref serve_chain_since) = announcement.serve_chain_since {
+		pairs.push(encode_pair(Key::ServeChainSince, serve_chain_since));
+	}
+	if let Some(ref serve_state_since) = announcement.serve_state_since {
+		pairs.push(encode_pair(Key::ServeStateSince, serve_state_since));
+	}
+	if announcement.tx_relay {
+		pairs.push(encode_flag(Key::TxRelay));
+	}
+
+	let mut stream = RlpStream::new_list(4 + pairs.len());
+	stream
+		.append(&announcement.head_hash)
+		.append(&announcement.head_num)
+		.append(&announcement.head_td)
+		.append(&announcement.reorg_depth);
+
+	for item in pairs {
+		stream.append_raw(&item, 1);
+	}
+
+	stream.out()
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::super::buffer_flow::FlowParams;
+	use util::{U256, H256, FixedHash};
+	use rlp::{RlpStream, Stream ,UntrustedRlp, View};
+
+	#[test]
+	fn full_handshake() {
+		let status = Status {
+			protocol_version: 1,
+			network_id: NetworkId::Mainnet,
+			head_td: U256::default(),
+			head_hash: H256::default(),
+			head_num: 10,
+			genesis_hash: H256::zero(),
+			last_head: None,
+		};
+
+		let capabilities = Capabilities {
+			serve_headers: true,
+			serve_chain_since: Some(5),
+			serve_state_since: Some(8),
+			tx_relay: true,
+		};
+
+		let flow_params = FlowParams::new(
+			1_000_000.into(),
+			Default::default(),
+			1000.into(),
+		);
+
+		let handshake = write_handshake(&status, &capabilities, &flow_params);
+
+		let (read_status, read_capabilities, read_flow)
+			= parse_handshake(UntrustedRlp::new(&handshake)).unwrap();
+
+		assert_eq!(read_status, status);
+		assert_eq!(read_capabilities, capabilities);
+		assert_eq!(read_flow, flow_params);
+	}
+
+	#[test]
+	fn partial_handshake() {
+		let status = Status {
+			protocol_version: 1,
+			network_id: NetworkId::Mainnet,
+			head_td: U256::default(),
+			head_hash: H256::default(),
+			head_num: 10,
+			genesis_hash: H256::zero(),
+			last_head: None,
+		};
+
+		let capabilities = Capabilities {
+			serve_headers: false,
+			serve_chain_since: Some(5),
+			serve_state_since: None,
+			tx_relay: true,
+		};
+
+		let flow_params = FlowParams::new(
+			1_000_000.into(),
+			Default::default(),
+			1000.into(),
+		);
+
+		let handshake = write_handshake(&status, &capabilities, &flow_params);
+
+		let (read_status, read_capabilities, read_flow)
+			= parse_handshake(UntrustedRlp::new(&handshake)).unwrap();
+
+		assert_eq!(read_status, status);
+		assert_eq!(read_capabilities, capabilities);
+		assert_eq!(read_flow, flow_params);
+	}
+
+	#[test]
+	fn skip_unknown_keys() {
+		let status = Status {
+			protocol_version: 1,
+			network_id: NetworkId::Mainnet,
+			head_td: U256::default(),
+			head_hash: H256::default(),
+			head_num: 10,
+			genesis_hash: H256::zero(),
+			last_head: None,
+		};
+
+		let capabilities = Capabilities {
+			serve_headers: false,
+			serve_chain_since: Some(5),
+			serve_state_since: None,
+			tx_relay: true,
+		};
+
+		let flow_params = FlowParams::new(
+			1_000_000.into(),
+			Default::default(),
+			1000.into(),
+		);
+
+		let handshake = write_handshake(&status, &capabilities, &flow_params);
+		let interleaved = {
+			let handshake = UntrustedRlp::new(&handshake);
+			let mut stream = RlpStream::new_list(handshake.item_count() * 3);
+
+			for item in handshake.iter() {
+				stream.append_raw(item.as_raw(), 1);
+				let (mut s1, mut s2) = (RlpStream::new_list(2), RlpStream::new_list(2));
+				s1.append(&"foo").append_empty_data();
+				s2.append(&"bar").append_empty_data();
+				stream.append_raw(&s1.out(), 1);
+				stream.append_raw(&s2.out(), 1);
+			}
+
+			stream.out()
+		};
+
+		let (read_status, read_capabilities, read_flow)
+			= parse_handshake(UntrustedRlp::new(&interleaved)).unwrap();
+
+		assert_eq!(read_status, status);
+		assert_eq!(read_capabilities, capabilities);
+		assert_eq!(read_flow, flow_params);
+	}
+
+	#[test]
+	fn announcement_roundtrip() {
+		let announcement = Announcement {
+			head_hash: H256::random(),
+			head_num: 100_000,
+			head_td: 1_000_000.into(),
+			reorg_depth: 4,
+			serve_headers: false,
+			serve_state_since: Some(99_000),
+			serve_chain_since: Some(1),
+			tx_relay: true,
+		};
+
+		let serialized = write_announcement(&announcement);
+		let read = parse_announcement(UntrustedRlp::new(&serialized)).unwrap();
+
+		assert_eq!(read, announcement);
+	}
+
+	#[test]
+	fn keys_out_of_order() {
+		use super::{Key, encode_pair, encode_flag};
+
+		let mut stream = RlpStream::new_list(6);
+		stream
+			.append(&H256::zero())
+			.append(&10u64)
+			.append(&100_000u64)
+			.append(&2u64)
+			.append_raw(&encode_pair(Key::ServeStateSince, &44u64), 1)
+			.append_raw(&encode_flag(Key::ServeHeaders), 1);
+
+		let out = stream.drain();
+		assert!(parse_announcement(UntrustedRlp::new(&out)).is_err());
+
+		let mut stream = RlpStream::new_list(6);
+		stream
+			.append(&H256::zero())
+			.append(&10u64)
+			.append(&100_000u64)
+			.append(&2u64)
+			.append_raw(&encode_flag(Key::ServeHeaders), 1)
+			.append_raw(&encode_pair(Key::ServeStateSince, &44u64), 1);
+
+		let out = stream.drain();
+		assert!(parse_announcement(UntrustedRlp::new(&out)).is_ok());
+	}
+}

ethcore/light/src/provider.rs

@@ -0,0 +1,71 @@
+// 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/>.
+
+//! A provider for the LES protocol. This is typically a full node, who can
+//! give as much data as necessary to its peers.
+
+use ethcore::transaction::SignedTransaction;
+use ethcore::blockchain_info::BlockChainInfo;
+use util::{Bytes, H256};
+
+use request;
+
+/// Defines the operations that a provider for `LES` must fulfill.
+///
+/// These are defined at [1], but may be subject to change.
+/// Requests which can't be fulfilled should return an empty RLP list.
+///
+/// [1]: https://github.com/ethcore/parity/wiki/Light-Ethereum-Subprotocol-(LES)
+pub trait Provider: Send + Sync {
+	/// Provide current blockchain info.
+	fn chain_info(&self) -> BlockChainInfo;
+
+	/// Find the depth of a common ancestor between two blocks.
+	fn reorg_depth(&self, a: &H256, b: &H256) -> Option<u64>;
+
+	/// Earliest state.
+	fn earliest_state(&self) -> Option<u64>;
+
+	/// Provide a list of headers starting at the requested block,
+	/// possibly in reverse and skipping `skip` at a time.
+	///
+	/// The returned vector may have any length in the range [0, `max`], but the
+	/// results within must adhere to the `skip` and `reverse` parameters.
+	fn block_headers(&self, req: request::Headers) -> Vec<Bytes>;
+
+	/// Provide as many as possible of the requested blocks (minus the headers) encoded
+	/// in RLP format.
+	fn block_bodies(&self, req: request::Bodies) -> Vec<Bytes>;
+
+	/// Provide the receipts as many as possible of the requested blocks.
+	/// Returns a vector of RLP-encoded lists of receipts.
+	fn receipts(&self, req: request::Receipts) -> Vec<Bytes>;
+
+	/// Provide a set of merkle proofs, as requested. Each request is a
+	/// block hash and request parameters.
+	///
+	/// Returns a vector to RLP-encoded lists satisfying the requests.
+	fn proofs(&self, req: request::StateProofs) -> Vec<Bytes>;
+
+	/// Provide contract code for the specified (block_hash, account_hash) pairs.
+	fn code(&self, req: request::ContractCodes) -> Vec<Bytes>;
+
+	/// Provide header proofs from the Canonical Hash Tries.
+	fn header_proofs(&self, req: request::HeaderProofs) -> Vec<Bytes>;
+
+	/// Provide pending transactions.
+	fn pending_transactions(&self) -> Vec<SignedTransaction>;
+}

ethcore/light/src/request.rs

@@ -0,0 +1,145 @@
+// 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/>.
+
+//! LES request types.
+
+// TODO: make IPC compatible.
+
+use util::H256;
+
+/// A request for block headers.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Headers {
+	/// Block information for the request being made.
+	pub block: (u64, H256),
+	/// The maximum amount of headers which can be returned.
+	pub max: usize,
+	/// The amount of headers to skip between each response entry.
+	pub skip: usize,
+	/// Whether the headers should proceed in falling number from the initial block.
+	pub reverse: bool,
+}
+
+/// A request for specific block bodies.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Bodies {
+	/// Hashes which bodies are being requested for.
+	pub block_hashes: Vec<H256>
+}
+
+/// A request for transaction receipts.
+///
+/// This request is answered with a list of transaction receipts for each block
+/// requested.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Receipts {
+	/// Block hashes to return receipts for.
+	pub block_hashes: Vec<H256>,
+}
+
+/// A request for a state proof
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StateProof {
+	/// Block hash to query state from.
+	pub block: H256,
+	/// Key of the state trie -- corresponds to account hash.
+	pub key1: H256,
+	/// Key in that account's storage trie; if empty, then the account RLP should be
+	/// returned.
+	pub key2: Option<H256>,
+	/// if greater than zero, trie nodes beyond this level may be omitted.
+	pub from_level: u32, // could even safely be u8; trie w/ 32-byte key can be at most 64-levels deep.
+}
+
+/// A request for state proofs.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StateProofs {
+	/// All the proof requests.
+	pub requests: Vec<StateProof>,
+}
+
+/// A request for contract code.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ContractCodes {
+	/// Block hash and account key (== sha3(address)) pairs to fetch code for.
+	pub code_requests: Vec<(H256, H256)>,
+}
+
+/// A request for a header proof from the Canonical Hash Trie.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HeaderProof {
+	/// Number of the CHT.
+	pub cht_number: u64,
+	/// Block number requested.
+	pub block_number: u64,
+	/// If greater than zero, trie nodes beyond this level may be omitted.
+	pub from_level: u32,
+}
+
+/// A request for header proofs from the CHT.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HeaderProofs {
+	/// All the proof requests.
+	pub requests: Vec<HeaderProofs>,
+}
+
+/// Kinds of requests.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Kind {
+	/// Requesting headers.
+	Headers,
+	/// Requesting block bodies.
+	Bodies,
+	/// Requesting transaction receipts.
+	Receipts,
+	/// Requesting proofs of state trie nodes.
+	StateProofs,
+	/// Requesting contract code by hash.
+	Codes,
+	/// Requesting header proofs (from the CHT).
+	HeaderProofs,
+}
+
+/// Encompasses all possible types of requests in a single structure.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Request {
+	/// Requesting headers.
+	Headers(Headers),
+	/// Requesting block bodies.
+	Bodies(Bodies),
+	/// Requesting transaction receipts.
+	Receipts(Receipts),
+	/// Requesting state proofs.
+	StateProofs(StateProofs),
+	/// Requesting contract codes.
+	Codes(ContractCodes),
+	/// Requesting header proofs.
+	HeaderProofs(HeaderProofs),
+}
+
+impl Request {
+	/// Get the kind of request this is.
+	pub fn kind(&self) -> Kind {
+		match *self {
+			Request::Headers(_) => Kind::Headers,
+			Request::Bodies(_) => Kind::Bodies,
+			Request::Receipts(_) => Kind::Receipts,
+			Request::StateProofs(_) => Kind::StateProofs,
+			Request::Codes(_) => Kind::Codes,
+			Request::HeaderProofs(_) => Kind::HeaderProofs,
+		}
+	}
+}

ethcore/src/lib.rs

@@ -137,6 +137,7 @@ pub mod miner;
 pub mod snapshot;
 pub mod action_params;
 pub mod db;
+pub mod verification;
 #[macro_use] pub mod evm;
 
 mod cache_manager;
@@ -150,7 +151,6 @@ mod account_db;
 mod builtin;
 mod executive;
 mod externalities;
-mod verification;
 mod blockchain;
 mod types;
 mod factory;

ethcore/src/types/mod.rs.in

@@ -33,4 +33,4 @@ pub mod transaction_import;
 pub mod block_import_error;
 pub mod restoration_status;
 pub mod snapshot_manifest;
-pub mod mode;
+pub mod mode;

ethcore/src/verification/canon_verifier.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! Canonical verifier.
+
 use blockchain::BlockProvider;
 use engines::Engine;
 use error::Error;
@@ -21,6 +23,7 @@ use header::Header;
 use super::Verifier;
 use super::verification;
 
+/// A canonial verifier -- this does full verification.
 pub struct CanonVerifier;
 
 impl Verifier for CanonVerifier {

ethcore/src/verification/mod.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! Block verification utilities.
+
 pub mod verification;
 pub mod verifier;
 pub mod queue;
@@ -44,6 +46,7 @@ impl Default for VerifierType {
 	}
 }
 
+/// Create a new verifier based on type.
 pub fn new(v: VerifierType) -> Box<Verifier> {
 	match v {
 		VerifierType::Canon | VerifierType::CanonNoSeal => Box::new(CanonVerifier),

ethcore/src/verification/noop_verifier.rs

@@ -14,12 +14,15 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! No-op verifier.
+
 use blockchain::BlockProvider;
 use engines::Engine;
 use error::Error;
 use header::Header;
 use super::Verifier;
 
+/// A no-op verifier -- this will verify everything it's given immediately.
 #[allow(dead_code)]
 pub struct NoopVerifier;
 

ethcore/src/verification/verification.rs

@@ -14,12 +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/>.
 
-/// Block and transaction verification functions
-///
-/// Block verification is done in 3 steps
-/// 1. Quick verification upon adding to the block queue
-/// 2. Signatures verification done in the queue.
-/// 3. Final verification against the blockchain done before enactment.
+//! Block and transaction verification functions
+//!
+//! Block verification is done in 3 steps
+//! 1. Quick verification upon adding to the block queue
+//! 2. Signatures verification done in the queue.
+//! 3. Final verification against the blockchain done before enactment.
 
 use util::*;
 use engines::Engine;

ethcore/src/verification/verifier.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! A generic verifier trait.
+
 use blockchain::BlockProvider;
 use engines::Engine;
 use error::Error;
@@ -21,6 +23,8 @@ use header::Header;
 
 /// Should be used to verify blocks.
 pub trait Verifier: Send + Sync {
+	/// Verify a block relative to its parent and uncles.
 	fn verify_block_family(&self, header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error>;
+	/// Do a final verification check for an enacted header vs its expected counterpart.
 	fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error>;
 }

js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parity.js",
-  "version": "0.2.29",
+  "version": "0.2.33",
   "main": "release/index.js",
   "jsnext:main": "src/index.js",
   "author": "Parity Team <admin@parity.io>",
@@ -100,6 +100,7 @@
     "postcss-loader": "^0.8.1",
     "postcss-nested": "^1.0.0",
     "postcss-simple-vars": "^3.0.0",
+    "raw-loader": "^0.5.1",
     "react-addons-test-utils": "^15.3.0",
     "react-copy-to-clipboard": "^4.2.3",
     "react-hot-loader": "^1.3.0",
@@ -118,6 +119,7 @@
   "dependencies": {
     "bignumber.js": "^2.3.0",
     "blockies": "0.0.2",
+    "brace": "^0.9.0",
     "bytes": "^2.4.0",
     "chart.js": "^2.3.0",
     "es6-promise": "^3.2.1",
@@ -138,9 +140,11 @@
     "moment": "^2.14.1",
     "qs": "^6.3.0",
     "react": "^15.2.1",
+    "react-ace": "^4.0.0",
     "react-addons-css-transition-group": "^15.2.1",
     "react-chartjs-2": "^1.5.0",
     "react-dom": "^15.2.1",
+    "react-dropzone": "^3.7.3",
     "react-redux": "^4.4.5",
     "react-router": "^2.6.1",
     "react-router-redux": "^4.0.5",
@@ -152,10 +156,13 @@
     "redux-thunk": "^2.1.0",
     "rlp": "^2.0.0",
     "scryptsy": "^2.0.0",
+    "solc": "ngotchac/solc-js",
     "store": "^1.3.20",
     "utf8": "^2.1.1",
+    "valid-url": "^1.0.9",
     "validator": "^5.7.0",
     "web3": "^0.17.0-beta",
-    "whatwg-fetch": "^1.0.0"
+    "whatwg-fetch": "^1.0.0",
+    "worker-loader": "^0.7.1"
   }
 }

js/src/api/api.spec.js

@@ -34,7 +34,7 @@ describe('api/Api', () => {
   });
 
   describe('interface', () => {
-    const api = new Api(new Api.Transport.Http(TEST_HTTP_URL));
+    const api = new Api(new Api.Transport.Http(TEST_HTTP_URL, -1));
 
     Object.keys(ethereumRpc).sort().forEach((endpoint) => {
       describe(endpoint, () => {

js/src/api/contract/contract.spec.js

@@ -25,7 +25,7 @@ import Api from '../api';
 import Contract from './contract';
 import { isInstanceOf, isFunction } from '../util/types';
 
-const transport = new Api.Transport.Http(TEST_HTTP_URL);
+const transport = new Api.Transport.Http(TEST_HTTP_URL, -1);
 const eth = new Api(transport);
 
 describe('api/contract/Contract', () => {

js/src/api/rpc/db/db.spec.js

@@ -19,7 +19,7 @@ import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
 import Http from '../../transport/http';
 import Db from './db';
 
-const instance = new Db(new Http(TEST_HTTP_URL));
+const instance = new Db(new Http(TEST_HTTP_URL, -1));
 
 describe('api/rpc/Db', () => {
   let scope;

js/src/api/rpc/eth/eth.spec.js

@@ -20,7 +20,7 @@ import { isBigNumber } from '../../../../test/types';
 import Http from '../../transport/http';
 import Eth from './eth';
 
-const instance = new Eth(new Http(TEST_HTTP_URL));
+const instance = new Eth(new Http(TEST_HTTP_URL, -1));
 
 describe('rpc/Eth', () => {
   const address = '0x63Cf90D3f0410092FC0fca41846f596223979195';

js/src/api/rpc/net/net.spec.js

@@ -20,7 +20,7 @@ import { isBigNumber } from '../../../../test/types';
 import Http from '../../transport/http';
 import Net from './net';
 
-const instance = new Net(new Http(TEST_HTTP_URL));
+const instance = new Net(new Http(TEST_HTTP_URL, -1));
 
 describe('api/rpc/Net', () => {
   describe('peerCount', () => {

js/src/api/rpc/parity/parity.spec.js

@@ -20,7 +20,7 @@ import { isBigNumber } from '../../../../test/types';
 import Http from '../../transport/http';
 import Parity from './parity';
 
-const instance = new Parity(new Http(TEST_HTTP_URL));
+const instance = new Parity(new Http(TEST_HTTP_URL, -1));
 
 describe('api/rpc/parity', () => {
   describe('accountsInfo', () => {

js/src/api/rpc/personal/personal.spec.js

@@ -19,7 +19,7 @@ import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
 import Http from '../../transport/http';
 import Personal from './personal';
 
-const instance = new Personal(new Http(TEST_HTTP_URL));
+const instance = new Personal(new Http(TEST_HTTP_URL, -1));
 
 describe('rpc/Personal', () => {
   const account = '0x63cf90d3f0410092fc0fca41846f596223979195';

js/src/api/rpc/trace/trace.spec.js

@@ -19,7 +19,7 @@ import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
 import Http from '../../transport/http';
 import Trace from './trace';
 
-const instance = new Trace(new Http(TEST_HTTP_URL));
+const instance = new Trace(new Http(TEST_HTTP_URL, -1));
 
 describe('api/rpc/Trace', () => {
   let scope;

js/src/api/rpc/web3/web3.spec.js

@@ -19,7 +19,7 @@ import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
 import Http from '../../transport/http';
 import Web3 from './web3';
 
-const instance = new Web3(new Http(TEST_HTTP_URL));
+const instance = new Web3(new Http(TEST_HTTP_URL, -1));
 
 describe('api/rpc/Web3', () => {
   let scope;

js/src/api/transport/http/http.js

@@ -19,11 +19,14 @@ import JsonRpcBase from '../jsonRpcBase';
 
 /* global fetch */
 export default class Http extends JsonRpcBase {
-  constructor (url) {
+  constructor (url, connectTimeout = 1000) {
     super();
 
     this._connected = true;
     this._url = url;
+    this._connectTimeout = connectTimeout;
+
+    this._pollConnection();
   }
 
   _encodeOptions (method, params) {
@@ -77,4 +80,17 @@ export default class Http extends JsonRpcBase {
         return response.result;
       });
   }
+
+  _pollConnection = () => {
+    if (this._connectTimeout <= 0) {
+      return;
+    }
+
+    const nextTimeout = () => setTimeout(this._pollConnection, this._connectTimeout);
+
+    this
+      .execute('net_listening')
+      .then(nextTimeout)
+      .catch(nextTimeout);
+  }
 }

js/src/api/transport/http/http.spec.js

@@ -17,7 +17,7 @@
 import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
 import Http from './http';
 
-const transport = new Http(TEST_HTTP_URL);
+const transport = new Http(TEST_HTTP_URL, -1);
 
 describe('api/transport/Http', () => {
   describe('instance', () => {

js/src/contracts/snippets/human-standard-token.sol

@@ -0,0 +1,60 @@
+/*
+This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.
+
+In other words. This is intended for deployment in something like a Token Factory or Mist wallet, and then used by humans.
+Imagine coins, currencies, shares, voting weight, etc.
+Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.
+
+1) Initial Finite Supply (upon creation one specifies how much is minted).
+2) In the absence of a token registry: Optional Decimal, Symbol & Name.
+3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.
+
+.*/
+
+import "StandardToken.sol";
+
+contract HumanStandardToken is StandardToken {
+
+    function () {
+        //if ether is sent to this address, send it back.
+        throw;
+    }
+
+    /* Public variables of the token */
+
+    /*
+    NOTE:
+    The following variables are OPTIONAL vanities. One does not have to include them.
+    They allow one to customise the token contract & in no way influences the core functionality.
+    Some wallets/interfaces might not even bother to look at this information.
+    */
+    string public name;                   //fancy name: eg Simon Bucks
+    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
+    string public symbol;                 //An identifier: eg SBX
+    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.
+
+    function HumanStandardToken(
+        uint256 _initialAmount,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol
+        ) {
+        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
+        totalSupply = _initialAmount;                        // Update total supply
+        name = _tokenName;                                   // Set the name for display purposes
+        decimals = _decimalUnits;                            // Amount of decimals for display purposes
+        symbol = _tokenSymbol;                               // Set the symbol for display purposes
+    }
+
+    /* Approves and then calls the receiving contract */
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+
+        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
+        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
+        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
+        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
+        return true;
+    }
+}

js/src/contracts/snippets/standard-token.sol

@@ -0,0 +1,55 @@
+/*
+You should inherit from StandardToken or, for a token like you would want to
+deploy in something like Mist, see HumanStandardToken.sol.
+(This implements ONLY the standard functions and NOTHING else.
+If you deploy this, you won't have anything useful.)
+
+Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
+.*/
+
+import "Token.sol";
+
+contract StandardToken is Token {
+
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        //Default assumes totalSupply can't be over max (2^256 - 1).
+        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
+        //Replace the if with this one instead.
+        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else { return false; }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        //same as above. Replace this line with the following if you want to protect against wrapping uints.
+        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else { return false; }
+    }
+
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+      return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}

js/src/contracts/snippets/token.sol

@@ -0,0 +1,47 @@
+// Abstract contract for the full ERC 20 Token standard
+// https://github.com/ethereum/EIPs/issues/20
+
+contract Token {
+    /* This is a slight change to the ERC20 base standard.
+    function totalSupply() constant returns (uint256 supply);
+    is replaced with:
+    uint256 public totalSupply;
+    This automatically creates a getter function for the totalSupply.
+    This is moved to the base contract since public getter functions are not
+    currently recognised as an implementation of the matching abstract
+    function by the compiler.
+    */
+    /// total amount of tokens
+    uint256 public totalSupply;
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return The balance
+    function balanceOf(address _owner) constant returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+
+    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of wei to be approved for transfer
+    /// @return Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}

js/src/dapps/tokenreg/Accounts/AccountSelector/account-selector.js

@@ -70,7 +70,8 @@ export default class AccountSelector extends Component {
   static propTypes = {
     list: PropTypes.array.isRequired,
     selected: PropTypes.object.isRequired,
-    handleSetSelected: PropTypes.func.isRequired
+    handleSetSelected: PropTypes.func.isRequired,
+    onAccountChange: PropTypes.func
   };
 
   state = {
@@ -85,7 +86,8 @@ export default class AccountSelector extends Component {
         nestedItems={ nestedAccounts }
         open={ this.state.open }
         onSelectAccount={ this.onToggleOpen }
-        autoGenerateNestedIndicator={ false } />
+        autoGenerateNestedIndicator={ false }
+        nestedListStyle={ { maxHeight: '14em', overflow: 'auto' } } />
     );
 
     return (
@@ -110,6 +112,10 @@ export default class AccountSelector extends Component {
 
   onToggleOpen = () => {
     this.setState({ open: !this.state.open });
+
+    if (typeof this.props.onAccountChange === 'function') {
+      this.props.onAccountChange();
+    }
   }
 
   onSelectAccount = (address) => {

js/src/dapps/tokenreg/Actions/Register/register.js

@@ -81,6 +81,7 @@ export default class RegisterAction extends Component {
         className={ styles.dialog }
         onRequestClose={ this.onClose }
         actions={ this.renderActions() }
+        ref='dialog'
         autoScrollBodyContent
       >
         { this.renderContent() }
@@ -149,7 +150,9 @@ export default class RegisterAction extends Component {
   renderForm () {
     return (
       <div>
-        <AccountSelector />
+        <AccountSelector
+          onAccountChange={ this.onAccountChange }
+        />
         { this.renderInputs() }
       </div>
     );
@@ -175,6 +178,11 @@ export default class RegisterAction extends Component {
     });
   }
 
+  onAccountChange = () => {
+    const { dialog } = this.refs;
+    dialog.forceUpdate();
+  }
+
   onChange (fieldKey, valid, value) {
     const { fields } = this.state;
     const field = fields[fieldKey];

js/src/dapps/tokenreg/Inputs/validation.js

@@ -75,7 +75,7 @@ const validateTokenAddress = (address, contract, simple) => {
 
   return getTokenTotalSupply(address)
     .then(balance => {
-      if (balance === null) {
+      if (balance === null || balance.equals(0)) {
         return {
           error: ERRORS.invalidTokenAddress,
           valid: false

js/src/dapps/tokenreg/Tokens/Token/token.js

@@ -57,6 +57,7 @@ export default class Token extends Component {
     isLoading: PropTypes.bool,
     isPending: PropTypes.bool,
     isTokenOwner: PropTypes.bool.isRequired,
+    isContractOwner: PropTypes.bool.isRequired,
 
     fullWidth: PropTypes.bool
   };
@@ -220,7 +221,7 @@ export default class Token extends Component {
   }
 
   renderUnregister () {
-    if (!this.props.isTokenOwner) {
+    if (!this.props.isContractOwner) {
       return null;
     }
 

js/src/dapps/tokenreg/Tokens/tokens.js

@@ -45,7 +45,7 @@ export default class Tokens extends Component {
   }
 
   renderTokens (tokens) {
-    const { accounts } = this.props;
+    const { accounts, isOwner } = this.props;
 
     return tokens.map((token, index) => {
       if (!token || !token.tla) {
@@ -61,7 +61,8 @@ export default class Tokens extends Component {
           handleMetaLookup={ this.props.handleMetaLookup }
           handleAddMeta={ this.props.handleAddMeta }
           key={ index }
-          isTokenOwner={ isTokenOwner } />
+          isTokenOwner={ isTokenOwner }
+          isContractOwner={ isOwner } />
       );
     });
   }

js/src/index.js

@@ -31,7 +31,7 @@ import ContractInstances from './contracts';
 
 import { initStore } from './redux';
 import { ContextProvider, muiTheme } from './ui';
-import { Accounts, Account, Addresses, Address, Application, Contract, Contracts, Dapp, Dapps, Settings, SettingsBackground, SettingsParity, SettingsProxy, SettingsViews, Signer, Status } from './views';
+import { Accounts, Account, Addresses, Address, Application, Contract, Contracts, WriteContract, Dapp, Dapps, Settings, SettingsBackground, SettingsParity, SettingsProxy, SettingsViews, Signer, Status } from './views';
 
 import { setApi } from './redux/providers/apiActions';
 
@@ -76,6 +76,7 @@ ReactDOM.render(
         <Route path='apps' component={ Dapps } />
         <Route path='app/:id' component={ Dapp } />
         <Route path='contracts' component={ Contracts } />
+        <Route path='contracts/write' component={ WriteContract } />
         <Route path='contract/:address' component={ Contract } />
         <Route path='settings' component={ Settings }>
           <Route path='background' component={ SettingsBackground } />

js/src/modals/DeployContract/DetailsStep/detailsStep.js

@@ -25,7 +25,7 @@ import styles from '../deployContract.css';
 export default class DetailsStep extends Component {
   static contextTypes = {
     api: PropTypes.object.isRequired
-  }
+  };
 
   static propTypes = {
     accounts: PropTypes.object.isRequired,
@@ -46,16 +46,33 @@ export default class DetailsStep extends Component {
     onFromAddressChange: PropTypes.func.isRequired,
     onDescriptionChange: PropTypes.func.isRequired,
     onNameChange: PropTypes.func.isRequired,
-    onParamsChange: PropTypes.func.isRequired
-  }
+    onParamsChange: PropTypes.func.isRequired,
+    readOnly: PropTypes.bool
+  };
+
+  static defaultProps = {
+    readOnly: false
+  };
 
   state = {
     inputs: []
   }
 
+  componentDidMount () {
+    const { abi, code } = this.props;
+
+    if (abi) {
+      this.onAbiChange(abi);
+    }
+
+    if (code) {
+      this.onCodeChange(code);
+    }
+  }
+
   render () {
     const { accounts } = this.props;
-    const { abi, abiError, code, codeError, fromAddress, fromAddressError, name, nameError } = this.props;
+    const { abi, abiError, code, codeError, fromAddress, fromAddressError, name, nameError, readOnly } = this.props;
 
     return (
       <Form>
@@ -77,13 +94,15 @@ export default class DetailsStep extends Component {
           hint='the abi of the contract to deploy'
           error={ abiError }
           value={ abi }
-          onSubmit={ this.onAbiChange } />
+          onSubmit={ this.onAbiChange }
+          readOnly={ readOnly } />
         <Input
           label='code'
           hint='the compiled code of the contract to deploy'
           error={ codeError }
           value={ code }
-          onSubmit={ this.onCodeChange } />
+          onSubmit={ this.onCodeChange }
+          readOnly={ readOnly } />
         { this.renderConstructorInputs() }
       </Form>
     );

js/src/modals/DeployContract/deployContract.js

@@ -36,8 +36,17 @@ export default class DeployContract extends Component {
 
   static propTypes = {
     accounts: PropTypes.object.isRequired,
-    onClose: PropTypes.func.isRequired
-  }
+    onClose: PropTypes.func.isRequired,
+    abi: PropTypes.string,
+    code: PropTypes.string,
+    readOnly: PropTypes.bool,
+    source: PropTypes.string
+  };
+
+  static defaultProps = {
+    readOnly: false,
+    source: ''
+  };
 
   state = {
     abi: '',
@@ -57,6 +66,31 @@ export default class DeployContract extends Component {
     deployError: null
   }
 
+  componentWillMount () {
+    const { abi, code } = this.props;
+
+    if (abi && code) {
+      this.setState({ abi, code });
+    }
+  }
+
+  componentWillReceiveProps (nextProps) {
+    const { abi, code } = nextProps;
+    const newState = {};
+
+    if (abi !== this.props.abi) {
+      newState.abi = abi;
+    }
+
+    if (code !== this.props.code) {
+      newState.code = code;
+    }
+
+    if (Object.keys(newState).length) {
+      this.setState(newState);
+    }
+  }
+
   render () {
     const { step, deployError } = this.state;
 
@@ -115,7 +149,7 @@ export default class DeployContract extends Component {
   }
 
   renderStep () {
-    const { accounts } = this.props;
+    const { accounts, readOnly } = this.props;
     const { address, deployError, step, deployState, txhash } = this.state;
 
     if (deployError) {
@@ -129,6 +163,7 @@ export default class DeployContract extends Component {
         return (
           <DetailsStep
             { ...this.state }
+            readOnly={ readOnly }
             accounts={ accounts }
             onAbiChange={ this.onAbiChange }
             onCodeChange={ this.onCodeChange }
@@ -200,6 +235,7 @@ export default class DeployContract extends Component {
 
   onDeployStart = () => {
     const { api, store } = this.context;
+    const { source } = this.props;
     const { abiParsed, code, description, name, params, fromAddress } = this.state;
     const options = {
       data: code,
@@ -219,6 +255,7 @@ export default class DeployContract extends Component {
             contract: true,
             timestamp: Date.now(),
             deleted: false,
+            source,
             description
           })
         ])

js/src/modals/LoadContract/index.js

@@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './loadContract';

js/src/modals/LoadContract/loadContract.css

@@ -0,0 +1,52 @@
+/* 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/>.
+*/
+
+.loadContainer {
+  display: flex;
+  flex-direction: row;
+
+  > * {
+    flex: 50%;
+    width: 0;
+  }
+}
+
+.editor {
+  display: flex;
+  flex-direction: column;
+  padding-left: 1em;
+
+  p {
+    line-height: 48px;
+    height: 48px;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+
+    margin: 0;
+    font-size: 1.2em;
+  }
+}
+
+.confirmRemoval {
+  text-align: center;
+
+  .editor {
+    text-align: left;
+    margin-top: 0.5em;
+  }
+}

js/src/modals/LoadContract/loadContract.js

@@ -0,0 +1,284 @@
+// 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/>.
+
+import React, { Component, PropTypes } from 'react';
+
+import ContentClear from 'material-ui/svg-icons/content/clear';
+import CheckIcon from 'material-ui/svg-icons/navigation/check';
+import DeleteIcon from 'material-ui/svg-icons/action/delete';
+
+import { List, ListItem, makeSelectable } from 'material-ui/List';
+import { Subheader, IconButton, Tabs, Tab } from 'material-ui';
+import moment from 'moment';
+
+import { Button, Modal, Editor } from '../../ui';
+
+import styles from './loadContract.css';
+
+const SelectableList = makeSelectable(List);
+
+const SELECTED_STYLE = {
+  backgroundColor: 'rgba(255, 255, 255, 0.1)'
+};
+
+export default class LoadContract extends Component {
+
+  static propTypes = {
+    onClose: PropTypes.func.isRequired,
+    onLoad: PropTypes.func.isRequired,
+    onDelete: PropTypes.func.isRequired,
+    contracts: PropTypes.object.isRequired,
+    snippets: PropTypes.object.isRequired
+  };
+
+  state = {
+    selected: -1,
+    deleteRequest: false,
+    deleteId: -1
+  };
+
+  render () {
+    const { deleteRequest } = this.state;
+
+    const title = deleteRequest
+      ? 'confirm removal'
+      : 'view contracts';
+
+    return (
+      <Modal
+        title={ title }
+        actions={ this.renderDialogActions() }
+        visible
+        scroll
+      >
+        { this.renderBody() }
+      </Modal>
+    );
+  }
+
+  renderBody () {
+    if (this.state.deleteRequest) {
+      return this.renderConfirmRemoval();
+    }
+
+    const { contracts, snippets } = this.props;
+
+    const contractsTab = Object.keys(contracts).length === 0
+      ? null
+      : (
+      <Tab label='Local' >
+        { this.renderEditor() }
+
+        <SelectableList
+          onChange={ this.onClickContract }
+        >
+          <Subheader>Saved Contracts</Subheader>
+          { this.renderContracts(contracts) }
+        </SelectableList>
+      </Tab>
+      );
+
+    return (
+      <div className={ styles.loadContainer }>
+        <Tabs onChange={ this.handleChangeTab }>
+          { contractsTab }
+
+          <Tab label='Snippets' >
+            { this.renderEditor() }
+
+            <SelectableList
+              onChange={ this.onClickContract }
+            >
+              <Subheader>Contract Snippets</Subheader>
+              { this.renderContracts(snippets, false) }
+            </SelectableList>
+          </Tab>
+        </Tabs>
+      </div>
+    );
+  }
+
+  renderConfirmRemoval () {
+    const { deleteId } = this.state;
+    const { name, timestamp, sourcecode } = this.props.contracts[deleteId];
+
+    return (
+      <div className={ styles.confirmRemoval }>
+        <p>
+          Are you sure you want to remove the following
+          contract from your saved contracts?
+        </p>
+        <ListItem
+          primaryText={ name }
+          secondaryText={ `Saved ${moment(timestamp).fromNow()}` }
+          style={ { backgroundColor: 'none', cursor: 'default' } }
+        />
+
+        <div className={ styles.editor }>
+          <Editor
+            value={ sourcecode }
+            maxLines={ 20 }
+            readOnly
+          />
+        </div>
+      </div>
+    );
+  }
+
+  renderEditor () {
+    const { contracts, snippets } = this.props;
+    const { selected } = this.state;
+
+    const mergedContracts = Object.assign({}, contracts, snippets);
+
+    if (selected === -1 || !mergedContracts[selected]) {
+      return null;
+    }
+
+    const { sourcecode, name } = mergedContracts[selected];
+
+    return (
+      <div className={ styles.editor }>
+        <p>{ name }</p>
+        <Editor
+          value={ sourcecode }
+          maxLines={ 20 }
+          readOnly
+        />
+      </div>
+    );
+  }
+
+  renderContracts (contracts, removable = true) {
+    const { selected } = this.state;
+
+    return Object
+      .values(contracts)
+      .map((contract) => {
+        const { id, name, timestamp, description } = contract;
+        const onDelete = () => this.onDeleteRequest(id);
+
+        const secondaryText = description || `Saved ${moment(timestamp).fromNow()}`;
+        const remove = removable
+          ? (
+          <IconButton onClick={ onDelete }>
+            <DeleteIcon />
+          </IconButton>
+          )
+          : null;
+
+        return (
+          <ListItem
+            value={ id }
+            key={ id }
+            primaryText={ name }
+            secondaryText={ secondaryText }
+            style={ selected === id ? SELECTED_STYLE : null }
+            rightIconButton={ remove }
+          />
+        );
+      });
+  }
+
+  renderDialogActions () {
+    const { deleteRequest } = this.state;
+
+    if (deleteRequest) {
+      return [
+        <Button
+          icon={ <ContentClear /> }
+          label='No'
+          key='No'
+          onClick={ this.onRejectRemoval }
+        />,
+        <Button
+          icon={ <DeleteIcon /> }
+          label='Yes'
+          key='Yes'
+          onClick={ this.onConfirmRemoval }
+        />
+      ];
+    }
+
+    const cancelBtn = (
+      <Button
+        icon={ <ContentClear /> }
+        label='Cancel'
+        onClick={ this.onClose }
+      />
+    );
+
+    const loadBtn = (
+      <Button
+        icon={ <CheckIcon /> }
+        label='Load'
+        onClick={ this.onLoad }
+        disabled={ this.state.selected === -1 }
+      />
+    );
+
+    return [ cancelBtn, loadBtn ];
+  }
+
+  handleChangeTab = () => {
+    this.setState({ selected: -1 });
+  }
+
+  onClickContract = (_, value) => {
+    this.setState({ selected: value });
+  }
+
+  onClose = () => {
+    this.props.onClose();
+  }
+
+  onLoad = () => {
+    const { contracts, snippets } = this.props;
+    const { selected } = this.state;
+
+    const mergedContracts = Object.assign({}, contracts, snippets);
+    const contract = mergedContracts[selected];
+
+    this.props.onLoad(contract);
+    this.props.onClose();
+  }
+
+  onDeleteRequest = (id) => {
+    this.setState({
+      deleteRequest: true,
+      deleteId: id
+    });
+  }
+
+  onConfirmRemoval = () => {
+    const { deleteId } = this.state;
+    this.props.onDelete(deleteId);
+
+    this.setState({
+      deleteRequest: false,
+      deleteId: -1,
+      selected: -1
+    });
+  }
+
+  onRejectRemoval = () => {
+    this.setState({
+      deleteRequest: false,
+      deleteId: -1
+    });
+  }
+
+}

js/src/modals/SaveContract/index.js

@@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './saveContract';

js/src/modals/SaveContract/saveContract.css

@@ -0,0 +1,20 @@
+/* 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/>.
+*/
+
+.source {
+  margin-top: 2em;
+}

js/src/modals/SaveContract/saveContract.js

@@ -0,0 +1,109 @@
+// 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/>.
+
+import React, { Component, PropTypes } from 'react';
+
+import SaveIcon from 'material-ui/svg-icons/content/save';
+import ContentClear from 'material-ui/svg-icons/content/clear';
+
+import { Button, Modal, Editor, Form, Input } from '../../ui';
+import { ERRORS, validateName } from '../../util/validation';
+
+import styles from './saveContract.css';
+
+export default class SaveContract extends Component {
+
+  static propTypes = {
+    sourcecode: PropTypes.string.isRequired,
+    onClose: PropTypes.func.isRequired,
+    onSave: PropTypes.func.isRequired
+  };
+
+  state = {
+    name: '',
+    nameError: ERRORS.invalidName
+  };
+
+  render () {
+    const { sourcecode } = this.props;
+    const { name, nameError } = this.state;
+
+    return (
+      <Modal
+        title='save contract'
+        actions={ this.renderDialogActions() }
+        visible
+      >
+        <div>
+          <Form>
+            <Input
+              label='contract name'
+              hint='choose a name for this contract'
+              value={ name }
+              error={ nameError }
+              onChange={ this.onChangeName }
+            />
+          </Form>
+          <Editor
+            className={ styles.source }
+            value={ sourcecode }
+            maxLines={ 20 }
+            readOnly
+          />
+        </div>
+      </Modal>
+    );
+  }
+
+  renderDialogActions () {
+    const cancelBtn = (
+      <Button
+        icon={ <ContentClear /> }
+        label='Cancel'
+        onClick={ this.onClose }
+      />
+    );
+
+    const confirmBtn = (
+      <Button
+        icon={ <SaveIcon /> }
+        label='Save'
+        disabled={ !!this.state.nameError }
+        onClick={ this.onSave }
+      />
+    );
+
+    return [ cancelBtn, confirmBtn ];
+  }
+
+  onClose = () => {
+    this.props.onClose();
+  }
+
+  onSave = () => {
+    const { name } = this.state;
+    const { sourcecode } = this.props;
+
+    this.props.onSave({ name, sourcecode });
+    this.onClose();
+  }
+
+  onChangeName = (event, value) => {
+    const { name, nameError } = validateName(value);
+    this.setState({ name, nameError });
+  }
+
+}

js/src/modals/index.js

@@ -24,6 +24,8 @@ import FirstRun from './FirstRun';
 import Shapeshift from './Shapeshift';
 import Transfer from './Transfer';
 import PasswordManager from './PasswordManager';
+import SaveContract from './SaveContract';
+import LoadContract from './LoadContract';
 
 export {
   AddAddress,
@@ -35,5 +37,7 @@ export {
   FirstRun,
   Shapeshift,
   Transfer,
-  PasswordManager
+  PasswordManager,
+  LoadContract,
+  SaveContract
 };

js/src/redux/providers/compilerActions.js

@@ -0,0 +1,37 @@
+// 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/>.
+
+import CompilerWorker from 'worker-loader!./compilerWorker.js';
+
+export function setWorker (worker) {
+  return {
+    type: 'setWorker',
+    worker
+  };
+}
+
+export function setupWorker () {
+  return (dispatch, getState) => {
+    const state = getState();
+
+    if (state.compiler.worker) {
+      return;
+    }
+
+    const worker = new CompilerWorker();
+    dispatch(setWorker(worker));
+  };
+}

js/src/redux/providers/compilerReducer.js

@@ -0,0 +1,29 @@
+// 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/>.
+
+import { handleActions } from 'redux-actions';
+
+const initialState = {
+  worker: null
+};
+
+export default handleActions({
+  setWorker (state, action) {
+    const { worker } = action;
+
+    return Object.assign({}, state, { worker });
+  }
+}, initialState);

js/src/redux/providers/compilerWorker.js

@@ -0,0 +1,177 @@
+// 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/>.
+
+import solc from 'solc/browser-wrapper';
+import { isWebUri } from 'valid-url';
+
+self.solcVersions = {};
+self.files = {};
+self.lastCompile = {
+  sourcecode: '',
+  result: '',
+  version: ''
+};
+
+// eslint-disable-next-line no-undef
+onmessage = (event) => {
+  const message = JSON.parse(event.data);
+
+  switch (message.action) {
+    case 'compile':
+      compile(message.data);
+      break;
+    case 'load':
+      load(message.data);
+      break;
+    case 'setFiles':
+      setFiles(message.data);
+      break;
+    case 'close':
+      close();
+      break;
+  }
+};
+
+function setFiles (files) {
+  const prevFiles = self.files;
+  const nextFiles = files.reduce((obj, file) => {
+    obj[file.name] = file.sourcecode;
+    return obj;
+  }, {});
+
+  self.files = {
+    ...prevFiles,
+    ...nextFiles
+  };
+}
+
+function findImports (path) {
+  if (self.files[path]) {
+    if (self.files[path].error) {
+      return { error: self.files[path].error };
+    }
+
+    return { contents: self.files[path] };
+  }
+
+  if (isWebUri(path)) {
+    console.log('[worker] fetching', path);
+
+    fetch(path)
+      .then((r) => r.text())
+      .then((c) => {
+        console.log('[worker]', 'got content at ' + path);
+        self.files[path] = c;
+
+        postMessage(JSON.stringify({
+          event: 'try-again'
+        }));
+      })
+      .catch((e) => {
+        console.error('[worker]', 'fetching', path, e);
+        self.files[path] = { error: e };
+      });
+
+    return { error: '__parity_tryAgain' };
+  }
+
+  console.log(`[worker] path ${path} not found...`);
+  return { error: 'File not found' };
+}
+
+function compile (data) {
+  const { sourcecode, build } = data;
+  const { longVersion } = build;
+
+  if (self.lastCompile.sourcecode === sourcecode && self.lastCompile.longVersion === longVersion) {
+    return postMessage(JSON.stringify({
+      event: 'compiled',
+      data: self.lastCompile.result
+    }));
+  }
+
+  fetchSolc(build)
+    .then((compiler) => {
+      const input = {
+        '': sourcecode
+      };
+
+      const compiled = compiler.compile({ sources: input }, 0, findImports);
+
+      self.lastCompile = {
+        version: longVersion, result: compiled,
+        sourcecode
+      };
+
+      postMessage(JSON.stringify({
+        event: 'compiled',
+        data: compiled
+      }));
+    });
+}
+
+function load (build) {
+  postMessage(JSON.stringify({
+    event: 'loading',
+    data: true
+  }));
+
+  fetchSolc(build)
+    .then(() => {
+      postMessage(JSON.stringify({
+        event: 'loading',
+        data: false
+      }));
+    })
+    .catch(() => {
+      postMessage(JSON.stringify({
+        event: 'loading',
+        data: false
+      }));
+    });
+}
+
+function fetchSolc (build) {
+  const { path, longVersion } = build;
+
+  if (self.solcVersions[path]) {
+    return Promise.resolve(self.solcVersions[path]);
+  }
+
+  const URL = `https://raw.githubusercontent.com/ethereum/solc-bin/gh-pages/bin/${path}`;
+  console.log(`[worker] fetching solc-bin ${longVersion} at ${URL}`);
+
+  return fetch(URL)
+    .then((r) => r.text())
+    .then((code) => {
+      const solcCode = code.replace(/^var Module;/, 'var Module=self.__solcModule;');
+      self.__solcModule = {};
+
+      console.log(`[worker] evaluating ${longVersion}`);
+
+      // eslint-disable-next-line no-eval
+      eval(solcCode);
+
+      console.log(`[worker] done evaluating ${longVersion}`);
+
+      const compiler = solc(self.__solcModule);
+      self.solcVersions[path] = compiler;
+      return compiler;
+    })
+    .catch((e) => {
+      console.error('fetching solc', e);
+    });
+}

js/src/redux/providers/index.js

@@ -26,3 +26,4 @@ export personalReducer from './personalReducer';
 export signerReducer from './signerReducer';
 export statusReducer from './statusReducer';
 export blockchainReducer from './blockchainReducer';
+export compilerReducer from './compilerReducer';

js/src/redux/reducers.js

@@ -17,7 +17,7 @@
 import { combineReducers } from 'redux';
 import { routerReducer } from 'react-router-redux';
 
-import { apiReducer, balancesReducer, blockchainReducer, imagesReducer, personalReducer, signerReducer, statusReducer as nodeStatusReducer } from './providers';
+import { apiReducer, balancesReducer, blockchainReducer, compilerReducer, imagesReducer, personalReducer, signerReducer, statusReducer as nodeStatusReducer } from './providers';
 
 import { errorReducer } from '../ui/Errors';
 import { settingsReducer } from '../views/Settings';
@@ -33,6 +33,7 @@ export default function () {
 
     balances: balancesReducer,
     blockchain: blockchainReducer,
+    compiler: compilerReducer,
     images: imagesReducer,
     nodeStatus: nodeStatusReducer,
     personal: personalReducer,

js/src/secureApi.js

@@ -26,6 +26,7 @@ export default class SecureApi extends Api {
     this._connectState = sysuiToken === 'initial' ? 1 : 0;
     this._needsToken = false;
     this._dappsPort = 8080;
+    this._dappsInterface = null;
     this._signerPort = 8180;
 
     console.log('SecureApi:constructor', sysuiToken);
@@ -100,10 +101,12 @@ export default class SecureApi extends Api {
     Promise
       .all([
         this.parity.dappsPort(),
+        this.parity.dappsInterface(),
         this.parity.signerPort()
       ])
-      .then(([dappsPort, signerPort]) => {
+      .then(([dappsPort, dappsInterface, signerPort]) => {
         this._dappsPort = dappsPort.toNumber();
+        this._dappsInterface = dappsInterface;
         this._signerPort = signerPort.toNumber();
       });
 
@@ -122,7 +125,17 @@ export default class SecureApi extends Api {
   }
 
   get dappsUrl () {
-    return `http://${window.location.hostname}:${this._dappsPort}`;
+    let hostname;
+
+    if (window.location.hostname === 'home.parity') {
+      hostname = 'dapps.parity';
+    } else if (!this._dappsInterface || this._dappsInterface === '0.0.0.0') {
+      hostname = window.location.hostname;
+    } else {
+      hostname = this._dappsInterface;
+    }
+
+    return `http://${hostname}:${this._dappsPort}`;
   }
 
   get signerPort () {

js/src/ui/Actionbar/Import/import.css

@@ -0,0 +1,45 @@
+/* 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/>.
+*/
+
+.importZone {
+  width: 100%;
+  height: 200px;
+  border-width: 2px;
+  border-color: #666;
+  border-style: dashed;
+  border-radius: 10px;
+
+  background-color: rgba(50, 50, 50, 0.2);
+
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 1.2em;
+
+  transition: all 0.5s ease;
+
+  &:hover {
+    cursor: pointer;
+    border-radius: 0;
+    background-color: rgba(50, 50, 50, 0.5);
+  }
+}
+
+.desc {
+  margin-top: 0;
+  color: #ccc;
+}

js/src/ui/Actionbar/Import/import.js

@@ -0,0 +1,198 @@
+  // 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/>.
+
+import React, { Component, PropTypes } from 'react';
+import Dropzone from 'react-dropzone';
+import FileUploadIcon from 'material-ui/svg-icons/file/file-upload';
+import ContentClear from 'material-ui/svg-icons/content/clear';
+import ActionDoneAll from 'material-ui/svg-icons/action/done-all';
+
+import { Modal, Button } from '../../';
+
+import styles from './import.css';
+
+const initialState = {
+  step: 0,
+  show: false,
+  validate: false,
+  validationBody: null,
+  content: ''
+};
+
+export default class ActionbarImport extends Component {
+
+  static propTypes = {
+    onConfirm: PropTypes.func.isRequired,
+    renderValidation: PropTypes.func,
+    className: PropTypes.string,
+    title: PropTypes.string
+  };
+
+  static defaultProps = {
+    title: 'Import from a file'
+  };
+
+  state = Object.assign({}, initialState);
+
+  render () {
+    const { className } = this.props;
+
+    return (
+      <div>
+        <Button
+          className={ className }
+          icon={ <FileUploadIcon /> }
+          label='import'
+          onClick={ this.onOpenModal }
+        />
+        { this.renderModal() }
+      </div>
+    );
+  }
+
+  renderModal () {
+    const { title, renderValidation } = this.props;
+    const { show, step } = this.state;
+
+    if (!show) {
+      return null;
+    }
+
+    const hasSteps = typeof renderValidation === 'function';
+
+    const steps = hasSteps ? [ 'select a file', 'validate' ] : null;
+
+    return (
+      <Modal
+        actions={ this.renderActions() }
+        title={ title }
+        steps={ steps }
+        current={ step }
+        visible
+      >
+        { this.renderBody() }
+      </Modal>
+    );
+  }
+
+  renderActions () {
+    const { validate } = this.state;
+
+    const cancelBtn = (
+      <Button
+        key='cancel'
+        label='Cancel'
+        icon={ <ContentClear /> }
+        onClick={ this.onCloseModal }
+      />
+    );
+
+    if (validate) {
+      const confirmBtn = (
+        <Button
+          key='confirm'
+          label='Confirm'
+          icon={ <ActionDoneAll /> }
+          onClick={ this.onConfirm }
+        />
+      );
+
+      return [ cancelBtn, confirmBtn ];
+    }
+
+    return [ cancelBtn ];
+  }
+
+  renderBody () {
+    const { validate } = this.state;
+
+    if (validate) {
+      return this.renderValidation();
+    }
+
+    return this.renderFileSelect();
+  }
+
+  renderFileSelect () {
+    return (
+      <div>
+        <Dropzone
+          onDrop={ this.onDrop }
+          multiple={ false }
+          className={ styles.importZone }
+        >
+          <div>Drop a file here, or click to select a file to upload.</div>
+        </Dropzone>
+      </div>
+    );
+  }
+
+  renderValidation () {
+    const { validationBody } = this.state;
+
+    return (
+      <div>
+        <p className={ styles.desc }>
+          Confirm that this is what was intended to import.
+        </p>
+        <div>
+          { validationBody }
+        </div>
+      </div>
+    );
+  }
+
+  onDrop = (files) => {
+    const { renderValidation } = this.props;
+
+    const file = files[0];
+    const reader = new FileReader();
+
+    reader.onload = (e) => {
+      const content = e.target.result;
+
+      if (typeof renderValidation !== 'function') {
+        this.props.onConfirm(content);
+        return this.onCloseModal();
+      }
+
+      this.setState({
+        step: 1,
+        validate: true,
+        validationBody: renderValidation(content),
+        content
+      });
+    };
+
+    reader.readAsText(file);
+  }
+
+  onConfirm = () => {
+    const { content } = this.state;
+
+    this.props.onConfirm(content);
+    return this.onCloseModal();
+  }
+
+  onOpenModal = () => {
+    this.setState({ show: true });
+  }
+
+  onCloseModal = () => {
+    this.setState(initialState);
+  }
+
+}

js/src/ui/Actionbar/Import/index.js

@@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './import';

js/src/ui/Button/button.js

@@ -19,6 +19,7 @@ import { FlatButton } from 'material-ui';
 
 export default class Button extends Component {
   static propTypes = {
+    backgroundColor: PropTypes.string,
     className: PropTypes.string,
     disabled: PropTypes.bool,
     icon: PropTypes.node,
@@ -26,19 +27,25 @@ export default class Button extends Component {
       React.PropTypes.string,
       React.PropTypes.object
     ]),
-    onClick: PropTypes.func
+    onClick: PropTypes.func,
+    primary: PropTypes.bool
+  }
+
+  static defaultProps = {
+    primary: true
   }
 
   render () {
-    const { className, disabled, icon, label, onClick } = this.props;
+    const { className, backgroundColor, disabled, icon, label, primary, onClick } = this.props;
 
     return (
       <FlatButton
         className={ className }
+        backgroundColor={ backgroundColor }
         disabled={ disabled }
         icon={ icon }
         label={ label }
-        primary
+        primary={ primary }
         onTouchTap={ onClick } />
     );
   }

js/src/ui/Editor/editor.js

@@ -0,0 +1,103 @@
+// 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/>.
+
+import React, { PropTypes, Component } from 'react';
+
+import 'brace';
+import AceEditor from 'react-ace';
+import { noop } from 'lodash';
+
+import 'brace/theme/solarized_dark';
+import 'brace/mode/json';
+import './mode-solidity';
+
+export default class Editor extends Component {
+
+  static propTypes = {
+    className: PropTypes.string,
+    value: PropTypes.string,
+    mode: PropTypes.string,
+    maxLines: PropTypes.number,
+    annotations: PropTypes.array,
+    onExecute: PropTypes.func,
+    onChange: PropTypes.func,
+    readOnly: PropTypes.bool
+  };
+
+  static defaultProps = {
+    className: '',
+    value: '',
+    mode: 'javascript',
+    annotations: [],
+    onExecute: noop,
+    onChange: noop,
+    readOnly: false
+  };
+
+  componentWillMount () {
+    this.name = `PARITY_EDITOR_${Math.round(Math.random() * 99999)}`;
+  }
+
+  render () {
+    const { className, annotations, value, readOnly, mode, maxLines } = this.props;
+    const commands = [
+      {
+        name: 'execut',
+        bindKey: { win: 'Ctrl-Enter', mac: 'Command-Enter' },
+        exec: this.handleExecute
+      }
+    ];
+
+    const max = (maxLines !== undefined)
+      ? maxLines
+      : (readOnly ? value.split('\n').length + 1 : null);
+
+    return (
+      <AceEditor
+        mode={ mode }
+        theme='solarized_dark'
+        width='100%'
+        ref='brace'
+        style={ { flex: 1 } }
+        onChange={ this.handleOnChange }
+        name={ this.name }
+        editorProps={ { $blockScrolling: Infinity } }
+        setOptions={ {
+          useWorker: false,
+          fontFamily: 'monospace',
+          fontSize: '0.9em'
+        } }
+        maxLines={ max }
+        enableBasicAutocompletion={ !readOnly }
+        showPrintMargin={ false }
+        annotations={ annotations }
+        value={ value }
+        commands={ commands }
+        readOnly={ readOnly }
+        className={ className }
+      />
+    );
+  }
+
+  handleExecute = () => {
+    this.props.onExecute();
+  }
+
+  handleOnChange = (value) => {
+    this.props.onChange(value);
+  }
+
+}

js/src/ui/Editor/index.js

@@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './editor';

js/src/ui/Editor/mode-solidity.js

@@ -0,0 +1,994 @@
+// 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/>.
+
+/**
+ * This file has been taken from `ethereum/browser-solidity`
+ *
+ * @see: https://raw.githubusercontent.com/ethereum/browser-solidity/master/src/mode-solidity.js
+ */
+/* eslint-disable */
+var ace = window.ace;
+
+ace.define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(acequire, exports, module) {
+"use strict";
+
+var oop = acequire("../lib/oop");
+var TextHighlightRules = acequire("./text_highlight_rules").TextHighlightRules;
+
+var DocCommentHighlightRules = function() {
+    this.$rules = {
+        "start" : [ {
+            token : "comment.doc.tag",
+            regex : "@[\\w\\d_]+" // TODO: fix email addresses
+        },
+        DocCommentHighlightRules.getTagRule(),
+        {
+            defaultToken : "comment.doc",
+            caseInsensitive: true
+        }]
+    };
+};
+
+oop.inherits(DocCommentHighlightRules, TextHighlightRules);
+
+DocCommentHighlightRules.getTagRule = function(start) {
+    return {
+        token : "comment.doc.tag.storage.type",
+        regex : "\\b(?:TODO|FIXME|XXX|HACK)\\b"
+    };
+};
+
+DocCommentHighlightRules.getStartRule = function(start) {
+    return {
+        token : "comment.doc", // doc comment
+        regex : "\\/\\*(?=\\*)",
+        next  : start
+    };
+};
+
+DocCommentHighlightRules.getEndRule = function (start) {
+    return {
+        token : "comment.doc", // closing comment
+        regex : "\\*\\/",
+        next  : start
+    };
+};
+
+
+exports.DocCommentHighlightRules = DocCommentHighlightRules;
+
+});
+
+ace.define("ace/mode/javascript_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/doc_comment_highlight_rules","ace/mode/text_highlight_rules"], function(acequire, exports, module) {
+"use strict";
+
+var oop = acequire("../lib/oop");
+var DocCommentHighlightRules = acequire("./doc_comment_highlight_rules").DocCommentHighlightRules;
+var TextHighlightRules = acequire("./text_highlight_rules").TextHighlightRules;
+
+var JavaScriptHighlightRules = function(options) {
+    var intTypes = 'bytes|int|uint';
+    for (var width = 8; width <= 256; width += 8)
+        intTypes += '|bytes' + (width / 8) + '|uint' + width + '|int' + width;
+    var keywordMapper = this.createKeywordMapper({
+        "variable.language":
+            "this|bool|string|byte|bytes|bytes0|address|" + intTypes,
+        "keyword":
+            "contract|library|constant|event|modifier|" +
+            "struct|mapping|enum|break|continue|delete|else|for|function|" +
+            "if|new|return|returns|var|while|using|" +
+            "private|public|external|internal|storage|memory",
+        "storage.type":
+            "constant|var|function",
+        "constant.language.boolean": "true|false"
+    }, "identifier");
+    var kwBeforeRe = "case|do|else|finally|in|instanceof|return|throw|try|typeof|yield|void";
+    var identifierRe = "[a-zA-Z\\$_\u00a1-\uffff][a-zA-Z\\d\\$_\u00a1-\uffff]*\\b";
+
+    var escapedRe = "\\\\(?:x[0-9a-fA-F]{2}|" + // hex
+        "u[0-9a-fA-F]{4}|" + // unicode
+        "[0-2][0-7]{0,2}|" + // oct
+        "3[0-6][0-7]?|" + // oct
+        "37[0-7]?|" + // oct
+        "[4-7][0-7]?|" + //oct
+        ".)";
+
+    this.$rules = {
+        "no_regex" : [
+            {
+                token : "comment",
+                regex : "\\/\\/",
+                next : "line_comment"
+            },
+            DocCommentHighlightRules.getStartRule("doc-start"),
+            {
+                token : "comment", // multi line comment
+                regex : /\/\*/,
+                next : "comment"
+            }, {
+                token : "string",
+                regex : "'(?=.)",
+                next  : "qstring"
+            }, {
+                token : "string",
+                regex : '"(?=.)',
+                next  : "qqstring"
+            }, {
+                token : "constant.numeric", // hex
+                regex : /0[xX][0-9a-fA-F]+\b/
+            }, {
+                token : "constant.numeric", // float
+                regex : /[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/
+            }, {
+                token : [
+                    "storage.type", "punctuation.operator", "support.function",
+                    "punctuation.operator", "entity.name.function", "text","keyword.operator"
+                ],
+                regex : "(" + identifierRe + ")(\\.)(prototype)(\\.)(" + identifierRe +")(\\s*)(=)",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "storage.type", "punctuation.operator", "entity.name.function", "text",
+                    "keyword.operator", "text", "storage.type", "text", "paren.lparen"
+                ],
+                regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "entity.name.function", "text", "keyword.operator", "text", "storage.type",
+                    "text", "paren.lparen"
+                ],
+                regex : "(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "storage.type", "punctuation.operator", "entity.name.function", "text",
+                    "keyword.operator", "text",
+                    "storage.type", "text", "entity.name.function", "text", "paren.lparen"
+                ],
+                regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s+)(\\w+)(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "storage.type", "text", "entity.name.function", "text", "paren.lparen"
+                ],
+                regex : "(function)(\\s+)(" + identifierRe + ")(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "entity.name.function", "text", "punctuation.operator",
+                    "text", "storage.type", "text", "paren.lparen"
+                ],
+                regex : "(" + identifierRe + ")(\\s*)(:)(\\s*)(function)(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : [
+                    "text", "text", "storage.type", "text", "paren.lparen"
+                ],
+                regex : "(:)(\\s*)(function)(\\s*)(\\()",
+                next: "function_arguments"
+            }, {
+                token : "keyword",
+                regex : "(?:" + kwBeforeRe + ")\\b",
+                next : "start"
+            }, {
+                token : ["punctuation.operator", "support.function"],
+                regex : /(\.)(s(?:h(?:ift|ow(?:Mod(?:elessDialog|alDialog)|Help))|croll(?:X|By(?:Pages|Lines)?|Y|To)?|t(?:op|rike)|i(?:n|zeToContent|debar|gnText)|ort|u(?:p|b(?:str(?:ing)?)?)|pli(?:ce|t)|e(?:nd|t(?:Re(?:sizable|questHeader)|M(?:i(?:nutes|lliseconds)|onth)|Seconds|Ho(?:tKeys|urs)|Year|Cursor|Time(?:out)?|Interval|ZOptions|Date|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(?:ome|andleEvent)|navigate|c(?:har(?:CodeAt|At)|o(?:s|n(?:cat|textual|firm)|mpile)|eil|lear(?:Timeout|Interval)?|a(?:ptureEvents|ll)|reate(?:StyleSheet|Popup|EventObject))|t(?:o(?:GMTString|S(?:tring|ource)|U(?:TCString|pperCase)|Lo(?:caleString|werCase))|est|a(?:n|int(?:Enabled)?))|i(?:s(?:NaN|Finite)|ndexOf|talics)|d(?:isableExternalCapture|ump|etachEvent)|u(?:n(?:shift|taint|escape|watch)|pdateCommands)|j(?:oin|avaEnabled)|p(?:o(?:p|w)|ush|lugins.refresh|a(?:ddings|rse(?:Int|Float)?)|r(?:int|ompt|eference))|e(?:scape|nableExternalCapture|val|lementFromPoint|x(?:p|ec(?:Script|Command)?))|valueOf|UTC|queryCommand(?:State|Indeterm|Enabled|Value)|f(?:i(?:nd|le(?:ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(?:nt(?:size|color)|rward)|loor|romCharCode)|watch|l(?:ink|o(?:ad|g)|astIndexOf)|a(?:sin|nchor|cos|t(?:tachEvent|ob|an(?:2)?)|pply|lert|b(?:s|ort))|r(?:ou(?:nd|teEvents)|e(?:size(?:By|To)|calc|turnValue|place|verse|l(?:oad|ease(?:Capture|Events)))|andom)|g(?:o|et(?:ResponseHeader|M(?:i(?:nutes|lliseconds)|onth)|Se(?:conds|lection)|Hours|Year|Time(?:zoneOffset)?|Da(?:y|te)|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Da(?:y|te)|FullYear)|FullYear|A(?:ttention|llResponseHeaders)))|m(?:in|ove(?:B(?:y|elow)|To(?:Absolute)?|Above)|ergeAttributes|a(?:tch|rgins|x))|b(?:toa|ig|o(?:ld|rderWidths)|link|ack))\b(?=\()/
+            }, {
+                token : ["punctuation.operator", "support.function.dom"],
+                regex : /(\.)(s(?:ub(?:stringData|mit)|plitText|e(?:t(?:NamedItem|Attribute(?:Node)?)|lect))|has(?:ChildNodes|Feature)|namedItem|c(?:l(?:ick|o(?:se|neNode))|reate(?:C(?:omment|DATASection|aption)|T(?:Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(?:ntityReference|lement)|Attribute))|tabIndex|i(?:nsert(?:Row|Before|Cell|Data)|tem)|open|delete(?:Row|C(?:ell|aption)|T(?:Head|Foot)|Data)|focus|write(?:ln)?|a(?:dd|ppend(?:Child|Data))|re(?:set|place(?:Child|Data)|move(?:NamedItem|Child|Attribute(?:Node)?)?)|get(?:NamedItem|Element(?:sBy(?:Name|TagName)|ById)|Attribute(?:Node)?)|blur)\b(?=\()/
+            }, {
+                token : ["punctuation.operator", "support.constant"],
+                regex : /(\.)(s(?:ystemLanguage|cr(?:ipts|ollbars|een(?:X|Y|Top|Left))|t(?:yle(?:Sheets)?|atus(?:Text|bar)?)|ibling(?:Below|Above)|ource|uffixes|e(?:curity(?:Policy)?|l(?:ection|f)))|h(?:istory|ost(?:name)?|as(?:h|Focus))|y|X(?:MLDocument|SLDocument)|n(?:ext|ame(?:space(?:s|URI)|Prop))|M(?:IN_VALUE|AX_VALUE)|c(?:haracterSet|o(?:n(?:structor|trollers)|okieEnabled|lorDepth|mp(?:onents|lete))|urrent|puClass|l(?:i(?:p(?:boardData)?|entInformation)|osed|asses)|alle(?:e|r)|rypto)|t(?:o(?:olbar|p)|ext(?:Transform|Indent|Decoration|Align)|ags)|SQRT(?:1_2|2)|i(?:n(?:ner(?:Height|Width)|put)|ds|gnoreCase)|zIndex|o(?:scpu|n(?:readystatechange|Line)|uter(?:Height|Width)|p(?:sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(?:i(?:splay|alog(?:Height|Top|Width|Left|Arguments)|rectories)|e(?:scription|fault(?:Status|Ch(?:ecked|arset)|View)))|u(?:ser(?:Profile|Language|Agent)|n(?:iqueID|defined)|pdateInterval)|_content|p(?:ixelDepth|ort|ersonalbar|kcs11|l(?:ugins|atform)|a(?:thname|dding(?:Right|Bottom|Top|Left)|rent(?:Window|Layer)?|ge(?:X(?:Offset)?|Y(?:Offset)?))|r(?:o(?:to(?:col|type)|duct(?:Sub)?|mpter)|e(?:vious|fix)))|e(?:n(?:coding|abledPlugin)|x(?:ternal|pando)|mbeds)|v(?:isibility|endor(?:Sub)?|Linkcolor)|URLUnencoded|P(?:I|OSITIVE_INFINITY)|f(?:ilename|o(?:nt(?:Size|Family|Weight)|rmName)|rame(?:s|Element)|gColor)|E|whiteSpace|l(?:i(?:stStyleType|n(?:eHeight|kColor))|o(?:ca(?:tion(?:bar)?|lName)|wsrc)|e(?:ngth|ft(?:Context)?)|a(?:st(?:M(?:odified|atch)|Index|Paren)|yer(?:s|X)|nguage))|a(?:pp(?:MinorVersion|Name|Co(?:deName|re)|Version)|vail(?:Height|Top|Width|Left)|ll|r(?:ity|guments)|Linkcolor|bove)|r(?:ight(?:Context)?|e(?:sponse(?:XML|Text)|adyState))|global|x|m(?:imeTypes|ultiline|enubar|argin(?:Right|Bottom|Top|Left))|L(?:N(?:10|2)|OG(?:10E|2E))|b(?:o(?:ttom|rder(?:Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(?:Color|Image)))\b/
+            }, {
+                token : ["support.constant"],
+                regex : /that\b/
+            }, {
+                token : ["storage.type", "punctuation.operator", "support.function.firebug"],
+                regex : /(console)(\.)(warn|info|log|error|time|trace|timeEnd|assert)\b/
+            }, {
+                token : keywordMapper,
+                regex : identifierRe
+            }, {
+                token : "keyword.operator",
+                regex : /--|\*\*|\+\+|===|==|=|!=|!==|=>|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|[!$%&*+\-~\/^]=?/,
+                next  : "start"
+            }, {
+                token : "punctuation.operator",
+                regex : /[?:,;.]/,
+                next  : "start"
+            }, {
+                token : "paren.lparen",
+                regex : /[\[({]/,
+                next  : "start"
+            }, {
+                token : "paren.rparen",
+                regex : /[\])}]/
+            }, {
+                token: "comment",
+                regex: /^#!.*$/
+            }
+        ],
+        "start": [
+            DocCommentHighlightRules.getStartRule("doc-start"),
+            {
+                token : "comment", // multi line comment
+                regex : "\\/\\*",
+                next : "comment_regex_allowed"
+            }, {
+                token : "comment",
+                regex : "\\/\\/",
+                next : "line_comment_regex_allowed"
+            }, {
+                token: "string.regexp",
+                regex: "\\/",
+                next: "regex"
+            }, {
+                token : "text",
+                regex : "\\s+|^$",
+                next : "start"
+            }, {
+                token: "empty",
+                regex: "",
+                next: "no_regex"
+            }
+        ],
+        "regex": [
+            {
+                token: "regexp.keyword.operator",
+                regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"
+            }, {
+                token: "string.regexp",
+                regex: "/[sxngimy]*",
+                next: "no_regex"
+            }, {
+                token : "invalid",
+                regex: /\{\d+\b,?\d*\}[+*]|[+*$^?][+*]|[$^][?]|\?{3,}/
+            }, {
+                token : "constant.language.escape",
+                regex: /\(\?[:=!]|\)|\{\d+\b,?\d*\}|[+*]\?|[()$^+*?.]/
+            }, {
+                token : "constant.language.delimiter",
+                regex: /\|/
+            }, {
+                token: "constant.language.escape",
+                regex: /\[\^?/,
+                next: "regex_character_class"
+            }, {
+                token: "empty",
+                regex: "$",
+                next: "no_regex"
+            }, {
+                defaultToken: "string.regexp"
+            }
+        ],
+        "regex_character_class": [
+            {
+                token: "regexp.charclass.keyword.operator",
+                regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"
+            }, {
+                token: "constant.language.escape",
+                regex: "]",
+                next: "regex"
+            }, {
+                token: "constant.language.escape",
+                regex: "-"
+            }, {
+                token: "empty",
+                regex: "$",
+                next: "no_regex"
+            }, {
+                defaultToken: "string.regexp.charachterclass"
+            }
+        ],
+        "function_arguments": [
+            {
+                token: "variable.parameter",
+                regex: identifierRe
+            }, {
+                token: "punctuation.operator",
+                regex: "[, ]+"
+            }, {
+                token: "punctuation.operator",
+                regex: "$"
+            }, {
+                token: "empty",
+                regex: "",
+                next: "no_regex"
+            }
+        ],
+        "comment_regex_allowed" : [
+            DocCommentHighlightRules.getTagRule(),
+            {token : "comment", regex : "\\*\\/", next : "start"},
+            {defaultToken : "comment", caseInsensitive: true}
+        ],
+        "comment" : [
+            DocCommentHighlightRules.getTagRule(),
+            {token : "comment", regex : "\\*\\/", next : "no_regex"},
+            {defaultToken : "comment", caseInsensitive: true}
+        ],
+        "line_comment_regex_allowed" : [
+            DocCommentHighlightRules.getTagRule(),
+            {token : "comment", regex : "$|^", next : "start"},
+            {defaultToken : "comment", caseInsensitive: true}
+        ],
+        "line_comment" : [
+            DocCommentHighlightRules.getTagRule(),
+            {token : "comment", regex : "$|^", next : "no_regex"},
+            {defaultToken : "comment", caseInsensitive: true}
+        ],
+        "qqstring" : [
+            {
+                token : "constant.language.escape",
+                regex : escapedRe
+            }, {
+                token : "string",
+                regex : "\\\\$",
+                next  : "qqstring"
+            }, {
+                token : "string",
+                regex : '"|$',
+                next  : "no_regex"
+            }, {
+                defaultToken: "string"
+            }
+        ],
+        "qstring" : [
+            {
+                token : "constant.language.escape",
+                regex : escapedRe
+            }, {
+                token : "string",
+                regex : "\\\\$",
+                next  : "qstring"
+            }, {
+                token : "string",
+                regex : "'|$",
+                next  : "no_regex"
+            }, {
+                defaultToken: "string"
+            }
+        ]
+    };
+
+
+    if (!options || !options.noES6) {
+        this.$rules.no_regex.unshift({
+            regex: "[{}]", onMatch: function(val, state, stack) {
+                this.next = val == "{" ? this.nextState : "";
+                if (val == "{" && stack.length) {
+                    stack.unshift("start", state);
+                    return "paren";
+                }
+                if (val == "}" && stack.length) {
+                    stack.shift();
+                    this.next = stack.shift();
+                    if (this.next.indexOf("string") != -1)
+                        return "paren.quasi.end";
+                }
+                return val == "{" ? "paren.lparen" : "paren.rparen";
+            },
+            nextState: "start"
+        }, {
+            token : "string.quasi.start",
+            regex : /`/,
+            push  : [{
+                token : "constant.language.escape",
+                regex : escapedRe
+            }, {
+                token : "paren.quasi.start",
+                regex : /\${/,
+                push  : "start"
+            }, {
+                token : "string.quasi.end",
+                regex : /`/,
+                next  : "pop"
+            }, {
+                defaultToken: "string.quasi"
+            }]
+        });
+    }
+
+    this.embedRules(DocCommentHighlightRules, "doc-",
+        [ DocCommentHighlightRules.getEndRule("no_regex") ]);
+
+    this.normalizeRules();
+};
+
+oop.inherits(JavaScriptHighlightRules, TextHighlightRules);
+
+exports.JavaScriptHighlightRules = JavaScriptHighlightRules;
+});
+
+ace.define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"], function(acequire, exports, module) {
+"use strict";
+
+var Range = acequire("../range").Range;
+
+var MatchingBraceOutdent = function() {};
+
+(function() {
+
+    this.checkOutdent = function(line, input) {
+        if (! /^\s+$/.test(line))
+            return false;
+
+        return /^\s*\}/.test(input);
+    };
+
+    this.autoOutdent = function(doc, row) {
+        var line = doc.getLine(row);
+        var match = line.match(/^(\s*\})/);
+
+        if (!match) return 0;
+
+        var column = match[1].length;
+        var openBracePos = doc.findMatchingBracket({row: row, column: column});
+
+        if (!openBracePos || openBracePos.row == row) return 0;
+
+        var indent = this.$getIndent(doc.getLine(openBracePos.row));
+        doc.replace(new Range(row, 0, row, column-1), indent);
+    };
+
+    this.$getIndent = function(line) {
+        return line.match(/^\s*/)[0];
+    };
+
+}).call(MatchingBraceOutdent.prototype);
+
+exports.MatchingBraceOutdent = MatchingBraceOutdent;
+});
+
+ace.define("ace/mode/behaviour/cstyle",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"], function(acequire, exports, module) {
+"use strict";
+
+var oop = acequire("../../lib/oop");
+var Behaviour = acequire("../behaviour").Behaviour;
+var TokenIterator = acequire("../../token_iterator").TokenIterator;
+var lang = acequire("../../lib/lang");
+
+var SAFE_INSERT_IN_TOKENS =
+    ["text", "paren.rparen", "punctuation.operator"];
+var SAFE_INSERT_BEFORE_TOKENS =
+    ["text", "paren.rparen", "punctuation.operator", "comment"];
+
+var context;
+var contextCache = {};
+var initContext = function(editor) {
+    var id = -1;
+    if (editor.multiSelect) {
+        id = editor.selection.index;
+        if (contextCache.rangeCount != editor.multiSelect.rangeCount)
+            contextCache = {rangeCount: editor.multiSelect.rangeCount};
+    }
+    if (contextCache[id])
+        return context = contextCache[id];
+    context = contextCache[id] = {
+        autoInsertedBrackets: 0,
+        autoInsertedRow: -1,
+        autoInsertedLineEnd: "",
+        maybeInsertedBrackets: 0,
+        maybeInsertedRow: -1,
+        maybeInsertedLineStart: "",
+        maybeInsertedLineEnd: ""
+    };
+};
+
+var CstyleBehaviour = function() {
+    this.add("braces", "insertion", function(state, action, editor, session, text) {
+        var cursor = editor.getCursorPosition();
+        var line = session.doc.getLine(cursor.row);
+        if (text == '{') {
+            initContext(editor);
+            var selection = editor.getSelectionRange();
+            var selected = session.doc.getTextRange(selection);
+            if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) {
+                return {
+                    text: '{' + selected + '}',
+                    selection: false
+                };
+            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
+                if (/[\]\}\)]/.test(line[cursor.column]) || editor.inMultiSelectMode) {
+                    CstyleBehaviour.recordAutoInsert(editor, session, "}");
+                    return {
+                        text: '{}',
+                        selection: [1, 1]
+                    };
+                } else {
+                    CstyleBehaviour.recordMaybeInsert(editor, session, "{");
+                    return {
+                        text: '{',
+                        selection: [1, 1]
+                    };
+                }
+            }
+        } else if (text == '}') {
+            initContext(editor);
+            var rightChar = line.substring(cursor.column, cursor.column + 1);
+            if (rightChar == '}') {
+                var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row});
+                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
+                    CstyleBehaviour.popAutoInsertedClosing();
+                    return {
+                        text: '',
+                        selection: [1, 1]
+                    };
+                }
+            }
+        } else if (text == "\n" || text == "\r\n") {
+            initContext(editor);
+            var closing = "";
+            if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
+                closing = lang.stringRepeat("}", context.maybeInsertedBrackets);
+                CstyleBehaviour.clearMaybeInsertedClosing();
+            }
+            var rightChar = line.substring(cursor.column, cursor.column + 1);
+            if (rightChar === '}') {
+                var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column+1}, '}');
+                if (!openBracePos)
+                     return null;
+                var next_indent = this.$getIndent(session.getLine(openBracePos.row));
+            } else if (closing) {
+                var next_indent = this.$getIndent(line);
+            } else {
+                CstyleBehaviour.clearMaybeInsertedClosing();
+                return;
+            }
+            var indent = next_indent + session.getTabString();
+
+            return {
+                text: '\n' + indent + '\n' + next_indent + closing,
+                selection: [1, indent.length, 1, indent.length]
+            };
+        } else {
+            CstyleBehaviour.clearMaybeInsertedClosing();
+        }
+    });
+
+    this.add("braces", "deletion", function(state, action, editor, session, range) {
+        var selected = session.doc.getTextRange(range);
+        if (!range.isMultiLine() && selected == '{') {
+            initContext(editor);
+            var line = session.doc.getLine(range.start.row);
+            var rightChar = line.substring(range.end.column, range.end.column + 1);
+            if (rightChar == '}') {
+                range.end.column++;
+                return range;
+            } else {
+                context.maybeInsertedBrackets--;
+            }
+        }
+    });
+
+    this.add("parens", "insertion", function(state, action, editor, session, text) {
+        if (text == '(') {
+            initContext(editor);
+            var selection = editor.getSelectionRange();
+            var selected = session.doc.getTextRange(selection);
+            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
+                return {
+                    text: '(' + selected + ')',
+                    selection: false
+                };
+            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
+                CstyleBehaviour.recordAutoInsert(editor, session, ")");
+                return {
+                    text: '()',
+                    selection: [1, 1]
+                };
+            }
+        } else if (text == ')') {
+            initContext(editor);
+            var cursor = editor.getCursorPosition();
+            var line = session.doc.getLine(cursor.row);
+            var rightChar = line.substring(cursor.column, cursor.column + 1);
+            if (rightChar == ')') {
+                var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row});
+                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
+                    CstyleBehaviour.popAutoInsertedClosing();
+                    return {
+                        text: '',
+                        selection: [1, 1]
+                    };
+                }
+            }
+        }
+    });
+
+    this.add("parens", "deletion", function(state, action, editor, session, range) {
+        var selected = session.doc.getTextRange(range);
+        if (!range.isMultiLine() && selected == '(') {
+            initContext(editor);
+            var line = session.doc.getLine(range.start.row);
+            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
+            if (rightChar == ')') {
+                range.end.column++;
+                return range;
+            }
+        }
+    });
+
+    this.add("brackets", "insertion", function(state, action, editor, session, text) {
+        if (text == '[') {
+            initContext(editor);
+            var selection = editor.getSelectionRange();
+            var selected = session.doc.getTextRange(selection);
+            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
+                return {
+                    text: '[' + selected + ']',
+                    selection: false
+                };
+            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
+                CstyleBehaviour.recordAutoInsert(editor, session, "]");
+                return {
+                    text: '[]',
+                    selection: [1, 1]
+                };
+            }
+        } else if (text == ']') {
+            initContext(editor);
+            var cursor = editor.getCursorPosition();
+            var line = session.doc.getLine(cursor.row);
+            var rightChar = line.substring(cursor.column, cursor.column + 1);
+            if (rightChar == ']') {
+                var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row});
+                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
+                    CstyleBehaviour.popAutoInsertedClosing();
+                    return {
+                        text: '',
+                        selection: [1, 1]
+                    };
+                }
+            }
+        }
+    });
+
+    this.add("brackets", "deletion", function(state, action, editor, session, range) {
+        var selected = session.doc.getTextRange(range);
+        if (!range.isMultiLine() && selected == '[') {
+            initContext(editor);
+            var line = session.doc.getLine(range.start.row);
+            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
+            if (rightChar == ']') {
+                range.end.column++;
+                return range;
+            }
+        }
+    });
+
+    this.add("string_dquotes", "insertion", function(state, action, editor, session, text) {
+        if (text == '"' || text == "'") {
+            initContext(editor);
+            var quote = text;
+            var selection = editor.getSelectionRange();
+            var selected = session.doc.getTextRange(selection);
+            if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {
+                return {
+                    text: quote + selected + quote,
+                    selection: false
+                };
+            } else {
+                var cursor = editor.getCursorPosition();
+                var line = session.doc.getLine(cursor.row);
+                var leftChar = line.substring(cursor.column-1, cursor.column);
+                if (leftChar == '\\') {
+                    return null;
+                }
+                var tokens = session.getTokens(selection.start.row);
+                var col = 0, token;
+                var quotepos = -1; // Track whether we're inside an open quote.
+
+                for (var x = 0; x < tokens.length; x++) {
+                    token = tokens[x];
+                    if (token.type == "string") {
+                      quotepos = -1;
+                    } else if (quotepos < 0) {
+                      quotepos = token.value.indexOf(quote);
+                    }
+                    if ((token.value.length + col) > selection.start.column) {
+                        break;
+                    }
+                    col += tokens[x].value.length;
+                }
+                if (!token || (quotepos < 0 && token.type !== "comment" && (token.type !== "string" || ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
+                    if (!CstyleBehaviour.isSaneInsertion(editor, session))
+                        return;
+                    return {
+                        text: quote + quote,
+                        selection: [1,1]
+                    };
+                } else if (token && token.type === "string") {
+                    var rightChar = line.substring(cursor.column, cursor.column + 1);
+                    if (rightChar == quote) {
+                        return {
+                            text: '',
+                            selection: [1, 1]
+                        };
+                    }
+                }
+            }
+        }
+    });
+
+    this.add("string_dquotes", "deletion", function(state, action, editor, session, range) {
+        var selected = session.doc.getTextRange(range);
+        if (!range.isMultiLine() && (selected == '"' || selected == "'")) {
+            initContext(editor);
+            var line = session.doc.getLine(range.start.row);
+            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
+            if (rightChar == selected) {
+                range.end.column++;
+                return range;
+            }
+        }
+    });
+
+};
+
+
+CstyleBehaviour.isSaneInsertion = function(editor, session) {
+    var cursor = editor.getCursorPosition();
+    var iterator = new TokenIterator(session, cursor.row, cursor.column);
+    if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) {
+        var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
+        if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS))
+            return false;
+    }
+    iterator.stepForward();
+    return iterator.getCurrentTokenRow() !== cursor.row ||
+        this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS);
+};
+
+CstyleBehaviour.$matchTokenType = function(token, types) {
+    return types.indexOf(token.type || token) > -1;
+};
+
+CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
+    var cursor = editor.getCursorPosition();
+    var line = session.doc.getLine(cursor.row);
+    if (!this.isAutoInsertedClosing(cursor, line, context.autoInsertedLineEnd[0]))
+        context.autoInsertedBrackets = 0;
+    context.autoInsertedRow = cursor.row;
+    context.autoInsertedLineEnd = bracket + line.substr(cursor.column);
+    context.autoInsertedBrackets++;
+};
+
+CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
+    var cursor = editor.getCursorPosition();
+    var line = session.doc.getLine(cursor.row);
+    if (!this.isMaybeInsertedClosing(cursor, line))
+        context.maybeInsertedBrackets = 0;
+    context.maybeInsertedRow = cursor.row;
+    context.maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
+    context.maybeInsertedLineEnd = line.substr(cursor.column);
+    context.maybeInsertedBrackets++;
+};
+
+CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
+    return context.autoInsertedBrackets > 0 &&
+        cursor.row === context.autoInsertedRow &&
+        bracket === context.autoInsertedLineEnd[0] &&
+        line.substr(cursor.column) === context.autoInsertedLineEnd;
+};
+
+CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
+    return context.maybeInsertedBrackets > 0 &&
+        cursor.row === context.maybeInsertedRow &&
+        line.substr(cursor.column) === context.maybeInsertedLineEnd &&
+        line.substr(0, cursor.column) == context.maybeInsertedLineStart;
+};
+
+CstyleBehaviour.popAutoInsertedClosing = function() {
+    context.autoInsertedLineEnd = context.autoInsertedLineEnd.substr(1);
+    context.autoInsertedBrackets--;
+};
+
+CstyleBehaviour.clearMaybeInsertedClosing = function() {
+    if (context) {
+        context.maybeInsertedBrackets = 0;
+        context.maybeInsertedRow = -1;
+    }
+};
+
+
+
+oop.inherits(CstyleBehaviour, Behaviour);
+
+exports.CstyleBehaviour = CstyleBehaviour;
+});
+
+ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"], function(acequire, exports, module) {
+"use strict";
+
+var oop = acequire("../../lib/oop");
+var Range = acequire("../../range").Range;
+var BaseFoldMode = acequire("./fold_mode").FoldMode;
+
+var FoldMode = exports.FoldMode = function(commentRegex) {
+    if (commentRegex) {
+        this.foldingStartMarker = new RegExp(
+            this.foldingStartMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.start)
+        );
+        this.foldingStopMarker = new RegExp(
+            this.foldingStopMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.end)
+        );
+    }
+};
+oop.inherits(FoldMode, BaseFoldMode);
+
+(function() {
+
+    this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/;
+    this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;
+
+    this.getFoldWidgetRange = function(session, foldStyle, row, forceMultiline) {
+        var line = session.getLine(row);
+        var match = line.match(this.foldingStartMarker);
+        if (match) {
+            var i = match.index;
+
+            if (match[1])
+                return this.openingBracketBlock(session, match[1], row, i);
+
+            var range = session.getCommentFoldRange(row, i + match[0].length, 1);
+
+            if (range && !range.isMultiLine()) {
+                if (forceMultiline) {
+                    range = this.getSectionRange(session, row);
+                } else if (foldStyle != "all")
+                    range = null;
+            }
+
+            return range;
+        }
+
+        if (foldStyle === "markbegin")
+            return;
+
+        var match = line.match(this.foldingStopMarker);
+        if (match) {
+            var i = match.index + match[0].length;
+
+            if (match[1])
+                return this.closingBracketBlock(session, match[1], row, i);
+
+            return session.getCommentFoldRange(row, i, -1);
+        }
+    };
+
+    this.getSectionRange = function(session, row) {
+        var line = session.getLine(row);
+        var startIndent = line.search(/\S/);
+        var startRow = row;
+        var startColumn = line.length;
+        row = row + 1;
+        var endRow = row;
+        var maxRow = session.getLength();
+        while (++row < maxRow) {
+            line = session.getLine(row);
+            var indent = line.search(/\S/);
+            if (indent === -1)
+                continue;
+            if  (startIndent > indent)
+                break;
+            var subRange = this.getFoldWidgetRange(session, "all", row);
+
+            if (subRange) {
+                if (subRange.start.row <= startRow) {
+                    break;
+                } else if (subRange.isMultiLine()) {
+                    row = subRange.end.row;
+                } else if (startIndent == indent) {
+                    break;
+                }
+            }
+            endRow = row;
+        }
+
+        return new Range(startRow, startColumn, endRow, session.getLine(endRow).length);
+    };
+
+}).call(FoldMode.prototype);
+
+});
+
+ace.define("ace/mode/javascript",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/javascript_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/worker/worker_client","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle"], function(acequire, exports, module) {
+"use strict";
+
+var oop = acequire("../lib/oop");
+var TextMode = acequire("./text").Mode;
+var JavaScriptHighlightRules = acequire("./javascript_highlight_rules").JavaScriptHighlightRules;
+var MatchingBraceOutdent = acequire("./matching_brace_outdent").MatchingBraceOutdent;
+var Range = acequire("../range").Range;
+var WorkerClient = acequire("../worker/worker_client").WorkerClient;
+var CstyleBehaviour = acequire("./behaviour/cstyle").CstyleBehaviour;
+var CStyleFoldMode = acequire("./folding/cstyle").FoldMode;
+
+var Mode = function() {
+    this.HighlightRules = JavaScriptHighlightRules;
+
+    this.$outdent = new MatchingBraceOutdent();
+    this.$behaviour = new CstyleBehaviour();
+    this.foldingRules = new CStyleFoldMode();
+};
+oop.inherits(Mode, TextMode);
+
+(function() {
+
+    this.lineCommentStart = "//";
+    this.blockComment = {start: "/*", end: "*/"};
+
+    this.getNextLineIndent = function(state, line, tab) {
+        var indent = this.$getIndent(line);
+
+        var tokenizedLine = this.getTokenizer().getLineTokens(line, state);
+        var tokens = tokenizedLine.tokens;
+        var endState = tokenizedLine.state;
+
+        if (tokens.length && tokens[tokens.length-1].type == "comment") {
+            return indent;
+        }
+
+        if (state == "start" || state == "no_regex") {
+            var match = line.match(/^.*(?:\bcase\b.*\:|[\{\(\[])\s*$/);
+            if (match) {
+                indent += tab;
+            }
+        } else if (state == "doc-start") {
+            if (endState == "start" || endState == "no_regex") {
+                return "";
+            }
+            var match = line.match(/^\s*(\/?)\*/);
+            if (match) {
+                if (match[1]) {
+                    indent += " ";
+                }
+                indent += "* ";
+            }
+        }
+
+        return indent;
+    };
+
+    this.checkOutdent = function(state, line, input) {
+        return this.$outdent.checkOutdent(line, input);
+    };
+
+    this.autoOutdent = function(state, doc, row) {
+        this.$outdent.autoOutdent(doc, row);
+    };
+
+//    this.createWorker = function(session) {
+//        var worker = new WorkerClient(["ace"], "ace/mode/javascript_worker", "JavaScriptWorker");
+//        worker.attachToDocument(session.getDocument());
+//
+//        worker.on("jslint", function(results) {
+//            session.setAnnotations(results.data);
+//        });
+//
+//        worker.on("terminate", function() {
+//            session.clearAnnotations();
+//        });
+//
+//        return worker;
+//    };
+
+    this.$id = "ace/mode/javascript";
+}).call(Mode.prototype);
+
+exports.Mode = Mode;
+});

js/src/ui/index.js

@@ -16,6 +16,7 @@
 
 import Actionbar from './Actionbar';
 import ActionbarExport from './Actionbar/Export';
+import ActionbarImport from './Actionbar/Import';
 import ActionbarSearch from './Actionbar/Search';
 import ActionbarSort from './Actionbar/Sort';
 import Badge from './Badge';
@@ -26,6 +27,7 @@ import ConfirmDialog from './ConfirmDialog';
 import Container, { Title as ContainerTitle } from './Container';
 import ContextProvider from './ContextProvider';
 import CopyToClipboard from './CopyToClipboard';
+import Editor from './Editor';
 import Errors from './Errors';
 import Form, { AddressSelect, FormWrap, Input, InputAddress, InputAddressSelect, InputChip, InputInline, Select } from './Form';
 import IdentityIcon from './IdentityIcon';
@@ -43,6 +45,7 @@ import TxHash from './TxHash';
 export {
   Actionbar,
   ActionbarExport,
+  ActionbarImport,
   ActionbarSearch,
   ActionbarSort,
   AddressSelect,
@@ -55,6 +58,7 @@ export {
   ContainerTitle,
   ContextProvider,
   CopyToClipboard,
+  Editor,
   Errors,
   Form,
   FormWrap,

js/src/views/Accounts/List/list.js

@@ -145,6 +145,8 @@ export default class List extends Component {
       return tagsA.localeCompare(tagsB);
     }
 
+    const reverse = key === 'timestamp' ? -1 : 1;
+
     const metaA = accountA.meta[key];
     const metaB = accountB.meta[key];
 
@@ -152,14 +154,22 @@ export default class List extends Component {
       return 0;
     }
 
-    if ((metaA && !metaB) || (metaA < metaB)) {
+    if (metaA && !metaB) {
       return -1;
     }
 
-    if ((!metaA && metaB) || (metaA > metaB)) {
+    if (metaA < metaB) {
+      return -1 * reverse;
+    }
+
+    if (!metaA && metaB) {
       return 1;
     }
 
+    if (metaA > metaB) {
+      return 1 * reverse;
+    }
+
     return 0;
   }
 

js/src/views/Application/TabBar/tabBar.js

@@ -29,7 +29,8 @@ const TABMAP = {
   accounts: 'account',
   addresses: 'address',
   apps: 'app',
-  contracts: 'contract'
+  contracts: 'contract',
+  deploy: 'contract'
 };
 
 class TabBar extends Component {

js/src/views/Application/application.css

@@ -18,4 +18,6 @@
 .outer,
 .container {
   min-height: 100vh;
+  display: flex;
+  flex-direction: column;
 }

js/src/views/Contract/contract.css

@@ -90,3 +90,12 @@
   margin-bottom: -10px;
   margin-right: 0.5em;
 }
+
+.details {
+  margin-top: -1.5em;
+
+  h4 {
+    text-transform: uppercase;
+    margin: 1.5em 0 1em;
+  }
+}

js/src/views/Contract/contract.js

@@ -20,10 +20,12 @@ import { bindActionCreators } from 'redux';
 import ActionDelete from 'material-ui/svg-icons/action/delete';
 import AvPlayArrow from 'material-ui/svg-icons/av/play-arrow';
 import ContentCreate from 'material-ui/svg-icons/content/create';
+import EyeIcon from 'material-ui/svg-icons/image/remove-red-eye';
+import ContentClear from 'material-ui/svg-icons/content/clear';
 
 import { newError } from '../../redux/actions';
 import { EditMeta, ExecuteContract } from '../../modals';
-import { Actionbar, Button, Page } from '../../ui';
+import { Actionbar, Button, Page, Modal, Editor } from '../../ui';
 
 import Header from '../Account/Header';
 import Delete from '../Address/Delete';
@@ -52,6 +54,7 @@ class Contract extends Component {
     showDeleteDialog: false,
     showEditDialog: false,
     showExecuteDialog: false,
+    showDetailsDialog: false,
     subscriptionId: -1,
     blockSubscriptionId: -1,
     allEvents: [],
@@ -118,11 +121,69 @@ class Contract extends Component {
           <Events
             isTest={ isTest }
             events={ allEvents } />
+
+          { this.renderDetails(account) }
         </Page>
       </div>
     );
   }
 
+  renderDetails (contract) {
+    const { showDetailsDialog } = this.state;
+
+    if (!showDetailsDialog) {
+      return null;
+    }
+
+    const cancelBtn = (
+      <Button
+        icon={ <ContentClear /> }
+        label='Close'
+        onClick={ this.closeDetailsDialog } />
+    );
+
+    return (
+      <Modal
+        actions={ [ cancelBtn ] }
+        title={ 'contract details' }
+        visible
+        scroll
+      >
+        <div className={ styles.details }>
+          { this.renderSource(contract) }
+
+          <div>
+            <h4>Contract ABI</h4>
+            <Editor
+              value={ JSON.stringify(contract.meta.abi, null, 2) }
+              mode='json'
+              maxLines={ 20 }
+              readOnly
+            />
+          </div>
+        </div>
+      </Modal>
+    );
+  }
+
+  renderSource (contract) {
+    const { source } = contract.meta;
+
+    if (!source) {
+      return null;
+    }
+
+    return (
+      <div>
+        <h4>Contract source code</h4>
+        <Editor
+          value={ source }
+          readOnly
+        />
+      </div>
+    );
+  }
+
   renderActionbar (account) {
     const buttons = [
       <Button
@@ -139,7 +200,12 @@ class Contract extends Component {
         key='delete'
         icon={ <ActionDelete /> }
         label='delete contract'
-        onClick={ this.showDeleteDialog } />
+        onClick={ this.showDeleteDialog } />,
+      <Button
+        key='viewDetails'
+        icon={ <EyeIcon /> }
+        label='view details'
+        onClick={ this.showDetailsDialog } />
     ];
 
     return (
@@ -235,6 +301,14 @@ class Contract extends Component {
     this.setState({ showDeleteDialog: true });
   }
 
+  showDetailsDialog = () => {
+    this.setState({ showDetailsDialog: true });
+  }
+
+  closeDetailsDialog = () => {
+    this.setState({ showDetailsDialog: false });
+  }
+
   closeExecuteDialog = () => {
     this.setState({ showExecuteDialog: false });
   }

js/src/views/Contracts/contracts.js

@@ -15,9 +15,11 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 import React, { Component, PropTypes } from 'react';
+import { Link } from 'react-router';
 import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
 import ContentAdd from 'material-ui/svg-icons/content/add';
+import FileIcon from 'material-ui/svg-icons/action/description';
 import { uniq } from 'lodash';
 
 import { Actionbar, ActionbarSearch, ActionbarSort, Button, Page } from '../../ui';
@@ -114,6 +116,15 @@ class Contracts extends Component {
         icon={ <ContentAdd /> }
         label='deploy contract'
         onClick={ this.onDeployContract } />,
+      <Link
+        to='/contracts/write'
+        key='writeContract'
+      >
+        <Button
+          icon={ <FileIcon /> }
+          label='write contract'
+        />
+      </Link>,
 
       this.renderSearchButton(),
       this.renderSortButton()

js/src/views/Dapps/builtin.json

@@ -0,0 +1,43 @@
+[
+  {
+    "id": "0xf9f2d620c2e08f83e45555247146c62185e4ab7cf82a4b9002a265a0d020348f",
+    "url": "basiccoin",
+    "name": "Token Deployment",
+    "description": "Deploy new basic tokens that you are able to send around",
+    "author": "Parity Team <admin@ethcore.io>",
+    "version": "1.0.0"
+  },
+  {
+    "id": "0xd1adaede68d344519025e2ff574650cd99d3830fe6d274c7a7843cdc00e17938",
+    "url": "registry",
+    "name": "Registry",
+    "description": "A global registry of addresses on the network",
+    "author": "Parity Team <admin@ethcore.io>",
+    "version": "1.0.0"
+  },
+  {
+    "id": "0x0a8048117e51e964628d0f2d26342b3cd915248b59bcce2721e1d05f5cfa2208",
+    "url": "tokenreg",
+    "name": "Token Registry",
+    "description": "A registry of transactable tokens on the network",
+    "author": "Parity Team <admin@ethcore.io>",
+    "version": "1.0.0"
+  },
+  {
+    "id": "0xf49089046f53f5d2e5f3513c1c32f5ff57d986e46309a42d2b249070e4e72c46",
+    "url": "signaturereg",
+    "name": "Method Registry",
+    "description": "A registry of method signatures for lookups on transactions",
+    "author": "Parity Team <admin@ethcore.io>",
+    "version": "1.0.0"
+  },
+  {
+    "id": "0x058740ee9a5a3fb9f1cfa10752baec87e09cc45cd7027fd54708271aca300c75",
+    "url": "githubhint",
+    "name": "GitHub Hint",
+    "description": "A mapping of GitHub URLs to hashes for use in contracts as references",
+    "author": "Parity Team <admin@ethcore.io>",
+    "version": "1.0.0",
+    "secure": true
+  }
+]

js/src/views/Dapps/dappsStore.js

@@ -14,69 +14,39 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-import { action, computed, observable } from 'mobx';
+import { action, computed, observable, transaction } from 'mobx';
 
 import Contracts from '../../contracts';
 import { hashToImageUrl } from '../../redux/util';
 
-const builtinApps = [
-  {
-    id: '0xf9f2d620c2e08f83e45555247146c62185e4ab7cf82a4b9002a265a0d020348f',
-    url: 'basiccoin',
-    name: 'Token Deployment',
-    description: 'Deploy new basic tokens that you are able to send around',
-    author: 'Parity Team <admin@ethcore.io>',
-    version: '1.0.0'
-  },
-  {
-    id: '0xd1adaede68d344519025e2ff574650cd99d3830fe6d274c7a7843cdc00e17938',
-    url: 'registry',
-    name: 'Registry',
-    description: 'A global registry of addresses on the network',
-    author: 'Parity Team <admin@ethcore.io>',
-    version: '1.0.0'
-  },
-  {
-    id: '0x0a8048117e51e964628d0f2d26342b3cd915248b59bcce2721e1d05f5cfa2208',
-    url: 'tokenreg',
-    name: 'Token Registry',
-    description: 'A registry of transactable tokens on the network',
-    author: 'Parity Team <admin@ethcore.io>',
-    version: '1.0.0'
-  },
-  {
-    id: '0xf49089046f53f5d2e5f3513c1c32f5ff57d986e46309a42d2b249070e4e72c46',
-    url: 'signaturereg',
-    name: 'Method Registry',
-    description: 'A registry of method signatures for lookups on transactions',
-    author: 'Parity Team <admin@ethcore.io>',
-    version: '1.0.0'
-  },
-  {
-    id: '0x058740ee9a5a3fb9f1cfa10752baec87e09cc45cd7027fd54708271aca300c75',
-    url: 'githubhint',
-    name: 'GitHub Hint',
-    description: 'A mapping of GitHub URLs to hashes for use in contracts as references',
-    author: 'Parity Team <admin@ethcore.io>',
-    version: '1.0.0',
-    secure: true
-  }
-];
+import builtinApps from './builtin.json';
+
+const LS_KEY_HIDDEN = 'hiddenApps';
+const LS_KEY_EXTERNAL = 'externalApps';
 
 export default class DappsStore {
   @observable apps = [];
-  @observable hidden = [];
+  @observable externalApps = [];
+  @observable hiddenApps = [];
   @observable modalOpen = false;
 
   constructor (api) {
     this._api = api;
 
     this._readHiddenApps();
-    this._fetch();
+    this._readExternalApps();
+
+    this._fetchBuiltinApps();
+    this._fetchLocalApps();
+    this._fetchRegistryApps();
   }
 
   @computed get visible () {
-    return this.apps.filter((app) => !this.hidden.includes(app.id));
+    return this.apps
+      .filter((app) => {
+        return this.externalApps.includes(app.id) || !this.hiddenApps.includes(app.id);
+      })
+      .sort((a, b) => a.name.localeCompare(b.name));
   }
 
   @action openModal = () => {
@@ -88,12 +58,12 @@ export default class DappsStore {
   }
 
   @action hideApp = (id) => {
-    this.hidden = this.hidden.concat(id);
+    this.hiddenApps = this.hiddenApps.concat(id);
     this._writeHiddenApps();
   }
 
   @action showApp = (id) => {
-    this.hidden = this.hidden.filter((_id) => _id !== id);
+    this.hiddenApps = this.hiddenApps.filter((_id) => _id !== id);
     this._writeHiddenApps();
   }
 
@@ -103,25 +73,48 @@ export default class DappsStore {
       : '';
   }
 
-  _fetch () {
-    Promise
-      .all([
-        this._fetchLocal(),
-        this._fetchRegistry()
-      ])
-      .then(([localApps, registryApps]) => {
-        this.apps = []
-          .concat(localApps)
-          .concat(registryApps)
-          .filter((app) => app.id)
-          .sort((a, b) => (a.name || '').localeCompare(b.name || ''));
-      })
-      .catch((error) => {
-        console.warn('DappStore:fetch', error);
+  _fetchBuiltinApps () {
+    const { dappReg } = Contracts.get();
+
+    return Promise
+      .all(builtinApps.map((app) => dappReg.getImage(app.id)))
+      .then((imageIds) => {
+        transaction(() => {
+          builtinApps.forEach((app, index) => {
+            app.type = 'builtin';
+            app.image = hashToImageUrl(imageIds[index]);
+            this.apps.push(app);
+          });
+        });
       });
   }
 
-  _fetchRegistry () {
+  _fetchLocalApps () {
+    return fetch(`${this._getHost()}/api/apps`)
+      .then((response) => {
+        return response.ok
+          ? response.json()
+          : [];
+      })
+      .then((apps) => {
+        return apps
+          .map((app) => {
+            app.type = 'local';
+            return app;
+          })
+          .filter((app) => app.id && !['ui'].includes(app.id));
+      })
+      .then((apps) => {
+        transaction(() => {
+          (apps || []).forEach((app) => this.apps.push(app));
+        });
+      })
+      .catch((error) => {
+        console.warn('DappsStore:fetchLocal', error);
+      });
+  }
+
+  _fetchRegistryApps () {
     const { dappReg } = Contracts.get();
 
     return dappReg
@@ -137,9 +130,9 @@ export default class DappsStore {
         return Promise.all(promises);
       })
       .then((appsInfo) => {
-        const appIds = appsInfo.map(([appId, owner]) => {
-          return this._api.util.bytesToHex(appId);
-        });
+        const appIds = appsInfo
+          .map(([appId, owner]) => this._api.util.bytesToHex(appId))
+          .filter((appId) => !builtinApps.find((app) => app.id === appId));
 
         return Promise
           .all([
@@ -149,27 +142,21 @@ export default class DappsStore {
           ])
           .then(([imageIds, contentIds, manifestIds]) => {
             return appIds.map((appId, index) => {
-              const app = builtinApps.find((ba) => ba.id === appId) || {
+              const app = {
                 id: appId,
+                image: hashToImageUrl(imageIds[index]),
                 contentHash: this._api.util.bytesToHex(contentIds[index]).substr(2),
                 manifestHash: this._api.util.bytesToHex(manifestIds[index]).substr(2),
                 type: 'network'
               };
 
-              app.image = hashToImageUrl(imageIds[index]);
-              app.type = app.type || 'builtin';
-
               return app;
             });
           });
       })
       .then((apps) => {
         return Promise
-          .all(apps.map((app) => {
-            return app.manifestHash
-              ? this._fetchManifest(app.manifestHash)
-              : null;
-          }))
+          .all(apps.map((app) => this._fetchManifest(app.manifestHash)))
           .then((manifests) => {
             return apps.map((app, index) => {
               const manifest = manifests[index];
@@ -177,7 +164,7 @@ export default class DappsStore {
               if (manifest) {
                 app.manifestHash = null;
                 Object.keys(manifest)
-                  .filter((key) => key !== 'id')
+                  .filter((key) => ['author', 'description', 'name', 'version'].includes(key))
                   .forEach((key) => {
                     app[key] = manifest[key];
                   });
@@ -192,6 +179,11 @@ export default class DappsStore {
             });
           });
       })
+      .then((apps) => {
+        transaction(() => {
+          (apps || []).forEach((app) => this.apps.push(app));
+        });
+      })
       .catch((error) => {
         console.warn('DappsStore:fetchRegistry', error);
       });
@@ -210,39 +202,43 @@ export default class DappsStore {
       });
   }
 
-  _fetchLocal () {
-    return fetch(`${this._getHost()}/api/apps`)
-      .then((response) => {
-        return response.ok
-          ? response.json()
-          : [];
-      })
-      .then((localApps) => {
-        return localApps
-          .filter((app) => app && app.id && !['ui'].includes(app.id))
-          .map((app) => {
-            app.type = 'local';
-            return app;
-          });
-      })
-      .catch((error) => {
-        console.warn('DappsStore:fetchLocal', error);
-      });
-  }
-
   _readHiddenApps () {
-    const stored = localStorage.getItem('hiddenApps');
+    const stored = localStorage.getItem(LS_KEY_HIDDEN);
 
     if (stored) {
       try {
-        this.hidden = JSON.parse(stored);
+        this.hiddenApps = JSON.parse(stored);
       } catch (error) {
         console.warn('DappsStore:readHiddenApps', error);
       }
     }
   }
 
+  _readExternalApps () {
+    const stored = localStorage.getItem(LS_KEY_EXTERNAL);
+
+    if (stored) {
+      try {
+        this.externalApps = JSON.parse(stored);
+      } catch (error) {
+        console.warn('DappsStore:readExternalApps', error);
+      }
+    }
+  }
+
+  _writeExternalApps () {
+    try {
+      localStorage.setItem(LS_KEY_EXTERNAL, JSON.stringify(this.externalApps));
+    } catch (error) {
+      console.error('DappsStore:writeExternalApps', error);
+    }
+  }
+
   _writeHiddenApps () {
-    localStorage.setItem('hiddenApps', JSON.stringify(this.hidden));
+    try {
+      localStorage.setItem(LS_KEY_HIDDEN, JSON.stringify(this.hiddenApps));
+    } catch (error) {
+      console.error('DappsStore:writeHiddenApps', error);
+    }
   }
 }

js/src/views/WriteContract/index.js

@@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './writeContract';

js/src/views/WriteContract/writeContract.css

@@ -0,0 +1,174 @@
+/* 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/>.
+*/
+.outer, .page, .editor {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+}
+
+.timestamp {
+  font-size: 0.75em;
+  margin-left: 1em;
+  color: #ccc;
+}
+
+.container {
+  padding: 1em 0;
+  display: flex;
+  flex: 1;
+  flex-direction: row;
+
+  > * {
+    margin: 0;
+
+    > h2 {
+      margin-top: 0;
+    }
+  }
+}
+
+.mainEditor {
+  &:global(.ace-solarized-dark) {
+    background-color: rgba(0, 0, 0, 0.5);
+
+    :global(.ace_gutter) {
+      background-color: rgba(0, 0, 0, 0.7);
+    }
+
+    :global(.ace_content) {
+      background-color: transparent;
+    }
+  }
+}
+
+.big {
+  font-size: 1.2em;
+}
+
+.centeredMessage {
+  width: 100%;
+  height: 75%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.resizing * {
+  cursor: ew-resize !important;
+  user-select: none !important;
+}
+
+.editor {
+  width: 0;
+  margin-left: 0.5em;
+}
+
+.parameters {
+  width: 0;
+  display: flex;
+  flex-direction: column;
+  margin-right: 0.5em;
+
+  .panel {
+    background-color: rgba(0, 0, 0, 0.5);
+    padding: 1em;
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .compilation {
+    flex: 1 0 0;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .errors {
+    flex: 1 0 0;
+    overflow: auto;
+    margin-right: -0.5em;
+    margin-top: 0.5em;
+  }
+}
+
+.messageContainer {
+  padding: 0.5em 0;
+  margin-right: 0.5em;
+
+  &:first-child {
+    padding-top: 0;
+  }
+
+  &:last-child {
+    padding-bottom: 0;
+  }
+
+  .errorPosition {
+    background-color: rgba(0, 0, 0, 0.5);
+    padding: 0.25em 0.5em;
+    top: 0;
+    position: relative;
+    margin-bottom: 0.25em;
+    font-size: 0.75em;
+  }
+}
+
+.message {
+  font-family: monospace;
+  padding: 0.5em;
+  font-size: 0.9em;
+  white-space: pre;
+  overflow: auto;
+
+  &.error {
+    background-color: rgba(244, 67, 54, 0.5);
+  }
+
+  &.warning {
+    background-color: rgba(255, 235, 59, 0.5);
+  }
+
+  &.formal {
+    background-color: rgba(243, 156, 18, 0.5);
+  }
+}
+
+.messagesHeader {
+  margin-bottom: 0.25em;
+  text-transform: uppercase;
+  font-size: 0.9em;
+}
+
+.sliderContainer {
+  flex: 0 0 .8em;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  .slider {
+    width: 0.4em;
+    height: 3em;
+    border-radius: 0.75em;
+    background-color: rgba(0, 0, 0, 0.5);
+    content: ' ';
+
+    &:hover {
+      cursor: ew-resize;
+    }
+  }
+}

js/src/views/WriteContract/writeContract.js

@@ -0,0 +1,502 @@
+  // 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/>.
+
+import React, { PropTypes, Component } from 'react';
+import { observer } from 'mobx-react';
+import { MenuItem } from 'material-ui';
+import { connect } from 'react-redux';
+import { bindActionCreators } from 'redux';
+import CircularProgress from 'material-ui/CircularProgress';
+import moment from 'moment';
+
+import ContentClear from 'material-ui/svg-icons/content/clear';
+import SaveIcon from 'material-ui/svg-icons/content/save';
+import ListIcon from 'material-ui/svg-icons/action/view-list';
+import SettingsIcon from 'material-ui/svg-icons/action/settings';
+import SendIcon from 'material-ui/svg-icons/content/send';
+
+import { Actionbar, ActionbarExport, ActionbarImport, Button, Editor, Page, Select, Input } from '../../ui';
+import { DeployContract, SaveContract, LoadContract } from '../../modals';
+
+import { setupWorker } from '../../redux/providers/compilerActions';
+
+import WriteContractStore from './writeContractStore';
+import styles from './writeContract.css';
+
+@observer
+class WriteContract extends Component {
+
+  static propTypes = {
+    accounts: PropTypes.object.isRequired,
+    setupWorker: PropTypes.func.isRequired,
+    worker: PropTypes.object
+  };
+
+  store = new WriteContractStore();
+
+  state = {
+    resizing: false,
+    size: 65
+  };
+
+  componentWillMount () {
+    const { setupWorker, worker } = this.props;
+    setupWorker();
+
+    if (worker) {
+      this.store.setCompiler(worker);
+    }
+  }
+
+  componentDidMount () {
+    this.store.setEditor(this.refs.editor);
+
+    // Wait for editor to be loaded
+    window.setTimeout(() => {
+      this.store.resizeEditor();
+    }, 2000);
+  }
+
+  componentWillReceiveProps (nextProps) {
+    if (!this.props.worker && nextProps.worker) {
+      this.store.setCompiler(nextProps.worker);
+    }
+  }
+
+  render () {
+    const { sourcecode } = this.store;
+    const { size, resizing } = this.state;
+
+    const annotations = this.store.annotations
+      .slice()
+      .filter((a) => a.contract === '');
+
+    return (
+      <div className={ styles.outer }>
+        { this.renderDeployModal() }
+        { this.renderSaveModal() }
+        { this.renderLoadModal() }
+
+        { this.renderActionBar() }
+        <Page className={ styles.page }>
+          <div
+            className={ `${styles.container} ${resizing ? styles.resizing : ''}` }
+            onMouseMove={ this.handleResize }
+            onMouseUp={ this.handleStopResize }
+            onMouseLeave={ this.handleStopResize }
+          >
+            <div
+              className={ styles.editor }
+              style={ { flex: `${size}%` } }
+            >
+              <h2>{ this.renderTitle() }</h2>
+
+              <Editor
+                ref='editor'
+                onChange={ this.store.handleEditSourcecode }
+                onExecute={ this.store.handleCompile }
+                annotations={ annotations }
+                value={ sourcecode }
+                className={ styles.mainEditor }
+              />
+            </div>
+
+            <div className={ styles.sliderContainer }>
+              <span
+                className={ styles.slider }
+                onMouseDown={ this.handleStartResize }
+              >
+              </span>
+            </div>
+
+            <div
+              className={ styles.parameters }
+              style={ { flex: `${100 - size}%` } }
+            >
+              <h2>Parameters</h2>
+              { this.renderParameters() }
+            </div>
+          </div>
+        </Page>
+      </div>
+    );
+  }
+
+  renderTitle () {
+    const { selectedContract } = this.store;
+
+    if (!selectedContract || !selectedContract.name) {
+      return 'New Solidity Contract';
+    }
+
+    return (
+      <span>
+        { selectedContract.name }
+        <span
+          className={ styles.timestamp }
+          title={ `saved @ ${(new Date(selectedContract.timestamp)).toISOString()}` }
+        >
+          (saved { moment(selectedContract.timestamp).fromNow() })
+        </span>
+      </span>
+    );
+  }
+
+  renderActionBar () {
+    const { sourcecode, selectedContract } = this.store;
+
+    const filename = selectedContract && selectedContract.name
+      ? selectedContract.name
+        .replace(/[^a-z0-9]+/gi, '-')
+        .replace(/-$/, '')
+        .toLowerCase()
+      : 'contract.sol';
+
+    const extension = /\.sol$/.test(filename) ? '' : '.sol';
+
+    const buttons = [
+      <Button
+        icon={ <ContentClear /> }
+        label='New'
+        key='newContract'
+        onClick={ this.store.handleNewContract }
+      />,
+      <Button
+        icon={ <ListIcon /> }
+        label='Load'
+        key='loadContract'
+        onClick={ this.store.handleOpenLoadModal }
+      />,
+      <Button
+        icon={ <SaveIcon /> }
+        label='Save'
+        key='saveContract'
+        onClick={ this.store.handleSaveContract }
+      />,
+      <ActionbarExport
+        key='exportSourcecode'
+        content={ sourcecode }
+        filename={ `${filename}${extension}` }
+      />,
+      <ActionbarImport
+        key='importSourcecode'
+        title='Import Solidity code'
+        onConfirm={ this.store.handleImport }
+        renderValidation={ this.renderImportValidation }
+      />
+    ];
+
+    return (
+      <Actionbar
+        title='Write a Contract'
+        buttons={ buttons }
+      />
+    );
+  }
+
+  renderImportValidation = (content) => {
+    return (
+      <Editor
+        readOnly
+        value={ content }
+        maxLines={ 20 }
+      />
+    );
+  }
+
+  renderParameters () {
+    const { compiling, contract, selectedBuild, loading } = this.store;
+
+    if (selectedBuild < 0) {
+      return (
+        <div className={ `${styles.panel} ${styles.centeredMessage}` }>
+          <CircularProgress size={ 80 } thickness={ 5 } />
+          <p>Loading...</p>
+        </div>
+      );
+    }
+
+    if (loading) {
+      const { longVersion } = this.store.builds[selectedBuild];
+
+      return (
+        <div className={ styles.panel }>
+          <div className={ styles.centeredMessage }>
+            <CircularProgress size={ 80 } thickness={ 5 } />
+            <p>Loading Solidity { longVersion }</p>
+          </div>
+        </div>
+      );
+    }
+
+    return (
+      <div className={ styles.panel }>
+        <div>
+          <Button
+            icon={ <SettingsIcon /> }
+            label='Compile'
+            onClick={ this.store.handleCompile }
+            primary={ false }
+            disabled={ compiling }
+          />
+          {
+            contract
+            ? <Button
+              icon={ <SendIcon /> }
+              label='Deploy'
+              onClick={ this.store.handleOpenDeployModal }
+              primary={ false }
+            />
+            : null
+          }
+        </div>
+        { this.renderSolidityVersions() }
+        { this.renderCompilation() }
+      </div>
+    );
+  }
+
+  renderSolidityVersions () {
+    const { builds, selectedBuild } = this.store;
+
+    const buildsList = builds.map((build, index) => (
+      <MenuItem
+        key={ index }
+        value={ index }
+        label={ build.release ? build.version : build.longVersion }
+      >
+        {
+          build.release
+          ? (<span className={ styles.big }>{ build.version }</span>)
+          : build.longVersion
+        }
+      </MenuItem>
+    ));
+
+    return (
+      <div>
+        <Select
+          label='Select a Solidity version'
+          value={ selectedBuild }
+          onChange={ this.store.handleSelectBuild }
+        >
+          { buildsList }
+        </Select>
+      </div>
+    );
+  }
+
+  renderDeployModal () {
+    const { showDeployModal, contract, sourcecode } = this.store;
+
+    if (!showDeployModal) {
+      return null;
+    }
+
+    return (
+      <DeployContract
+        abi={ contract.interface }
+        code={ `0x${contract.bytecode}` }
+        source={ sourcecode }
+        accounts={ this.props.accounts }
+        onClose={ this.store.handleCloseDeployModal }
+        readOnly
+      />
+    );
+  }
+
+  renderLoadModal () {
+    const { showLoadModal } = this.store;
+
+    if (!showLoadModal) {
+      return null;
+    }
+
+    return (
+      <LoadContract
+        onLoad={ this.store.handleLoadContract }
+        onDelete={ this.store.handleDeleteContract }
+        onClose={ this.store.handleCloseLoadModal }
+        contracts={ this.store.savedContracts }
+        snippets={ this.store.snippets }
+      />
+    );
+  }
+
+  renderSaveModal () {
+    const { showSaveModal, sourcecode } = this.store;
+
+    if (!showSaveModal) {
+      return null;
+    }
+
+    return (
+      <SaveContract
+        sourcecode={ sourcecode }
+        onSave={ this.store.handleSaveNewContract }
+        onClose={ this.store.handleCloseSaveModal }
+      />
+    );
+  }
+
+  renderCompilation () {
+    const { compiled, contracts, compiling, contractIndex, contract } = this.store;
+
+    if (compiling) {
+      return (
+        <div className={ styles.centeredMessage }>
+          <CircularProgress size={ 80 } thickness={ 5 } />
+          <p>Compiling...</p>
+        </div>
+      );
+    }
+
+    if (!compiled) {
+      return (
+        <div className={ styles.centeredMessage }>
+          <p>Please compile the source code.</p>
+        </div>
+      );
+    }
+
+    if (!contracts) {
+      return this.renderErrors();
+    }
+
+    const contractKeys = Object.keys(contracts);
+
+    if (contractKeys.length === 0) {
+      return (
+        <div className={ styles.centeredMessage }>
+          <p>No contract has been found.</p>
+        </div>
+      );
+    }
+
+    const contractsList = contractKeys.map((name, index) => (
+      <MenuItem
+        key={ index }
+        value={ index }
+        label={ name }
+      >
+        { name }
+      </MenuItem>
+    ));
+
+    return (
+      <div className={ styles.compilation }>
+        <Select
+          label='Select a contract'
+          value={ contractIndex }
+          onChange={ this.store.handleSelectContract }
+        >
+          { contractsList }
+        </Select>
+        { this.renderContract(contract) }
+
+        <h4 className={ styles.messagesHeader }>Compiler messages</h4>
+        { this.renderErrors() }
+      </div>
+    );
+  }
+
+  renderContract (contract) {
+    const { bytecode } = contract;
+    const abi = contract.interface;
+
+    return (
+      <div>
+        <Input
+          readOnly
+          value={ abi }
+          label='ABI Interface'
+        />
+
+        <Input
+          readOnly
+          value={ `0x${bytecode}` }
+          label='Bytecode'
+        />
+      </div>
+    );
+  }
+
+  renderErrors () {
+    const { annotations } = this.store;
+
+    const body = annotations.map((annotation, index) => {
+      const { text, row, column, contract, type, formal } = annotation;
+      const classType = formal ? 'formal' : type;
+      const classes = [ styles.message, styles[classType] ];
+
+      return (
+        <div key={ index } className={ styles.messageContainer }>
+          <div className={ classes.join(' ') }>{ text }</div>
+          <span className={ styles.errorPosition }>
+            { contract ? `[ ${contract} ]   ` : '' }
+            { row }: { column }
+          </span>
+        </div>
+      );
+    });
+
+    return (
+      <div className={ styles.errors }>
+        { body }
+      </div>
+    );
+  }
+
+  handleStartResize = () => {
+    this.setState({ resizing: true });
+  }
+
+  handleStopResize = () => {
+    this.setState({ resizing: false });
+  }
+
+  handleResize = (event) => {
+    if (!this.state.resizing) {
+      return;
+    }
+
+    const { pageX, currentTarget } = event;
+    const { width, left } = currentTarget.getBoundingClientRect();
+
+    const x = pageX - left;
+
+    this.setState({ size: 100 * x / width });
+    event.stopPropagation();
+  }
+
+}
+
+function mapStateToProps (state) {
+  const { accounts } = state.personal;
+  const { worker } = state.compiler;
+  return { accounts, worker };
+}
+
+function mapDispatchToProps (dispatch) {
+  return bindActionCreators({
+    setupWorker
+  }, dispatch);
+}
+
+export default connect(
+  mapStateToProps,
+  mapDispatchToProps
+)(WriteContract);

js/src/views/WriteContract/writeContractStore.js

@@ -0,0 +1,373 @@
+// 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/>.
+
+import { action, observable } from 'mobx';
+import store from 'store';
+import { debounce } from 'lodash';
+
+const WRITE_CONTRACT_STORE_KEY = '_parity::writeContractStore';
+
+const SNIPPETS = {
+  snippet0: {
+    name: 'Token.sol',
+    description: 'Standard ERP20 Token Contract',
+    id: 'snippet0', sourcecode: require('raw!../../contracts/snippets/token.sol')
+  },
+  snippet1: {
+    name: 'StandardToken.sol',
+    description: 'Implementation of ERP20 Token Contract',
+    id: 'snippet1', sourcecode: require('raw!../../contracts/snippets/standard-token.sol')
+  },
+  snippet2: {
+    name: 'HumanStandardToken.sol',
+    description: 'Implementation of the Human Token Contract',
+    id: 'snippet2', sourcecode: require('raw!../../contracts/snippets/human-standard-token.sol')
+  }
+};
+
+export default class WriteContractStore {
+
+  @observable sourcecode = '';
+
+  @observable compiled = false;
+  @observable compiling = false;
+  @observable loading = true;
+
+  @observable contractIndex = -1;
+  @observable contract = null;
+  @observable contracts = {};
+
+  @observable errors = [];
+  @observable annotations = [];
+
+  @observable builds = [];
+  @observable selectedBuild = -1;
+
+  @observable showDeployModal = false;
+  @observable showSaveModal = false;
+  @observable showLoadModal = false;
+
+  @observable savedContracts = {};
+  @observable selectedContract = {};
+
+  snippets = SNIPPETS;
+
+  constructor () {
+    this.reloadContracts();
+    this.fetchSolidityVersions();
+
+    this.debouncedCompile = debounce(this.handleCompile, 1000);
+  }
+
+  @action setEditor (editor) {
+    this.editor = editor;
+  }
+
+  @action setCompiler (compiler) {
+    this.compiler = compiler;
+
+    this.compiler.onmessage = (event) => {
+      const message = JSON.parse(event.data);
+
+      switch (message.event) {
+        case 'compiled':
+          this.parseCompiled(message.data);
+          break;
+        case 'loading':
+          this.parseLoading(message.data);
+          break;
+        case 'try-again':
+          this.handleCompile();
+          break;
+      }
+    };
+  }
+
+  fetchSolidityVersions () {
+    fetch('https://raw.githubusercontent.com/ethereum/solc-bin/gh-pages/bin/list.json')
+      .then((r) => r.json())
+      .then((data) => {
+        const { builds, releases, latestRelease } = data;
+        let latestIndex = -1;
+
+        this.builds = builds.reverse().map((build, index) => {
+          if (releases[build.version] === build.path) {
+            build.release = true;
+
+            if (build.version === latestRelease) {
+              build.latest = true;
+              this.loadSolidityVersion(build);
+              latestIndex = index;
+            }
+          }
+
+          return build;
+        });
+
+        this.selectedBuild = latestIndex;
+      });
+  }
+
+  @action closeWorker = () => {
+    this.compiler.postMessage(JSON.stringify({
+      action: 'close'
+    }));
+  }
+
+  @action handleImport = (sourcecode) => {
+    this.reloadContracts(-1, sourcecode);
+  }
+
+  @action handleSelectBuild = (_, index, value) => {
+    this.selectedBuild = value;
+    this.loadSolidityVersion(this.builds[value]);
+  }
+
+  @action loadSolidityVersion = (build) => {
+    this.compiler.postMessage(JSON.stringify({
+      action: 'load',
+      data: build
+    }));
+  }
+
+  @action handleOpenDeployModal = () => {
+    this.showDeployModal = true;
+  }
+
+  @action handleCloseDeployModal = () => {
+    this.showDeployModal = false;
+  }
+
+  @action handleOpenLoadModal = () => {
+    this.showLoadModal = true;
+  }
+
+  @action handleCloseLoadModal = () => {
+    this.showLoadModal = false;
+  }
+
+  @action handleOpenSaveModal = () => {
+    this.showSaveModal = true;
+  }
+
+  @action handleCloseSaveModal = () => {
+    this.showSaveModal = false;
+  }
+
+  @action handleSelectContract = (_, index, value) => {
+    this.contractIndex = value;
+    this.contract = this.contracts[Object.keys(this.contracts)[value]];
+  }
+
+  @action handleCompile = () => {
+    this.compiled = false;
+    this.compiling = true;
+
+    const build = this.builds[this.selectedBuild];
+
+    if (this.compiler && typeof this.compiler.postMessage === 'function') {
+      this.sendFilesToWorker();
+
+      this.compiler.postMessage(JSON.stringify({
+        action: 'compile',
+        data: {
+          sourcecode: this.sourcecode,
+          build: build
+        }
+      }));
+    }
+  }
+
+  parseErrors = (data, formal = false) => {
+    const regex = /^(.*):(\d+):(\d+):\s*([a-z]+):\s*((.|[\r\n])+)$/i;
+
+    return (data || [])
+      .filter((e) => regex.test(e))
+      .map((error, index) => {
+        const match = regex.exec(error);
+
+        const contract = match[1];
+        const row = parseInt(match[2]) - 1;
+        const column = parseInt(match[3]);
+
+        const type = formal ? 'warning' : match[4].toLowerCase();
+        const text = match[5];
+
+        return {
+          contract,
+          row, column,
+          type, text,
+          formal
+        };
+      });
+  }
+
+  @action parseCompiled = (data) => {
+    const { contracts } = data;
+
+    const { errors = [] } = data;
+    const errorAnnotations = this.parseErrors(errors);
+    const formalAnnotations = this.parseErrors(data.formal && data.formal.errors, true);
+
+    const annotations = [].concat(
+      errorAnnotations,
+      formalAnnotations
+    );
+
+    if (annotations.findIndex((a) => /__parity_tryAgain/.test(a.text)) > -1) {
+      return;
+    }
+
+    const contractKeys = Object.keys(contracts || {});
+
+    this.contract = contractKeys.length ? contracts[contractKeys[0]] : null;
+    this.contractIndex = contractKeys.length ? 0 : -1;
+
+    this.contracts = contracts;
+    this.errors = errors;
+    this.annotations = annotations;
+
+    this.compiled = true;
+    this.compiling = false;
+  }
+
+  @action parseLoading = (isLoading) => {
+    this.loading = isLoading;
+
+    if (!isLoading) {
+      this.handleCompile();
+    }
+  }
+
+  @action handleEditSourcecode = (value, compile = false) => {
+    this.sourcecode = value;
+
+    const localStore = store.get(WRITE_CONTRACT_STORE_KEY) || {};
+    store.set(WRITE_CONTRACT_STORE_KEY, {
+      ...localStore,
+      current: value
+    });
+
+    if (compile) {
+      this.handleCompile();
+    } else {
+      this.debouncedCompile();
+    }
+  }
+
+  @action handleSaveContract = () => {
+    if (this.selectedContract && this.selectedContract.id !== undefined) {
+      return this.handleSaveNewContract({
+        ...this.selectedContract,
+        sourcecode: this.sourcecode
+      });
+    }
+
+    return this.handleOpenSaveModal();
+  }
+
+  getId (contracts) {
+    return Object.values(contracts)
+      .map((c) => c.id)
+      .reduce((max, id) => Math.max(max, id), 0) + 1;
+  }
+
+  @action handleSaveNewContract = (data) => {
+    const { name, sourcecode, id } = data;
+
+    const localStore = store.get(WRITE_CONTRACT_STORE_KEY) || {};
+    const savedContracts = localStore.saved || {};
+    const cId = (id !== undefined)
+      ? id
+      : this.getId(savedContracts);
+
+    store.set(WRITE_CONTRACT_STORE_KEY, {
+      ...localStore,
+      saved: {
+        ...savedContracts,
+        [ cId ]: { sourcecode, id: cId, name, timestamp: Date.now() }
+      }
+    });
+
+    this.reloadContracts(cId);
+  }
+
+  @action reloadContracts = (id, sourcecode) => {
+    const localStore = store.get(WRITE_CONTRACT_STORE_KEY) || {};
+    this.savedContracts = localStore.saved || {};
+
+    const cId = id !== undefined ? id : localStore.currentId;
+
+    this.selectedContract = this.savedContracts[cId] || {};
+    this.sourcecode = sourcecode !== undefined
+      ? sourcecode
+      : this.selectedContract.sourcecode || localStore.current || '';
+
+    store.set(WRITE_CONTRACT_STORE_KEY, {
+      ...localStore,
+      currentId: this.selectedContract ? cId : null,
+      current: this.sourcecode
+    });
+
+    this.handleCompile();
+    this.resizeEditor();
+  }
+
+  @action handleLoadContract = (contract) => {
+    const { sourcecode, id } = contract;
+    this.reloadContracts(id, sourcecode);
+  }
+
+  @action handleDeleteContract = (id) => {
+    const localStore = store.get(WRITE_CONTRACT_STORE_KEY) || {};
+
+    const savedContracts = Object.assign({}, localStore.saved || {});
+
+    if (savedContracts[id]) {
+      delete savedContracts[id];
+    }
+
+    store.set(WRITE_CONTRACT_STORE_KEY, {
+      ...localStore,
+      saved: savedContracts
+    });
+
+    this.reloadContracts();
+  }
+
+  @action handleNewContract = () => {
+    this.reloadContracts(-1, '');
+  }
+
+  @action resizeEditor = () => {
+    try {
+      this.editor.refs.brace.editor.resize();
+    } catch (e) {}
+  }
+
+  sendFilesToWorker = () => {
+    const files = [].concat(
+      Object.values(this.snippets),
+      Object.values(this.savedContracts)
+    );
+
+    this.compiler.postMessage(JSON.stringify({
+      action: 'setFiles',
+      data: files
+    }));
+  }
+
+}

js/src/views/index.js

@@ -21,6 +21,7 @@ import Addresses from './Addresses';
 import Application from './Application';
 import Contract from './Contract';
 import Contracts from './Contracts';
+import WriteContract from './WriteContract';
 import Dapp from './Dapp';
 import Dapps from './Dapps';
 import ParityBar from './ParityBar';
@@ -36,6 +37,7 @@ export {
   Application,
   Contract,
   Contracts,
+  WriteContract,
   Dapp,
   Dapps,
   ParityBar,

parity/helpers.rs

@@ -279,17 +279,18 @@ pub fn execute_upgrades(
 /// Prompts user asking for password.
 pub fn password_prompt() -> Result<String, String> {
 	use rpassword::read_password;
+	const STDIN_ERROR: &'static str = "Unable to ask for password on non-interactive terminal.";
 
 	println!("Please note that password is NOT RECOVERABLE.");
 	print!("Type password: ");
 	flush_stdout();
 
-	let password = read_password().unwrap();
+	let password = try!(read_password().map_err(|_| STDIN_ERROR.to_owned()));
 
 	print!("Repeat password: ");
 	flush_stdout();
 
-	let password_repeat = read_password().unwrap();
+	let password_repeat = try!(read_password().map_err(|_| STDIN_ERROR.to_owned()));
 
 	if password != password_repeat {
 		return Err("Passwords do not match!".into());
@@ -314,7 +315,7 @@ pub fn passwords_from_files(files: Vec<String>) -> Result<Vec<String>, String> {
 		let file = try!(File::open(filename).map_err(|_| format!("{} Unable to read password file. Ensure it exists and permissions are correct.", filename)));
 		let reader = BufReader::new(&file);
 		let lines = reader.lines()
-			.map(|l| l.unwrap())
+			.filter_map(|l| l.ok())
 			.collect::<Vec<String>>();
 		Ok(lines)
 		}).collect::<Result<Vec<Vec<String>>, String>>();

sync/src/sync_io.rs

@@ -22,7 +22,7 @@ use ethcore::header::BlockNumber;
 use ethcore::snapshot::SnapshotService;
 use parking_lot::RwLock;
 
-/// IO interface for the syning handler.
+/// IO interface for the syncing handler.
 /// Provides peer connection management and an interface to the blockchain client.
 // TODO: ratings
 pub trait SyncIo {
@@ -70,7 +70,7 @@ pub struct NetSyncIo<'s, 'h> where 'h: 's {
 
 impl<'s, 'h> NetSyncIo<'s, 'h> {
 	/// Creates a new instance from the `NetworkContext` and the blockchain client reference.
-	pub fn new(network: &'s NetworkContext<'h>, 
+	pub fn new(network: &'s NetworkContext<'h>,
 		chain: &'s BlockChainClient,
 		snapshot_service: &'s SnapshotService,
 		chain_overlay: &'s RwLock<HashMap<BlockNumber, Bytes>>) -> NetSyncIo<'s, 'h> {

util/fetch/src/lib.rs

@@ -26,4 +26,4 @@ extern crate rand;
 pub mod client;
 pub mod fetch_file;
 
-pub use self::client::{Client, Fetch, FetchError, FetchResult};
+pub use self::client::{Client, Fetch, FetchError, FetchResult};