forked from cerc-io/plugeth
ba47d800b1
#23773 added a JS tracer which uses Goja as its engine. In this PR I remove the previous tracer which used duktape as well as remove the dependencies. This PR also comes with 2 fixes in the Goja tracer and one small behavioural change: I had handled errors in the native Go functions by panicing. My oversight was that Goja only handles panics with a Goja.Value as argument. The difference is panic(goja.Value) allows JS to catch the exception whereas Interrupt(error) doesn't. There was a race in how I handled Stop. Because of 1. some of the methods that simply return nil on error (like memory.slice) now throw an exception.
391 lines
14 KiB
Go
391 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"`
|
|
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))
|
|
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))
|
|
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)
|
|
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")
|
|
}
|
|
}
|