Add error information to the invoice

Author: majecty

core/src/block.rs

@@ -20,9 +20,9 @@ use ccrypto::BLAKE_NULL_RLP;
 use ckey::Address;
 use cmerkle::skewed_merkle_root;
 use cstate::{StateDB, StateError, StateWithCache, TopLevelState};
-use ctypes::invoice::{Invoice, ParcelInvoice};
+use ctypes::invoice::ParcelInvoice;
 use ctypes::machine::{LiveBlock, Parcels};
-use ctypes::parcel::{Error as ParcelError, Outcome as ParcelOutcome};
+use ctypes::parcel::Error as ParcelError;
 use ctypes::util::unexpected::Mismatch;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
@@ -153,23 +153,11 @@ impl<'x> OpenBlock<'x> {
             return Err(StateError::Parcel(ParcelError::ParcelAlreadyImported).into())
         }
 
-        let outcomes = self.block.state.apply(&parcel, parcel.sender(), &parcel.public_key())?;
+        let invoice = self.block.state.apply(&parcel, parcel.sender(), &parcel.public_key())?;
 
         self.block.parcels_set.insert(h.unwrap_or_else(|| parcel.hash()));
         self.block.parcels.push(parcel.into());
-        match outcomes {
-            ParcelOutcome::Single {
-                invoice,
-                ..
-            } => {
-                self.block.invoices.push(ParcelInvoice::Single(invoice));
-            }
-            ParcelOutcome::Transactions(invoices) => {
-                self.block
-                    .invoices
-                    .push(invoices.into_iter().map(|outcome| outcome.invoice).collect::<Vec<Invoice>>().into());
-            }
-        }
+        self.block.invoices.push(invoice);
         Ok(())
     }
 
@@ -208,7 +196,7 @@ impl<'x> OpenBlock<'x> {
         self.block.header.set_state_root(self.block.state.root().clone());
         self.block.header.set_invoices_root(skewed_merkle_root(
             parent_invoices_root,
-            self.block.invoices.iter().flat_map(|invoices| invoices.iter().map(|invoice| invoice.rlp_bytes())),
+            self.block.invoices.iter().flat_map(|invoices| invoices.iter_result().map(|invoice| invoice.rlp_bytes())),
         ));
 
         ClosedBlock {
@@ -235,7 +223,10 @@ impl<'x> OpenBlock<'x> {
         if self.block.header.invoices_root().is_zero() || self.block.header.invoices_root() == &BLAKE_NULL_RLP {
             self.block.header.set_invoices_root(skewed_merkle_root(
                 parent_invoices_root,
-                self.block.invoices.iter().flat_map(|invoices| invoices.iter().map(|invoice| invoice.rlp_bytes())),
+                self.block
+                    .invoices
+                    .iter()
+                    .flat_map(|invoices| invoices.iter_result().map(|invoice| invoice.rlp_bytes())),
             ));
         }
         self.block.header.set_state_root(self.block.state.root().clone());

core/src/client/client.rs

@@ -58,8 +58,8 @@ use super::super::views::{BlockView, HeaderView};
 use super::{
     AccountData, AssetClient, Balance, BlockChain as BlockChainTrait, BlockChainClient, BlockChainInfo, BlockInfo,
     BlockProducer, ChainInfo, ChainNotify, ClientConfig, DatabaseClient, EngineClient, EngineInfo,
-    Error as ClientError, ExecuteClient, ImportBlock, ImportResult, ImportSealedBlock, Invoice, MiningBlockChainClient,
-    Nonce, ParcelInfo, PrepareOpenBlock, RegularKey, ReopenBlock, Shard, StateOrBlock, TransactionInfo,
+    Error as ClientError, ExecuteClient, ImportBlock, ImportResult, ImportSealedBlock, MiningBlockChainClient, Nonce,
+    ParcelInfo, PrepareOpenBlock, RegularKey, ReopenBlock, Shard, StateOrBlock, TransactionInfo, TransactionInvoice,
 };
 
 const MAX_MEM_POOL_SIZE: usize = 4096;
@@ -492,14 +492,15 @@ impl BlockChainClient for Client {
         self.transaction_address(id).and_then(|address| chain.transaction(&address))
     }
 
-    fn transaction_invoice(&self, id: TransactionId) -> Option<Invoice> {
+    fn transaction_invoice(&self, id: TransactionId) -> Option<TransactionInvoice> {
         self.transaction_address(id).and_then(|transaction_address| {
             let parcel_address = transaction_address.parcel_address.clone();
             let parcel_id = parcel_address.into();
 
             self.parcel_invoice(parcel_id).and_then(|parcel_invoice| match parcel_invoice {
                 ParcelInvoice::Multiple(invoices) => invoices.get(transaction_address.index).cloned(),
-                ParcelInvoice::Single(_) => None,
+                ParcelInvoice::SingleSuccess => None,
+                ParcelInvoice::SingleFail(_) => None,
             })
         })
     }

core/src/client/mod.rs

@@ -33,7 +33,7 @@ use ckey::{Address, Public};
 use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{ActionHandler, Asset, AssetScheme, AssetSchemeAddress, TopStateInfo};
-use ctypes::invoice::{Invoice, ParcelInvoice};
+use ctypes::invoice::{ParcelInvoice, TransactionInvoice};
 use ctypes::parcel::ChangeShard;
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
@@ -216,7 +216,7 @@ pub trait BlockChainClient: Sync + Send + AccountData + BlockChain + ImportBlock
     /// Get the transaction with given hash.
     fn transaction(&self, id: TransactionId) -> Option<Transaction>;
 
-    fn transaction_invoice(&self, id: TransactionId) -> Option<Invoice>;
+    fn transaction_invoice(&self, id: TransactionId) -> Option<TransactionInvoice>;
 
     fn custom_handlers(&self) -> Vec<Arc<ActionHandler>>;
 }

core/src/client/test_client.rs

@@ -39,7 +39,7 @@ use ckey::{Address, Generator, Random};
 use cmerkle::skewed_merkle_root;
 use cnetwork::NodeId;
 use cstate::{ActionHandler, StateDB};
-use ctypes::invoice::ParcelInvoice;
+use ctypes::invoice::{ParcelInvoice, TransactionInvoice};
 use ctypes::parcel::{Action, Parcel};
 use ctypes::transaction::Transaction;
 use ctypes::BlockNumber;
@@ -55,7 +55,7 @@ use super::super::blockchain_info::BlockChainInfo;
 use super::super::client::ImportResult;
 use super::super::client::{
     AccountData, Balance, BlockChain, BlockChainClient, BlockInfo, BlockProducer, BlockStatus, ChainInfo, ImportBlock,
-    ImportSealedBlock, Invoice, MiningBlockChainClient, Nonce, ParcelInfo, PrepareOpenBlock, ReopenBlock, StateOrBlock,
+    ImportSealedBlock, MiningBlockChainClient, Nonce, ParcelInfo, PrepareOpenBlock, ReopenBlock, StateOrBlock,
     TransactionInfo,
 };
 use super::super::db::{COL_STATE, NUM_COLUMNS};
@@ -512,7 +512,7 @@ impl BlockChainClient for TestBlockChainClient {
         unimplemented!();
     }
 
-    fn transaction_invoice(&self, _id: TransactionId) -> Option<Invoice> {
+    fn transaction_invoice(&self, _id: TransactionId) -> Option<TransactionInvoice> {
         unimplemented!()
     }
 

rpc/src/v1/impls/chain.rs

@@ -22,7 +22,7 @@ use ccore::{
 };
 use ckey::{Address, Public};
 use cstate::{Asset, AssetScheme, AssetSchemeAddress};
-use ctypes::invoice::{Invoice, ParcelInvoice};
+use ctypes::invoice::{ParcelInvoice, TransactionInvoice};
 use ctypes::parcel::{Action, ChangeShard};
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
@@ -99,7 +99,7 @@ where
         Ok(self.client.transaction(transaction_hash.into()))
     }
 
-    fn get_transaction_invoice(&self, transaction_hash: H256) -> Result<Option<Invoice>> {
+    fn get_transaction_invoice(&self, transaction_hash: H256) -> Result<Option<TransactionInvoice>> {
         Ok(self.client.transaction_invoice(transaction_hash.into()))
     }
 

rpc/src/v1/traits/chain.rs

@@ -16,7 +16,7 @@
 
 use ckey::{Address, Public};
 use cstate::{Asset, AssetScheme};
-use ctypes::invoice::{Invoice, ParcelInvoice};
+use ctypes::invoice::{ParcelInvoice, TransactionInvoice};
 use ctypes::parcel::ChangeShard;
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
@@ -46,7 +46,7 @@ build_rpc_trait! {
 
         /// Gets transaction invoice with given hash.
         # [rpc(name = "chain_getTransactionInvoice")]
-        fn get_transaction_invoice(&self, H256) -> Result<Option<Invoice>>;
+        fn get_transaction_invoice(&self, H256) -> Result<Option<TransactionInvoice>>;
 
         /// Gets asset scheme with given transaction hash.
         # [rpc(name = "chain_getAssetSchemeByHash")]

state/src/action_handler/hit.rs

@@ -16,8 +16,7 @@
 
 use ccrypto::blake256;
 use cmerkle::TrieMut;
-use ctypes::invoice::Invoice;
-use ctypes::parcel::Outcome;
+use ctypes::invoice::ParcelInvoice;
 use primitives::{Bytes, H256};
 use rlp::{self, Decodable, DecoderError, Encodable, UntrustedRlp};
 
@@ -72,15 +71,12 @@ impl ActionHandler for HitHandler {
     }
 
     /// `bytes` must be valid encoding of HitAction
-    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<Outcome>> {
+    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<ParcelInvoice>> {
         HitAction::decode(&UntrustedRlp::new(bytes)).ok().map(|action| {
             let prev_counter: u32 = rlp::decode(&state.action_data(&self.address())?);
             let increase = action.increase as u32;
             state.update_action_data(&self.address(), (prev_counter + increase).rlp_bytes().to_vec())?;
-            Ok(Outcome::Single {
-                invoice: Invoice::Success,
-                error: None,
-            })
+            Ok(ParcelInvoice::SingleSuccess)
         })
     }
 }

state/src/action_handler/mod.rs

@@ -17,15 +17,15 @@
 mod hit;
 
 use cmerkle::TrieMut;
-use ctypes::parcel::Outcome;
+use ctypes::invoice::ParcelInvoice;
 use primitives::Bytes;
 
 use super::{StateResult, TopLevelState};
 
 pub trait ActionHandler: Send + Sync {
     fn init(&self, state: &mut TrieMut) -> StateResult<()>;
     fn is_target(&self, bytes: &Bytes) -> bool;
-    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<Outcome>>;
+    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<ParcelInvoice>>;
 }
 
 pub use self::hit::HitHandler;