Extended tracer sei

accounts/abi/bind/backends/simulated.go

@@ -681,7 +681,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 
  // Set infinite balance to the fake caller account.
  from := stateDB.(*state.StateDB).GetOrNewStateObject(call.From)
- from.SetBalance(math.MaxBig256)
+ from.SetBalance(math.MaxBig256, state.BalanceChangeUnspecified)
 
  // Execute the call.
  msg := &core.Message{

cmd/evm/internal/t8ntool/execution.go

@@ -187,7 +187,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  }
  if beaconRoot := pre.Env.ParentBeaconBlockRoot; beaconRoot != nil {
  evm := vm.NewEVM(vmContext, vm.TxContext{}, statedb, chainConfig, vmConfig)
- core.ProcessBeaconBlockRoot(*beaconRoot, evm, statedb)
+ core.ProcessBeaconBlockRoot(*beaconRoot, evm, statedb, nil)
  }
  var blobGasUsed uint64
 
@@ -234,13 +234,19 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  )
  evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
 
+ if tracer != nil {
+ tracer.CaptureTxStart(evm, tx, msg.From)
+ }
  // (ret []byte, usedGas uint64, failed bool, err error)
  msgResult, err := core.ApplyMessage(evm, msg, gaspool)
  if err != nil {
  statedb.RevertToSnapshot(snapshot)
  log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From, "error", err)
  rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
  gaspool.SetGas(prevGas)
+ if tracer != nil {
+ tracer.CaptureTxEnd(nil, err)
+ }
  continue
  }
  includedTxs = append(includedTxs, tx)
@@ -282,6 +288,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  //receipt.BlockNumber
  receipt.TransactionIndex = uint(txIndex)
  receipts = append(receipts, receipt)
+ if tracer != nil {
+ tracer.CaptureTxEnd(receipt, nil)
+ }
  }
 
  txIndex++
@@ -307,15 +316,15 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  reward.Sub(reward, new(big.Int).SetUint64(ommer.Delta))
  reward.Mul(reward, blockReward)
  reward.Div(reward, big.NewInt(8))
- statedb.AddBalance(ommer.Address, reward)
+ statedb.AddBalance(ommer.Address, reward, state.BalanceIncreaseRewardMineUncle)
  }
- statedb.AddBalance(pre.Env.Coinbase, minerReward)
+ statedb.AddBalance(pre.Env.Coinbase, minerReward, state.BalanceIncreaseRewardMineBlock)
  }
  // Apply withdrawals
  for _, w := range pre.Env.Withdrawals {
  // Amount is in gwei, turn into wei
  amount := new(big.Int).Mul(new(big.Int).SetUint64(w.Amount), big.NewInt(params.GWei))
- statedb.AddBalance(w.Address, amount)
+ statedb.AddBalance(w.Address, amount, state.BalanceIncreaseWithdrawal)
  }
  // Commit block
  root, err := statedb.Commit(vmContext.BlockNumber.Uint64(), chainConfig.IsEIP158(vmContext.BlockNumber))
@@ -358,7 +367,7 @@ func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB
  for addr, a := range accounts {
  statedb.SetCode(addr, a.Code)
  statedb.SetNonce(addr, a.Nonce)
- statedb.SetBalance(addr, a.Balance)
+ statedb.SetBalance(addr, a.Balance, state.BalanceIncreaseGenesisBalance)
  for k, v := range a.Storage {
  statedb.SetState(addr, k, v)
  }

cmd/evm/internal/t8ntool/flags.go

@@ -30,6 +30,14 @@ var (
  Name: "trace",
  Usage: "Output full trace logs to files <txhash>.jsonl",
  }
+ TraceTracerFlag = &cli.StringFlag{
+ Name: "trace.tracer",
+ Usage: "Configures the use of a custom tracer, e.g native or js tracers. Examples are callTracer and 4byteTracer. These tracers emit results into files as trace-<txIndex>-<txHash>.json",
+ }
+ TraceTracerConfigFlag = &cli.StringFlag{
+ Name: "trace.jsonconfig",
+ Usage: "The configurations for the custom tracer specified by --trace.tracer. If provided, must be in JSON format",
+ }
  TraceDisableMemoryFlag = &cli.BoolFlag{
  Name: "trace.nomemory",
  Value: true,

cmd/evm/internal/t8ntool/tracewriter.go

@@ -0,0 +1,92 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package t8ntool
+
+import (
+ "encoding/json"
+ "io"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/tracers/directory"
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// traceWriter is an vm.EVMLogger which also holds an inner logger/tracer.
+// When the TxEnd event happens, the inner tracer result is written to the file, and
+// the file is closed.
+type traceWriter struct {
+ inner vm.EVMLogger
+ f io.WriteCloser
+}
+
+// Compile-time interface check
+var _ = vm.EVMLogger((*traceWriter)(nil))
+
+func (t *traceWriter) CaptureTxEnd(receipt *types.Receipt, err error) {
+ t.inner.CaptureTxEnd(receipt, err)
+ defer t.f.Close()
+
+ if tracer, ok := t.inner.(directory.Tracer); ok {
+ result, err := tracer.GetResult()
+ if err != nil {
+ log.Warn("Error in tracer", "err", err)
+ return
+ }
+ err = json.NewEncoder(t.f).Encode(result)
+ if err != nil {
+ log.Warn("Error writing tracer output", "err", err)
+ return
+ }
+ }
+}
+
+func (t *traceWriter) CaptureTxStart(env *vm.EVM, tx *types.Transaction, from common.Address) {
+ t.inner.CaptureTxStart(env, tx, from)
+}
+func (t *traceWriter) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+ t.inner.CaptureStart(from, to, create, input, gas, value)
+}
+
+func (t *traceWriter) CaptureEnd(output []byte, gasUsed uint64, err error, reverted bool) {
+ t.inner.CaptureEnd(output, gasUsed, err, reverted)
+}
+
+func (t *traceWriter) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+ t.inner.CaptureEnter(typ, from, to, input, gas, value)
+}
+
+func (t *traceWriter) CaptureExit(output []byte, gasUsed uint64, err error, reverted bool) {
+ t.inner.CaptureExit(output, gasUsed, err, reverted)
+}
+
+func (t *traceWriter) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+ t.inner.CaptureState(pc, op, gas, cost, scope, rData, depth, err)
+}
+func (t *traceWriter) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) {
+ t.inner.CaptureFault(pc, op, gas, cost, scope, depth, err)
+}
+
+func (t *traceWriter) CaptureKeccakPreimage(hash common.Hash, data []byte) {
+ t.inner.CaptureKeccakPreimage(hash, data)
+}
+
+func (t *traceWriter) OnGasChange(old, new uint64, reason vm.GasChangeReason) {
+ t.inner.OnGasChange(old, new, reason)
+}

cmd/evm/internal/t8ntool/transition.go

@@ -33,6 +33,7 @@ import (
  "github.com/ethereum/go-ethereum/core/state"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/tracers/directory"
  "github.com/ethereum/go-ethereum/eth/tracers/logger"
  "github.com/ethereum/go-ethereum/log"
  "github.com/ethereum/go-ethereum/params"
@@ -135,9 +136,21 @@ func Transition(ctx *cli.Context) error {
  prevFile = traceFile
  return logger.NewJSONLogger(logConfig, traceFile), nil
  }
- } else {
- getTracer = func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error) {
- return nil, nil
+ } else if ctx.IsSet(TraceTracerFlag.Name) {
+ var config json.RawMessage
+ if ctx.IsSet(TraceTracerConfigFlag.Name) {
+ config = []byte(ctx.String(TraceTracerConfigFlag.Name))
+ }
+ getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
+ traceFile, err := os.Create(path.Join(baseDir, fmt.Sprintf("trace-%d-%v.json", txIndex, txHash.String())))
+ if err != nil {
+ return nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
+ }
+ tracer, err := directory.DefaultDirectory.New(ctx.String(TraceTracerFlag.Name), nil, config)
+ if err != nil {
+ return nil, NewError(ErrorConfig, fmt.Errorf("failed instantiating tracer: %w", err))
+ }
+ return &traceWriter{tracer, traceFile}, nil
  }
  }
  // We need to load three things: alloc, env and transactions. May be either in

cmd/geth/chaincmd.go

@@ -97,6 +97,7 @@ if one is set. Otherwise it prints the genesis from the datadir.`,
  utils.MetricsInfluxDBBucketFlag,
  utils.MetricsInfluxDBOrganizationFlag,
  utils.TxLookupLimitFlag,
+ utils.VMTraceFlag,
  utils.TransactionHistoryFlag,
  utils.StateHistoryFlag,
  }, utils.DatabaseFlags),

cmd/geth/config.go

@@ -36,6 +36,7 @@ import (
  "github.com/ethereum/go-ethereum/common/hexutil"
  "github.com/ethereum/go-ethereum/eth/catalyst"
  "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/ethereum/go-ethereum/eth/tracers/directory/live"
  "github.com/ethereum/go-ethereum/lib/ethapi"
  "github.com/ethereum/go-ethereum/lib/flags"
  "github.com/ethereum/go-ethereum/lib/version"
@@ -177,6 +178,18 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
  v := ctx.Uint64(utils.OverrideVerkle.Name)
  cfg.Eth.OverrideVerkle = &v
  }
+
+ if ctx.IsSet(utils.VMTraceFlag.Name) {
+ if name := ctx.String(utils.VMTraceFlag.Name); name != "" {
+ t, err := live.Directory.New(name)
+ if err != nil {
+ utils.Fatalf("Failed to create tracer %q: %v", name, err)
+ }
+
+ cfg.Eth.VMTracer = t
+ }
+ }
+
  backend, eth := utils.RegisterEthService(stack, &cfg.Eth)
 
  // Create gauge with geth system and build information

cmd/geth/main.go

@@ -43,6 +43,7 @@ import (
 
  // Force-load the tracer engines to trigger registration
  _ "github.com/ethereum/go-ethereum/eth/tracers/js"
+ _ "github.com/ethereum/go-ethereum/eth/tracers/live"
  _ "github.com/ethereum/go-ethereum/eth/tracers/native"
 
  "github.com/urfave/cli/v2"
@@ -136,6 +137,7 @@ var (
  utils.DeveloperGasLimitFlag,
  utils.DeveloperPeriodFlag,
  utils.VMEnableDebugFlag,
+ utils.VMTraceFlag,
  utils.NetworkIdFlag,
  utils.EthStatsURLFlag,
  utils.NoCompactionFlag,

cmd/utils/flags.go

@@ -51,6 +51,7 @@ import (
  "github.com/ethereum/go-ethereum/eth/filters"
  "github.com/ethereum/go-ethereum/eth/gasprice"
  "github.com/ethereum/go-ethereum/eth/tracers"
+ "github.com/ethereum/go-ethereum/eth/tracers/directory/live"
  "github.com/ethereum/go-ethereum/ethdb"
  "github.com/ethereum/go-ethereum/ethdb/remotedb"
  "github.com/ethereum/go-ethereum/ethstats"
@@ -496,6 +497,11 @@ var (
  Usage: "Record information useful for VM and contract debugging",
  Category: flags.VMCategory,
  }
+ VMTraceFlag = &cli.StringFlag{
+ Name: "vmtrace",
+ Usage: "Name of tracer which should record internal VM operations (costly)",
+ Category: flags.VMCategory,
+ }
 
  // API options.
  RPCGlobalGasCapFlag = &cli.Uint64Flag{
@@ -2116,12 +2122,21 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh
  cache.TrieDirtyLimit = ctx.Int(CacheFlag.Name) * ctx.Int(CacheGCFlag.Name) / 100
  }
  vmcfg := vm.Config{EnablePreimageRecording: ctx.Bool(VMEnableDebugFlag.Name)}
-
+ if ctx.IsSet(VMTraceFlag.Name) {
+ if name := ctx.String(VMTraceFlag.Name); name != "" {
+ t, err := live.Directory.New(name)
+ if err != nil {
+ Fatalf("Failed to create tracer %q: %v", name, err)
+ }
+ vmcfg.Tracer = t
+ }
+ }
  // Disable transaction indexing/unindexing by default.
  chain, err := core.NewBlockChain(chainDb, cache, gspec, nil, engine, vmcfg, nil, nil)
  if err != nil {
  Fatalf("Can't create BlockChain: %v", err)
  }
+
  return chain, chainDb
 }
 

consensus/beacon/consensus.go

@@ -25,6 +25,7 @@ import (
  "github.com/ethereum/go-ethereum/consensus"
  "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
  "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
+ "github.com/ethereum/go-ethereum/core/state"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/core/vm"
  "github.com/ethereum/go-ethereum/params"
@@ -347,17 +348,17 @@ func (beacon *Beacon) Prepare(chain consensus.ChainHeaderReader, header *types.H
 }
 
 // Finalize implements consensus.Engine and processes withdrawals on top.
-func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state vm.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) {
+func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.Header, stateDB vm.StateDB, txs []*types.Transaction, uncles []*types.Header, withdrawals []*types.Withdrawal) {
  if !beacon.IsPoSHeader(header) {
- beacon.ethone.Finalize(chain, header, state, txs, uncles, nil)
+ beacon.ethone.Finalize(chain, header, stateDB, txs, uncles, nil)
  return
  }
  // Withdrawals processing.
  for _, w := range withdrawals {
  // Convert amount from gwei to wei.
  amount := new(big.Int).SetUint64(w.Amount)
  amount = amount.Mul(amount, big.NewInt(params.GWei))
- state.AddBalance(w.Address, amount)
+ stateDB.AddBalance(w.Address, amount, state.BalanceIncreaseWithdrawal)
  }
  // No block reward which is issued by consensus layer instead.
 }

consensus/ethash/consensus.go

@@ -28,6 +28,7 @@ import (
  "github.com/ethereum/go-ethereum/consensus"
  "github.com/ethereum/go-ethereum/consensus/misc"
  "github.com/ethereum/go-ethereum/consensus/misc/eip1559"
+ "github.com/ethereum/go-ethereum/core/state"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/core/vm"
  "github.com/ethereum/go-ethereum/params"
@@ -569,7 +570,7 @@ var (
 // AccumulateRewards credits the coinbase of the given block with the mining
 // reward. The total reward consists of the static block reward and rewards for
 // included uncles. The coinbase of each uncle block is also rewarded.
-func accumulateRewards(config *params.ChainConfig, state vm.StateDB, header *types.Header, uncles []*types.Header) {
+func accumulateRewards(config *params.ChainConfig, stateDB vm.StateDB, header *types.Header, uncles []*types.Header) {
  // Select the correct block reward based on chain progression
  blockReward := FrontierBlockReward
  if config.IsByzantium(header.Number) {
@@ -586,10 +587,10 @@ func accumulateRewards(config *params.ChainConfig, state vm.StateDB, header *typ
  r.Sub(r, header.Number)
  r.Mul(r, blockReward)
  r.Div(r, big8)
- state.AddBalance(uncle.Coinbase, r)
+ stateDB.AddBalance(uncle.Coinbase, r, state.BalanceIncreaseRewardMineUncle)
 
  r.Div(blockReward, big32)
  reward.Add(reward, r)
  }
- state.AddBalance(header.Coinbase, reward)
+ stateDB.AddBalance(header.Coinbase, reward, state.BalanceIncreaseRewardMineBlock)
 }

consensus/misc/dao.go

@@ -21,6 +21,7 @@ import (
  "errors"
  "math/big"
 
+ "github.com/ethereum/go-ethereum/core/state"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/core/vm"
  "github.com/ethereum/go-ethereum/params"
@@ -80,7 +81,7 @@ func ApplyDAOHardFork(statedb vm.StateDB) {
 
  // Move every DAO account and extra-balance account funds into the refund contract
  for _, addr := range params.DAODrainList() {
- statedb.AddBalance(params.DAORefundContract, statedb.GetBalance(addr))
- statedb.SetBalance(addr, new(big.Int))
+ statedb.AddBalance(params.DAORefundContract, statedb.GetBalance(addr), state.BalanceIncreaseDaoContract)
+ statedb.SetBalance(addr, new(big.Int), state.BalanceDecreaseDaoAccount)
  }
 }