Allow an optional config struct for all trace calls

Author: sorpaas

src/rpc/mod.rs

@@ -121,6 +121,14 @@ pub struct RPCTrace {
     pub struct_logs: Vec<RPCStep>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct RPCTraceConfig {
+    pub disable_memory: bool,
+    pub disable_stack: bool,
+    pub disable_storage: bool,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct RPCBlockTrace {
@@ -134,11 +142,11 @@ pub struct RPCStep {
     pub error: String,
     pub gas: Hex<Gas>,
     pub gas_cost: Hex<Gas>,
-    pub memory: Vec<Hex<M256>>,
     pub op: u8,
     pub pc: usize,
-    pub stack: Vec<Hex<M256>>,
-    pub storage: HashMap<Hex<U256>, Hex<M256>>,
+    pub memory: Option<Vec<Hex<M256>>>,
+    pub stack: Option<Vec<Hex<M256>>>,
+    pub storage: Option<HashMap<Hex<U256>, Hex<M256>>>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -260,15 +268,20 @@ build_rpc_trait! {
         #[rpc(name = "debug_getBlockRlp")]
         fn block_rlp(&self, usize) -> Result<Bytes, Error>;
         #[rpc(name = "debug_traceTransaction")]
-        fn trace_transaction(&self, Hex<H256>) -> Result<RPCTrace, Error>;
+        fn trace_transaction(&self, Hex<H256>, Trailing<RPCTraceConfig>)
+                             -> Result<RPCTrace, Error>;
         #[rpc(name = "debug_traceBlock")]
-        fn trace_block(&self, Bytes) -> Result<RPCBlockTrace, Error>;
+        fn trace_block(&self, Bytes, Trailing<RPCTraceConfig>)
+                       -> Result<RPCBlockTrace, Error>;
         #[rpc(name = "debug_traceBlockByNumber")]
-        fn trace_block_by_number(&self, usize) -> Result<RPCBlockTrace, Error>;
+        fn trace_block_by_number(&self, usize, Trailing<RPCTraceConfig>)
+                                 -> Result<RPCBlockTrace, Error>;
         #[rpc(name = "debug_traceBlockByHash")]
-        fn trace_block_by_hash(&self, Hex<H256>) -> Result<RPCBlockTrace, Error>;
+        fn trace_block_by_hash(&self, Hex<H256>, Trailing<RPCTraceConfig>)
+                               -> Result<RPCBlockTrace, Error>;
         #[rpc(name = "debug_traceBlockFromFile")]
-        fn trace_block_from_file(&self, String) -> Result<RPCBlockTrace, Error>;
+        fn trace_block_from_file(&self, String, Trailing<RPCTraceConfig>)
+                                 -> Result<RPCBlockTrace, Error>;
         #[rpc(name = "debug_dumpBlock")]
         fn dump_block(&self, usize) -> Result<RPCDump, Error>;
     }

src/rpc/serves.rs

@@ -1,4 +1,4 @@
-use super::{EthereumRPC, DebugRPC, Either, RPCTransaction, RPCTrace, RPCStep, RPCBlock, RPCLog, RPCReceipt, RPCLogFilter, RPCBlockTrace, RPCDump, RPCDumpAccount};
+use super::{EthereumRPC, DebugRPC, Either, RPCTransaction, RPCTrace, RPCStep, RPCBlock, RPCLog, RPCReceipt, RPCLogFilter, RPCBlockTrace, RPCDump, RPCDumpAccount, RPCTraceConfig};
 use super::util::*;
 use super::filter::*;
 use super::serialize::*;
@@ -574,7 +574,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         Ok(Bytes(rlp::encode(&block).to_vec()))
     }
 
-    fn trace_transaction(&self, hash: Hex<H256>) -> Result<RPCTrace, Error> {
+    fn trace_transaction(&self, hash: Hex<H256>, config: Trailing<RPCTraceConfig>) -> Result<RPCTrace, Error> {
+        let config = config.unwrap_or(RPCTraceConfig::default());
         let state = self.state.lock().unwrap();
 
         let transaction = state.get_transaction_by_hash(hash.0)?;
@@ -592,7 +593,7 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
             }
         }
 
-        let (steps, vm) = replay_transaction::<P>(&stateful, transaction, &block, &last_hashes)?;
+        let (steps, vm) = replay_transaction::<P>(&stateful, transaction, &block, &last_hashes, &config)?;
 
         let gas = Hex(vm.real_used_gas());
         let return_value = Bytes(vm.out().into());
@@ -603,7 +604,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         })
     }
 
-    fn trace_block(&self, block_rlp: Bytes) -> Result<RPCBlockTrace, Error> {
+    fn trace_block(&self, block_rlp: Bytes, config: Trailing<RPCTraceConfig>) -> Result<RPCBlockTrace, Error> {
+        let config = config.unwrap_or(RPCTraceConfig::default());
         let state = self.state.lock().unwrap();
         let block: Block = UntrustedRlp::new(&block_rlp.0).as_val()?;
         let last_hashes = state.get_last_256_block_hashes_by_number(block.header.number.as_usize());
@@ -612,7 +614,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         let mut steps = Vec::new();
         for transaction in block.transactions.clone() {
             let (mut local_steps, vm) = replay_transaction::<P>(&stateful, transaction,
-                                                                &block, &last_hashes)?;
+                                                                &block, &last_hashes,
+                                                                &config)?;
             steps.append(&mut local_steps);
             let mut accounts = Vec::new();
             for account in vm.accounts() {
@@ -626,7 +629,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         })
     }
 
-    fn trace_block_by_number(&self, number: usize) -> Result<RPCBlockTrace, Error> {
+    fn trace_block_by_number(&self, number: usize, config: Trailing<RPCTraceConfig>) -> Result<RPCBlockTrace, Error> {
+        let config = config.unwrap_or(RPCTraceConfig::default());
         let state = self.state.lock().unwrap();
         if number > state.block_height() {
             return Err(Error::NotFound);
@@ -638,7 +642,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         let mut steps = Vec::new();
         for transaction in block.transactions.clone() {
             let (mut local_steps, vm) = replay_transaction::<P>(&stateful, transaction,
-                                                                &block, &last_hashes)?;
+                                                                &block, &last_hashes,
+                                                                &config)?;
             steps.append(&mut local_steps);
             let mut accounts = Vec::new();
             for account in vm.accounts() {
@@ -652,7 +657,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         })
     }
 
-    fn trace_block_by_hash(&self, hash: Hex<H256>) -> Result<RPCBlockTrace, Error> {
+    fn trace_block_by_hash(&self, hash: Hex<H256>, config: Trailing<RPCTraceConfig>) -> Result<RPCBlockTrace, Error> {
+        let config = config.unwrap_or(RPCTraceConfig::default());
         let state = self.state.lock().unwrap();
         let block: Block = state.get_block_by_hash(hash.0)?;
         let last_hashes = state.get_last_256_block_hashes_by_number(block.header.number.as_usize());
@@ -661,7 +667,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         let mut steps = Vec::new();
         for transaction in block.transactions.clone() {
             let (mut local_steps, vm) = replay_transaction::<P>(&stateful, transaction,
-                                                                &block, &last_hashes)?;
+                                                                &block, &last_hashes,
+                                                                &config)?;
             steps.append(&mut local_steps);
             let mut accounts = Vec::new();
             for account in vm.accounts() {
@@ -675,10 +682,11 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         })
     }
 
-    fn trace_block_from_file(&self, path: String) -> Result<RPCBlockTrace, Error> {
+    fn trace_block_from_file(&self, path: String, config: Trailing<RPCTraceConfig>) -> Result<RPCBlockTrace, Error> {
         use std::fs::File;
         use std::io::Read;
 
+        let config = config.unwrap_or(RPCTraceConfig::default());
         let mut file = File::open(path).unwrap();
         let mut buffer = Vec::new();
         file.read_to_end(&mut buffer).unwrap();
@@ -691,7 +699,8 @@ impl<P: 'static + Patch + Send> DebugRPC for MinerDebugRPC<P> {
         let mut steps = Vec::new();
         for transaction in block.transactions.clone() {
             let (mut local_steps, vm) = replay_transaction::<P>(&stateful, transaction,
-                                                                &block, &last_hashes)?;
+                                                                &block, &last_hashes,
+                                                                &config)?;
             steps.append(&mut local_steps);
             let mut accounts = Vec::new();
             for account in vm.accounts() {

src/rpc/util.rs

@@ -1,4 +1,4 @@
-use super::{EthereumRPC, Either, RPCStep, RPCTransaction, RPCBlock, RPCLog, RPCReceipt, RPCTopicFilter, RPCLogFilter};
+use super::{EthereumRPC, Either, RPCStep, RPCTransaction, RPCBlock, RPCLog, RPCReceipt, RPCTopicFilter, RPCLogFilter, RPCTraceConfig};
 use super::filter::*;
 use super::serialize::*;
 use error::Error;
@@ -344,7 +344,8 @@ pub fn from_log_filter(state: &MinerState, filter: RPCLogFilter) -> Result<LogFi
 }
 
 pub fn replay_transaction<P: Patch>(
-    stateful: &MemoryStateful<'static>, transaction: Transaction, block: &Block, last_hashes: &[H256]
+    stateful: &MemoryStateful<'static>, transaction: Transaction, block: &Block,
+    last_hashes: &[H256], config: &RPCTraceConfig
 ) -> Result<(Vec<RPCStep>, SeqTransactionVM<P>), Error> {
     let valid = stateful.to_valid::<P>(transaction)?;
     let mut vm = SeqTransactionVM::<P>::new(valid, HeaderParams::from(&block.header));
@@ -368,7 +369,12 @@ pub fn replay_transaction<P: Patch>(
                         MachineStatus::ExitedErr(err) => format!("{:?}", err),
                         _ => "".to_string(),
                     };
-                    let memory = {
+                    let pc = machine.pc().position();
+                    let op = machine.pc().code()[pc];
+
+                    let memory = if config.disable_memory {
+                        None
+                    } else {
                         let mut ret = Vec::new();
                         for i in 0..(if machine.state().memory.len() % 32 == 0 {
                             machine.state().memory.len() / 32
@@ -378,19 +384,21 @@ pub fn replay_transaction<P: Patch>(
                             ret.push(Hex(machine.state().memory.read(U256::from(i) *
                                                                      U256::from(32))));
                         }
-                        ret
+                        Some(ret)
                     };
-                    let pc = machine.pc().position();
-                    let op = machine.pc().code()[pc];
-                    let stack = {
+                    let stack = if config.disable_stack {
+                        None
+                    } else {
                         let mut ret = Vec::new();
 
                         for i in 0..machine.state().stack.len() {
                             ret.push(Hex(machine.state().stack.peek(i).unwrap()));
                         }
-                        ret
+                        Some(ret)
                     };
-                    let storage = {
+                    let storage = if config.disable_storage {
+                        None
+                    } else {
                         let storage = machine.state().account_state.storage(
                             machine.state().context.address);
 
@@ -401,7 +409,7 @@ pub fn replay_transaction<P: Patch>(
                                 ret.insert(Hex(key), Hex(value));
                             }
                         }
-                        ret
+                        Some(ret)
                     };
 
                     steps.push(RPCStep {