fix(core): refresh coinbase owner per transaction

Problem: block processing reused a coinbase owner value captured before the transaction loop, so fee credits could go to a stale owner when the owner mapping changed during execution.
Cause: Process and ProcessBlockNoValidator computed coinbaseOwner once and passed it through ApplyTransactionWithEVM for every transaction in the block.
Solution: move the owner lookup into ApplyTransactionWithEVM so each transaction reads the current owner from state, remove the unused helper, and update tests to the new function signature.

Author: gzliudan

core/state_processor.go

@@ -100,7 +100,6 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, tra
 	context := NewEVMBlockContext(header, p.bc, nil)
 	evm := vm.NewEVM(context, tracingStateDB, tradingState, p.config, cfg)
 	signer := types.MakeSigner(p.config, blockNumber)
-	coinbaseOwner := getCoinbaseOwner(p.bc, statedb, header, nil)
 
 	if p.config.IsPrague(block.Number()) {
 		ProcessParentBlockHash(block.ParentHash(), evm)
@@ -146,7 +145,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, tra
 		}
 		statedb.SetTxContext(tx.Hash(), i)
 
-		receipt, gas, tokenFeeUsed, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, balanceFee, coinbaseOwner)
+		receipt, gas, tokenFeeUsed, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, balanceFee)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
@@ -207,7 +206,6 @@ func (p *StateProcessor) ProcessBlockNoValidator(cBlock *CalculatedBlock, stated
 	context := NewEVMBlockContext(header, p.bc, nil)
 	evm := vm.NewEVM(context, tracingStateDB, tradingState, p.config, cfg)
 	signer := types.MakeSigner(p.config, blockNumber)
-	coinbaseOwner := getCoinbaseOwner(p.bc, statedb, header, nil)
 
 	if p.config.IsPrague(block.Number()) {
 		ProcessParentBlockHash(block.ParentHash(), evm)
@@ -253,7 +251,7 @@ func (p *StateProcessor) ProcessBlockNoValidator(cBlock *CalculatedBlock, stated
 		}
 		statedb.SetTxContext(tx.Hash(), i)
 
-		receipt, gas, tokenFeeUsed, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, balanceFee, coinbaseOwner)
+		receipt, gas, tokenFeeUsed, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, balanceFee)
 		if err != nil {
 			return nil, nil, 0, err
 		}
@@ -279,7 +277,7 @@ func (p *StateProcessor) ProcessBlockNoValidator(cBlock *CalculatedBlock, stated
 // ApplyTransactionWithEVM attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment similar to ApplyTransaction. However,
 // this method takes an already created EVM instance as input.
-func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, balanceFee *big.Int, coinbaseOwner common.Address) (receipt *types.Receipt, gasUsed uint64, tokenFeeUsed bool, err error) {
+func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, balanceFee *big.Int) (receipt *types.Receipt, gasUsed uint64, tokenFeeUsed bool, err error) {
 	if hooks := evm.Config.Tracer; hooks != nil {
 		if hooks.OnTxStart != nil {
 			hooks.OnTxStart(evm.GetVMContext(), tx, msg.From)
@@ -458,6 +456,10 @@ func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB,
 	// End Bypass denylist address
 
 	// Apply the transaction to the current state (included in the env)
+	var coinbaseOwner common.Address
+	if balanceFee != nil && blockNumber.Cmp(common.TIPTRC21Fee) > 0 {
+		coinbaseOwner = statedb.GetOwner(evm.Context.Coinbase)
+	}
 	result, err := ApplyMessage(evm, msg, gp, coinbaseOwner)
 	if err != nil {
 		return nil, 0, false, err
@@ -506,17 +508,6 @@ func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, b
 	return receipt
 }
 
-func getCoinbaseOwner(bc *BlockChain, statedb *state.StateDB, header *types.Header, author *common.Address) common.Address {
-	// If we don't have an explicit author (i.e. not mining), extract from the header
-	var beneficiary common.Address
-	if author == nil {
-		beneficiary, _ = bc.Engine().Author(header) // Ignore error, we're past header validation
-	} else {
-		beneficiary = *author
-	}
-	return statedb.GetOwner(beneficiary)
-}
-
 // ApplyTransaction attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment. It returns the receipt
 // for the transaction, gas used and an error if the transaction failed,
@@ -534,8 +525,7 @@ func ApplyTransaction(tokensFee map[common.Address]*big.Int, evm *vm.EVM, gp *Ga
 	if err != nil {
 		return nil, 0, false, err
 	}
-	coinbaseOwner := statedb.GetOwner(evm.Context.Coinbase)
-	return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm, balanceFee, coinbaseOwner)
+	return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm, balanceFee)
 }
 
 func ApplySignTransaction(msg *Message, config *params.ChainConfig, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (receipt *types.Receipt, gasUsed uint64, tokenFeeUsed bool, err error) {

core/state_processor_test.go

@@ -501,7 +501,7 @@ func TestApplyTransactionWithEVMTracer(t *testing.T) {
 
 			// Apply transaction
 			var usedGas uint64
-			_, _, _, err = ApplyTransactionWithEVM(msg, gasPool, statedb, blockNumber, blockHash, signedTx, &usedGas, evm, big.NewInt(0), common.Address{})
+			_, _, _, err = ApplyTransactionWithEVM(msg, gasPool, statedb, blockNumber, blockHash, signedTx, &usedGas, evm, big.NewInt(0))
 			// NOTE: Some special transactions (like BlockSignersBinary or XDCXAddrBinary)
 			// may fail in test environment due to missing configuration or state, but
 			// the tracer should still be called at the beginning of ApplyTransactionWithEVM.
@@ -589,7 +589,7 @@ func TestApplyTransactionWithEVMStateChangeHooks(t *testing.T) {
 
 	gasPool := new(GasPool).AddGas(1000000)
 	var usedGas uint64
-	_, _, _, err = ApplyTransactionWithEVM(msg, gasPool, statedb, big.NewInt(1), genesis.Hash(), signedTx, &usedGas, evmenv, nil, common.Address{})
+	_, _, _, err = ApplyTransactionWithEVM(msg, gasPool, statedb, big.NewInt(1), genesis.Hash(), signedTx, &usedGas, evmenv, nil)
 	if err != nil {
 		t.Fatalf("ApplyTransactionWithEVM failed: %v", err)
 	}
@@ -598,6 +598,158 @@ func TestApplyTransactionWithEVMStateChangeHooks(t *testing.T) {
 	}
 }
 
+func TestProcessReReadsCoinbaseOwnerPerTransaction(t *testing.T) {
+	var (
+		config = &params.ChainConfig{
+			ChainID:             big.NewInt(1),
+			HomesteadBlock:      big.NewInt(0),
+			EIP150Block:         big.NewInt(0),
+			EIP155Block:         big.NewInt(0),
+			EIP158Block:         big.NewInt(0),
+			ByzantiumBlock:      big.NewInt(0),
+			ConstantinopleBlock: big.NewInt(0),
+			PetersburgBlock:     big.NewInt(0),
+			IstanbulBlock:       big.NewInt(0),
+			BerlinBlock:         big.NewInt(0),
+			LondonBlock:         big.NewInt(0),
+			Eip1559Block:        big.NewInt(0),
+			Ethash:              new(params.EthashConfig),
+		}
+		chainEngine = ethash.NewFaker()
+		engine      = noOpFinalizeEngine{Engine: chainEngine}
+		signer      = types.LatestSigner(config)
+		testKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		sender      = crypto.PubkeyToAddress(testKey.PublicKey)
+		coinbase    = common.HexToAddress("0x00000000000000000000000000000000000000c0")
+		owner1      = common.HexToAddress("0x00000000000000000000000000000000000000a1")
+		owner2      = common.HexToAddress("0x00000000000000000000000000000000000000a2")
+		tokenAddr   = common.HexToAddress("0x00000000000000000000000000000000000000b0")
+		blockNumber = new(big.Int).Add(common.TIPTRC21Fee, common.Big1)
+		gasTipCap   = new(big.Int).Set(common.BaseFee)
+		gasFeeCap   = new(big.Int).Mul(new(big.Int).Set(common.BaseFee), big.NewInt(2))
+	)
+
+	db := rawdb.NewMemoryDatabase()
+	gspec := &Genesis{
+		Config: config,
+		Alloc: types.GenesisAlloc{
+			sender: {
+				Balance: big.NewInt(1000000000000000000),
+				Nonce:   0,
+			},
+		},
+	}
+	genesis := gspec.MustCommit(db)
+	blockchain, _ := NewBlockChain(db, nil, gspec, chainEngine, vm.Config{})
+	defer blockchain.Stop()
+
+	statedb, err := blockchain.State()
+	if err != nil {
+		t.Fatalf("Failed to get state: %v", err)
+	}
+	setCoinbaseOwner(statedb, coinbase, owner1)
+
+	tx1, err := types.SignTx(types.NewTx(&types.DynamicFeeTx{
+		Nonce:     0,
+		GasTipCap: gasTipCap,
+		GasFeeCap: gasFeeCap,
+		Gas:       21000,
+		To:        &tokenAddr,
+		Value:     big.NewInt(0),
+	}), signer, testKey)
+	if err != nil {
+		t.Fatalf("Failed to sign first tx: %v", err)
+	}
+	tx2, err := types.SignTx(types.NewTx(&types.DynamicFeeTx{
+		Nonce:     1,
+		GasTipCap: gasTipCap,
+		GasFeeCap: gasFeeCap,
+		Gas:       21068,
+		To:        &tokenAddr,
+		Value:     big.NewInt(0),
+		Data:      []byte{0x01},
+	}), signer, testKey)
+	if err != nil {
+		t.Fatalf("Failed to sign second tx: %v", err)
+	}
+
+	header := &types.Header{
+		ParentHash: genesis.Hash(),
+		Coinbase:   coinbase,
+		Difficulty: big.NewInt(0),
+		GasLimit:   1000000,
+		Number:     blockNumber,
+		Time:       genesis.Time() + 10,
+		UncleHash:  types.EmptyUncleHash,
+		BaseFee:    new(big.Int).Set(common.BaseFee),
+	}
+	block := types.NewBlock(header, &types.Body{Transactions: types.Transactions{tx1, tx2}}, nil, trie.NewStackTrie(nil))
+
+	txEndCalls := 0
+	cfg := vm.Config{Tracer: &tracing.Hooks{
+		OnTxEnd: func(receipt *types.Receipt, err error) {
+			txEndCalls++
+			if txEndCalls == 1 {
+				setCoinbaseOwner(statedb, coinbase, owner2)
+			}
+		},
+	}}
+	tokensFee := map[common.Address]*big.Int{
+		tokenAddr: new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil),
+	}
+
+	processor := NewStateProcessor(config, blockchain, engine)
+	receipts, _, _, err := processor.Process(block, statedb, nil, cfg, tokensFee)
+	if err != nil {
+		t.Fatalf("Process failed: %v", err)
+	}
+	if len(receipts) != 2 {
+		t.Fatalf("expected 2 receipts, got %d", len(receipts))
+	}
+	if txEndCalls != 2 {
+		t.Fatalf("expected 2 OnTxEnd calls, got %d", txEndCalls)
+	}
+
+	owner1Balance := statedb.GetBalance(owner1)
+	owner2Balance := statedb.GetBalance(owner2)
+	if owner1Balance.Sign() <= 0 {
+		t.Fatalf("expected initial owner to receive first tx fee credit, have %v", owner1Balance)
+	}
+	if owner2Balance.Sign() <= 0 {
+		t.Fatalf("expected updated owner to receive second tx fee credit, have %v", owner2Balance)
+	}
+	expectedOwner1 := common.GetGasFee(blockNumber.Uint64(), receipts[0].GasUsed)
+	expectedOwner2 := common.GetGasFee(blockNumber.Uint64(), receipts[1].GasUsed)
+	if owner1Balance.Cmp(expectedOwner1) != 0 {
+		t.Fatalf("unexpected first owner fee credit: got %v want %v", owner1Balance, expectedOwner1)
+	}
+	if owner2Balance.Cmp(expectedOwner2) != 0 {
+		t.Fatalf("unexpected updated owner fee credit: got %v want %v", owner2Balance, expectedOwner2)
+	}
+
+	totalCredited := new(big.Int).Add(new(big.Int).Set(owner1Balance), owner2Balance)
+	expectedTotal := new(big.Int).Add(expectedOwner1, expectedOwner2)
+	if totalCredited.Cmp(expectedTotal) != 0 {
+		t.Fatalf("unexpected total fee credit: got %v want %v", totalCredited, expectedTotal)
+	}
+	if owner1Balance.Cmp(expectedTotal) == 0 {
+		t.Fatalf("all fee credit stayed with original owner, updated owner balance %v", owner2Balance)
+	}
+}
+
+func setCoinbaseOwner(statedb *state.StateDB, coinbase common.Address, owner common.Address) {
+	ownerSlot := state.GetLocMappingAtKey(coinbase.Hash(), 1)
+	statedb.SetState(common.MasternodeVotingSMCBinary, common.BigToHash(ownerSlot), owner.Hash())
+}
+
+type noOpFinalizeEngine struct {
+	consensus.Engine
+}
+
+func (e noOpFinalizeEngine) Finalize(chain consensus.ChainReader, header *types.Header, state vm.StateDB, parentState *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
+	return nil, nil
+}
+
 func TestProcessParentBlockHash(t *testing.T) {
 	var (
 		chainConfig = params.MergedTestChainConfig

eth/tracers/api.go

@@ -931,7 +931,7 @@ func (api *API) traceTx(ctx context.Context, tx *types.Transaction, message *cor
 
 	// Call SetTxContext to clear out the statedb access list
 	statedb.SetTxContext(txctx.TxHash, txctx.TxIndex)
-	_, _, _, err = core.ApplyTransactionWithEVM(message, new(core.GasPool).AddGas(message.GasLimit), statedb, vmctx.BlockNumber, txctx.BlockHash, tx, &usedGas, evm, balance, common.Address{})
+	_, _, _, err = core.ApplyTransactionWithEVM(message, new(core.GasPool).AddGas(message.GasLimit), statedb, vmctx.BlockNumber, txctx.BlockHash, tx, &usedGas, evm, balance)
 	if err != nil {
 		return nil, fmt.Errorf("tracing failed: %w", err)
 	}