core,core/tracing,core/vm,eth/feemarket,params: add some rough logic around fee distribution at state_transition

Author: ziogaschr

core/state_feemarket_tracker.go

@@ -66,18 +66,20 @@ func (t *feeMarketTracker) Hooks() (*tracing.Hooks, error) {
 	wrapped.OnExit = t.OnExit
 	wrapped.OnLog = t.OnLog
 
-	journaledHooks, err := tracing.WrapWithJournal(&wrapped)
-	if err != nil {
-		return nil, err
-	}
 
-	return journaledHooks, nil
+	return &wrapped, nil
 }
 
+// GetGasMap returns the gas map for the fee market
 func (t *feeMarketTracker) GetGasMap() map[common.Address]*uint256.Int {
 	return t.gasTracker
 }
 
+// GetAddressesToInvalidateCache returns the addresses to invalidate cache for the fee market
+func (t *feeMarketTracker) GetAddressesToInvalidateCache() []common.Address {
+	return t.addressesToInvalidateCache
+}
+
 func (t *feeMarketTracker) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
 	if t.hooks != nil && t.hooks.OnEnter != nil {
 		t.hooks.OnEnter(depth, typ, from, to, input, gas, value)
@@ -99,6 +101,7 @@ func (t *feeMarketTracker) OnExit(depth int, output []byte, gasUsed uint64, err
 		t.hooks.OnExit(depth, output, gasUsed, err, reverted)
 	}
 
+	// TODO: do we care if the tx reverted? the gas cost happened either way
 	if reverted || t.internalTxToAddress == (common.Address{}) {
 		return
 	}
@@ -129,15 +132,20 @@ func (t *feeMarketTracker) OnTxEnd(receipt *types.Receipt, err error) {
 		t.hooks.OnTxEnd(receipt, err)
 	}
 
-	if receipt == nil || receipt.Status == types.ReceiptStatusFailed {
+	// Error happened during tx validation.
+	if err != nil || receipt == nil {
 		return
 	}
 
+	// We want to track the gas used by the tx even if it failed.
 	if t.txToAddress == (common.Address{}) {
 		return
 	}
 
-	t.gasTracker[t.txToAddress] = t.gasTracker[t.txToAddress].Add(t.gasTracker[t.txToAddress], uint256.NewInt(receipt.GasUsed))
+	// As this is the actual TX gas used, we don't need to add it on top of the internal tx gas used
+	t.gasTracker[t.txToAddress] = uint256.NewInt(receipt.GasUsed)
+
+	// TODO: shall we invalidate gas use for other addresses too? or mark this address as root level?
 
 	t.txToAddress = (common.Address{})
 }

core/state_transition.go

@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/holiman/uint256"
 )
@@ -458,36 +459,80 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 
 	fee := new(uint256.Int).SetUint64(st.gasUsed())
 	fee.Mul(fee, effectiveTipU256)
+
 	// consensus engine is satoshi
 	if st.evm.ChainConfig().Satoshi != nil {
-
-		// Calculate full system reward
-		totalSystemReward := new(uint256.Int).Set(fee)
-		remainingSystemReward := new(uint256.Int).Set(totalSystemReward)
-
 		// Check if is a contract call
 		if st.msg.To != nil && st.state.GetCodeSize(*st.msg.To) > 0 {
 
 			tracer := st.evm.Config.Tracer
 			feeMarket := st.evm.Context.FeeMarket
 			feeMarketTracker := *st.evm.TxContext.FeeMarketTracker
+			feeMarketDenominator := st.evm.Context.FeeMarket.GetDenominator()
 
 			if tracer != nil && feeMarket != nil && feeMarketTracker != nil {
-				// Try to access the gas usage stats
-				gasUsageMap := feeMarketTracker.GetGasMap()
+				// Invalidate cache for the addresses that are being tracked
+				addressesToInvalidateCache := feeMarketTracker.GetAddressesToInvalidateCache()
+				for _, addr := range addressesToInvalidateCache {
+					feeMarket.InvalidateConfig(addr)
+				}
+
+				feeConfigs := feeConfigs{}
 
-				for addr, gas := range gasUsageMap {
+				// Get the gas usage map for the addresses that are being tracked
+				gasUsageMap := feeMarketTracker.GetGasMap()
+				for addr, gasUsed := range gasUsageMap {
 					fmt.Println()
-					fmt.Printf("🤡 TransitionDb -> Tracked addr: %v, gas: %v\n", addr, gas)
+					fmt.Printf("🤡 TransitionDb -> Tracked addr: %v, gasUsed: %v\n", addr, gasUsed)
 
 					// Get discount configuration from fee market
 					config, found := st.evm.Context.FeeMarket.GetConfig(addr, st.state)
-					fmt.Println("🤡 TransitionDb -> read config:", found, config)
+					if !found || !config.IsActive {
+						continue
+					}
+
+					// fmt.Println("🤡 TransitionDb -> read config:", found, config)
+
+					feeConfigs.addConfig(addr, gasUsed, config)
+				}
+
+				// Calculate the total gas used by the configurations
+				totalConfigGasUsed := feeConfigs.getConfigTotalGas()
+
+				for addr, feeConfig := range feeConfigs.configs {
+					// The portion of the total gas used by this specific configuration
+					configurationGasPercentage := uint256.NewInt(0).Div(feeConfig.gasUsed, totalConfigGasUsed)
+
+					// The portion of FeeMarketRewardGas that will be distributed to this configuration
+					rewardsGas := uint256.NewInt(0).Mul(configurationGasPercentage, uint256.NewInt(params.FeeMarketRewardGas))
+
+					fmt.Println("🤡 1️⃣ TransitionDb -> Config:", addr, "configurationGasPercentage:", configurationGasPercentage, "rewardsGas:", rewardsGas)
+
+					// Calculate the reward amount for each reward in the configuration
+					for _, reward := range feeConfig.configuration.Rewards {
+						// Gas to reward for this specific address
+						rewardGas := uint256.NewInt(0).Mul(rewardsGas, uint256.NewInt(0).Div(reward.RewardPercentage, feeMarketDenominator))
+
+						// TODO: handle overflow
+						st.gasRemaining -= rewardGas.Uint64()
+
+						// Reward amount for this specific address
+						rewardAmount := uint256.NewInt(0).Mul(rewardGas, effectiveTipU256)
+
+						fmt.Println("🤡 2️⃣ TransitionDb -> Reward:", reward.RewardAddress, "rewardGas:", rewardGas, "rewardAmount:", rewardAmount)
+
+						// Add fee reward to address
+						st.state.AddBalance(reward.RewardAddress, rewardAmount, tracing.BalanceIncreaseFeeMarketReward)
+
+						log.Info("Add reward fee",
+							"rewardAddress", reward.RewardAddress,
+							"rewardAmount", rewardAmount)
+					}
 				}
 			}
 		}
 
-		st.state.AddBalance(consensus.SystemAddress, remainingSystemReward, tracing.BalanceIncreaseRewardTransactionFee)
+		st.state.AddBalance(consensus.SystemAddress, fee, tracing.BalanceIncreaseRewardTransactionFee)
 		// add extra blob fee reward
 		if rules.IsCancun {
 			blobFee := new(big.Int).SetUint64(st.blobGasUsed())
@@ -547,3 +592,29 @@ func (st *StateTransition) gasUsed() uint64 {
 func (st *StateTransition) blobGasUsed() uint64 {
 	return uint64(len(st.msg.BlobHashes) * params.BlobTxBlobGasPerBlob)
 }
+
+type feeConfig struct {
+	gasUsed       *uint256.Int
+	configuration types.FeeMarketConfig
+}
+type feeConfigs struct {
+	configs            map[common.Address]feeConfig
+	totalConfigGasUsed *uint256.Int
+	// totalTxGasUsed     *uint256.Int
+}
+
+func (fc *feeConfigs) addConfig(addr common.Address, gasUsed *uint256.Int, configuration types.FeeMarketConfig) {
+	fc.configs[addr] = feeConfig{
+		gasUsed:       gasUsed,
+		configuration: configuration,
+	}
+}
+
+func (fc *feeConfigs) getConfigTotalGas() *uint256.Int {
+	totalGasUsed := uint256.NewInt(0)
+	for _, feeConfig := range fc.configs {
+		totalGasUsed = totalGasUsed.Add(totalGasUsed, feeConfig.gasUsed)
+	}
+	fc.totalConfigGasUsed = totalGasUsed
+	return fc.totalConfigGasUsed
+}

core/tracing/hooks.go

@@ -320,6 +320,8 @@ const (
 	// BalanceIncreaseCoreDistributeReward is a balance change that increases the block validator's balance and
 	// happens when Core is distributing rewards to validator.
 	BalanceIncreaseCoreDistributeReward BalanceChangeReason = 181
+	// BalanceIncreaseRewardTransactionFee is the reward for a transaction.
+	BalanceIncreaseFeeMarketReward BalanceChangeReason = 182
 )
 
 // GasChangeReason is used to indicate the reason for a gas change, useful

core/vm/interface.go

@@ -117,4 +117,6 @@ type FeeMarketTrackerReader interface {
 	Hooks() (*tracing.Hooks, error)
 	// GetGasMap returns the gas map for the fee market.
 	GetGasMap() map[common.Address]*uint256.Int
+	// GetAddressesToInvalidateCache returns the addresses to invalidate cache for the fee market.
+	GetAddressesToInvalidateCache() []common.Address
 }

eth/feemarket/storage.go

@@ -67,6 +67,10 @@ func (p *StorageProvider) GetConfig(address common.Address, state FeeMarketState
 	}
 
 	config, found = p.findConfigForAddress(address, state)
+	if !config.IsValidConfig(GetDenominator()) {
+		return types.FeeMarketConfig{}, false
+	}
+
 	if found {
 		p.configCache[address] = config // set in cache
 	}

params/protocol_params.go

@@ -37,6 +37,7 @@ const (
 	CallNewAccountGas     uint64 = 25000  // Paid for CALL when the destination address didn't exist prior.
 	TxGas                 uint64 = 21000  // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
 	SystemTxsGas          uint64 = 500000 // The gas reserved for system txs; only for satoshi consensus
+	FeeMarketRewardGas    uint64 = 100000 // The gas added for fee market rewards; only for satoshi consensus
 	TxGasContractCreation uint64 = 53000  // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
 	TxDataZeroGas         uint64 = 4      // Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.
 	QuadCoeffDiv          uint64 = 512    // Divisor for the quadratic particle of the memory cost equation.