cmd, core, eth/tracers: support fancier js tracing (#15516)

* cmd, core, eth/tracers: support fancier js tracing

* eth, internal/web3ext: rework trace API, concurrency, chain tracing

* eth/tracers: add three more JavaScript tracers

* eth/tracers, vendor: swap ottovm to duktape for tracing

* core, eth, internal: finalize call tracer and needed extras

* eth, tests: prestate tracer, call test suite, rewinding

* vendor: fix windows builds for tracer js engine

* vendor: temporary duktape fix

* eth/tracers: fix up 4byte and evmdis tracer

* vendor: pull in latest duktape with my upstream fixes

* eth: fix some review comments

* eth: rename rewind to reexec to make it more obvious

* core/vm: terminate tracing using defers

1 files changed, 140 insertions, 0 deletions

diff --git a/eth/tracers/tracer_test.go b/eth/tracers/tracer_test.go
new file mode 100644
index 000000000..7224a1489
--- /dev/null
+++ b/eth/tracers/tracer_test.go
@@ -0,0 +1,140 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package tracers
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+type account struct{}
+
+func (account) SubBalance(amount *big.Int)                          {}
+func (account) AddBalance(amount *big.Int)                          {}
+func (account) SetAddress(common.Address)                           {}
+func (account) Value() *big.Int                                     { return nil }
+func (account) SetBalance(*big.Int)                                 {}
+func (account) SetNonce(uint64)                                     {}
+func (account) Balance() *big.Int                                   { return nil }
+func (account) Address() common.Address                             { return common.Address{} }
+func (account) ReturnGas(*big.Int)                                  {}
+func (account) SetCode(common.Hash, []byte)                         {}
+func (account) ForEachStorage(cb func(key, value common.Hash) bool) {}
+
+func runTrace(tracer *Tracer) (json.RawMessage, error) {
+	env := vm.NewEVM(vm.Context{BlockNumber: big.NewInt(1)}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer})
+
+	contract := vm.NewContract(account{}, account{}, big.NewInt(0), 10000)
+	contract.Code = []byte{byte(vm.PUSH1), 0x1, byte(vm.PUSH1), 0x1, 0x0}
+
+	_, err := env.Interpreter().Run(contract, []byte{})
+	if err != nil {
+		return nil, err
+	}
+	return tracer.GetResult()
+}
+
+func TestTracing(t *testing.T) {
+	tracer, err := New("{count: 0, step: function() { this.count += 1; }, fault: function() {}, result: function() { return this.count; }}")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ret, err := runTrace(tracer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(ret, []byte("3")) {
+		t.Errorf("Expected return value to be 3, got %s", string(ret))
+	}
+}
+
+func TestStack(t *testing.T) {
+	tracer, err := New("{depths: [], step: function(log) { this.depths.push(log.stack.length()); }, fault: function() {}, result: function() { return this.depths; }}")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ret, err := runTrace(tracer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(ret, []byte("[0,1,2]")) {
+		t.Errorf("Expected return value to be [0,1,2], got %s", string(ret))
+	}
+}
+
+func TestOpcodes(t *testing.T) {
+	tracer, err := New("{opcodes: [], step: function(log) { this.opcodes.push(log.op.toString()); }, fault: function() {}, result: function() { return this.opcodes; }}")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ret, err := runTrace(tracer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(ret, []byte("[\"PUSH1\",\"PUSH1\",\"STOP\"]")) {
+		t.Errorf("Expected return value to be [\"PUSH1\",\"PUSH1\",\"STOP\"], got %s", string(ret))
+	}
+}
+
+func TestHalt(t *testing.T) {
+	t.Skip("duktape doesn't support abortion")
+
+	timeout := errors.New("stahp")
+	tracer, err := New("{step: function() { while(1); }, result: function() { return null; }}")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	go func() {
+		time.Sleep(1 * time.Second)
+		tracer.Stop(timeout)
+	}()
+
+	if _, err = runTrace(tracer); err.Error() != "stahp    in server-side tracer function 'step'" {
+		t.Errorf("Expected timeout error, got %v", err)
+	}
+}
+
+func TestHaltBetweenSteps(t *testing.T) {
+	tracer, err := New("{step: function() {}, fault: function() {}, result: function() { return null; }}")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	env := vm.NewEVM(vm.Context{BlockNumber: big.NewInt(1)}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer})
+	contract := vm.NewContract(&account{}, &account{}, big.NewInt(0), 0)
+
+	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, contract, 0, nil)
+	timeout := errors.New("stahp")
+	tracer.Stop(timeout)
+	tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, contract, 0, nil)
+
+	if _, err := tracer.GetResult(); err.Error() != timeout.Error() {
+		t.Errorf("Expected timeout error, got %v", err)
+	}
+}