Fixed receipt serialization and RPC

ethcore/light/src/on_demand/request.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 use ethcore::basic_account::BasicAccount;
 use ethcore::encoded;
 use ethcore::engines::{Engine, StateDependentProof};
-use ethcore::receipt::Receipt;
+use ethcore::receipt::{Receipt, TransactionOutcome};
 use ethcore::state::{self, ProvedExecution};
 use ethcore::transaction::SignedTransaction;
 use vm::EnvInfo;
@@ -973,8 +973,7 @@ mod tests {
 	#[test]
 	fn check_receipts() {
 		let receipts = (0..5).map(|_| Receipt {
-			state_root: Some(H256::random()),
-			status_code: None,
+			outcome: TransactionOutcome::StateRoot(H256::random()),
 			gas_used: 21_000u64.into(),
 			log_bloom: Default::default(),
 			logs: Vec::new(),

ethcore/light/src/types/request/mod.rs

@@ -1739,13 +1739,15 @@ mod tests {
 
 	#[test]
 	fn receipts_roundtrip() {
+		use ethcore::receipt::{Receipt, TransactionOutcome};
 		let req = IncompleteReceiptsRequest {
 			hash: Field::Scalar(Default::default()),
 		};
 
 		let full_req = Request::Receipts(req.clone());
+		let receipt = Receipt::new(TransactionOutcome::Unknown, Default::default(), Vec::new());
 		let res = ReceiptsResponse {
-			receipts: vec![Default::default(), Default::default()],
+			receipts: vec![receipt.clone(), receipt],
 		};
 		let full_res = Response::Receipts(res.clone());
 
@@ -1900,14 +1902,15 @@ mod tests {
 
 	#[test]
 	fn responses_vec() {
+		use ethcore::receipt::{Receipt, TransactionOutcome};
 		let mut stream = RlpStream::new_list(2);
 				stream.begin_list(0).begin_list(0);
 
 		let body = ::ethcore::encoded::Body::new(stream.out());
 		let reqs = vec![
 			Response::Headers(HeadersResponse { headers: vec![] }),
 			Response::HeaderProof(HeaderProofResponse { proof: vec![], hash: Default::default(), td: 100.into()}),
-			Response::Receipts(ReceiptsResponse { receipts: vec![Default::default()] }),
+			Response::Receipts(ReceiptsResponse { receipts: vec![Receipt::new(TransactionOutcome::Unknown, Default::default(), Vec::new())] }),
 			Response::Body(BodyResponse { body: body }),
 			Response::Account(AccountResponse {
 				proof: vec![],

ethcore/src/block.rs

@@ -35,7 +35,7 @@ use engines::Engine;
 use error::{Error, BlockError, TransactionError};
 use factory::Factories;
 use header::Header;
-use receipt::Receipt;
+use receipt::{Receipt, TransactionOutcome};
 use state::State;
 use state_db::StateDB;
 use trace::FlatTrace;
@@ -533,7 +533,7 @@ impl LockedBlock {
 	pub fn strip_receipts(self) -> LockedBlock {
 		let mut block = self;
 		for receipt in &mut block.block.receipts {
-			receipt.state_root = None;
+			receipt.outcome = TransactionOutcome::Unknown;
 		}
 		block.block.header.set_receipts_root(ordered_trie_root(block.block.receipts.iter().map(|r| r.rlp_bytes().into_vec())));
 		block

ethcore/src/blockchain/blockchain.rs

@@ -1481,7 +1481,7 @@ mod tests {
 	use hash::keccak;
 	use util::kvdb::KeyValueDB;
 	use bigint::hash::*;
-	use receipt::Receipt;
+	use receipt::{Receipt, TransactionOutcome};
 	use blockchain::{BlockProvider, BlockChain, Config, ImportRoute};
 	use tests::helpers::*;
 	use blockchain::generator::{ChainGenerator, ChainIterator, BlockFinalizer};
@@ -2048,8 +2048,7 @@ mod tests {
 		let db = new_db();
 		let bc = new_chain(&genesis, db.clone());
 		insert_block(&db, &bc, &b1, vec![Receipt {
-			state_root: Some(H256::default()),
-			status_code: None,
+			outcome: TransactionOutcome::StateRoot(H256::default()),
 			gas_used: 10_000.into(),
 			log_bloom: Default::default(),
 			logs: vec![
@@ -2058,8 +2057,7 @@ mod tests {
 			],
 		},
 		Receipt {
-			state_root: Some(H256::default()),
-			status_code: None,
+			outcome: TransactionOutcome::StateRoot(H256::default()),
 			gas_used: 10_000.into(),
 			log_bloom: Default::default(),
 			logs: vec![
@@ -2068,8 +2066,7 @@ mod tests {
 		}]);
 		insert_block(&db, &bc, &b2, vec![
 			Receipt {
-				state_root: Some(H256::default()),
-				status_code: None,
+				outcome: TransactionOutcome::StateRoot(H256::default()),
 				gas_used: 10_000.into(),
 				log_bloom: Default::default(),
 				logs: vec![

ethcore/src/client/client.rs

@@ -2054,7 +2054,7 @@ fn transaction_receipt(engine: &Engine, mut tx: LocalizedTransaction, mut receip
 			log_index: no_of_logs + i,
 		}).collect(),
 		log_bloom: receipt.log_bloom,
-		state_root: receipt.state_root,
+		outcome: receipt.outcome,
 	}
 }
 
@@ -2100,7 +2100,7 @@ mod tests {
 		use super::transaction_receipt;
 		use ethkey::KeyPair;
 		use log_entry::{LogEntry, LocalizedLogEntry};
-		use receipt::{Receipt, LocalizedReceipt};
+		use receipt::{Receipt, LocalizedReceipt, TransactionOutcome};
 		use transaction::{Transaction, LocalizedTransaction, Action};
 		use tests::helpers::TestEngine;
 
@@ -2111,7 +2111,7 @@ mod tests {
 
 		let block_number = 1;
 		let block_hash = 5.into();
-		let state_root = Some(99.into());
+		let state_root = 99.into();
 		let gas_used = 10.into();
 		let raw_tx = Transaction {
 			nonce: 0.into(),
@@ -2139,14 +2139,12 @@ mod tests {
 			data: vec![],
 		}];
 		let receipts = vec![Receipt {
-			state_root: state_root,
-			status_code: None,
+			outcome: TransactionOutcome::StateRoot(state_root),
 			gas_used: 5.into(),
 			log_bloom: Default::default(),
 			logs: vec![logs[0].clone()],
 		}, Receipt {
-			state_root: state_root,
-			status_code: None,
+			outcome: TransactionOutcome::StateRoot(state_root),
 			gas_used: gas_used,
 			log_bloom: Default::default(),
 			logs: logs.clone(),
@@ -2182,7 +2180,7 @@ mod tests {
 				log_index: 2,
 			}],
 			log_bloom: Default::default(),
-			state_root: state_root,
+			outcome: TransactionOutcome::StateRoot(state_root),
 		});
 	}
 }

ethcore/src/client/test_client.rs

@@ -42,7 +42,7 @@ use db::{NUM_COLUMNS, COL_STATE};
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
-use receipt::{Receipt, LocalizedReceipt};
+use receipt::{Receipt, LocalizedReceipt, TransactionOutcome};
 use blockchain::extras::BlockReceipts;
 use error::{ImportResult, Error as EthcoreError};
 use evm::{Factory as EvmFactory, VMType};
@@ -618,8 +618,7 @@ impl BlockChainClient for TestBlockChainClient {
 		// starts with 'f' ?
 		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
 			let receipt = BlockReceipts::new(vec![Receipt::new(
-				Some(H256::zero()),
-				None,
+				TransactionOutcome::StateRoot(H256::zero()),
 				U256::zero(),
 				vec![])]);
 			let mut rlp = RlpStream::new();

ethcore/src/miner/miner.rs

@@ -1022,7 +1022,7 @@ impl MinerService for Miner {
 							},
 							logs: receipt.logs.clone(),
 							log_bloom: receipt.log_bloom,
-							state_root: receipt.state_root,
+							outcome: receipt.outcome.clone(),
 						}
 					})
 			}

ethcore/src/state/mod.rs

@@ -26,7 +26,7 @@ use std::fmt;
 use std::sync::Arc;
 use hash::{KECCAK_NULL_RLP, KECCAK_EMPTY};
 
-use receipt::Receipt;
+use receipt::{Receipt, TransactionOutcome};
 use engines::Engine;
 use vm::EnvInfo;
 use error::Error;
@@ -699,21 +699,19 @@ impl<B: Backend> State<B> {
 			eip658 ||
 			(env_info.number >= engine.params().eip98_transition && env_info.number >= engine.params().validate_receipts_transition);
 
-		let state_root = if no_intermediate_commits {
-			None
+		let outcome = if no_intermediate_commits {
+			if eip658 {
+				TransactionOutcome::StatusCode(if e.exception.is_some() { 0 } else { 1 })
+			} else {
+				TransactionOutcome::Unknown
+			}
 		} else {
 			self.commit()?;
-			Some(self.root().clone())
-		};
-
-		let status_byte = if eip658 {
-			Some(if e.exception.is_some() { 0 } else { 1 })
-		} else {
-			None
+			TransactionOutcome::StateRoot(self.root().clone())
 		};
 
 		let output = e.output;
-		let receipt = Receipt::new(state_root, status_byte, e.cumulative_gas_used, e.logs);
+		let receipt = Receipt::new(outcome, e.cumulative_gas_used, e.logs);
 		trace!(target: "state", "Transaction receipt: {:?}", receipt);
 
 		Ok(ApplyOutcome {