Remove TransactionOutcome

Since Invoice has TransactionOutcome only, there is no reason that TransactionOutcome exists.

Author: Seulgi Kim

core/src/blockchain/extras.rs

@@ -275,31 +275,18 @@ pub struct EpochTransitions {
 
 #[cfg(test)]
 mod tests {
- use super::super::super::invoice::TransactionOutcome;
  use super::*;
  use rlp::{Encodable, UntrustedRlp};
 
  #[test]
  fn rlp_encode_and_decode_parcel_invoices() {
  let invoices = vec![
- Invoice {
- outcome: TransactionOutcome::Success,
- },
- Invoice {
- outcome: TransactionOutcome::Success,
- },
- Invoice {
- outcome: TransactionOutcome::Failed,
- },
- Invoice {
- outcome: TransactionOutcome::Success,
- },
- Invoice {
- outcome: TransactionOutcome::Success,
- },
- Invoice {
- outcome: TransactionOutcome::Success,
- },
+ Invoice::Success,
+ Invoice::Success,
+ Invoice::Failed,
+ Invoice::Success,
+ Invoice::Success,
+ Invoice::Success,
  ];
  let parcel_invoices = ParcelInvoices {
  invoices,
@@ -312,14 +299,7 @@ mod tests {
 
  #[test]
  fn rlp_encode_and_decode_block_invoices() {
- let invoices = vec![
- Invoice {
- outcome: TransactionOutcome::Success,
- },
- Invoice {
- outcome: TransactionOutcome::Failed,
- },
- ];
+ let invoices = vec![Invoice::Success, Invoice::Failed];
  let parcel_invoices = ParcelInvoices {
  invoices,
  };

core/src/invoice.rs

@@ -18,45 +18,26 @@ use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
 /// Information describing execution of a parcel.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Invoice {
- /// Transaction outcome.
- pub outcome: TransactionOutcome,
-}
-
-/// Transaction outcome store in the invoice.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum TransactionOutcome {
+pub enum Invoice {
  Success,
  Failed,
 }
 
-impl Invoice {
- /// Create a new invocie.
- pub fn new(outcome: TransactionOutcome) -> Self {
- Self {
- outcome,
- }
- }
-}
-
 impl Encodable for Invoice {
  fn rlp_append(&self, s: &mut RlpStream) {
- match self.outcome {
- TransactionOutcome::Success => s.append(&1u8),
- TransactionOutcome::Failed => s.append(&0u8),
+ match self {
+ Invoice::Success => s.append(&1u8),
+ Invoice::Failed => s.append(&0u8),
  };
  }
 }
 
 impl Decodable for Invoice {
  fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
- let outcome = match rlp.as_val::<u8>()? {
- 1 => TransactionOutcome::Success,
- 0 => TransactionOutcome::Failed,
+ Ok(match rlp.as_val::<u8>()? {
+ 1 => Invoice::Success,
+ 0 => Invoice::Failed,
  _ => return Err(DecoderError::Custom("Invalid parcel outcome")),
- };
- Ok(Self {
- outcome,
  })
  }
 }

core/src/state/mod.rs

@@ -32,7 +32,7 @@ use trie::{self, Trie, TrieError, TrieFactory};
 use unexpected::Mismatch;
 
 use self::cache::Cache;
-use super::invoice::{Invoice, TransactionOutcome};
+use super::invoice::Invoice;
 use super::parcel::ParcelError;
 use super::state_db::StateDB;
 use super::{Transaction, TransactionError};
@@ -535,7 +535,7 @@ impl<B: Backend> State<B> {
  Ok(_) => {
  cinfo!(TX, "Tx({}) is applied", t.hash());
  self.discard_checkpoint(TRANSACTION_CHECKPOINT);
- let invoice = Invoice::new(TransactionOutcome::Success);
+ let invoice = Invoice::Success;
  let error = None;
  ApplyOutcome {
  invoice,
@@ -545,7 +545,7 @@ impl<B: Backend> State<B> {
  Err(Error::Transaction(err)) => {
  cinfo!(TX, "Cannot apply Tx({}): {:?}", t.hash(), err);
  self.revert_to_checkpoint(TRANSACTION_CHECKPOINT);
- let invoice = Invoice::new(TransactionOutcome::Failed);
+ let invoice = Invoice::Failed;
  let error = Some(err);
  ApplyOutcome {
  invoice,
@@ -885,7 +885,7 @@ mod tests {
  let res = state.apply(&signed_parcel).unwrap();
  assert_eq!(1, res.len());
  let res = &res[0];
- assert_eq!(res.invoice.outcome, TransactionOutcome::Success);
+ assert_eq!(res.invoice, Invoice::Success);
  assert!(res.error.is_none());
  assert_eq!(state.balance(&receiver).unwrap(), 10.into());
  assert_eq!(state.balance(&sender).unwrap(), 5.into());
@@ -918,7 +918,7 @@ mod tests {
  let res = state.apply(&signed_parcel).unwrap();
  assert_eq!(1, res.len());
  let res = &res[0];
- assert_eq!(res.invoice.outcome, TransactionOutcome::Success);
+ assert_eq!(res.invoice, Invoice::Success);
  assert_eq!(state.regular_key(&sender).unwrap(), Some(key));
  }
 
@@ -947,7 +947,7 @@ mod tests {
  let res = state.apply(&signed_parcel).unwrap();
  assert_eq!(1, res.len());
  let res = &res[0];
- assert_eq!(res.invoice.outcome, TransactionOutcome::Failed);
+ assert_eq!(res.invoice, Invoice::Failed);
  assert_eq!(
  res.error.as_ref().unwrap(),
  &TransactionError::InsufficientBalance {