From 34edecd59dec8e408101d31c8cd8b2d240f6dd13 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Tue, 31 May 2016 21:03:44 +0200 Subject: [PATCH] State diffing, exposed through JSONRPC. --- ethcore/src/account_diff.rs | 151 ---------------------- ethcore/src/client/client.rs | 26 ++-- ethcore/src/client/mod.rs | 11 +- ethcore/src/client/test_client.rs | 4 +- ethcore/src/executive.rs | 2 + ethcore/src/json_tests/state.rs | 5 +- ethcore/src/lib.rs | 2 - ethcore/src/pod_account.rs | 56 +++++++- ethcore/src/pod_state.rs | 83 +++++++++++- ethcore/src/state.rs | 26 +++- ethcore/src/state_diff.rs | 126 ------------------ ethcore/src/types/executed.rs | 5 +- ethcore/src/types/mod.rs.in | 2 + miner/src/lib.rs | 4 +- miner/src/miner.rs | 19 ++- rpc/src/v1/impls/eth.rs | 8 +- rpc/src/v1/impls/ethcore.rs | 63 ++++++++- rpc/src/v1/tests/helpers/miner_service.rs | 4 +- rpc/src/v1/traits/ethcore.rs | 4 + util/src/misc.rs | 27 ---- 20 files changed, 278 insertions(+), 350 deletions(-) delete mode 100644 ethcore/src/account_diff.rs delete mode 100644 ethcore/src/state_diff.rs diff --git a/ethcore/src/account_diff.rs b/ethcore/src/account_diff.rs deleted file mode 100644 index c02b7ec7b..000000000 --- a/ethcore/src/account_diff.rs +++ /dev/null @@ -1,151 +0,0 @@ -// Copyright 2015, 2016 Ethcore (UK) Ltd. -// This file is part of Parity. - -// Parity is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Parity is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Parity. If not, see . - -//! Diff between two accounts. - -use util::*; -#[cfg(test)] -use pod_account::*; - -#[derive(Debug,Clone,PartialEq,Eq)] -/// Change in existance type. -// TODO: include other types of change. -pub enum Existance { - /// Item came into existance. - Born, - /// Item stayed in existance. - Alive, - /// Item went out of existance. - Died, -} - -impl fmt::Display for Existance { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - Existance::Born => try!(write!(f, "+++")), - Existance::Alive => try!(write!(f, "***")), - Existance::Died => try!(write!(f, "XXX")), - } - Ok(()) - } -} - -#[derive(Debug,Clone,PartialEq,Eq)] -/// Account diff. -pub struct AccountDiff { - /// Change in balance, allowed to be `Diff::Same`. - pub balance: Diff, - /// Change in nonce, allowed to be `Diff::Same`. - pub nonce: Diff, // Allowed to be Same - /// Change in code, allowed to be `Diff::Same`. - pub code: Diff, // Allowed to be Same - /// Change in storage, values are not allowed to be `Diff::Same`. - pub storage: BTreeMap>, -} - -impl AccountDiff { - /// Get `Existance` projection. - pub fn existance(&self) -> Existance { - match self.balance { - Diff::Born(_) => Existance::Born, - Diff::Died(_) => Existance::Died, - _ => Existance::Alive, - } - } - - #[cfg(test)] - /// Determine difference between two optionally existant `Account`s. Returns None - /// if they are the same. - pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option { - match (pre, post) { - (None, Some(x)) => Some(AccountDiff { - balance: Diff::Born(x.balance), - nonce: Diff::Born(x.nonce), - code: Diff::Born(x.code.clone()), - storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Born(v.clone()))).collect(), - }), - (Some(x), None) => Some(AccountDiff { - balance: Diff::Died(x.balance), - nonce: Diff::Died(x.nonce), - code: Diff::Died(x.code.clone()), - storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Died(v.clone()))).collect(), - }), - (Some(pre), Some(post)) => { - let storage: Vec<_> = pre.storage.keys().merge(post.storage.keys()) - .filter(|k| pre.storage.get(k).unwrap_or(&H256::new()) != post.storage.get(k).unwrap_or(&H256::new())) - .collect(); - let r = AccountDiff { - balance: Diff::new(pre.balance, post.balance), - nonce: Diff::new(pre.nonce, post.nonce), - code: Diff::new(pre.code.clone(), post.code.clone()), - storage: storage.into_iter().map(|k| - (k.clone(), Diff::new( - pre.storage.get(&k).cloned().unwrap_or_else(H256::new), - post.storage.get(&k).cloned().unwrap_or_else(H256::new) - ))).collect(), - }; - if r.balance.is_same() && r.nonce.is_same() && r.code.is_same() && r.storage.is_empty() { - None - } else { - Some(r) - } - }, - _ => None, - } - } -} - -// TODO: refactor into something nicer. -fn interpreted_hash(u: &H256) -> String { - if u <= &H256::from(0xffffffff) { - format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u32(), U256::from(u.as_slice()).low_u32()) - } else if u <= &H256::from(u64::max_value()) { - format!("{} = 0x{:x}", U256::from(u.as_slice()).low_u64(), U256::from(u.as_slice()).low_u64()) -// } else if u <= &H256::from("0xffffffffffffffffffffffffffffffffffffffff") { -// format!("@{}", Address::from(u)) - } else { - format!("#{}", u) - } -} - -impl fmt::Display for AccountDiff { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.nonce { - Diff::Born(ref x) => try!(write!(f, " non {}", x)), - Diff::Changed(ref pre, ref post) => try!(write!(f, "#{} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - * min(pre, post))), - _ => {}, - } - match self.balance { - Diff::Born(ref x) => try!(write!(f, " bal {}", x)), - Diff::Changed(ref pre, ref post) => try!(write!(f, "${} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - *min(pre, post))), - _ => {}, - } - if let Diff::Born(ref x) = self.code { - try!(write!(f, " code {}", x.pretty())); - } - try!(write!(f, "\n")); - for (k, dv) in &self.storage { - match *dv { - Diff::Born(ref v) => try!(write!(f, " + {} => {}\n", interpreted_hash(k), interpreted_hash(v))), - Diff::Changed(ref pre, ref post) => try!(write!(f, " * {} => {} (was {})\n", interpreted_hash(k), interpreted_hash(post), interpreted_hash(pre))), - Diff::Died(_) => try!(write!(f, " X {}\n", interpreted_hash(k))), - _ => {}, - } - } - Ok(()) - } -} - diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index 7229b7436..f417c4e43 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -37,7 +37,7 @@ use filter::Filter; use log_entry::LocalizedLogEntry; use block_queue::{BlockQueue, BlockQueueInfo}; use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute}; -use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, TraceFilter}; +use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, TraceFilter, CallAnalytics}; use client::Error as ClientError; use env_info::EnvInfo; use executive::{Executive, Executed, TransactOptions, contract_address}; @@ -414,14 +414,14 @@ impl Client where V: Verifier { TransactionID::Hash(ref hash) => self.chain.transaction_address(hash), TransactionID::Location(id, index) => Self::block_hash(&self.chain, id).map(|hash| TransactionAddress { block_hash: hash, - index: index + index: index, }) } } } impl BlockChainClient for Client where V: Verifier { - fn call(&self, t: &SignedTransaction, vm_tracing: bool) -> Result { + fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result { let header = self.block_header(BlockID::Latest).unwrap(); let view = HeaderView::new(&header); let last_hashes = self.build_last_hashes(view.hash()); @@ -441,11 +441,20 @@ impl BlockChainClient for Client where V: Verifier { ExecutionError::TransactionMalformed(message) })); let balance = state.balance(&sender); - // give the sender a decent balance - state.sub_balance(&sender, &balance); - state.add_balance(&sender, &(U256::from(1) << 200)); - let options = TransactOptions { tracing: false, vm_tracing: vm_tracing, check_nonce: false }; - Executive::new(&mut state, &env_info, self.engine.deref().deref(), &self.vm_factory).transact(t, options) + let needed_balance = t.value + t.gas * t.gas_price; + if balance < needed_balance { + // give the sender a sufficient balance + state.add_balance(&sender, &(needed_balance - balance)); + } + let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false }; + let mut ret = Executive::new(&mut state, &env_info, self.engine.deref().deref(), &self.vm_factory).transact(t, options); + // TODO gav move this into Executive. + if analytics.diffing { + if let Ok(ref mut x) = ret { + x.diff = Some(state.diff_from(self.state())); + } + } + ret } // TODO [todr] Should be moved to miner crate eventually. @@ -561,7 +570,6 @@ impl BlockChainClient for Client where V: Verifier { self.state_at(id).map(|s| s.nonce(address)) } - fn block_hash(&self, id: BlockID) -> Option { Self::block_hash(&self.chain, id) } diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs index 2154c12bd..193ae8eba 100644 --- a/ethcore/src/client/mod.rs +++ b/ethcore/src/client/mod.rs @@ -47,6 +47,15 @@ use receipt::LocalizedReceipt; use trace::LocalizedTrace; use evm::Factory as EvmFactory; +/// Options concerning what analytics we run on the call. +#[derive(Eq, PartialEq, Default, Clone, Copy, Debug)] +pub struct CallAnalytics { + /// Make a VM trace. + pub vm_tracing: bool, + /// Make a diff. + pub diffing: bool, +} + /// Blockchain database client. Owns and manages a blockchain and a block queue. pub trait BlockChainClient : Sync + Send { /// Get raw block header data by block id. @@ -165,7 +174,7 @@ pub trait BlockChainClient : Sync + Send { /// Makes a non-persistent transaction call. // TODO: should be able to accept blockchain location for call. - fn call(&self, t: &SignedTransaction, vm_tracing: bool) -> Result; + fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result; /// Returns EvmFactory. fn vm_factory(&self) -> &EvmFactory; diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs index d1b4408e6..abffb250b 100644 --- a/ethcore/src/client/test_client.rs +++ b/ethcore/src/client/test_client.rs @@ -20,7 +20,7 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder}; use util::*; use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action}; use blockchain::TreeRoute; -use client::{BlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes}; +use client::{BlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics}; use header::{Header as BlockHeader, BlockNumber}; use filter::Filter; use log_entry::LocalizedLogEntry; @@ -233,7 +233,7 @@ impl TestBlockChainClient { } impl BlockChainClient for TestBlockChainClient { - fn call(&self, _t: &SignedTransaction, _vm_tracing: bool) -> Result { + fn call(&self, _t: &SignedTransaction, _analytics: CallAnalytics) -> Result { Ok(self.execution_result.read().unwrap().clone().unwrap()) } diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs index 483e3fa31..4284bfa8d 100644 --- a/ethcore/src/executive.rs +++ b/ethcore/src/executive.rs @@ -450,6 +450,7 @@ impl<'a> Executive<'a> { output: output, trace: trace, vm_trace: vm_trace, + diff: None, }) }, _ => { @@ -463,6 +464,7 @@ impl<'a> Executive<'a> { output: output, trace: trace, vm_trace: vm_trace, + diff: None, }) }, } diff --git a/ethcore/src/json_tests/state.rs b/ethcore/src/json_tests/state.rs index 5cc611491..5307fb319 100644 --- a/ethcore/src/json_tests/state.rs +++ b/ethcore/src/json_tests/state.rs @@ -16,8 +16,7 @@ use super::test_common::*; use tests::helpers::*; -use pod_state::*; -use state_diff::*; +use pod_state::{self, PodState}; use ethereum; use ethjson; @@ -71,7 +70,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec { let our_post = state.to_pod(); println!("Got:\n{}", our_post); println!("Expect:\n{}", post); - println!("Diff ---expect -> +++got:\n{}", StateDiff::diff_pod(&post, &our_post)); + println!("Diff ---expect -> +++got:\n{}", pod_state::diff_pod(&post, &our_post)); } if let Ok(r) = res { diff --git a/ethcore/src/lib.rs b/ethcore/src/lib.rs index 809f86517..2a95c317d 100644 --- a/ethcore/src/lib.rs +++ b/ethcore/src/lib.rs @@ -117,8 +117,6 @@ mod basic_types; #[macro_use] mod evm; mod env_info; mod pod_account; -mod account_diff; -mod state_diff; mod state; mod account; mod account_db; diff --git a/ethcore/src/pod_account.rs b/ethcore/src/pod_account.rs index 27ddc8a97..5c58499c2 100644 --- a/ethcore/src/pod_account.rs +++ b/ethcore/src/pod_account.rs @@ -18,6 +18,7 @@ use util::*; use account::*; use account_db::*; use ethjson; +use types::account_diff::*; #[derive(Debug, Clone, PartialEq, Eq)] /// An account, expressed as Plain-Old-Data (hence the name). @@ -106,17 +107,58 @@ impl fmt::Display for PodAccount { } } +/// Determine difference between two optionally existant `Account`s. Returns None +/// if they are the same. +pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option { + match (pre, post) { + (None, Some(x)) => Some(AccountDiff { + balance: Diff::Born(x.balance), + nonce: Diff::Born(x.nonce), + code: Diff::Born(x.code.clone()), + storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Born(v.clone()))).collect(), + }), + (Some(x), None) => Some(AccountDiff { + balance: Diff::Died(x.balance), + nonce: Diff::Died(x.nonce), + code: Diff::Died(x.code.clone()), + storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Died(v.clone()))).collect(), + }), + (Some(pre), Some(post)) => { + let storage: Vec<_> = pre.storage.keys().merge(post.storage.keys()) + .filter(|k| pre.storage.get(k).unwrap_or(&H256::new()) != post.storage.get(k).unwrap_or(&H256::new())) + .collect(); + let r = AccountDiff { + balance: Diff::new(pre.balance, post.balance), + nonce: Diff::new(pre.nonce, post.nonce), + code: Diff::new(pre.code.clone(), post.code.clone()), + storage: storage.into_iter().map(|k| + (k.clone(), Diff::new( + pre.storage.get(&k).cloned().unwrap_or_else(H256::new), + post.storage.get(&k).cloned().unwrap_or_else(H256::new) + ))).collect(), + }; + if r.balance.is_same() && r.nonce.is_same() && r.code.is_same() && r.storage.is_empty() { + None + } else { + Some(r) + } + }, + _ => None, + } +} + + #[cfg(test)] mod test { use common::*; - use account_diff::*; - use super::*; + use types::account_diff::*; + use super::diff_pod; #[test] fn existence() { let a = PodAccount{balance: x!(69), nonce: x!(0), code: vec![], storage: map![]}; - assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&a)), None); - assert_eq!(AccountDiff::diff_pod(None, Some(&a)), Some(AccountDiff{ + assert_eq!(diff_pod(Some(&a), Some(&a)), None); + assert_eq!(diff_pod(None, Some(&a)), Some(AccountDiff{ balance: Diff::Born(x!(69)), nonce: Diff::Born(x!(0)), code: Diff::Born(vec![]), @@ -128,7 +170,7 @@ mod test { fn basic() { let a = PodAccount{balance: x!(69), nonce: x!(0), code: vec![], storage: map![]}; let b = PodAccount{balance: x!(42), nonce: x!(1), code: vec![], storage: map![]}; - assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff { + assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff { balance: Diff::Changed(x!(69), x!(42)), nonce: Diff::Changed(x!(0), x!(1)), code: Diff::Same, @@ -140,7 +182,7 @@ mod test { fn code() { let a = PodAccount{balance: x!(0), nonce: x!(0), code: vec![], storage: map![]}; let b = PodAccount{balance: x!(0), nonce: x!(1), code: vec![0], storage: map![]}; - assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff { + assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff { balance: Diff::Same, nonce: Diff::Changed(x!(0), x!(1)), code: Diff::Changed(vec![], vec![0]), @@ -162,7 +204,7 @@ mod test { code: vec![], storage: mapx![1 => 1, 2 => 3, 3 => 0, 5 => 0, 7 => 7, 8 => 0, 9 => 9] }; - assert_eq!(AccountDiff::diff_pod(Some(&a), Some(&b)), Some(AccountDiff { + assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff { balance: Diff::Same, nonce: Diff::Same, code: Diff::Same, diff --git a/ethcore/src/pod_state.rs b/ethcore/src/pod_state.rs index df0dea010..e09fbc367 100644 --- a/ethcore/src/pod_state.rs +++ b/ethcore/src/pod_state.rs @@ -17,7 +17,8 @@ //! State of all accounts in the system expressed in Plain Old Data. use util::*; -use pod_account::*; +use pod_account::{self, PodAccount}; +use types::state_diff::StateDiff; use ethjson; /// State of all accounts in the system expressed in Plain Old Data. @@ -69,3 +70,83 @@ impl fmt::Display for PodState { } } +/// Calculate and return diff between `pre` state and `post` state. +pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff { + StateDiff(pre.get().keys().merge(post.get().keys()).filter_map(|acc| pod_account::diff_pod(pre.get().get(acc), post.get().get(acc)).map(|d|(acc.clone(), d))).collect()) +} + +#[cfg(test)] +mod test { + use common::*; + use types::state_diff::*; + use types::account_diff::*; + use pod_account::{self, PodAccount}; + use super::PodState; + + #[test] + fn create_delete() { + let a = PodState::from(map![ x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]) ]); + assert_eq!(super::diff_pod(&a, &PodState::new()), StateDiff(map![ + x!(1) => AccountDiff{ + balance: Diff::Died(x!(69)), + nonce: Diff::Died(x!(0)), + code: Diff::Died(vec![]), + storage: map![], + } + ])); + assert_eq!(super::diff_pod(&PodState::new(), &a), StateDiff(map![ + x!(1) => AccountDiff{ + balance: Diff::Born(x!(69)), + nonce: Diff::Born(x!(0)), + code: Diff::Born(vec![]), + storage: map![], + } + ])); + } + + #[test] + fn create_delete_with_unchanged() { + let a = PodState::from(map![ x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]) ]); + let b = PodState::from(map![ + x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]), + x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) + ]); + assert_eq!(super::diff_pod(&a, &b), StateDiff(map![ + x!(2) => AccountDiff{ + balance: Diff::Born(x!(69)), + nonce: Diff::Born(x!(0)), + code: Diff::Born(vec![]), + storage: map![], + } + ])); + assert_eq!(super::diff_pod(&b, &a), StateDiff(map![ + x!(2) => AccountDiff{ + balance: Diff::Died(x!(69)), + nonce: Diff::Died(x!(0)), + code: Diff::Died(vec![]), + storage: map![], + } + ])); + } + + #[test] + fn change_with_unchanged() { + let a = PodState::from(map![ + x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]), + x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) + ]); + let b = PodState::from(map![ + x!(1) => PodAccount::new(x!(69), x!(1), vec![], map![]), + x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) + ]); + assert_eq!(super::diff_pod(&a, &b), StateDiff(map![ + x!(1) => AccountDiff{ + balance: Diff::Same, + nonce: Diff::Changed(x!(0), x!(1)), + code: Diff::Same, + storage: map![], + } + ])); + } + +} diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs index 99ffd3944..5f7ff3239 100644 --- a/ethcore/src/state.rs +++ b/ethcore/src/state.rs @@ -21,8 +21,8 @@ use evm::Factory as EvmFactory; use account_db::*; use trace::Trace; use pod_account::*; -use pod_state::PodState; -//use state_diff::*; // TODO: uncomment once to_pod() works correctly. +use pod_state::{self, PodState}; +use types::state_diff::StateDiff; /// Used to return information about an `State::apply` operation. pub struct ApplyOutcome { @@ -220,7 +220,7 @@ impl State { let e = try!(Executive::new(self, env_info, engine, vm_factory).transact(t, options)); // TODO uncomment once to_pod() works correctly. -// trace!("Applied transaction. Diff:\n{}\n", StateDiff::diff_pod(&old, &self.to_pod())); +// trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod())); self.commit(); let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs); // trace!("Transaction receipt: {:?}", receipt); @@ -275,6 +275,7 @@ impl State { pub fn to_pod(&self) -> PodState { assert!(self.snapshots.borrow().is_empty()); // TODO: handle database rather than just the cache. + // will need fat db. PodState::from(self.cache.borrow().iter().fold(BTreeMap::new(), |mut m, (add, opt)| { if let Some(ref acc) = *opt { m.insert(add.clone(), PodAccount::from_account(acc)); @@ -283,6 +284,25 @@ impl State { })) } + fn query_pod(&mut self, query: &PodState) { + query.get().iter().foreach(|(ref address, ref pod_account)| { + if self.get(address, true).is_some() { + pod_account.storage.iter().foreach(|(ref key, _)| { + self.storage_at(address, key); + }); + } + }); + } + + /// Returns a `StateDiff` describing the difference from `orig` to `self`. + /// Consumes self. + pub fn diff_from(&self, orig: State) -> StateDiff { + let pod_state_post = self.to_pod(); + let mut state_pre = orig; + state_pre.query_pod(&pod_state_post); + pod_state::diff_pod(&state_pre.to_pod(), &pod_state_post) + } + /// Pull account `a` in our cache from the trie DB and return it. /// `require_code` requires that the code be cached, too. fn get<'a>(&'a self, a: &Address, require_code: bool) -> &'a Option { diff --git a/ethcore/src/state_diff.rs b/ethcore/src/state_diff.rs deleted file mode 100644 index 6c41d167c..000000000 --- a/ethcore/src/state_diff.rs +++ /dev/null @@ -1,126 +0,0 @@ -// Copyright 2015, 2016 Ethcore (UK) Ltd. -// This file is part of Parity. - -// Parity is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Parity is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Parity. If not, see . - -use util::*; -#[cfg(test)] -use pod_state::*; -use account_diff::*; - -#[derive(Debug,Clone,PartialEq,Eq)] -/// Expression for the delta between two system states. Encoded the -/// delta of every altered account. -pub struct StateDiff (BTreeMap); - -impl StateDiff { - #[cfg(test)] - /// Calculate and return diff between `pre` state and `post` state. - pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff { - StateDiff(pre.get().keys().merge(post.get().keys()).filter_map(|acc| AccountDiff::diff_pod(pre.get().get(acc), post.get().get(acc)).map(|d|(acc.clone(), d))).collect()) - } -} - -impl fmt::Display for StateDiff { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - for (add, acc) in &self.0 { - try!(write!(f, "{} {}: {}", acc.existance(), add, acc)); - } - Ok(()) - } -} - -impl Deref for StateDiff { - type Target = BTreeMap; - - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -#[cfg(test)] -mod test { - use common::*; - use pod_state::*; - use account_diff::*; - use pod_account::*; - use super::*; - - #[test] - fn create_delete() { - let a = PodState::from(map![ x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]) ]); - assert_eq!(StateDiff::diff_pod(&a, &PodState::new()), StateDiff(map![ - x!(1) => AccountDiff{ - balance: Diff::Died(x!(69)), - nonce: Diff::Died(x!(0)), - code: Diff::Died(vec![]), - storage: map![], - } - ])); - assert_eq!(StateDiff::diff_pod(&PodState::new(), &a), StateDiff(map![ - x!(1) => AccountDiff{ - balance: Diff::Born(x!(69)), - nonce: Diff::Born(x!(0)), - code: Diff::Born(vec![]), - storage: map![], - } - ])); - } - - #[test] - fn create_delete_with_unchanged() { - let a = PodState::from(map![ x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]) ]); - let b = PodState::from(map![ - x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]), - x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) - ]); - assert_eq!(StateDiff::diff_pod(&a, &b), StateDiff(map![ - x!(2) => AccountDiff{ - balance: Diff::Born(x!(69)), - nonce: Diff::Born(x!(0)), - code: Diff::Born(vec![]), - storage: map![], - } - ])); - assert_eq!(StateDiff::diff_pod(&b, &a), StateDiff(map![ - x!(2) => AccountDiff{ - balance: Diff::Died(x!(69)), - nonce: Diff::Died(x!(0)), - code: Diff::Died(vec![]), - storage: map![], - } - ])); - } - - #[test] - fn change_with_unchanged() { - let a = PodState::from(map![ - x!(1) => PodAccount::new(x!(69), x!(0), vec![], map![]), - x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) - ]); - let b = PodState::from(map![ - x!(1) => PodAccount::new(x!(69), x!(1), vec![], map![]), - x!(2) => PodAccount::new(x!(69), x!(0), vec![], map![]) - ]); - assert_eq!(StateDiff::diff_pod(&a, &b), StateDiff(map![ - x!(1) => AccountDiff{ - balance: Diff::Same, - nonce: Diff::Changed(x!(0), x!(1)), - code: Diff::Same, - storage: map![], - } - ])); - } - -} diff --git a/ethcore/src/types/executed.rs b/ethcore/src/types/executed.rs index 823c9dda1..c1a136855 100644 --- a/ethcore/src/types/executed.rs +++ b/ethcore/src/types/executed.rs @@ -20,13 +20,14 @@ use util::numbers::*; use util::Bytes; use trace::{Trace, VMTrace}; use types::log_entry::LogEntry; +use types::state_diff::StateDiff; use ipc::binary::BinaryConvertError; use std::fmt; use std::mem; use std::collections::VecDeque; /// Transaction execution receipt. -#[derive(Debug, PartialEq, Clone, Binary)] +#[derive(Debug, PartialEq, Clone)] pub struct Executed { /// Gas paid up front for execution of transaction. pub gas: U256, @@ -61,6 +62,8 @@ pub struct Executed { pub trace: Option, /// The VM trace of this transaction. pub vm_trace: Option, + /// The state diff, if we traced it. + pub diff: Option, } /// Result of executing the transaction. diff --git a/ethcore/src/types/mod.rs.in b/ethcore/src/types/mod.rs.in index 1f67a9184..b51e9e57b 100644 --- a/ethcore/src/types/mod.rs.in +++ b/ethcore/src/types/mod.rs.in @@ -23,3 +23,5 @@ pub mod log_entry; pub mod trace_types; pub mod executed; pub mod block_status; +pub mod account_diff; +pub mod state_diff; diff --git a/miner/src/lib.rs b/miner/src/lib.rs index 911ca1cee..8702295f6 100644 --- a/miner/src/lib.rs +++ b/miner/src/lib.rs @@ -62,7 +62,7 @@ pub use external::{ExternalMiner, ExternalMinerService}; use std::collections::BTreeMap; use util::{H256, U256, Address, Bytes}; -use ethcore::client::{BlockChainClient, Executed}; +use ethcore::client::{BlockChainClient, Executed, CallAnalytics}; use ethcore::block::ClosedBlock; use ethcore::receipt::Receipt; use ethcore::error::{Error, ExecutionError}; @@ -159,7 +159,7 @@ pub trait MinerService : Send + Sync { fn balance(&self, chain: &BlockChainClient, address: &Address) -> U256; /// Call into contract code using pending state. - fn call(&self, chain: &BlockChainClient, t: &SignedTransaction, vm_tracing: bool) -> Result; + fn call(&self, chain: &BlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result; /// Get storage value in pending state. fn storage_at(&self, chain: &BlockChainClient, address: &Address, position: &H256) -> H256; diff --git a/miner/src/miner.rs b/miner/src/miner.rs index 91ff7c319..e1e140f57 100644 --- a/miner/src/miner.rs +++ b/miner/src/miner.rs @@ -20,10 +20,9 @@ use std::sync::atomic::AtomicBool; use util::*; use util::keys::store::{AccountService, AccountProvider}; use ethcore::views::{BlockView, HeaderView}; -use ethcore::client::{BlockChainClient, BlockID}; +use ethcore::client::{Executive, Executed, EnvInfo, TransactOptions, BlockChainClient, BlockID, CallAnalytics}; use ethcore::block::{ClosedBlock, IsBlock}; use ethcore::error::*; -use ethcore::client::{Executive, Executed, EnvInfo, TransactOptions}; use ethcore::transaction::SignedTransaction; use ethcore::receipt::{Receipt}; use ethcore::spec::Spec; @@ -252,7 +251,7 @@ impl MinerService for Miner { } } - fn call(&self, chain: &BlockChainClient, t: &SignedTransaction, vm_tracing: bool) -> Result { + fn call(&self, chain: &BlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result { let sealing_work = self.sealing_work.lock().unwrap(); match sealing_work.peek_last_ref() { Some(work) => { @@ -278,13 +277,19 @@ impl MinerService for Miner { // give the sender max balance state.sub_balance(&sender, &balance); state.add_balance(&sender, &U256::max_value()); - let options = TransactOptions { tracing: false, vm_tracing: vm_tracing, check_nonce: false }; + let options = TransactOptions { tracing: false, vm_tracing: analytics.vm_tracing, check_nonce: false }; - // TODO: use vm_trace here. - Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options) + let mut ret = Executive::new(&mut state, &env_info, self.engine(), chain.vm_factory()).transact(t, options); + // TODO gav move this into Executive. + if analytics.diffing { + if let Ok(ref mut x) = ret { + x.diff = Some(state.diff_from(block.state().clone())); + } + } + ret }, None => { - chain.call(t, vm_tracing) + chain.call(t, analytics) } } } diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 8f0c7930e..886c1f379 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -530,8 +530,8 @@ impl Eth for EthClient where .and_then(|(request, block_number,)| { let signed = try!(self.sign_call(request)); let r = match block_number { - BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, false), - BlockNumber::Latest => take_weak!(self.client).call(&signed, false), + BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, Default::default()), + BlockNumber::Latest => take_weak!(self.client).call(&signed, Default::default()), _ => panic!("{:?}", block_number), }; to_value(&r.map(|e| Bytes(e.output)).unwrap_or(Bytes::new(vec![]))) @@ -543,8 +543,8 @@ impl Eth for EthClient where .and_then(|(request, block_number,)| { let signed = try!(self.sign_call(request)); let r = match block_number { - BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, false), - BlockNumber::Latest => take_weak!(self.client).call(&signed, false), + BlockNumber::Pending => take_weak!(self.miner).call(take_weak!(self.client).deref(), &signed, Default::default()), + BlockNumber::Latest => take_weak!(self.client).call(&signed, Default::default()), _ => return Err(Error::invalid_params()), }; to_value(&r.map(|res| res.gas_used + res.refunded).unwrap_or(From::from(0))) diff --git a/rpc/src/v1/impls/ethcore.rs b/rpc/src/v1/impls/ethcore.rs index 56598eb7e..5b6fa5627 100644 --- a/rpc/src/v1/impls/ethcore.rs +++ b/rpc/src/v1/impls/ethcore.rs @@ -22,8 +22,11 @@ use std::sync::{Arc, Weak}; use std::ops::Deref; use std::collections::BTreeMap; use jsonrpc_core::*; +use serde; use ethminer::MinerService; -use ethcore::client::BlockChainClient; +use ethcore::state_diff::StateDiff; +use ethcore::account_diff::{Diff, Existance}; +use ethcore::client::{BlockChainClient, CallAnalytics}; use ethcore::trace::VMTrace; use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action}; use v1::traits::Ethcore; @@ -115,6 +118,47 @@ fn vm_trace_to_object(t: &VMTrace) -> Value { Value::Object(ret) } +fn diff_to_object(d: &Diff) -> Value where T: serde::Serialize + Eq { + let mut ret = BTreeMap::new(); + match *d { + Diff::Same => { + ret.insert("diff".to_owned(), Value::String("=".to_owned())); + } + Diff::Born(ref x) => { + ret.insert("diff".to_owned(), Value::String("+".to_owned())); + ret.insert("+".to_owned(), to_value(x).unwrap()); + } + Diff::Died(ref x) => { + ret.insert("diff".to_owned(), Value::String("-".to_owned())); + ret.insert("-".to_owned(), to_value(x).unwrap()); + } + Diff::Changed(ref from, ref to) => { + ret.insert("diff".to_owned(), Value::String("*".to_owned())); + ret.insert("-".to_owned(), to_value(from).unwrap()); + ret.insert("+".to_owned(), to_value(to).unwrap()); + } + }; + Value::Object(ret) +} + +fn state_diff_to_object(t: &StateDiff) -> Value { + Value::Object(t.iter().map(|(address, account)| { + (address.hex(), Value::Object(map![ + "existance".to_owned() => Value::String(match account.existance() { + Existance::Born => "+", + Existance::Alive => ".", + Existance::Died => "-", + }.to_owned()), + "balance".to_owned() => diff_to_object(&account.balance), + "nonce".to_owned() => diff_to_object(&account.nonce), + "code".to_owned() => diff_to_object(&account.code), + "storage".to_owned() => Value::Object(account.storage.iter().map(|(key, val)| { + (key.hex(), diff_to_object(&val)) + }).collect::>()) + ])) + }).collect::>()) +} + impl Ethcore for EthcoreClient where C: BlockChainClient + 'static, M: MinerService + 'static { fn set_min_gas_price(&self, params: Params) -> Result { @@ -211,7 +255,7 @@ impl Ethcore for EthcoreClient where C: BlockChainClient + 'static, from_params(params) .and_then(|(request,)| { let signed = try!(self.sign_call(request)); - let r = take_weak!(self.client).call(&signed, true); + let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: true, diffing: false }); if let Ok(executed) = r { if let Some(vm_trace) = executed.vm_trace { return Ok(vm_trace_to_object(&vm_trace)); @@ -220,4 +264,19 @@ impl Ethcore for EthcoreClient where C: BlockChainClient + 'static, Ok(Value::Null) }) } + + fn diff_call(&self, params: Params) -> Result { + trace!(target: "jsonrpc", "diff_call: {:?}", params); + from_params(params) + .and_then(|(request,)| { + let signed = try!(self.sign_call(request)); + let r = take_weak!(self.client).call(&signed, CallAnalytics{ vm_tracing: false, diffing: true }); + if let Ok(executed) = r { + if let Some(state_diff) = executed.diff { + return Ok(state_diff_to_object(&state_diff)); + } + } + Ok(Value::Null) + }) + } } diff --git a/rpc/src/v1/tests/helpers/miner_service.rs b/rpc/src/v1/tests/helpers/miner_service.rs index 1b162b6b8..98973982e 100644 --- a/rpc/src/v1/tests/helpers/miner_service.rs +++ b/rpc/src/v1/tests/helpers/miner_service.rs @@ -19,7 +19,7 @@ use util::{Address, H256, Bytes, U256, FixedHash, Uint}; use util::standard::*; use ethcore::error::{Error, ExecutionError}; -use ethcore::client::{BlockChainClient, Executed}; +use ethcore::client::{BlockChainClient, Executed, CallAnalytics}; use ethcore::block::{ClosedBlock, IsBlock}; use ethcore::transaction::SignedTransaction; use ethcore::receipt::Receipt; @@ -202,7 +202,7 @@ impl MinerService for TestMinerService { self.latest_closed_block.lock().unwrap().as_ref().map_or_else(U256::zero, |b| b.block().fields().state.balance(address).clone()) } - fn call(&self, _chain: &BlockChainClient, _t: &SignedTransaction, _vm_tracing: bool) -> Result { + fn call(&self, _chain: &BlockChainClient, _t: &SignedTransaction, _analytics: CallAnalytics) -> Result { unimplemented!(); } diff --git a/rpc/src/v1/traits/ethcore.rs b/rpc/src/v1/traits/ethcore.rs index abc87bbb8..563e42536 100644 --- a/rpc/src/v1/traits/ethcore.rs +++ b/rpc/src/v1/traits/ethcore.rs @@ -75,6 +75,9 @@ pub trait Ethcore: Sized + Send + Sync + 'static { /// Executes the given call and returns the VM trace for it. fn vm_trace_call(&self, _: Params) -> Result; + /// Executes the given call and returns the diff for it. + fn diff_call(&self, params: Params) -> Result; + /// Should be used to convert object to io delegate. fn to_delegate(self) -> IoDelegate { let mut delegate = IoDelegate::new(Arc::new(self)); @@ -98,6 +101,7 @@ pub trait Ethcore: Sized + Send + Sync + 'static { delegate.add_method("ethcore_defaultExtraData", Ethcore::default_extra_data); delegate.add_method("ethcore_vmTraceCall", Ethcore::vm_trace_call); + delegate.add_method("ethcore_diffCall", Ethcore::diff_call); delegate } diff --git a/util/src/misc.rs b/util/src/misc.rs index 159381603..8d22e04d7 100644 --- a/util/src/misc.rs +++ b/util/src/misc.rs @@ -24,33 +24,6 @@ use target_info::Target; include!(concat!(env!("OUT_DIR"), "/version.rs")); include!(concat!(env!("OUT_DIR"), "/rustc_version.rs")); -#[derive(Debug,Clone,PartialEq,Eq)] -/// Diff type for specifying a change (or not). -pub enum Diff where T: Eq { - /// Both sides are the same. - Same, - /// Left (pre, source) side doesn't include value, right side (post, destination) does. - Born(T), - /// Both sides include data; it chaged value between them. - Changed(T, T), - /// Left (pre, source) side does include value, right side (post, destination) does not. - Died(T), -} - -impl Diff where T: Eq { - /// Construct new object with given `pre` and `post`. - pub fn new(pre: T, post: T) -> Self { if pre == post { Diff::Same } else { Diff::Changed(pre, post) } } - - /// Get the before value, if there is one. - pub fn pre(&self) -> Option<&T> { match *self { Diff::Died(ref x) | Diff::Changed(ref x, _) => Some(x), _ => None } } - - /// Get the after value, if there is one. - pub fn post(&self) -> Option<&T> { match *self { Diff::Born(ref x) | Diff::Changed(_, ref x) => Some(x), _ => None } } - - /// Determine whether there was a change or not. - pub fn is_same(&self) -> bool { match *self { Diff::Same => true, _ => false }} -} - #[derive(PartialEq,Eq,Clone,Copy)] /// Boolean type for clean/dirty status. pub enum Filth {