add statediff tracer

Author: avatarH

eth/tracers/api.go

@@ -20,6 +20,7 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -172,6 +173,8 @@ type TraceConfig struct {
 	Tracer  *string
 	Timeout *string
 	Reexec  *uint64
+
+	TracerConfig json.RawMessage
 }
 
 // TraceCallConfig is the config for traceCall API. It holds one more
@@ -935,7 +938,7 @@ func (api *API) traceTx(ctx context.Context, message core.Message, txctx *Contex
 				return nil, err
 			}
 		}
-		if t, err := New(*config.Tracer, txctx); err != nil {
+		if t, err := New(*config.Tracer, txctx, config.TracerConfig); err != nil {
 			return nil, err
 		} else {
 			deadlineCtx, cancel := context.WithTimeout(ctx, timeout)

eth/tracers/js/tracer.go

@@ -424,7 +424,7 @@ type jsTracer struct {
 // New instantiates a new tracer instance. code specifies a Javascript snippet,
 // which must evaluate to an expression returning an object with 'step', 'fault'
 // and 'result' functions.
-func newJsTracer(code string, ctx *tracers2.Context) (tracers2.Tracer, error) {
+func newJsTracer(code string, ctx *tracers2.Context, cfg json.RawMessage) (tracers2.Tracer, error) {
 	if c, ok := assetTracers[code]; ok {
 		code = c
 	}

eth/tracers/native/call.go

@@ -56,11 +56,11 @@ type callTracer struct {
 
 // newCallTracer returns a native go tracer which tracks
 // call frames of a tx, and implements vm.EVMLogger.
-func newCallTracer() tracers.Tracer {
+func newCallTracer(ctx *tracers.Context, cfg json.RawMessage) (tracers.Tracer, error) {
 	// First callframe contains tx context info
 	// and is populated on start and end.
 	t := &callTracer{callstack: make([]callFrame, 1)}
-	return t
+	return t, nil
 }
 
 // CaptureStart implements the EVMLogger interface to initialize the tracing operation.

eth/tracers/native/noop.go

@@ -35,8 +35,8 @@ func init() {
 type noopTracer struct{}
 
 // newNoopTracer returns a new noop tracer.
-func newNoopTracer() tracers.Tracer {
-	return &noopTracer{}
+func newNoopTracer(ctx *tracers.Context, cfg json.RawMessage) (tracers.Tracer, error) {
+	return &noopTracer{}, nil
 }
 
 // CaptureStart implements the EVMLogger interface to initialize the tracing operation.

eth/tracers/native/prestate.go

@@ -0,0 +1,280 @@
+// Copyright 2022 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 native
+
+import (
+	"encoding/json"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"math/big"
+	"sync/atomic"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth/tracers"
+)
+
+func init() {
+	register("stateDiff", newStateDiffTracer)
+}
+
+type state = map[common.Address]*account
+type account struct {
+	Balance string `json:"balance,omitempty"`
+	Nonce   uint64 `json:"nonce,omitempty"`
+	storage map[common.Hash]common.Hash
+}
+
+func (a account) exists() bool {
+	bi := new(big.Int)
+	bi.SetString(a.Balance[2:], 16)
+	return a.Nonce > 0 || (bi.Sign() != 0)
+}
+
+type stateDiffTracer struct {
+	env       *vm.EVM
+	pre       state
+	post      state
+	to        common.Address
+	create    bool
+	config    stateDiffTracerConfig
+	gasLimit  uint64 // Amount of gas bought for the whole tx
+	interrupt uint32 // Atomic flag to signal execution interruption
+	reason    error  // Textual reason for the interruption
+	created   map[common.Address]bool
+	deleted   map[common.Address]bool
+}
+
+type stateDiffTracerConfig struct {
+	DiffMode bool `json:"diffMode"` // If true, this tracer will return state modifications
+}
+
+func newStateDiffTracer(ctx *tracers.Context, cfg json.RawMessage) (tracers.Tracer, error) {
+	var config stateDiffTracerConfig
+	if cfg != nil {
+		if err := json.Unmarshal(cfg, &config); err != nil {
+			return nil, err
+		}
+	}
+	// and is populated on start and end.
+	return &stateDiffTracer{
+		pre:     state{},
+		post:    state{},
+		config:  config,
+		created: make(map[common.Address]bool),
+		deleted: make(map[common.Address]bool),
+	}, nil
+}
+
+// CaptureStart implements the EVMLogger interface to initialize the tracing operation.
+func (t *stateDiffTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+	t.env = env
+	t.create = create
+	t.to = to
+
+	t.lookupAccount(from)
+	t.lookupAccount(to)
+	t.lookupAccount(env.Context.Coinbase)
+	//t.lookupAccount(consensus.SystemAddress)
+
+	// The recipient balance includes the value transferred.
+	toAccount := t.pre[to]
+	toBal := hexutil.MustDecodeBig(toAccount.Balance)
+	toBal = new(big.Int).Sub(toBal, value)
+	toAccount.Balance = hexutil.EncodeBig(toBal)
+	t.pre[to] = toAccount
+
+	// The sender balance is after reducing: value and gasLimit.
+	// We need to re-add them to get the pre-tx balance.
+	fromAccount := t.pre[from]
+	fromBal := hexutil.MustDecodeBig(fromAccount.Balance)
+	gasPrice := env.TxContext.GasPrice
+	consumedGas := new(big.Int).Mul(gasPrice, new(big.Int).SetUint64(t.gasLimit))
+	fromBal.Add(fromBal, new(big.Int).Add(value, consumedGas))
+	fromAccount.Balance = hexutil.EncodeBig(fromBal)
+	fromAccount.Nonce--
+	t.pre[from] = fromAccount
+
+	if create && t.config.DiffMode {
+		t.created[to] = true
+	}
+}
+
+// CaptureEnd is called after the call finishes to finalize the tracing.
+func (t *stateDiffTracer) CaptureEnd(output []byte, gasUsed uint64, _ time.Duration, err error) {
+	if err != nil {
+		return
+	}
+	if t.config.DiffMode {
+		return
+	}
+
+	if t.create {
+		// Keep existing account prior to contract creation at that address
+		if s := t.pre[t.to]; !s.exists() {
+			// Exclude newly created contract.
+			delete(t.pre, t.to)
+		}
+	}
+}
+
+// CaptureState implements the EVMLogger interface to trace a single step of VM execution.
+func (t *stateDiffTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+	if err != nil {
+		return
+	}
+	stack := scope.Stack
+	stackData := stack.Data()
+	stackLen := len(stackData)
+	caller := scope.Contract.Address()
+	switch {
+	case stackLen >= 1 && (op == vm.SLOAD || op == vm.SSTORE):
+		slot := common.Hash(stackData[stackLen-1].Bytes32())
+		t.lookupStorage(caller, slot)
+	case stackLen >= 1 && (op == vm.EXTCODECOPY || op == vm.EXTCODEHASH || op == vm.EXTCODESIZE || op == vm.BALANCE || op == vm.SELFDESTRUCT):
+		addr := common.Address(stackData[stackLen-1].Bytes20())
+		t.lookupAccount(addr)
+		if op == vm.SELFDESTRUCT {
+			t.deleted[caller] = true
+		}
+	case stackLen >= 5 && (op == vm.DELEGATECALL || op == vm.CALL || op == vm.STATICCALL || op == vm.CALLCODE):
+		addr := common.Address(stackData[stackLen-2].Bytes20())
+		t.lookupAccount(addr)
+	case op == vm.CREATE:
+		nonce := t.env.StateDB.GetNonce(caller)
+		addr := crypto.CreateAddress(caller, nonce)
+		t.lookupAccount(addr)
+		t.created[addr] = true
+	case stackLen >= 4 && op == vm.CREATE2:
+		offset := stackData[stackLen-2]
+		size := stackData[stackLen-3]
+		init := scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
+		inithash := crypto.Keccak256(init)
+		salt := stackData[stackLen-4]
+		addr := crypto.CreateAddress2(caller, salt.Bytes32(), inithash)
+		t.lookupAccount(addr)
+		t.created[addr] = true
+	}
+}
+
+// CaptureFault implements the EVMLogger interface to trace an execution fault.
+func (t *stateDiffTracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, _ *vm.ScopeContext, depth int, err error) {
+}
+
+// CaptureEnter is called when EVM enters a new scope (via call, create or selfdestruct).
+func (t *stateDiffTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+}
+
+// CaptureExit is called when EVM exits a scope, even if the scope didn't
+// execute any code.
+func (t *stateDiffTracer) CaptureExit(output []byte, gasUsed uint64, err error) {
+}
+
+func (t *stateDiffTracer) CaptureTxStart(gasLimit uint64) {
+	t.gasLimit = gasLimit
+}
+
+func (t *stateDiffTracer) CaptureTxEnd(restGas uint64) {
+	if !t.config.DiffMode {
+		return
+	}
+
+	//for addr, state := range t.pre {
+	for addr, _ := range t.pre {
+		// The deleted account's state is pruned from `post` but kept in `pre`
+		if _, ok := t.deleted[addr]; ok {
+			continue
+		}
+		modified := false
+		postAccount := account{storage: make(map[common.Hash]common.Hash)}
+		newBalance := bigToHex(t.env.StateDB.GetBalance(addr))
+		newNonce := t.env.StateDB.GetNonce(addr)
+
+		if newBalance != t.pre[addr].Balance {
+			modified = true
+			postAccount.Balance = newBalance
+		}
+		if newNonce != t.pre[addr].Nonce {
+			modified = true
+			postAccount.Nonce = newNonce
+		}
+
+		if modified {
+			t.post[addr] = &postAccount
+		} else {
+			// if state is not modified, then no need to include into the pre state
+			delete(t.pre, addr)
+		}
+	}
+	// the new created contracts' prestate were empty, so delete them
+	for a := range t.created {
+		// the created contract maybe exists in statedb before the creating tx
+		if s := t.pre[a]; !s.exists() {
+			delete(t.pre, a)
+		}
+	}
+}
+
+// GetResult returns the json-encoded nested list of call traces, and any
+// error arising from the encoding or forceful termination (via `Stop`).
+func (t *stateDiffTracer) GetResult() (json.RawMessage, error) {
+	var res []byte
+	var err error
+	if t.config.DiffMode {
+		res, err = json.Marshal(struct {
+			Post state `json:"post"`
+			Pre  state `json:"pre"`
+		}{t.post, t.pre})
+	} else {
+		res, err = json.Marshal(t.pre)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return json.RawMessage(res), t.reason
+}
+
+// Stop terminates execution of the tracer at the first opportune moment.
+func (t *stateDiffTracer) Stop(err error) {
+	t.reason = err
+	atomic.StoreUint32(&t.interrupt, 1)
+}
+
+// lookupAccount fetches details of an account and adds it to the prestate
+// if it doesn't exist there.
+func (t *stateDiffTracer) lookupAccount(addr common.Address) {
+	if _, ok := t.pre[addr]; ok {
+		return
+	}
+
+	t.pre[addr] = &account{
+		Balance: bigToHex(t.env.StateDB.GetBalance(addr)),
+		Nonce:   t.env.StateDB.GetNonce(addr),
+		storage: make(map[common.Hash]common.Hash),
+	}
+}
+
+// lookupStorage fetches the requested storage slot and adds
+// it to the prestate of the given contract. It assumes `lookupAccount`
+// has been performed on the contract before.
+func (t *stateDiffTracer) lookupStorage(addr common.Address, key common.Hash) {
+	if _, ok := t.pre[addr].storage[key]; ok {
+		return
+	}
+	t.pre[addr].storage[key] = t.env.StateDB.GetState(addr, key)
+}