merge with master

ethcore/src/builtin.rs

@@ -127,14 +127,14 @@ impl Impl for EcRecover {
 		let s = H256::from_slice(&input[96..128]);
 
 		let bit = match v[31] {
-			27 | 28 if &v.as_slice()[..31] == &[0; 31] => v[31] - 27,
+			27 | 28 if &v.0[..31] == &[0; 31] => v[31] - 27,
 			_ => return,
 		};
 
 		let s = Signature::from_rsv(&r, &s, bit);
 		if s.is_valid() {
 			if let Ok(p) = ec_recover(&s, &hash) {
-				let r = p.as_slice().sha3();
+				let r = p.sha3();
 
 				let out_len = min(output.len(), 32);
 

ethcore/src/error.rs

@@ -28,7 +28,7 @@ use ethkey::Error as EthkeyError;
 
 pub use types::executed::{ExecutionError, CallError};
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 /// Errors concerning transaction processing.
 pub enum TransactionError {
 	/// Transaction is already imported to the queue
@@ -87,7 +87,7 @@ impl fmt::Display for TransactionError {
 	}
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Clone, Copy, Eq)]
 /// Errors concerning block processing.
 pub enum BlockError {
 	/// Block has too many uncles.
@@ -185,7 +185,7 @@ impl fmt::Display for BlockError {
 	}
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 /// Import to the block queue result
 pub enum ImportError {
 	/// Already in the block chain.

ethcore/src/evm/interpreter/gasometer.rs

@@ -76,7 +76,7 @@ impl<Gas: CostType> Gasometer<Gas> {
 			instructions::SSTORE => {
 				let address = H256::from(stack.peek(0));
 				let newval = stack.peek(1);
-				let val = U256::from(ext.storage_at(&address).as_slice());
+				let val = U256::from(&*ext.storage_at(&address));
 
 				let gas = if val.is_zero() && !newval.is_zero() {
 					schedule.sstore_set_gas

ethcore/src/evm/interpreter/mod.rs

@@ -403,18 +403,18 @@ impl<Cost: CostType> Interpreter<Cost> {
 				let offset = stack.pop_back();
 				let size = stack.pop_back();
 				let sha3 = self.mem.read_slice(offset, size).sha3();
-				stack.push(U256::from(sha3.as_slice()));
+				stack.push(U256::from(&*sha3));
 			},
 			instructions::SLOAD => {
 				let key = H256::from(&stack.pop_back());
-				let word = U256::from(ext.storage_at(&key).as_slice());
+				let word = U256::from(&*ext.storage_at(&key));
 				stack.push(word);
 			},
 			instructions::SSTORE => {
 				let address = H256::from(&stack.pop_back());
 				let val = stack.pop_back();
 
-				let current_val = U256::from(ext.storage_at(&address).as_slice());
+				let current_val = U256::from(&*ext.storage_at(&address));
 				// Increase refund for clear
 				if !self.is_zero(&current_val) && self.is_zero(&val) {
 					ext.inc_sstore_clears();
@@ -491,7 +491,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 			instructions::BLOCKHASH => {
 				let block_number = stack.pop_back();
 				let block_hash = ext.blockhash(&block_number);
-				stack.push(U256::from(block_hash.as_slice()));
+				stack.push(U256::from(&*block_hash));
 			},
 			instructions::COINBASE => {
 				stack.push(address_to_u256(ext.env_info().author.clone()));
@@ -807,7 +807,7 @@ fn u256_to_address(value: &U256) -> Address {
 
 #[inline]
 fn address_to_u256(value: Address) -> U256 {
-	U256::from(H256::from(value).as_slice())
+	U256::from(&*H256::from(value))
 }
 
 #[test]

ethcore/src/pod_account.rs

@@ -58,7 +58,7 @@ impl PodAccount {
 		let mut stream = RlpStream::new_list(4);
 		stream.append(&self.nonce);
 		stream.append(&self.balance);
-		stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), rlp::encode(&U256::from(v.as_slice())).to_vec())).collect()));
+		stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), rlp::encode(&U256::from(&**v)).to_vec())).collect()));
 		stream.append(&self.code.as_ref().unwrap_or(&vec![]).sha3());
 		stream.out()
 	}
@@ -72,7 +72,7 @@ impl PodAccount {
 		let mut r = H256::new();
 		let mut t = SecTrieDBMut::new(db, &mut r);
 		for (k, v) in &self.storage {
-			if let Err(e) = t.insert(k, &rlp::encode(&U256::from(v.as_slice()))) {
+			if let Err(e) = t.insert(k, &rlp::encode(&U256::from(&**v))) {
 				warn!("Encountered potential DB corruption: {}", e);
 			}
 		}

ethcore/src/spec/spec.rs

@@ -232,7 +232,7 @@ impl Spec {
 			{
 				let mut t = SecTrieDBMut::new(db, &mut root);
 				for (address, account) in self.genesis_state.get().iter() {
-					try!(t.insert(address.as_slice(), &account.rlp()));
+					try!(t.insert(&**address, &account.rlp()));
 				}
 			}
 			for (address, account) in self.genesis_state.get().iter() {

ethcore/src/state/account.rs

@@ -288,7 +288,7 @@ impl Account {
 				// so we can call overloaded `to_bytes` method
 				let res = match v.is_zero() {
 					true => t.remove(k),
-					false => t.insert(k, &encode(&U256::from(v.as_slice()))),
+					false => t.insert(k, &encode(&U256::from(&*v))),
 				};
 
 				if let Err(e) = res {

ethcore/src/types/account_diff.rs

@@ -98,12 +98,10 @@ impl AccountDiff {
 
 // TODO: refactor into something nicer.
 fn interpreted_hash(u: &H256) -> String {
-	use util::bytes::*;
-
 	if u <= &H256::from(0xffffffff) {
-		format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u32(), U256::from(u.as_slice()).low_u32())
+		format!("{} = 0x{:x}", U256::from(&**u).low_u32(), U256::from(&**u).low_u32())
 	} else if u <= &H256::from(u64::max_value()) {
-		format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u64(), U256::from(u.as_slice()).low_u64())
+		format!("{} = 0x{:x}", U256::from(&**u).low_u64(), U256::from(&**u).low_u64())
 //	} else if u <= &H256::from("0xffffffffffffffffffffffffffffffffffffffff") {
 //		format!("@{}", Address::from(u))
 	} else {
@@ -113,7 +111,7 @@ fn interpreted_hash(u: &H256) -> String {
 
 impl fmt::Display for AccountDiff {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		use util::bytes::*;
+		use util::bytes::ToPretty;
 
 		match self.nonce {
 			Diff::Born(ref x) => try!(write!(f, "  non {}", x)),

ethcore/src/types/transaction_import.rs

@@ -18,9 +18,8 @@
 
 use ipc::binary::{BinaryConvertError, BinaryConvertable};
 use error::{TransactionError, Error};
-use util::Populatable;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 /// Represents the result of importing transaction.
 pub enum TransactionImportResult {
 	/// Transaction was imported to current queue.