Modified the chain to include only successful transactions

Author: Seulgi Kim

core/src/block.rs

@@ -21,13 +21,13 @@ use ckey::Address;
 use cmerkle::skewed_merkle_root;
 use cstate::{FindActionHandler, StateDB, StateError, StateWithCache, TopLevelState};
 use ctypes::errors::HistoryError;
-use ctypes::invoice::Invoice;
 use ctypes::machine::{LiveBlock, Transactions};
 use ctypes::util::unexpected::Mismatch;
 use cvm::ChainTimeInfo;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
+use super::invoice::Invoice;
 use crate::consensus::CodeChainEngine;
 use crate::error::{BlockError, Error};
 use crate::header::{Header, Seal};
@@ -174,12 +174,26 @@ impl<'x> OpenBlock<'x> {
             return Err(HistoryError::TransactionAlreadyImported.into())
         }
 
-        let invoice = self.block.state.apply(&tx, &tx.hash(), &tx.signer_public(), client)?;
-
-        self.block.transactions_set.insert(h.unwrap_or_else(|| tx.hash()));
-        self.block.transactions.push(tx);
-        self.block.invoices.push(invoice);
-        Ok(())
+        let hash = tx.hash();
+        let tracker = tx.tracker();
+        let error = match self.block.state.apply(&tx, &hash, &tx.signer_public(), client) {
+            Ok(()) => {
+                self.block.transactions_set.insert(h.unwrap_or(hash));
+                self.block.transactions.push(tx);
+                None
+            }
+            Err(err) => Some(err),
+        };
+        self.block.invoices.push(Invoice {
+            hash,
+            tracker,
+            error: error.clone().map(|err| err.to_string()),
+        });
+
+        match error {
+            None => Ok(()),
+            Some(err) => Err(err.into()),
+        }
     }
 
     /// Push transactions onto the block.
@@ -204,7 +218,7 @@ impl<'x> OpenBlock<'x> {
     }
 
     /// Turn this into a `ClosedBlock`.
-    pub fn close(mut self, parent_transactions_root: H256, parent_results_root: H256) -> Result<ClosedBlock, Error> {
+    pub fn close(mut self, parent_transactions_root: H256) -> Result<ClosedBlock, Error> {
         let unclosed_state = self.block.state.clone();
 
         if let Err(e) = self.engine.on_close_block(&mut self.block) {
@@ -220,10 +234,6 @@ impl<'x> OpenBlock<'x> {
             self.block.transactions.iter().map(|e| e.rlp_bytes()),
         ));
         self.block.header.set_state_root(state_root);
-        self.block.header.set_results_root(skewed_merkle_root(
-            parent_results_root,
-            self.block.invoices.iter().map(|invoice| invoice.to_bool().rlp_bytes()),
-        ));
 
         Ok(ClosedBlock {
             block: self.block,
@@ -232,11 +242,7 @@ impl<'x> OpenBlock<'x> {
     }
 
     /// Turn this into a `LockedBlock`.
-    pub fn close_and_lock(
-        mut self,
-        parent_transactions_root: H256,
-        parent_results_root: H256,
-    ) -> Result<LockedBlock, Error> {
+    pub fn close_and_lock(mut self, parent_transactions_root: H256) -> Result<LockedBlock, Error> {
         if let Err(e) = self.engine.on_close_block(&mut self.block) {
             warn!("Encountered error on closing the block: {}", e);
             return Err(e)
@@ -256,16 +262,6 @@ impl<'x> OpenBlock<'x> {
             self.block.header.transactions_root(),
             &skewed_merkle_root(parent_transactions_root, self.block.transactions.iter().map(Encodable::rlp_bytes),)
         );
-        if self.block.header.results_root().is_zero() || self.block.header.results_root() == &BLAKE_NULL_RLP {
-            self.block.header.set_results_root(skewed_merkle_root(
-                parent_results_root,
-                self.block.invoices.iter().map(|i| i.to_bool().rlp_bytes()),
-            ));
-        }
-        debug_assert_eq!(
-            self.block.header.results_root(),
-            &skewed_merkle_root(parent_results_root, self.block.invoices.iter().map(|i| i.to_bool().rlp_bytes()),)
-        );
         self.block.header.set_state_root(state_root);
 
         Ok(LockedBlock {
@@ -449,7 +445,7 @@ pub fn enact<C: ChainTimeInfo + FindActionHandler>(
     b.populate_from(header);
     b.push_transactions(transactions, client)?;
 
-    b.close_and_lock(*parent.transactions_root(), *parent.results_root())
+    b.close_and_lock(*parent.transactions_root())
 }
 
 #[cfg(test)]
@@ -466,8 +462,7 @@ mod tests {
         let db = scheme.ensure_genesis_state(get_temp_state_db()).unwrap();
         let b = OpenBlock::try_new(&*scheme.engine, db, &genesis_header, Address::default(), vec![], false).unwrap();
         let parent_transactions_root = *genesis_header.transactions_root();
-        let parent_results_root = *genesis_header.results_root();
-        let b = b.close_and_lock(parent_transactions_root, parent_results_root).unwrap();
+        let b = b.close_and_lock(parent_transactions_root).unwrap();
         let _ = b.seal(&*scheme.engine, vec![]);
     }
 }

core/src/blockchain/blockchain.rs

@@ -17,7 +17,6 @@
 use std::mem;
 use std::sync::Arc;
 
-use ctypes::invoice::{BlockInvoices, Invoice};
 use ctypes::BlockNumber;
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
@@ -26,7 +25,7 @@ use rlp::RlpStream;
 
 use super::block_info::BestBlockChanged;
 use super::body_db::{BodyDB, BodyProvider};
-use super::extras::{BlockDetails, EpochTransitions, TransactionAddress, TransactionAddresses, EPOCH_KEY_PREFIX};
+use super::extras::{BlockDetails, EpochTransitions, TransactionAddress, EPOCH_KEY_PREFIX};
 use super::headerchain::{HeaderChain, HeaderProvider};
 use super::invoice_db::{InvoiceDB, InvoiceProvider};
 use super::route::{tree_route, ImportRoute};
@@ -35,6 +34,7 @@ use crate::consensus::epoch::{PendingTransition as PendingEpochTransition, Trans
 use crate::consensus::CodeChainEngine;
 use crate::db::{self, Readable, Writable};
 use crate::encoded;
+use crate::invoice::Invoice;
 use crate::transaction::LocalizedTransaction;
 use crate::views::{BlockView, HeaderView};
 
@@ -146,7 +146,9 @@ impl BlockChain {
         self.headerchain.insert_header(batch, &new_header, engine);
         self.body_db.insert_body(batch, &new_block);
         self.body_db.update_best_block(batch, &best_block_changed);
-        self.invoice_db.insert_invoice(batch, &new_block_hash, invoices);
+        for invoice in invoices {
+            self.invoice_db.insert_invoice(batch, invoice.hash, invoice.tracker, invoice.error);
+        }
 
         if let Some(best_block_hash) = best_block_changed.new_best_hash() {
             let mut pending_best_block_hash = self.pending_best_block_hash.write();
@@ -563,8 +565,8 @@ impl BodyProvider for BlockChain {
         self.body_db.transaction_address(hash)
     }
 
-    fn transaction_addresses_by_tracker(&self, tracker: &H256) -> Option<TransactionAddresses> {
-        self.body_db.transaction_addresses_by_tracker(tracker)
+    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress> {
+        self.body_db.transaction_address_by_tracker(tracker)
     }
 
     fn block_body(&self, hash: &H256) -> Option<encoded::Body> {
@@ -574,18 +576,16 @@ impl BodyProvider for BlockChain {
 
 impl InvoiceProvider for BlockChain {
     /// Returns true if invoices for given hash is known
-    fn is_known_invoice(&self, hash: &H256) -> bool {
-        self.invoice_db.is_known_invoice(hash)
+    fn is_known_error_hint(&self, hash: &H256) -> bool {
+        self.invoice_db.is_known_error_hint(hash)
     }
 
-    /// Get invoices of block with given hash.
-    fn block_invoices(&self, hash: &H256) -> Option<BlockInvoices> {
-        self.invoice_db.block_invoices(hash)
+    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)> {
+        self.invoice_db.error_hints_by_tracker(tracker)
     }
 
-    /// Get transaction invoice.
-    fn invoice(&self, address: &TransactionAddress) -> Option<Invoice> {
-        self.invoice_db.invoice(address)
+    fn error_hint(&self, hash: &H256) -> Option<String> {
+        self.invoice_db.error_hint(hash)
     }
 }
 

core/src/blockchain/body_db.rs

@@ -283,7 +283,7 @@ pub trait BodyProvider {
     /// Get the address of parcel with given hash.
     fn transaction_address(&self, hash: &H256) -> Option<TransactionAddress>;
 
-    fn transaction_addresses_by_tracker(&self, tracker: &H256) -> Option<TransactionAddresses>;
+    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress>;
 
     /// Get the block body (uncles and parcels).
     fn block_body(&self, hash: &H256) -> Option<encoded::Body>;
@@ -300,8 +300,9 @@ impl BodyProvider for BodyDB {
         Some(result)
     }
 
-    fn transaction_addresses_by_tracker(&self, tracker: &H256) -> Option<TransactionAddresses> {
-        Some(self.db.read_with_cache(db::COL_EXTRA, &mut *self.transaction_address_cache.lock(), tracker)?)
+    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress> {
+        let addresses = self.db.read_with_cache(db::COL_EXTRA, &mut *self.transaction_address_cache.lock(), tracker)?;
+        addresses.into_iter().next()
     }
 
     /// Get block body data

core/src/blockchain/extras.rs

@@ -17,7 +17,6 @@
 use std::io::Write;
 use std::ops::{self, Add, AddAssign, Deref, Sub, SubAssign};
 
-use ctypes::invoice::BlockInvoices;
 use ctypes::BlockNumber;
 use kvdb::PREFIX_LEN as DB_PREFIX_LEN;
 use primitives::{H256, H264, U256};
@@ -37,12 +36,10 @@ enum ExtrasIndex {
     ParcelAddress = 2,
     /// Transaction address index
     TransactionAddress = 3,
-    /// Block invoices index
-    BlockInvoices = 4,
     /// Epoch transition data index.
-    EpochTransitions = 5,
+    EpochTransitions = 4,
     /// Pending epoch transition data index.
-    PendingEpochTransition = 6,
+    PendingEpochTransition = 5,
 }
 
 fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
@@ -93,14 +90,6 @@ impl Key<TransactionAddress> for H256 {
     }
 }
 
-impl Key<BlockInvoices> for H256 {
-    type Target = H264;
-
-    fn key(&self) -> H264 {
-        with_index(self, ExtrasIndex::BlockInvoices)
-    }
-}
-
 impl Key<TransactionAddresses> for H256 {
     type Target = H264;