1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright 2015-2018 Parity Technologies (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 <http://www.gnu.org/licenses/>.

//! Nonoperative tracer.

use ethereum_types::{U256, Address};
use bytes::Bytes;
use vm::ActionParams;
use trace::{Tracer, VMTracer, FlatTrace, TraceError};
use trace::trace::{Call, Create, VMTrace, RewardType};

/// Nonoperative tracer. Does not trace anything.
pub struct NoopTracer;

impl Tracer for NoopTracer {
	type Output = FlatTrace;

	fn prepare_trace_call(&self, _: &ActionParams) -> Option<Call> {
		None
	}

	fn prepare_trace_create(&self, _: &ActionParams) -> Option<Create> {
		None
	}

	fn prepare_trace_output(&self) -> Option<Bytes> {
		None
	}

	fn trace_call(&mut self, call: Option<Call>, _: U256, output: Option<Bytes>, _: Vec<FlatTrace>) {
		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
		assert!(output.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
	}

	fn trace_create(&mut self, create: Option<Create>, _: U256, code: Option<Bytes>, _: Address, _: Vec<FlatTrace>) {
		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
		assert!(code.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
	}

	fn trace_failed_call(&mut self, call: Option<Call>, _: Vec<FlatTrace>, _: TraceError) {
		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
	}

	fn trace_failed_create(&mut self, create: Option<Create>, _: Vec<FlatTrace>, _: TraceError) {
		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
	}

	fn trace_suicide(&mut self, _address: Address, _balance: U256, _refund_address: Address) {
	}

	fn trace_reward(&mut self, _: Address, _: U256, _: RewardType) {
	}

	fn subtracer(&self) -> Self {
		NoopTracer
	}

	fn drain(self) -> Vec<FlatTrace> {
		vec![]
	}
}

/// Nonoperative VM tracer. Does not trace anything.
pub struct NoopVMTracer;

impl VMTracer for NoopVMTracer {
	type Output = VMTrace;

	fn trace_next_instruction(&mut self, _pc: usize, _instruction: u8, _current_gas: U256) -> bool { false }

	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: U256) {}

	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}

	fn prepare_subtrace(&self, _code: &[u8]) -> Self { NoopVMTracer }

	fn done_subtrace(&mut self, _sub: Self) {}

	fn drain(self) -> Option<VMTrace> { None }
}