Transaction writeset store

chain/api/src/message.rs

@@ -14,6 +14,7 @@ use starcoin_types::{
     transaction::Transaction,
 };
 use starcoin_vm_types::access_path::AccessPath;
+use starcoin_vm_types::write_set::WriteSet;
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Clone, Debug)]
@@ -60,6 +61,7 @@ pub enum ChainRequest {
         access_path: Option<AccessPath>,
     },
     GetBlockInfos(Vec<HashValue>),
+    GetTransactionWriteSet(HashValue),
 }
 
 impl ServiceRequest for ChainRequest {
@@ -88,4 +90,5 @@ pub enum ChainResponse {
     HashVec(Vec<HashValue>),
     TransactionProof(Box<Option<TransactionInfoWithProof>>),
     BlockInfoVec(Box<Vec<Option<BlockInfo>>>),
+    TransactionWriteSet(Option<WriteSet>),
 }

chain/api/src/service.rs

@@ -15,6 +15,7 @@ use starcoin_types::{
     startup_info::StartupInfo,
 };
 use starcoin_vm_types::access_path::AccessPath;
+use starcoin_vm_types::write_set::WriteSet;
 
 /// Readable block chain service trait
 pub trait ReadableChainService {
@@ -72,6 +73,8 @@ pub trait ReadableChainService {
     ) -> Result<Option<TransactionInfoWithProof>>;
 
     fn get_block_infos(&self, ids: Vec<HashValue>) -> Result<Vec<Option<BlockInfo>>>;
+
+    fn get_transaction_write_set(&self, hash: HashValue) -> Result<Option<WriteSet>>;
 }
 
 /// Writeable block chain service trait
@@ -139,6 +142,8 @@ pub trait ChainAsyncService:
     ) -> Result<Option<TransactionInfoWithProof>>;
 
     async fn get_block_infos(&self, hashes: Vec<HashValue>) -> Result<Vec<Option<BlockInfo>>>;
+
+    async fn get_transaction_write_set(&self, hash: HashValue) -> Result<Option<WriteSet>>;
 }
 
 #[async_trait::async_trait]
@@ -436,4 +441,15 @@ where
             bail!("get block_infos error")
         }
     }
+
+    async fn get_transaction_write_set(&self, hash: HashValue) -> Result<Option<WriteSet>> {
+        let response = self
+            .send(ChainRequest::GetTransactionWriteSet(hash))
+            .await??;
+        if let ChainResponse::TransactionWriteSet(write_set) = response {
+            Ok(write_set)
+        } else {
+            bail!("get get_write_set error")
+        }
+    }
 }

chain/service/src/chain_service.rs

@@ -27,6 +27,7 @@ use starcoin_types::{
 };
 use starcoin_vm_runtime::metrics::VMMetrics;
 use starcoin_vm_types::access_path::AccessPath;
+use starcoin_vm_types::write_set::WriteSet;
 use std::sync::Arc;
 
 /// A Chain reader service to provider Reader API.
@@ -232,6 +233,9 @@ impl ServiceHandler<Self, ChainRequest> for ChainReaderService {
             ChainRequest::GetBlockInfos(ids) => Ok(ChainResponse::BlockInfoVec(Box::new(
                 self.inner.get_block_infos(ids)?,
             ))),
+            ChainRequest::GetTransactionWriteSet(hash) => Ok(ChainResponse::TransactionWriteSet(
+                self.inner.get_transaction_write_set(hash)?,
+            )),
         }
     }
 }
@@ -416,6 +420,10 @@ impl ReadableChainService for ChainReaderServiceInner {
     fn get_block_infos(&self, ids: Vec<HashValue>) -> Result<Vec<Option<BlockInfo>>> {
         self.storage.get_block_infos(ids)
     }
+
+    fn get_transaction_write_set(&self, hash: HashValue) -> Result<Option<WriteSet>> {
+        self.storage.get_write_set(hash)
+    }
 }
 
 #[cfg(test)]

chain/src/chain.rs

@@ -463,6 +463,7 @@ impl BlockChain {
         let block_id = block.id();
         let txn_infos = executed_data.txn_infos;
         let txn_events = executed_data.txn_events;
+        let txn_write_set = executed_data.txn_write_sets;
 
         debug_assert!(
             txn_events.len() == txn_infos.len(),
@@ -505,6 +506,10 @@ impl BlockChain {
 
         storage.save_block_info(block_info.clone())?;
 
+        for (hash_value, write_set) in txn_write_set.iter() {
+            storage.save_write_set(*hash_value, write_set.clone())?;
+        }
+
         watch(CHAIN_WATCH_NAME, "n26");
         Ok(ExecutedBlock { block, block_info })
     }

executor/src/block_executor.rs

@@ -9,12 +9,14 @@ use starcoin_types::transaction::TransactionStatus;
 use starcoin_types::transaction::{Transaction, TransactionInfo};
 use starcoin_vm_runtime::metrics::VMMetrics;
 use starcoin_vm_types::contract_event::ContractEvent;
+use starcoin_vm_types::write_set::WriteSet;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct BlockExecutedData {
     pub state_root: HashValue,
     pub txn_infos: Vec<TransactionInfo>,
     pub txn_events: Vec<Vec<ContractEvent>>,
+    pub txn_write_sets: Vec<(HashValue, WriteSet)>,
 }
 
 impl Default for BlockExecutedData {
@@ -23,6 +25,7 @@ impl Default for BlockExecutedData {
             state_root: HashValue::zero(),
             txn_events: vec![],
             txn_infos: vec![],
+            txn_write_sets: vec![],
         }
     }
 }
@@ -53,12 +56,13 @@ pub fn block_execute<S: ChainStateReader + ChainStateWriter>(
             }
             TransactionStatus::Keep(status) => {
                 chain_state
-                    .apply_write_set(write_set)
+                    .apply_write_set(write_set.clone())
                     .map_err(BlockExecutorError::BlockChainStateErr)?;
 
                 let txn_state_root = chain_state
                     .commit()
                     .map_err(BlockExecutorError::BlockChainStateErr)?;
+
                 #[cfg(testing)]
                 info!("txn_hash {} gas_used {}", txn_hash, gas_used);
                 executed_data.txn_infos.push(TransactionInfo::new(
@@ -68,7 +72,11 @@ pub fn block_execute<S: ChainStateReader + ChainStateWriter>(
                     gas_used,
                     status,
                 ));
+
                 executed_data.txn_events.push(events);
+
+                // Put write set into result
+                executed_data.txn_write_sets.push((txn_hash, write_set));
             }
         };
     }