2021-11-09 05:09:35 -06:00
|
|
|
// 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
|
2021-11-05 05:48:21 -05:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"math/big"
|
2022-05-16 04:59:35 -05:00
|
|
|
"os"
|
2021-11-05 05:48:21 -05:00
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"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"
|
2021-11-09 05:09:35 -06:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2021-11-05 05:48:21 -05:00
|
|
|
"github.com/ethereum/go-ethereum/eth/tracers"
|
2021-11-09 05:09:35 -06:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2021-11-05 05:48:21 -05:00
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
|
|
"github.com/ethereum/go-ethereum/tests"
|
|
|
|
)
|
|
|
|
|
|
|
|
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"`
|
|
|
|
}
|
|
|
|
|
2022-11-01 06:03:26 -05:00
|
|
|
// callLog is the result of LOG opCode
|
|
|
|
type callLog struct {
|
|
|
|
Address common.Address `json:"address"`
|
|
|
|
Topics []common.Hash `json:"topics"`
|
|
|
|
Data hexutil.Bytes `json:"data"`
|
|
|
|
}
|
|
|
|
|
2021-11-05 05:48:21 -05:00
|
|
|
// callTrace is the result of a callTracer run.
|
|
|
|
type callTrace struct {
|
2023-01-31 02:29:17 -06:00
|
|
|
From common.Address `json:"from"`
|
|
|
|
Gas *hexutil.Uint64 `json:"gas"`
|
|
|
|
GasUsed *hexutil.Uint64 `json:"gasUsed"`
|
2023-03-07 07:39:11 -06:00
|
|
|
To *common.Address `json:"to,omitempty"`
|
2023-01-31 02:29:17 -06:00
|
|
|
Input hexutil.Bytes `json:"input"`
|
|
|
|
Output hexutil.Bytes `json:"output,omitempty"`
|
|
|
|
Error string `json:"error,omitempty"`
|
|
|
|
RevertReason string `json:"revertReason,omitempty"`
|
|
|
|
Calls []callTrace `json:"calls,omitempty"`
|
|
|
|
Logs []callLog `json:"logs,omitempty"`
|
|
|
|
Value *hexutil.Big `json:"value,omitempty"`
|
2022-10-21 10:55:15 -05:00
|
|
|
// Gencodec adds overridden fields at the end
|
|
|
|
Type string `json:"type"`
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// callTracerTest defines a single test to check the call tracer against.
|
|
|
|
type callTracerTest struct {
|
2022-08-09 04:04:57 -05:00
|
|
|
Genesis *core.Genesis `json:"genesis"`
|
|
|
|
Context *callContext `json:"context"`
|
|
|
|
Input string `json:"input"`
|
|
|
|
TracerConfig json.RawMessage `json:"tracerConfig"`
|
|
|
|
Result *callTrace `json:"result"`
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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) {
|
2021-11-08 07:08:12 -06:00
|
|
|
testCallTracer("callTracer", "call_tracer", t)
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
|
|
|
|
2022-11-01 06:03:26 -05:00
|
|
|
func TestCallTracerNativeWithLog(t *testing.T) {
|
|
|
|
testCallTracer("callTracer", "call_tracer_withLog", t)
|
|
|
|
}
|
|
|
|
|
2021-11-05 05:48:21 -05:00
|
|
|
func testCallTracer(tracerName string, dirPath string, t *testing.T) {
|
2022-10-28 05:28:29 -05:00
|
|
|
isLegacy := strings.HasSuffix(dirPath, "_legacy")
|
2022-05-17 07:27:04 -05:00
|
|
|
files, err := os.ReadDir(filepath.Join("testdata", dirPath))
|
2021-11-05 05:48:21 -05:00
|
|
|
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
|
2022-05-16 04:59:35 -05:00
|
|
|
if blob, err := os.ReadFile(filepath.Join("testdata", dirPath, file.Name())); err != nil {
|
2021-11-05 05:48:21 -05:00
|
|
|
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)
|
|
|
|
}
|
2022-10-12 05:50:01 -05:00
|
|
|
if err := tx.UnmarshalBinary(common.FromHex(test.Input)); err != nil {
|
2021-11-05 05:48:21 -05:00
|
|
|
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)),
|
2023-01-25 05:12:28 -06:00
|
|
|
Time: uint64(test.Context.Time),
|
2021-11-05 05:48:21 -05:00
|
|
|
Difficulty: (*big.Int)(test.Context.Difficulty),
|
|
|
|
GasLimit: uint64(test.Context.GasLimit),
|
2022-10-12 05:50:01 -05:00
|
|
|
BaseFee: test.Genesis.BaseFee,
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
|
|
|
_, statedb = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false)
|
|
|
|
)
|
2023-01-10 08:11:53 -06:00
|
|
|
tracer, err := tracers.DefaultDirectory.New(tracerName, new(tracers.Context), test.TracerConfig)
|
2021-11-05 05:48:21 -05:00
|
|
|
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})
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg, err := core.TransactionToMessage(tx, signer, nil)
|
2021-11-05 05:48:21 -05:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to prepare transaction for tracing: %v", err)
|
|
|
|
}
|
2022-10-28 05:28:29 -05:00
|
|
|
vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas()))
|
|
|
|
if err != nil {
|
2021-11-05 05:48:21 -05:00
|
|
|
t.Fatalf("failed to execute transaction: %v", err)
|
|
|
|
}
|
2022-10-11 02:37:00 -05:00
|
|
|
// Retrieve the trace result and compare against the expected.
|
2021-11-05 05:48:21 -05:00
|
|
|
res, err := tracer.GetResult()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to retrieve trace result: %v", err)
|
|
|
|
}
|
2022-10-21 10:55:15 -05:00
|
|
|
// The legacy javascript calltracer marshals json in js, which
|
|
|
|
// is not deterministic (as opposed to the golang json encoder).
|
2022-10-28 05:28:29 -05:00
|
|
|
if isLegacy {
|
2022-10-21 10:55:15 -05:00
|
|
|
// This is a tweak to make it deterministic. Can be removed when
|
|
|
|
// we remove the legacy tracer.
|
|
|
|
var x callTrace
|
|
|
|
json.Unmarshal(res, &x)
|
|
|
|
res, _ = json.Marshal(x)
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
2022-10-21 10:55:15 -05:00
|
|
|
want, err := json.Marshal(test.Result)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to marshal test: %v", err)
|
|
|
|
}
|
|
|
|
if string(want) != string(res) {
|
|
|
|
t.Fatalf("trace mismatch\n have: %v\n want: %v\n", string(res), string(want))
|
2021-11-05 05:48:21 -05:00
|
|
|
}
|
2022-10-28 05:28:29 -05:00
|
|
|
// Sanity check: compare top call's gas used against vm result
|
|
|
|
type simpleResult struct {
|
|
|
|
GasUsed hexutil.Uint64
|
|
|
|
}
|
|
|
|
var topCall simpleResult
|
|
|
|
if err := json.Unmarshal(res, &topCall); err != nil {
|
|
|
|
t.Fatalf("failed to unmarshal top calls gasUsed: %v", err)
|
|
|
|
}
|
|
|
|
if uint64(topCall.GasUsed) != vmRet.UsedGas {
|
|
|
|
t.Fatalf("top call has invalid gasUsed. have: %d want: %d", topCall.GasUsed, vmRet.UsedGas)
|
|
|
|
}
|
2021-11-05 05:48:21 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkTracers(b *testing.B) {
|
2022-05-17 07:27:04 -05:00
|
|
|
files, err := os.ReadDir(filepath.Join("testdata", "call_tracer"))
|
2021-11-05 05:48:21 -05:00
|
|
|
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) {
|
2022-05-16 04:59:35 -05:00
|
|
|
blob, err := os.ReadFile(filepath.Join("testdata", "call_tracer", file.Name()))
|
2021-11-05 05:48:21 -05:00
|
|
|
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)
|
|
|
|
}
|
2022-05-18 09:34:18 -05:00
|
|
|
benchTracer("callTracer", test, b)
|
2021-11-05 05:48:21 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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)))
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg, err := core.TransactionToMessage(tx, signer, nil)
|
2021-11-05 05:48:21 -05:00
|
|
|
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)),
|
2023-01-25 05:12:28 -06:00
|
|
|
Time: uint64(test.Context.Time),
|
2021-11-05 05:48:21 -05:00
|
|
|
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++ {
|
2023-01-10 08:11:53 -06:00
|
|
|
tracer, err := tracers.DefaultDirectory.New(tracerName, new(tracers.Context), nil)
|
2021-11-05 05:48:21 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2021-11-09 05:09:35 -06:00
|
|
|
|
|
|
|
// 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),
|
2023-01-25 05:12:28 -06:00
|
|
|
Time: 5,
|
2021-11-09 05:09:35 -06:00
|
|
|
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
|
2023-01-10 08:11:53 -06:00
|
|
|
tracer, err := tracers.DefaultDirectory.New("callTracer", nil, nil)
|
2021-11-09 05:09:35 -06:00
|
|
|
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})
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
msg, err := core.TransactionToMessage(tx, signer, nil)
|
2021-11-09 05:09:35 -06:00
|
|
|
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)
|
|
|
|
}
|
2022-10-28 05:28:29 -05:00
|
|
|
wantStr := `{"from":"0x682a80a6f560eec50d54e63cbeda1c324c5f8d1b","gas":"0x7148","gasUsed":"0x54d8","to":"0x00000000000000000000000000000000deadbeef","input":"0x","calls":[{"from":"0x00000000000000000000000000000000deadbeef","gas":"0x6cbf","gasUsed":"0x0","to":"0x00000000000000000000000000000000000000ff","input":"0x","value":"0x0","type":"CALL"}],"value":"0x0","type":"CALL"}`
|
2022-10-21 10:55:15 -05:00
|
|
|
if string(res) != wantStr {
|
|
|
|
t.Fatalf("trace mismatch\n have: %v\n want: %v\n", string(res), wantStr)
|
2021-11-09 05:09:35 -06:00
|
|
|
}
|
|
|
|
}
|