feat: firehose live tracer

consensus/aura/aura.go

@@ -693,7 +693,7 @@ func (c *AuRa) applyRewards(header *types.Header, state *state.IntraBlockState,
 		return err
 	}
 	for _, r := range rewards {
-		state.AddBalance(r.Beneficiary, &r.Amount, evmtypes.BalanceChangeRewardMineBlock)
+		state.AddBalance(r.Beneficiary, &r.Amount, false, evmtypes.BalanceChangeRewardMineBlock)
 	}
 	return nil
 }

consensus/ethash/consensus.go

@@ -666,8 +666,8 @@ func accumulateRewards(config *chain.Config, state *state.IntraBlockState, heade
 	minerReward, uncleRewards := AccumulateRewards(config, header, uncles)
 	for i, uncle := range uncles {
 		if i < len(uncleRewards) {
-			state.AddBalance(uncle.Coinbase, &uncleRewards[i], evmtypes.BalanceChangeRewardMineUncle)
+			state.AddBalance(uncle.Coinbase, &uncleRewards[i], false, evmtypes.BalanceChangeRewardMineUncle)
 		}
 	}
-	state.AddBalance(header.Coinbase, &minerReward, evmtypes.BalanceChangeRewardMineBlock)
+	state.AddBalance(header.Coinbase, &minerReward, false, evmtypes.BalanceChangeRewardMineBlock)
 }

consensus/merge/merge.go

@@ -146,11 +146,11 @@ func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *stat
 	for _, r := range rewards {
 		switch r.Kind {
 		case consensus.RewardAuthor:
-			state.AddBalance(r.Beneficiary, &r.Amount, evmtypes.BalanceChangeRewardMineBlock)
+			state.AddBalance(r.Beneficiary, &r.Amount, false, evmtypes.BalanceChangeRewardMineBlock)
 		case consensus.RewardUncle:
-			state.AddBalance(r.Beneficiary, &r.Amount, evmtypes.BalanceChangeRewardMineUncle)
+			state.AddBalance(r.Beneficiary, &r.Amount, false, evmtypes.BalanceChangeRewardMineUncle)
 		default:
-			state.AddBalance(r.Beneficiary, &r.Amount, evmtypes.BalanceChangeUnspecified)
+			state.AddBalance(r.Beneficiary, &r.Amount, false, evmtypes.BalanceChangeUnspecified)
 		}
 	}
 
@@ -162,7 +162,7 @@ func (s *Merge) Finalize(config *chain.Config, header *types.Header, state *stat
 		} else {
 			for _, w := range withdrawals {
 				amountInWei := new(uint256.Int).Mul(uint256.NewInt(w.Amount), uint256.NewInt(params.GWei))
-				state.AddBalance(w.Address, amountInWei, evmtypes.BalanceChangeWithdrawal)
+				state.AddBalance(w.Address, amountInWei, false, evmtypes.BalanceChangeWithdrawal)
 			}
 		}
 	}

consensus/misc/dao.go

@@ -77,7 +77,7 @@ func ApplyDAOHardFork(statedb *state.IntraBlockState) {
 
 	// 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), evmtypes.BalanceChangeDaoRefundContract)
+		statedb.AddBalance(params.DAORefundContract, statedb.GetBalance(addr), false, evmtypes.BalanceChangeDaoRefundContract)
 		statedb.SetBalance(addr, new(uint256.Int), evmtypes.BalanceChangeDaoAdjustBalance)
 	}
 }

core/evm.go

@@ -129,7 +129,7 @@ func Transfer(db evmtypes.IntraBlockState, sender, recipient libcommon.Address,
 	if !bailout {
 		db.SubBalance(sender, amount, evmtypes.BalanceChangeTransfer)
 	}
-	db.AddBalance(recipient, amount, evmtypes.BalanceChangeTransfer)
+	db.AddBalance(recipient, amount, false, evmtypes.BalanceChangeTransfer)
 }
 
 // BorTransfer transfer in Bor
@@ -141,7 +141,7 @@ func BorTransfer(db evmtypes.IntraBlockState, sender, recipient libcommon.Addres
 	if !bailout {
 		db.SubBalance(sender, amount, evmtypes.BalanceChangeTransfer)
 	}
-	db.AddBalance(recipient, amount, evmtypes.BalanceChangeTransfer)
+	db.AddBalance(recipient, amount, false, evmtypes.BalanceChangeTransfer)
 
 	// get outputs after
 	output1 := db.GetBalance(sender).Clone()

core/genesis_write.go

@@ -579,7 +579,7 @@ func GenesisToBlock(g *types.Genesis, tmpDir string, bcLogger BlockchainLogger)
 			}
 			// This is not actually logged via tracer because OnGenesisBlock
 			// already captures the allocations.
-			statedb.AddBalance(addr, balance, evmtypes.BalanceChangeGenesisBalance)
+			statedb.AddBalance(addr, balance, false, evmtypes.BalanceChangeGenesisBalance)
 			statedb.SetCode(addr, account.Code)
 			statedb.SetNonce(addr, account.Nonce)
 			for key, value := range account.Storage {

core/state/database_test.go

@@ -851,7 +851,7 @@ func TestReproduceCrash(t *testing.T) {
 		t.Errorf("error finalising 1st tx: %v", err)
 	}
 	// Start the 3rd transaction
-	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), 0x0)
+	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), false, 0x0)
 	intraBlockState.SetState(contract, &storageKey2, *value2)
 	if err := intraBlockState.FinalizeTx(&chain.Rules{}, tsw); err != nil {
 		t.Errorf("error finalising 1st tx: %v", err)
@@ -1232,7 +1232,7 @@ func TestChangeAccountCodeBetweenBlocks(t *testing.T) {
 	oldCode := []byte{0x01, 0x02, 0x03, 0x04}
 
 	intraBlockState.SetCode(contract, oldCode)
-	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), 0x0)
+	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), false, 0x0)
 	if err := intraBlockState.FinalizeTx(&chain.Rules{}, tsw); err != nil {
 		t.Errorf("error finalising 1st tx: %v", err)
 	}
@@ -1270,7 +1270,7 @@ func TestCacheCodeSizeSeparately(t *testing.T) {
 	code := []byte{0x01, 0x02, 0x03, 0x04}
 
 	intraBlockState.SetCode(contract, code)
-	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), 0x0)
+	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), false, 0x0)
 	if err := intraBlockState.FinalizeTx(&chain.Rules{}, w); err != nil {
 		t.Errorf("error finalising 1st tx: %v", err)
 	}
@@ -1303,7 +1303,7 @@ func TestCacheCodeSizeInTrie(t *testing.T) {
 	code := []byte{0x01, 0x02, 0x03, 0x04}
 
 	intraBlockState.SetCode(contract, code)
-	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), 0x0)
+	intraBlockState.AddBalance(contract, uint256.NewInt(1000000000), false, 0x0)
 	if err := intraBlockState.FinalizeTx(&chain.Rules{}, w); err != nil {
 		t.Errorf("error finalising 1st tx: %v", err)
 	}

core/state/intra_block_state.go

@@ -329,7 +329,7 @@ func (sdb *IntraBlockState) HasSelfdestructed(addr libcommon.Address) bool {
 
 // AddBalance adds amount to the account associated with addr.
 // DESCRIBED: docs/programmers_guide/guide.md#address---identifier-of-an-account
-func (sdb *IntraBlockState) AddBalance(addr libcommon.Address, amount *uint256.Int, reason evmtypes.BalanceChangeReason) {
+func (sdb *IntraBlockState) AddBalance(addr libcommon.Address, amount *uint256.Int, checkPrecompile bool, reason evmtypes.BalanceChangeReason) {
 	if sdb.trace {
 		fmt.Printf("AddBalance %x, %d\n", addr, amount)
 	}
@@ -356,7 +356,7 @@ func (sdb *IntraBlockState) AddBalance(addr libcommon.Address, amount *uint256.I
 		}
 	}
 
-	stateObject := sdb.GetOrNewStateObject(addr)
+	stateObject := sdb.getOrNewStateObject(addr, checkPrecompile)
 	stateObject.AddBalance(amount, reason)
 }
 
@@ -509,7 +509,7 @@ func (sdb *IntraBlockState) getStateObject(addr libcommon.Address) (stateObject
 	// Load the object from the database.
 	if _, ok := sdb.nilAccounts[addr]; ok {
 		if bi, ok := sdb.balanceInc[addr]; ok && !bi.transferred {
-			return sdb.createObject(addr, nil)
+			return sdb.createObject(addr, nil, false)
 		}
 		return nil
 	}
@@ -521,7 +521,7 @@ func (sdb *IntraBlockState) getStateObject(addr libcommon.Address) (stateObject
 	if account == nil {
 		sdb.nilAccounts[addr] = struct{}{}
 		if bi, ok := sdb.balanceInc[addr]; ok && !bi.transferred {
-			return sdb.createObject(addr, nil)
+			return sdb.createObject(addr, nil, false)
 		}
 		return nil
 	}
@@ -543,16 +543,20 @@ func (sdb *IntraBlockState) setStateObject(addr libcommon.Address, object *state
 
 // Retrieve a state object or create a new state object if nil.
 func (sdb *IntraBlockState) GetOrNewStateObject(addr libcommon.Address) *stateObject {
+	return sdb.getOrNewStateObject(addr, false)
+}
+
+func (sdb *IntraBlockState) getOrNewStateObject(addr libcommon.Address, checkPrecompile bool) *stateObject {
 	stateObject := sdb.getStateObject(addr)
 	if stateObject == nil || stateObject.deleted {
-		stateObject = sdb.createObject(addr, stateObject /* previous */)
+		stateObject = sdb.createObject(addr, stateObject /* previous */, checkPrecompile)
 	}
 	return stateObject
 }
 
 // createObject creates a new state object. If there is an existing account with
 // the given address, it is overwritten.
-func (sdb *IntraBlockState) createObject(addr libcommon.Address, previous *stateObject) (newobj *stateObject) {
+func (sdb *IntraBlockState) createObject(addr libcommon.Address, previous *stateObject, checkPrecompile bool) (newobj *stateObject) {
 	account := new(accounts.Account)
 	var original *accounts.Account
 	if previous == nil {
@@ -572,7 +576,12 @@ func (sdb *IntraBlockState) createObject(addr libcommon.Address, previous *state
 	if sdb.logger != nil {
 		// Precompiled contracts are touched during a call.
 		// Make sure we avoid emitting a new account event for them.
-		if _, ok := sdb.precompiles[addr]; !ok {
+		// checkPrecompile is added to make the tracer backward compatible with old firehose merged blocks
+		if checkPrecompile {
+			if _, ok := sdb.precompiles[addr]; !ok {
+				sdb.logger.OnNewAccount(addr)
+			}
+		} else {
 			sdb.logger.OnNewAccount(addr)
 		}
 	}
@@ -607,7 +616,7 @@ func (sdb *IntraBlockState) CreateAccount(addr libcommon.Address, contractCreati
 		}
 	}
 
-	newObj := sdb.createObject(addr, previous)
+	newObj := sdb.createObject(addr, previous, false)
 	if previous != nil && !previous.selfdestructed {
 		newObj.data.Balance.Set(&previous.data.Balance)
 	}

core/state/state_test.go

@@ -161,7 +161,7 @@ func (s *StateSuite) TestTouchDelete(c *checker.C) {
 	s.state.Reset()
 
 	snapshot := s.state.Snapshot()
-	s.state.AddBalance(common.Address{}, new(uint256.Int), 0x0)
+	s.state.AddBalance(common.Address{}, new(uint256.Int), false, 0x0)
 
 	if len(s.state.journal.dirties) != 1 {
 		c.Fatal("expected one dirty state object")

core/state_transition.go

@@ -441,12 +441,12 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*Executi
 	}
 	amount := new(uint256.Int).SetUint64(st.gasUsed())
 	amount.Mul(amount, effectiveTip) // gasUsed * effectiveTip = how much goes to the block producer (miner, validator)
-	st.state.AddBalance(coinbase, amount, evmtypes.BalanceChangeRewardTransactionFee)
+	st.state.AddBalance(coinbase, amount, false, evmtypes.BalanceChangeRewardTransactionFee)
 	if !msg.IsFree() && rules.IsLondon {
 		burntContractAddress := st.evm.ChainConfig().GetBurntContract(st.evm.Context().BlockNumber)
 		if burntContractAddress != nil {
 			burnAmount := new(uint256.Int).Mul(new(uint256.Int).SetUint64(st.gasUsed()), st.evm.Context().BaseFee)
-			st.state.AddBalance(*burntContractAddress, burnAmount, evmtypes.BalanceChangeBurn)
+			st.state.AddBalance(*burntContractAddress, burnAmount, false, evmtypes.BalanceChangeBurn)
 		}
 	}
 	if st.isBor {
@@ -489,7 +489,7 @@ func (st *StateTransition) refundGas(refundQuotient uint64) {
 
 	// Return ETH for remaining gas, exchanged at the original rate.
 	remaining := new(uint256.Int).Mul(new(uint256.Int).SetUint64(st.gas), st.gasPrice)
-	st.state.AddBalance(st.msg.From(), remaining, evmtypes.BalanceChangeGasRefund)
+	st.state.AddBalance(st.msg.From(), remaining, false, evmtypes.BalanceChangeGasRefund)
 
 	if st.evm.Config().Tracer != nil && st.gas > 0 {
 		st.evm.Config().Tracer.OnGasChange(st.gas, 0, vm.GasChangeTxLeftOverReturned)

core/vm/evm.go

@@ -211,7 +211,7 @@ func (evm *EVM) call(typ OpCode, caller ContractRef, addr libcommon.Address, inp
 		// This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,
 		// but is the correct thing to do and matters on other networks, in tests, and potential
 		// future scenarios
-		evm.intraBlockState.AddBalance(addr, u256.Num0, evmtypes.BalanceChangeTouchAccount)
+		evm.intraBlockState.AddBalance(addr, u256.Num0, true, evmtypes.BalanceChangeTouchAccount)
 	}
 
 	// It is allowed to call precompiles, even via delegatecall

core/vm/evmtypes/evmtypes.go

@@ -82,7 +82,7 @@ type IntraBlockState interface {
 	CreateAccount(common.Address, bool)
 
 	SubBalance(common.Address, *uint256.Int, BalanceChangeReason)
-	AddBalance(common.Address, *uint256.Int, BalanceChangeReason)
+	AddBalance(common.Address, *uint256.Int, bool, BalanceChangeReason)
 	GetBalance(common.Address) *uint256.Int
 
 	GetNonce(common.Address) uint64

core/vm/instructions.go

@@ -902,7 +902,7 @@ func opSelfdestruct(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext
 	callerAddr := scope.Contract.Address()
 	beneficiaryAddr := libcommon.Address(beneficiary.Bytes20())
 	balance := *interpreter.evm.IntraBlockState().GetBalance(callerAddr)
-	interpreter.evm.IntraBlockState().AddBalance(beneficiaryAddr, &balance, evmtypes.BalanceChangeSuicideRefund)
+	interpreter.evm.IntraBlockState().AddBalance(beneficiaryAddr, &balance, false, evmtypes.BalanceChangeSuicideRefund)
 	interpreter.evm.IntraBlockState().Selfdestruct(callerAddr)
 	if interpreter.evm.Config().Tracer != nil {
 		interpreter.cfg.Tracer.CaptureEnter(SELFDESTRUCT, callerAddr, beneficiaryAddr, false /* precompile */, false /* create */, []byte{}, 0, &balance, nil /* code */)
@@ -920,7 +920,7 @@ func opSelfdestruct6780(pc *uint64, interpreter *EVMInterpreter, scope *ScopeCon
 	beneficiaryAddr := libcommon.Address(beneficiary.Bytes20())
 	balance := *interpreter.evm.IntraBlockState().GetBalance(callerAddr)
 	interpreter.evm.IntraBlockState().SubBalance(callerAddr, &balance, evmtypes.BalanceChangeSuicideWithdraw)
-	interpreter.evm.IntraBlockState().AddBalance(beneficiaryAddr, &balance, evmtypes.BalanceChangeSuicideRefund)
+	interpreter.evm.IntraBlockState().AddBalance(beneficiaryAddr, &balance, false, evmtypes.BalanceChangeSuicideRefund)
 	interpreter.evm.IntraBlockState().Selfdestruct6780(callerAddr)
 	if interpreter.evm.Config().Tracer != nil {
 		interpreter.cfg.Tracer.CaptureEnter(SELFDESTRUCT, callerAddr, beneficiaryAddr, false /* precompile */, false /* create */, []byte{}, 0, &balance, nil /* code */)

eth/tracers/live/firehose.go

@@ -825,10 +825,6 @@ func (f *Firehose) OnNewAccount(a libcommon.Address) {
 		return
 	}
 
-	if f.isPrecompileAddress(a) {
-		return
-	}
-
 	accountCreation := &pbeth.AccountCreation{
 		Account: a.Bytes(),
 		Ordinal: f.blockOrdinal.Next(),