86de2e516e
This PR allows users to pass in a config object directly to the tracers. Previously only the struct logger was configurable. It also adds an option to the call tracer which if enabled makes it ignore any subcall and collect only information about the top-level call. See #25419 for discussion. The tracers will silently ignore if they are passed a config they don't care about.
392 lines
14 KiB
Go
392 lines
14 KiB
Go
// Copyright 2021 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 tracetest
|
|
|
|
import (
|
|
"encoding/json"
|
|
"math/big"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"unicode"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/common/math"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/eth/tracers"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/tests"
|
|
|
|
// Force-load native and js pacakges, to trigger registration
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/js"
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/native"
|
|
)
|
|
|
|
// To generate a new callTracer test, copy paste the makeTest method below into
|
|
// a Geth console and call it with a transaction hash you which to export.
|
|
|
|
/*
|
|
// makeTest generates a callTracer test by running a prestate reassembled and a
|
|
// call trace run, assembling all the gathered information into a test case.
|
|
var makeTest = function(tx, rewind) {
|
|
// Generate the genesis block from the block, transaction and prestate data
|
|
var block = eth.getBlock(eth.getTransaction(tx).blockHash);
|
|
var genesis = eth.getBlock(block.parentHash);
|
|
|
|
delete genesis.gasUsed;
|
|
delete genesis.logsBloom;
|
|
delete genesis.parentHash;
|
|
delete genesis.receiptsRoot;
|
|
delete genesis.sha3Uncles;
|
|
delete genesis.size;
|
|
delete genesis.transactions;
|
|
delete genesis.transactionsRoot;
|
|
delete genesis.uncles;
|
|
|
|
genesis.gasLimit = genesis.gasLimit.toString();
|
|
genesis.number = genesis.number.toString();
|
|
genesis.timestamp = genesis.timestamp.toString();
|
|
|
|
genesis.alloc = debug.traceTransaction(tx, {tracer: "prestateTracer", rewind: rewind});
|
|
for (var key in genesis.alloc) {
|
|
genesis.alloc[key].nonce = genesis.alloc[key].nonce.toString();
|
|
}
|
|
genesis.config = admin.nodeInfo.protocols.eth.config;
|
|
|
|
// Generate the call trace and produce the test input
|
|
var result = debug.traceTransaction(tx, {tracer: "callTracer", rewind: rewind});
|
|
delete result.time;
|
|
|
|
console.log(JSON.stringify({
|
|
genesis: genesis,
|
|
context: {
|
|
number: block.number.toString(),
|
|
difficulty: block.difficulty,
|
|
timestamp: block.timestamp.toString(),
|
|
gasLimit: block.gasLimit.toString(),
|
|
miner: block.miner,
|
|
},
|
|
input: eth.getRawTransaction(tx),
|
|
result: result,
|
|
}, null, 2));
|
|
}
|
|
*/
|
|
|
|
type callContext struct {
|
|
Number math.HexOrDecimal64 `json:"number"`
|
|
Difficulty *math.HexOrDecimal256 `json:"difficulty"`
|
|
Time math.HexOrDecimal64 `json:"timestamp"`
|
|
GasLimit math.HexOrDecimal64 `json:"gasLimit"`
|
|
Miner common.Address `json:"miner"`
|
|
}
|
|
|
|
// callTrace is the result of a callTracer run.
|
|
type callTrace struct {
|
|
Type string `json:"type"`
|
|
From common.Address `json:"from"`
|
|
To common.Address `json:"to"`
|
|
Input hexutil.Bytes `json:"input"`
|
|
Output hexutil.Bytes `json:"output"`
|
|
Gas *hexutil.Uint64 `json:"gas,omitempty"`
|
|
GasUsed *hexutil.Uint64 `json:"gasUsed,omitempty"`
|
|
Value *hexutil.Big `json:"value,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
Calls []callTrace `json:"calls,omitempty"`
|
|
}
|
|
|
|
// callTracerTest defines a single test to check the call tracer against.
|
|
type callTracerTest struct {
|
|
Genesis *core.Genesis `json:"genesis"`
|
|
Context *callContext `json:"context"`
|
|
Input string `json:"input"`
|
|
TracerConfig json.RawMessage `json:"tracerConfig"`
|
|
Result *callTrace `json:"result"`
|
|
}
|
|
|
|
// Iterates over all the input-output datasets in the tracer test harness and
|
|
// runs the JavaScript tracers against them.
|
|
func TestCallTracerLegacy(t *testing.T) {
|
|
testCallTracer("callTracerLegacy", "call_tracer_legacy", t)
|
|
}
|
|
|
|
func TestCallTracerNative(t *testing.T) {
|
|
testCallTracer("callTracer", "call_tracer", t)
|
|
}
|
|
|
|
func testCallTracer(tracerName string, dirPath string, t *testing.T) {
|
|
files, err := os.ReadDir(filepath.Join("testdata", dirPath))
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve tracer test suite: %v", err)
|
|
}
|
|
for _, file := range files {
|
|
if !strings.HasSuffix(file.Name(), ".json") {
|
|
continue
|
|
}
|
|
file := file // capture range variable
|
|
t.Run(camel(strings.TrimSuffix(file.Name(), ".json")), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var (
|
|
test = new(callTracerTest)
|
|
tx = new(types.Transaction)
|
|
)
|
|
// Call tracer test found, read if from disk
|
|
if blob, err := os.ReadFile(filepath.Join("testdata", dirPath, file.Name())); err != nil {
|
|
t.Fatalf("failed to read testcase: %v", err)
|
|
} else if err := json.Unmarshal(blob, test); err != nil {
|
|
t.Fatalf("failed to parse testcase: %v", err)
|
|
}
|
|
if err := rlp.DecodeBytes(common.FromHex(test.Input), tx); err != nil {
|
|
t.Fatalf("failed to parse testcase input: %v", err)
|
|
}
|
|
// Configure a blockchain with the given prestate
|
|
var (
|
|
signer = types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)))
|
|
origin, _ = signer.Sender(tx)
|
|
txContext = vm.TxContext{
|
|
Origin: origin,
|
|
GasPrice: tx.GasPrice(),
|
|
}
|
|
context = vm.BlockContext{
|
|
CanTransfer: core.CanTransfer,
|
|
Transfer: core.Transfer,
|
|
Coinbase: test.Context.Miner,
|
|
BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)),
|
|
Time: new(big.Int).SetUint64(uint64(test.Context.Time)),
|
|
Difficulty: (*big.Int)(test.Context.Difficulty),
|
|
GasLimit: uint64(test.Context.GasLimit),
|
|
}
|
|
_, statedb = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false)
|
|
)
|
|
tracer, err := tracers.New(tracerName, new(tracers.Context), test.TracerConfig)
|
|
if err != nil {
|
|
t.Fatalf("failed to create call tracer: %v", err)
|
|
}
|
|
evm := vm.NewEVM(context, txContext, statedb, test.Genesis.Config, vm.Config{Debug: true, Tracer: tracer})
|
|
msg, err := tx.AsMessage(signer, nil)
|
|
if err != nil {
|
|
t.Fatalf("failed to prepare transaction for tracing: %v", err)
|
|
}
|
|
st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas()))
|
|
if _, err = st.TransitionDb(); err != nil {
|
|
t.Fatalf("failed to execute transaction: %v", err)
|
|
}
|
|
// Retrieve the trace result and compare against the etalon
|
|
res, err := tracer.GetResult()
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve trace result: %v", err)
|
|
}
|
|
ret := new(callTrace)
|
|
if err := json.Unmarshal(res, ret); err != nil {
|
|
t.Fatalf("failed to unmarshal trace result: %v", err)
|
|
}
|
|
|
|
if !jsonEqual(ret, test.Result) {
|
|
// uncomment this for easier debugging
|
|
//have, _ := json.MarshalIndent(ret, "", " ")
|
|
//want, _ := json.MarshalIndent(test.Result, "", " ")
|
|
//t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", string(have), string(want))
|
|
t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", ret, test.Result)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// jsonEqual is similar to reflect.DeepEqual, but does a 'bounce' via json prior to
|
|
// comparison
|
|
func jsonEqual(x, y interface{}) bool {
|
|
xTrace := new(callTrace)
|
|
yTrace := new(callTrace)
|
|
if xj, err := json.Marshal(x); err == nil {
|
|
json.Unmarshal(xj, xTrace)
|
|
} else {
|
|
return false
|
|
}
|
|
if yj, err := json.Marshal(y); err == nil {
|
|
json.Unmarshal(yj, yTrace)
|
|
} else {
|
|
return false
|
|
}
|
|
return reflect.DeepEqual(xTrace, yTrace)
|
|
}
|
|
|
|
// camel converts a snake cased input string into a camel cased output.
|
|
func camel(str string) string {
|
|
pieces := strings.Split(str, "_")
|
|
for i := 1; i < len(pieces); i++ {
|
|
pieces[i] = string(unicode.ToUpper(rune(pieces[i][0]))) + pieces[i][1:]
|
|
}
|
|
return strings.Join(pieces, "")
|
|
}
|
|
func BenchmarkTracers(b *testing.B) {
|
|
files, err := os.ReadDir(filepath.Join("testdata", "call_tracer"))
|
|
if err != nil {
|
|
b.Fatalf("failed to retrieve tracer test suite: %v", err)
|
|
}
|
|
for _, file := range files {
|
|
if !strings.HasSuffix(file.Name(), ".json") {
|
|
continue
|
|
}
|
|
file := file // capture range variable
|
|
b.Run(camel(strings.TrimSuffix(file.Name(), ".json")), func(b *testing.B) {
|
|
blob, err := os.ReadFile(filepath.Join("testdata", "call_tracer", file.Name()))
|
|
if err != nil {
|
|
b.Fatalf("failed to read testcase: %v", err)
|
|
}
|
|
test := new(callTracerTest)
|
|
if err := json.Unmarshal(blob, test); err != nil {
|
|
b.Fatalf("failed to parse testcase: %v", err)
|
|
}
|
|
benchTracer("callTracer", test, b)
|
|
})
|
|
}
|
|
}
|
|
|
|
func benchTracer(tracerName string, test *callTracerTest, b *testing.B) {
|
|
// Configure a blockchain with the given prestate
|
|
tx := new(types.Transaction)
|
|
if err := rlp.DecodeBytes(common.FromHex(test.Input), tx); err != nil {
|
|
b.Fatalf("failed to parse testcase input: %v", err)
|
|
}
|
|
signer := types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)))
|
|
msg, err := tx.AsMessage(signer, nil)
|
|
if err != nil {
|
|
b.Fatalf("failed to prepare transaction for tracing: %v", err)
|
|
}
|
|
origin, _ := signer.Sender(tx)
|
|
txContext := vm.TxContext{
|
|
Origin: origin,
|
|
GasPrice: tx.GasPrice(),
|
|
}
|
|
context := vm.BlockContext{
|
|
CanTransfer: core.CanTransfer,
|
|
Transfer: core.Transfer,
|
|
Coinbase: test.Context.Miner,
|
|
BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)),
|
|
Time: new(big.Int).SetUint64(uint64(test.Context.Time)),
|
|
Difficulty: (*big.Int)(test.Context.Difficulty),
|
|
GasLimit: uint64(test.Context.GasLimit),
|
|
}
|
|
_, statedb := tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false)
|
|
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
tracer, err := tracers.New(tracerName, new(tracers.Context), nil)
|
|
if err != nil {
|
|
b.Fatalf("failed to create call tracer: %v", err)
|
|
}
|
|
evm := vm.NewEVM(context, txContext, statedb, test.Genesis.Config, vm.Config{Debug: true, Tracer: tracer})
|
|
snap := statedb.Snapshot()
|
|
st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas()))
|
|
if _, err = st.TransitionDb(); err != nil {
|
|
b.Fatalf("failed to execute transaction: %v", err)
|
|
}
|
|
if _, err = tracer.GetResult(); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
statedb.RevertToSnapshot(snap)
|
|
}
|
|
}
|
|
|
|
// TestZeroValueToNotExitCall tests the calltracer(s) on the following:
|
|
// Tx to A, A calls B with zero value. B does not already exist.
|
|
// Expected: that enter/exit is invoked and the inner call is shown in the result
|
|
func TestZeroValueToNotExitCall(t *testing.T) {
|
|
var to = common.HexToAddress("0x00000000000000000000000000000000deadbeef")
|
|
privkey, err := crypto.HexToECDSA("0000000000000000deadbeef00000000000000000000000000000000deadbeef")
|
|
if err != nil {
|
|
t.Fatalf("err %v", err)
|
|
}
|
|
signer := types.NewEIP155Signer(big.NewInt(1))
|
|
tx, err := types.SignNewTx(privkey, signer, &types.LegacyTx{
|
|
GasPrice: big.NewInt(0),
|
|
Gas: 50000,
|
|
To: &to,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("err %v", err)
|
|
}
|
|
origin, _ := signer.Sender(tx)
|
|
txContext := vm.TxContext{
|
|
Origin: origin,
|
|
GasPrice: big.NewInt(1),
|
|
}
|
|
context := vm.BlockContext{
|
|
CanTransfer: core.CanTransfer,
|
|
Transfer: core.Transfer,
|
|
Coinbase: common.Address{},
|
|
BlockNumber: new(big.Int).SetUint64(8000000),
|
|
Time: new(big.Int).SetUint64(5),
|
|
Difficulty: big.NewInt(0x30000),
|
|
GasLimit: uint64(6000000),
|
|
}
|
|
var code = []byte{
|
|
byte(vm.PUSH1), 0x0, byte(vm.DUP1), byte(vm.DUP1), byte(vm.DUP1), // in and outs zero
|
|
byte(vm.DUP1), byte(vm.PUSH1), 0xff, byte(vm.GAS), // value=0,address=0xff, gas=GAS
|
|
byte(vm.CALL),
|
|
}
|
|
var alloc = core.GenesisAlloc{
|
|
to: core.GenesisAccount{
|
|
Nonce: 1,
|
|
Code: code,
|
|
},
|
|
origin: core.GenesisAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(500000000000000),
|
|
},
|
|
}
|
|
_, statedb := tests.MakePreState(rawdb.NewMemoryDatabase(), alloc, false)
|
|
// Create the tracer, the EVM environment and run it
|
|
tracer, err := tracers.New("callTracer", nil, nil)
|
|
if err != nil {
|
|
t.Fatalf("failed to create call tracer: %v", err)
|
|
}
|
|
evm := vm.NewEVM(context, txContext, statedb, params.MainnetChainConfig, vm.Config{Debug: true, Tracer: tracer})
|
|
msg, err := tx.AsMessage(signer, nil)
|
|
if err != nil {
|
|
t.Fatalf("failed to prepare transaction for tracing: %v", err)
|
|
}
|
|
st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas()))
|
|
if _, err = st.TransitionDb(); err != nil {
|
|
t.Fatalf("failed to execute transaction: %v", err)
|
|
}
|
|
// Retrieve the trace result and compare against the etalon
|
|
res, err := tracer.GetResult()
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve trace result: %v", err)
|
|
}
|
|
have := new(callTrace)
|
|
if err := json.Unmarshal(res, have); err != nil {
|
|
t.Fatalf("failed to unmarshal trace result: %v", err)
|
|
}
|
|
wantStr := `{"type":"CALL","from":"0x682a80a6f560eec50d54e63cbeda1c324c5f8d1b","to":"0x00000000000000000000000000000000deadbeef","value":"0x0","gas":"0x7148","gasUsed":"0x2d0","input":"0x","output":"0x","calls":[{"type":"CALL","from":"0x00000000000000000000000000000000deadbeef","to":"0x00000000000000000000000000000000000000ff","value":"0x0","gas":"0x6cbf","gasUsed":"0x0","input":"0x","output":"0x"}]}`
|
|
want := new(callTrace)
|
|
json.Unmarshal([]byte(wantStr), want)
|
|
if !jsonEqual(have, want) {
|
|
t.Error("have != want")
|
|
}
|
|
}
|