874 lines
24 KiB
Rust
874 lines
24 KiB
Rust
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Ethereum.
|
|
|
|
// Parity Ethereum 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 Ethereum 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 Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use std::collections::BTreeMap;
|
|
|
|
use ethcore::client::Executed;
|
|
use ethcore::trace as et;
|
|
use ethcore::trace::{FlatTrace, LocalizedTrace as EthLocalizedTrace, trace, TraceError};
|
|
use ethereum_types::{H160, H256, U256};
|
|
use serde::ser::SerializeStruct;
|
|
use serde::{Serialize, Serializer};
|
|
use types::account_diff;
|
|
use types::state_diff;
|
|
use vm;
|
|
|
|
use v1::types::Bytes;
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// A diff of some chunk of memory.
|
|
pub struct MemoryDiff {
|
|
/// Offset into memory the change begins.
|
|
pub off: usize,
|
|
/// The changed data.
|
|
pub data: Bytes,
|
|
}
|
|
|
|
impl From<et::MemoryDiff> for MemoryDiff {
|
|
fn from(c: et::MemoryDiff) -> Self {
|
|
MemoryDiff {
|
|
off: c.offset,
|
|
data: c.data.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// A diff of some storage value.
|
|
pub struct StorageDiff {
|
|
/// Which key in storage is changed.
|
|
pub key: U256,
|
|
/// What the value has been changed to.
|
|
pub val: U256,
|
|
}
|
|
|
|
impl From<et::StorageDiff> for StorageDiff {
|
|
fn from(c: et::StorageDiff) -> Self {
|
|
StorageDiff {
|
|
key: c.location,
|
|
val: c.value,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// A record of an executed VM operation.
|
|
pub struct VMExecutedOperation {
|
|
/// The total gas used.
|
|
pub used: u64,
|
|
/// The stack item placed, if any.
|
|
pub push: Vec<U256>,
|
|
/// If altered, the memory delta.
|
|
pub mem: Option<MemoryDiff>,
|
|
/// The altered storage value, if any.
|
|
pub store: Option<StorageDiff>,
|
|
}
|
|
|
|
impl From<et::VMExecutedOperation> for VMExecutedOperation {
|
|
fn from(c: et::VMExecutedOperation) -> Self {
|
|
VMExecutedOperation {
|
|
used: c.gas_used.low_u64(),
|
|
push: c.stack_push.into_iter().map(Into::into).collect(),
|
|
mem: c.mem_diff.map(Into::into),
|
|
store: c.store_diff.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// A record of the execution of a single VM operation.
|
|
pub struct VMOperation {
|
|
/// The program counter.
|
|
pub pc: usize,
|
|
/// The gas cost for this instruction.
|
|
pub cost: u64,
|
|
/// Information concerning the execution of the operation.
|
|
pub ex: Option<VMExecutedOperation>,
|
|
/// Subordinate trace of the CALL/CREATE if applicable.
|
|
#[serde(bound="VMTrace: Serialize")]
|
|
pub sub: Option<VMTrace>,
|
|
}
|
|
|
|
impl From<(et::VMOperation, Option<et::VMTrace>)> for VMOperation {
|
|
fn from(c: (et::VMOperation, Option<et::VMTrace>)) -> Self {
|
|
VMOperation {
|
|
pc: c.0.pc,
|
|
cost: c.0.gas_cost.low_u64(),
|
|
ex: c.0.executed.map(Into::into),
|
|
sub: c.1.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// A record of a full VM trace for a CALL/CREATE.
|
|
pub struct VMTrace {
|
|
/// The code to be executed.
|
|
pub code: Bytes,
|
|
/// The operations executed.
|
|
pub ops: Vec<VMOperation>,
|
|
}
|
|
|
|
impl From<et::VMTrace> for VMTrace {
|
|
fn from(c: et::VMTrace) -> Self {
|
|
let mut subs = c.subs.into_iter();
|
|
let mut next_sub = subs.next();
|
|
VMTrace {
|
|
code: c.code.into(),
|
|
ops: c.operations
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(i, op)| (op, {
|
|
let have_sub = next_sub.is_some() && next_sub.as_ref().unwrap().parent_step == i;
|
|
if have_sub {
|
|
let r = next_sub.clone();
|
|
next_sub = subs.next();
|
|
r
|
|
} else { None }
|
|
}).into())
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// Aux type for Diff::Changed.
|
|
pub struct ChangedType<T> where T: Serialize {
|
|
from: T,
|
|
to: T,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// Serde-friendly `Diff` shadow.
|
|
pub enum Diff<T> where T: Serialize {
|
|
#[serde(rename = "=")]
|
|
Same,
|
|
#[serde(rename = "+")]
|
|
Born(T),
|
|
#[serde(rename = "-")]
|
|
Died(T),
|
|
#[serde(rename = "*")]
|
|
Changed(ChangedType<T>),
|
|
}
|
|
|
|
impl<T, U> From<account_diff::Diff<T>> for Diff<U> where T: Eq, U: Serialize + From<T> {
|
|
fn from(c: account_diff::Diff<T>) -> Self {
|
|
match c {
|
|
account_diff::Diff::Same => Diff::Same,
|
|
account_diff::Diff::Born(t) => Diff::Born(t.into()),
|
|
account_diff::Diff::Died(t) => Diff::Died(t.into()),
|
|
account_diff::Diff::Changed(t, u) => Diff::Changed(ChangedType{from: t.into(), to: u.into()}),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
/// Serde-friendly `AccountDiff` shadow.
|
|
pub struct AccountDiff {
|
|
pub balance: Diff<U256>,
|
|
pub nonce: Diff<U256>,
|
|
pub code: Diff<Bytes>,
|
|
pub storage: BTreeMap<H256, Diff<H256>>,
|
|
}
|
|
|
|
impl From<account_diff::AccountDiff> for AccountDiff {
|
|
fn from(c: account_diff::AccountDiff) -> Self {
|
|
AccountDiff {
|
|
balance: c.balance.into(),
|
|
nonce: c.nonce.into(),
|
|
code: c.code.into(),
|
|
storage: c.storage.into_iter().map(|(k, v)| (k, v.into())).collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
/// Serde-friendly `StateDiff` shadow.
|
|
pub struct StateDiff(BTreeMap<H160, AccountDiff>);
|
|
|
|
impl Serialize for StateDiff {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where S: Serializer {
|
|
Serialize::serialize(&self.0, serializer)
|
|
}
|
|
}
|
|
|
|
impl From<state_diff::StateDiff> for StateDiff {
|
|
fn from(c: state_diff::StateDiff) -> Self {
|
|
StateDiff(c.raw.into_iter().map(|(k, v)| (k, v.into())).collect())
|
|
}
|
|
}
|
|
|
|
/// Create response
|
|
#[derive(Debug, Serialize)]
|
|
pub struct Create {
|
|
/// Sender
|
|
from: H160,
|
|
/// Value
|
|
value: U256,
|
|
/// Gas
|
|
gas: U256,
|
|
/// Initialization code
|
|
init: Bytes,
|
|
}
|
|
|
|
impl From<trace::Create> for Create {
|
|
fn from(c: trace::Create) -> Self {
|
|
Create {
|
|
from: c.from,
|
|
value: c.value,
|
|
gas: c.gas,
|
|
init: Bytes::new(c.init),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Call type.
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum CallType {
|
|
/// None
|
|
None,
|
|
/// Call
|
|
Call,
|
|
/// Call code
|
|
CallCode,
|
|
/// Delegate call
|
|
DelegateCall,
|
|
/// Static call
|
|
StaticCall,
|
|
}
|
|
|
|
impl From<vm::CallType> for CallType {
|
|
fn from(c: vm::CallType) -> Self {
|
|
match c {
|
|
vm::CallType::None => CallType::None,
|
|
vm::CallType::Call => CallType::Call,
|
|
vm::CallType::CallCode => CallType::CallCode,
|
|
vm::CallType::DelegateCall => CallType::DelegateCall,
|
|
vm::CallType::StaticCall => CallType::StaticCall,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Call response
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Call {
|
|
/// Sender
|
|
from: H160,
|
|
/// Recipient
|
|
to: H160,
|
|
/// Transfered Value
|
|
value: U256,
|
|
/// Gas
|
|
gas: U256,
|
|
/// Input data
|
|
input: Bytes,
|
|
/// The type of the call.
|
|
call_type: CallType,
|
|
}
|
|
|
|
impl From<trace::Call> for Call {
|
|
fn from(c: trace::Call) -> Self {
|
|
Call {
|
|
from: c.from,
|
|
to: c.to,
|
|
value: c.value,
|
|
gas: c.gas,
|
|
input: c.input.into(),
|
|
call_type: c.call_type.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reward type.
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub enum RewardType {
|
|
/// Block
|
|
Block,
|
|
/// Uncle
|
|
Uncle,
|
|
/// EmptyStep (AuthorityRound)
|
|
EmptyStep,
|
|
/// External (attributed as part of an external protocol)
|
|
External,
|
|
}
|
|
|
|
impl From<trace::RewardType> for RewardType {
|
|
fn from(c: trace::RewardType) -> Self {
|
|
match c {
|
|
trace::RewardType::Block => RewardType::Block,
|
|
trace::RewardType::Uncle => RewardType::Uncle,
|
|
trace::RewardType::EmptyStep => RewardType::EmptyStep,
|
|
trace::RewardType::External => RewardType::External,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reward action
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Reward {
|
|
/// Author's address.
|
|
pub author: H160,
|
|
/// Reward amount.
|
|
pub value: U256,
|
|
/// Reward type.
|
|
pub reward_type: RewardType,
|
|
}
|
|
|
|
impl From<trace::Reward> for Reward {
|
|
fn from(r: trace::Reward) -> Self {
|
|
Reward {
|
|
author: r.author,
|
|
value: r.value,
|
|
reward_type: r.reward_type.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Suicide
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Suicide {
|
|
/// Address.
|
|
pub address: H160,
|
|
/// Refund address.
|
|
pub refund_address: H160,
|
|
/// Balance.
|
|
pub balance: U256,
|
|
}
|
|
|
|
impl From<trace::Suicide> for Suicide {
|
|
fn from(s: trace::Suicide) -> Self {
|
|
Suicide {
|
|
address: s.address,
|
|
refund_address: s.refund_address,
|
|
balance: s.balance,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Action
|
|
#[derive(Debug)]
|
|
pub enum Action {
|
|
/// Call
|
|
Call(Call),
|
|
/// Create
|
|
Create(Create),
|
|
/// Suicide
|
|
Suicide(Suicide),
|
|
/// Reward
|
|
Reward(Reward),
|
|
}
|
|
|
|
impl From<trace::Action> for Action {
|
|
fn from(c: trace::Action) -> Self {
|
|
match c {
|
|
trace::Action::Call(call) => Action::Call(call.into()),
|
|
trace::Action::Create(create) => Action::Create(create.into()),
|
|
trace::Action::Suicide(suicide) => Action::Suicide(suicide.into()),
|
|
trace::Action::Reward(reward) => Action::Reward(reward.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Call Result
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CallResult {
|
|
/// Gas used
|
|
gas_used: U256,
|
|
/// Output bytes
|
|
output: Bytes,
|
|
}
|
|
|
|
impl From<trace::CallResult> for CallResult {
|
|
fn from(c: trace::CallResult) -> Self {
|
|
CallResult {
|
|
gas_used: c.gas_used,
|
|
output: c.output.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Craete Result
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CreateResult {
|
|
/// Gas used
|
|
gas_used: U256,
|
|
/// Code
|
|
code: Bytes,
|
|
/// Assigned address
|
|
address: H160,
|
|
}
|
|
|
|
impl From<trace::CreateResult> for CreateResult {
|
|
fn from(c: trace::CreateResult) -> Self {
|
|
CreateResult {
|
|
gas_used: c.gas_used,
|
|
code: c.code.into(),
|
|
address: c.address,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Response
|
|
#[derive(Debug)]
|
|
pub enum Res {
|
|
/// Call
|
|
Call(CallResult),
|
|
/// Create
|
|
Create(CreateResult),
|
|
/// Call failure
|
|
FailedCall(TraceError),
|
|
/// Creation failure
|
|
FailedCreate(TraceError),
|
|
/// None
|
|
None,
|
|
}
|
|
|
|
impl From<trace::Res> for Res {
|
|
fn from(t: trace::Res) -> Self {
|
|
match t {
|
|
trace::Res::Call(call) => Res::Call(CallResult::from(call)),
|
|
trace::Res::Create(create) => Res::Create(CreateResult::from(create)),
|
|
trace::Res::FailedCall(error) => Res::FailedCall(error),
|
|
trace::Res::FailedCreate(error) => Res::FailedCreate(error),
|
|
trace::Res::None => Res::None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Trace
|
|
#[derive(Debug)]
|
|
pub struct LocalizedTrace {
|
|
/// Action
|
|
action: Action,
|
|
/// Result
|
|
result: Res,
|
|
/// Trace address
|
|
trace_address: Vec<usize>,
|
|
/// Subtraces
|
|
subtraces: usize,
|
|
/// Transaction position
|
|
transaction_position: Option<usize>,
|
|
/// Transaction hash
|
|
transaction_hash: Option<H256>,
|
|
/// Block Number
|
|
block_number: u64,
|
|
/// Block Hash
|
|
block_hash: H256,
|
|
}
|
|
|
|
impl Serialize for LocalizedTrace {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where S: Serializer
|
|
{
|
|
let mut struc = serializer.serialize_struct("LocalizedTrace", 9)?;
|
|
match self.action {
|
|
Action::Call(ref call) => {
|
|
struc.serialize_field("type", "call")?;
|
|
struc.serialize_field("action", call)?;
|
|
},
|
|
Action::Create(ref create) => {
|
|
struc.serialize_field("type", "create")?;
|
|
struc.serialize_field("action", create)?;
|
|
},
|
|
Action::Suicide(ref suicide) => {
|
|
struc.serialize_field("type", "suicide")?;
|
|
struc.serialize_field("action", suicide)?;
|
|
},
|
|
Action::Reward(ref reward) => {
|
|
struc.serialize_field("type", "reward")?;
|
|
struc.serialize_field("action", reward)?;
|
|
},
|
|
}
|
|
|
|
match self.result {
|
|
Res::Call(ref call) => struc.serialize_field("result", call)?,
|
|
Res::Create(ref create) => struc.serialize_field("result", create)?,
|
|
Res::FailedCall(ref error) => struc.serialize_field("error", &error.to_string())?,
|
|
Res::FailedCreate(ref error) => struc.serialize_field("error", &error.to_string())?,
|
|
Res::None => struc.serialize_field("result", &None as &Option<u8>)?,
|
|
}
|
|
|
|
struc.serialize_field("traceAddress", &self.trace_address)?;
|
|
struc.serialize_field("subtraces", &self.subtraces)?;
|
|
struc.serialize_field("transactionPosition", &self.transaction_position)?;
|
|
struc.serialize_field("transactionHash", &self.transaction_hash)?;
|
|
struc.serialize_field("blockNumber", &self.block_number)?;
|
|
struc.serialize_field("blockHash", &self.block_hash)?;
|
|
|
|
struc.end()
|
|
}
|
|
}
|
|
|
|
impl From<EthLocalizedTrace> for LocalizedTrace {
|
|
fn from(t: EthLocalizedTrace) -> Self {
|
|
LocalizedTrace {
|
|
action: t.action.into(),
|
|
result: t.result.into(),
|
|
trace_address: t.trace_address.into_iter().map(Into::into).collect(),
|
|
subtraces: t.subtraces,
|
|
transaction_position: t.transaction_number.map(Into::into),
|
|
transaction_hash: t.transaction_hash.map(Into::into),
|
|
block_number: t.block_number,
|
|
block_hash: t.block_hash,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Trace
|
|
#[derive(Debug)]
|
|
pub struct Trace {
|
|
/// Trace address
|
|
trace_address: Vec<usize>,
|
|
/// Subtraces
|
|
subtraces: usize,
|
|
/// Action
|
|
action: Action,
|
|
/// Result
|
|
result: Res,
|
|
}
|
|
|
|
impl Serialize for Trace {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where S: Serializer
|
|
{
|
|
let mut struc = serializer.serialize_struct("Trace", 4)?;
|
|
match self.action {
|
|
Action::Call(ref call) => {
|
|
struc.serialize_field("type", "call")?;
|
|
struc.serialize_field("action", call)?;
|
|
},
|
|
Action::Create(ref create) => {
|
|
struc.serialize_field("type", "create")?;
|
|
struc.serialize_field("action", create)?;
|
|
},
|
|
Action::Suicide(ref suicide) => {
|
|
struc.serialize_field("type", "suicide")?;
|
|
struc.serialize_field("action", suicide)?;
|
|
},
|
|
Action::Reward(ref reward) => {
|
|
struc.serialize_field("type", "reward")?;
|
|
struc.serialize_field("action", reward)?;
|
|
},
|
|
}
|
|
|
|
match self.result {
|
|
Res::Call(ref call) => struc.serialize_field("result", call)?,
|
|
Res::Create(ref create) => struc.serialize_field("result", create)?,
|
|
Res::FailedCall(ref error) => struc.serialize_field("error", &error.to_string())?,
|
|
Res::FailedCreate(ref error) => struc.serialize_field("error", &error.to_string())?,
|
|
Res::None => struc.serialize_field("result", &None as &Option<u8>)?,
|
|
}
|
|
|
|
struc.serialize_field("traceAddress", &self.trace_address)?;
|
|
struc.serialize_field("subtraces", &self.subtraces)?;
|
|
|
|
struc.end()
|
|
}
|
|
}
|
|
|
|
impl From<FlatTrace> for Trace {
|
|
fn from(t: FlatTrace) -> Self {
|
|
Trace {
|
|
trace_address: t.trace_address.into_iter().map(Into::into).collect(),
|
|
subtraces: t.subtraces,
|
|
action: t.action.into(),
|
|
result: t.result.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
/// A diff of some chunk of memory.
|
|
pub struct TraceResults {
|
|
/// The output of the call/create
|
|
pub output: Bytes,
|
|
/// The transaction trace.
|
|
pub trace: Vec<Trace>,
|
|
/// The transaction trace.
|
|
pub vm_trace: Option<VMTrace>,
|
|
/// The transaction trace.
|
|
pub state_diff: Option<StateDiff>,
|
|
}
|
|
|
|
impl From<Executed> for TraceResults {
|
|
fn from(t: Executed) -> Self {
|
|
TraceResults {
|
|
output: t.output.into(),
|
|
trace: t.trace.into_iter().map(Into::into).collect(),
|
|
vm_trace: t.vm_trace.map(Into::into),
|
|
state_diff: t.state_diff.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
/// A diff of some chunk of memory.
|
|
pub struct TraceResultsWithTransactionHash {
|
|
/// The output of the call/create
|
|
pub output: Bytes,
|
|
/// The transaction trace.
|
|
pub trace: Vec<Trace>,
|
|
/// The transaction trace.
|
|
pub vm_trace: Option<VMTrace>,
|
|
/// The transaction trace.
|
|
pub state_diff: Option<StateDiff>,
|
|
/// The transaction Hash.
|
|
pub transaction_hash: H256,
|
|
}
|
|
|
|
impl From<(H256, Executed)> for TraceResultsWithTransactionHash {
|
|
fn from(t: (H256, Executed)) -> Self {
|
|
TraceResultsWithTransactionHash {
|
|
output: t.1.output.into(),
|
|
trace: t.1.trace.into_iter().map(Into::into).collect(),
|
|
vm_trace: t.1.vm_trace.map(Into::into),
|
|
state_diff: t.1.state_diff.map(Into::into),
|
|
transaction_hash: t.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use serde_json;
|
|
use std::collections::BTreeMap;
|
|
use v1::types::Bytes;
|
|
use ethcore::trace::TraceError;
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn should_serialize_trace_results() {
|
|
let r = TraceResults {
|
|
output: vec![0x60].into(),
|
|
trace: vec![],
|
|
vm_trace: None,
|
|
state_diff: None,
|
|
};
|
|
let serialized = serde_json::to_string(&r).unwrap();
|
|
assert_eq!(serialized, r#"{"output":"0x60","trace":[],"vmTrace":null,"stateDiff":null}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_call_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Call(Call {
|
|
from: 4.into(),
|
|
to: 5.into(),
|
|
value: 6.into(),
|
|
gas: 7.into(),
|
|
input: Bytes::new(vec![0x12, 0x34]),
|
|
call_type: CallType::Call,
|
|
}),
|
|
result: Res::Call(CallResult {
|
|
gas_used: 8.into(),
|
|
output: vec![0x56, 0x78].into(),
|
|
}),
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: Some(11),
|
|
transaction_hash: Some(12.into()),
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"call","action":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x6","gas":"0x7","input":"0x1234","callType":"call"},"result":{"gasUsed":"0x8","output":"0x5678"},"traceAddress":[10],"subtraces":1,"transactionPosition":11,"transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_failed_call_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Call(Call {
|
|
from: 4.into(),
|
|
to: 5.into(),
|
|
value: 6.into(),
|
|
gas: 7.into(),
|
|
input: Bytes::new(vec![0x12, 0x34]),
|
|
call_type: CallType::Call,
|
|
}),
|
|
result: Res::FailedCall(TraceError::OutOfGas),
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: Some(11),
|
|
transaction_hash: Some(12.into()),
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"call","action":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x6","gas":"0x7","input":"0x1234","callType":"call"},"error":"Out of gas","traceAddress":[10],"subtraces":1,"transactionPosition":11,"transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_create_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Create(Create {
|
|
from: 4.into(),
|
|
value: 6.into(),
|
|
gas: 7.into(),
|
|
init: Bytes::new(vec![0x12, 0x34]),
|
|
}),
|
|
result: Res::Create(CreateResult {
|
|
gas_used: 8.into(),
|
|
code: vec![0x56, 0x78].into(),
|
|
address: 0xff.into(),
|
|
}),
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: Some(11),
|
|
transaction_hash: Some(12.into()),
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"create","action":{"from":"0x0000000000000000000000000000000000000004","value":"0x6","gas":"0x7","init":"0x1234"},"result":{"gasUsed":"0x8","code":"0x5678","address":"0x00000000000000000000000000000000000000ff"},"traceAddress":[10],"subtraces":1,"transactionPosition":11,"transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_failed_create_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Create(Create {
|
|
from: 4.into(),
|
|
value: 6.into(),
|
|
gas: 7.into(),
|
|
init: Bytes::new(vec![0x12, 0x34]),
|
|
}),
|
|
result: Res::FailedCreate(TraceError::OutOfGas),
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: Some(11),
|
|
transaction_hash: Some(12.into()),
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"create","action":{"from":"0x0000000000000000000000000000000000000004","value":"0x6","gas":"0x7","init":"0x1234"},"error":"Out of gas","traceAddress":[10],"subtraces":1,"transactionPosition":11,"transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_suicide_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Suicide(Suicide {
|
|
address: 4.into(),
|
|
refund_address: 6.into(),
|
|
balance: 7.into(),
|
|
}),
|
|
result: Res::None,
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: Some(11),
|
|
transaction_hash: Some(12.into()),
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"suicide","action":{"address":"0x0000000000000000000000000000000000000004","refundAddress":"0x0000000000000000000000000000000000000006","balance":"0x7"},"result":null,"traceAddress":[10],"subtraces":1,"transactionPosition":11,"transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trace_reward_serialize() {
|
|
let t = LocalizedTrace {
|
|
action: Action::Reward(Reward {
|
|
author: 4.into(),
|
|
value: 6.into(),
|
|
reward_type: RewardType::Block,
|
|
}),
|
|
result: Res::None,
|
|
trace_address: vec![10],
|
|
subtraces: 1,
|
|
transaction_position: None,
|
|
transaction_hash: None,
|
|
block_number: 13,
|
|
block_hash: 14.into(),
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"type":"reward","action":{"author":"0x0000000000000000000000000000000000000004","value":"0x6","rewardType":"block"},"result":null,"traceAddress":[10],"subtraces":1,"transactionPosition":null,"transactionHash":null,"blockNumber":13,"blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_vmtrace_serialize() {
|
|
let t = VMTrace {
|
|
code: vec![0, 1, 2, 3].into(),
|
|
ops: vec![
|
|
VMOperation {
|
|
pc: 0,
|
|
cost: 10,
|
|
ex: None,
|
|
sub: None,
|
|
},
|
|
VMOperation {
|
|
pc: 1,
|
|
cost: 11,
|
|
ex: Some(VMExecutedOperation {
|
|
used: 10,
|
|
push: vec![69.into()],
|
|
mem: None,
|
|
store: None,
|
|
}),
|
|
sub: Some(VMTrace {
|
|
code: vec![0].into(),
|
|
ops: vec![
|
|
VMOperation {
|
|
pc: 0,
|
|
cost: 0,
|
|
ex: Some(VMExecutedOperation {
|
|
used: 10,
|
|
push: vec![42.into()].into(),
|
|
mem: Some(MemoryDiff {off: 42, data: vec![1, 2, 3].into()}),
|
|
store: Some(StorageDiff {key: 69.into(), val: 42.into()}),
|
|
}),
|
|
sub: None,
|
|
}
|
|
]
|
|
}),
|
|
}
|
|
]
|
|
};
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"code":"0x00010203","ops":[{"pc":0,"cost":10,"ex":null,"sub":null},{"pc":1,"cost":11,"ex":{"used":10,"push":["0x45"],"mem":null,"store":null},"sub":{"code":"0x00","ops":[{"pc":0,"cost":0,"ex":{"used":10,"push":["0x2a"],"mem":{"off":42,"data":"0x010203"},"store":{"key":"0x45","val":"0x2a"}},"sub":null}]}}]}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_statediff_serialize() {
|
|
let t = StateDiff(map![
|
|
42.into() => AccountDiff {
|
|
balance: Diff::Same,
|
|
nonce: Diff::Born(1.into()),
|
|
code: Diff::Same,
|
|
storage: map![
|
|
42.into() => Diff::Same
|
|
]
|
|
},
|
|
69.into() => AccountDiff {
|
|
balance: Diff::Same,
|
|
nonce: Diff::Changed(ChangedType { from: 1.into(), to: 0.into() }),
|
|
code: Diff::Died(vec![96].into()),
|
|
storage: map![],
|
|
}
|
|
]);
|
|
let serialized = serde_json::to_string(&t).unwrap();
|
|
assert_eq!(serialized, r#"{"0x000000000000000000000000000000000000002a":{"balance":"=","nonce":{"+":"0x1"},"code":"=","storage":{"0x000000000000000000000000000000000000000000000000000000000000002a":"="}},"0x0000000000000000000000000000000000000045":{"balance":"=","nonce":{"*":{"from":"0x1","to":"0x0"}},"code":{"-":"0x60"},"storage":{}}}"#);
|
|
}
|
|
}
|