core/tracing: state journal wrapper

core/blockchain.go

@@ -2375,6 +2375,10 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
 	if len(rebirthLogs) > 0 {
 		bc.logsFeed.Send(rebirthLogs)
 	}
+
+	if bc.logger != nil && bc.logger.OnReorg != nil {
+		bc.logger.OnReorg(oldChain)
+	}
 	return nil
 }
 

core/state/statedb.go

@@ -331,21 +331,28 @@ func (s *StateDB) Empty(addr common.Address) bool {
 
 // GetBalance retrieves the balance from the given address or 0 if object not found
 func (s *StateDB) GetBalance(addr common.Address) *uint256.Int {
+	bal := common.U2560
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.Balance()
+		bal = stateObject.Balance()
 	}
-	return common.U2560
+	if s.logger != nil && s.logger.OnBalanceRead != nil {
+		s.logger.OnBalanceRead(addr, bal.ToBig())
+	}
+	return bal
 }
 
 // GetNonce retrieves the nonce from the given address or 0 if object not found
 func (s *StateDB) GetNonce(addr common.Address) uint64 {
+	var nonce uint64
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.Nonce()
+		nonce = stateObject.Nonce()
 	}
-
-	return 0
+	if s.logger != nil && s.logger.OnNonceRead != nil {
+		s.logger.OnNonceRead(addr, nonce)
+	}
+	return nonce
 }
 
 // GetStorageRoot retrieves the storage root from the given address or empty
@@ -364,36 +371,52 @@ func (s *StateDB) TxIndex() int {
 }
 
 func (s *StateDB) GetCode(addr common.Address) []byte {
+	var code []byte
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.Code()
+		code = stateObject.Code()
 	}
-	return nil
+	if s.logger != nil && s.logger.OnCodeRead != nil {
+		s.logger.OnCodeRead(addr, code)
+	}
+	return code
 }
 
 func (s *StateDB) GetCodeSize(addr common.Address) int {
+	var size int
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.CodeSize()
+		size = stateObject.CodeSize()
+	}
+	if s.logger != nil && s.logger.OnCodeSizeRead != nil {
+		s.logger.OnCodeSizeRead(addr, size)
 	}
-	return 0
+	return size
 }
 
 func (s *StateDB) GetCodeHash(addr common.Address) common.Hash {
+	hash := common.Hash{}
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return common.BytesToHash(stateObject.CodeHash())
+		hash = common.BytesToHash(stateObject.CodeHash())
 	}
-	return common.Hash{}
+	if s.logger != nil && s.logger.OnCodeHashRead != nil {
+		s.logger.OnCodeHashRead(addr, hash)
+	}
+	return hash
 }
 
 // GetState retrieves the value associated with the specific key.
 func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
+	val := common.Hash{}
 	stateObject := s.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.GetState(hash)
+		val = stateObject.GetState(hash)
 	}
-	return common.Hash{}
+	if s.logger != nil && s.logger.OnStorageRead != nil {
+		s.logger.OnStorageRead(addr, hash, val)
+	}
+	return val
 }
 
 // GetCommittedState retrieves the value associated with the specific key

core/state_processor.go

@@ -183,7 +183,7 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
 func ProcessBeaconBlockRoot(beaconRoot common.Hash, vmenv *vm.EVM, statedb *state.StateDB) {
 	if tracer := vmenv.Config.Tracer; tracer != nil {
 		if tracer.OnSystemCallStart != nil {
-			tracer.OnSystemCallStart()
+			tracer.OnSystemCallStart(vmenv.GetVMContext())
 		}
 		if tracer.OnSystemCallEnd != nil {
 			defer tracer.OnSystemCallEnd()
@@ -212,7 +212,7 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, vmenv *vm.EVM, statedb *stat
 func ProcessParentBlockHash(prevHash common.Hash, vmenv *vm.EVM, statedb *state.StateDB) {
 	if tracer := vmenv.Config.Tracer; tracer != nil {
 		if tracer.OnSystemCallStart != nil {
-			tracer.OnSystemCallStart()
+			tracer.OnSystemCallStart(vmenv.GetVMContext())
 		}
 		if tracer.OnSystemCallEnd != nil {
 			defer tracer.OnSystemCallEnd()

core/tracing/hooks.go

@@ -41,6 +41,7 @@ type StateDB interface {
 	GetBalance(common.Address) *uint256.Int
 	GetNonce(common.Address) uint64
 	GetCode(common.Address) []byte
+	GetCodeHash(common.Address) common.Hash
 	GetState(common.Address, common.Hash) common.Hash
 	Exist(common.Address) bool
 	GetRefund() uint64
@@ -133,6 +134,9 @@ type (
 	// GenesisBlockHook is called when the genesis block is being processed.
 	GenesisBlockHook = func(genesis *types.Block, alloc types.GenesisAlloc)
 
+	// ReorgHook is called when a segment of the chain is reverted.
+	ReorgHook = func(reverted []*types.Block)
+
 	// OnSystemCallStartHook is called when a system call is about to be executed. Today,
 	// this hook is invoked when the EIP-4788 system call is about to be executed to set the
 	// beacon block root.
@@ -142,7 +146,7 @@ type (
 	//
 	// Note that system call happens outside normal transaction execution, so the `OnTxStart/OnTxEnd` hooks
 	// will not be invoked.
-	OnSystemCallStartHook = func()
+	OnSystemCallStartHook = func(vm *VMContext)
 
 	// OnSystemCallEndHook is called when a system call has finished executing. Today,
 	// this hook is invoked when the EIP-4788 system call is about to be executed to set the
@@ -167,6 +171,24 @@ type (
 
 	// LogHook is called when a log is emitted.
 	LogHook = func(log *types.Log)
+
+	// BalanceReadHook is called when EVM reads the balance of an account.
+	BalanceReadHook = func(addr common.Address, bal *big.Int)
+
+	// NonceReadHook is called when EVM reads the nonce of an account.
+	NonceReadHook = func(addr common.Address, nonce uint64)
+
+	// CodeReadHook is called when EVM reads the code of an account.
+	CodeReadHook = func(addr common.Address, code []byte)
+
+	// CodeSizeReadHook is called when EVM reads the code size of an account.
+	CodeSizeReadHook = func(addr common.Address, size int)
+
+	// CodeHashReadHook is called when EVM reads the code hash of an account.
+	CodeHashReadHook = func(addr common.Address, hash common.Hash)
+
+	// StorageReadHook is called when EVM reads a storage slot of an account.
+	StorageReadHook = func(addr common.Address, slot, value common.Hash)
 )
 
 type Hooks struct {
@@ -185,6 +207,7 @@ type Hooks struct {
 	OnBlockEnd        BlockEndHook
 	OnSkippedBlock    SkippedBlockHook
 	OnGenesisBlock    GenesisBlockHook
+	OnReorg           ReorgHook
 	OnSystemCallStart OnSystemCallStartHook
 	OnSystemCallEnd   OnSystemCallEndHook
 	// State events
@@ -193,6 +216,13 @@ type Hooks struct {
 	OnCodeChange    CodeChangeHook
 	OnStorageChange StorageChangeHook
 	OnLog           LogHook
+	// State reads
+	OnBalanceRead  BalanceReadHook
+	OnNonceRead    NonceReadHook
+	OnCodeRead     CodeReadHook
+	OnCodeSizeRead CodeSizeReadHook
+	OnCodeHashRead CodeHashReadHook
+	OnStorageRead  StorageReadHook
 }
 
 // BalanceChangeReason is used to indicate the reason for a balance change, useful
@@ -244,6 +274,9 @@ const (
 	// account within the same tx (captured at end of tx).
 	// Note it doesn't account for a self-destruct which appoints itself as recipient.
 	BalanceDecreaseSelfdestructBurn BalanceChangeReason = 14
+
+	// BalanceChangeRevert is emitted when the balance is reverted back to a previous value due to call failure.
+	BalanceChangeRevert BalanceChangeReason = 15
 )
 
 // GasChangeReason is used to indicate the reason for a gas change, useful