Merge pull request #166 from bane-labs/policy-basefee

systemcontracts: apply baseFee from policy contract for burning

Author: AnnaShaleva

cmd/evm/internal/t8ntool/execution.go

@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/systemcontracts"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -156,9 +157,12 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		GasLimit:    pre.Env.GasLimit,
 		GetHash:     getHash,
 	}
-	// If currentBaseFee is defined, add it to the vmContext.
+	// If currentBaseFee is defined, add it to the vmContext and to the state DB.
 	if pre.Env.BaseFee != nil {
 		vmContext.BaseFee = new(big.Int).Set(pre.Env.BaseFee)
+		if chainConfig.IsNeoXBurn(vmContext.BlockNumber, vmContext.Time) {
+			statedb.SetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBaseFeeStateHash(), common.BigToHash(pre.Env.BaseFee))
+		}
 	}
 	// If random is defined, add it to the vmContext.
 	if pre.Env.Random != nil {

cmd/evm/internal/t8ntool/transition.go

@@ -174,6 +174,9 @@ func Transition(ctx *cli.Context) error {
 	if err := applyLondonChecks(&prestate.Env, chainConfig); err != nil {
 		return err
 	}
+	if err := applyNeoXBurnChecks(&prestate.Env, chainConfig); err != nil {
+		return err
+	}
 	if err := applyShanghaiChecks(&prestate.Env, chainConfig); err != nil {
 		return err
 	}
@@ -194,6 +197,17 @@ func Transition(ctx *cli.Context) error {
 	return dispatchOutput(ctx, baseDir, result, collector, body)
 }
 
+func applyNeoXBurnChecks(env *stEnv, chainConfig *params.ChainConfig) error {
+	if !chainConfig.IsNeoXBurn(big.NewInt(int64(env.Number)), env.Timestamp) {
+		return nil
+	}
+	// Sanity check, to not `panic` in state_transition
+	if env.BaseFee == nil {
+		return NewError(ErrorConfig, errors.New("NeoXBurn config but missing 'currentBaseFee' in env section"))
+	}
+	return nil
+}
+
 func applyLondonChecks(env *stEnv, chainConfig *params.ChainConfig) error {
 	if !chainConfig.IsLondon(big.NewInt(int64(env.Number))) {
 		return nil

consensus/dbft/chainreader.go

@@ -17,7 +17,7 @@ type ChainHeaderReader interface {
 	HasBlock(hash common.Hash, number uint64) bool
 	GetBlockByNumber(uint64) *types.Block
 	VerifyBlock(block *types.Block) (*state.StateDB, types.Receipts, error)
-	ProcessState(block *types.Block) (*state.StateDB, types.Receipts, []*types.Log, uint64, error)
+	ProcessState(block *types.Block, statedb *state.StateDB) (*state.StateDB, types.Receipts, []*types.Log, uint64, error)
 }
 
 // ChainHeaderWriter is a Blockchain API abstraction needed for proper blockQueue

consensus/dbft/dbft.go

@@ -426,7 +426,7 @@ func New(config *params.DBFTConfig, _ ethdb.Database) (*DBFT, error) {
 			dbftBlock.transactions = c.sealingTransactions
 			ethBlock := dbftBlock.ToEthBlock()
 
-			state, _, _, _, err := c.chain.ProcessState(ethBlock)
+			state, _, _, _, err := c.chain.ProcessState(ethBlock, nil)
 			if err != nil {
 				log.Crit("failed to process state from proposal",
 					"err", err,

consensus/misc/eip1559/eip1559.go

@@ -24,6 +24,8 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/consensus/misc"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/systemcontracts"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
 )
@@ -44,6 +46,11 @@ func VerifyEIP1559Header(config *params.ChainConfig, parent, header *types.Heade
 	if header.BaseFee == nil {
 		return errors.New("header is missing baseFee")
 	}
+	// For NeoXBurn block BaseFee verification is performed by consensus nodes and hence
+	// not included into the state-independent ordinary block verification rules.
+	if config.IsNeoXBurn(parent.Number, parent.Time) {
+		return nil
+	}
 	// Verify the baseFee is correct based on the parent header.
 	expectedBaseFee := CalcBaseFee(config, parent)
 	if header.BaseFee.Cmp(expectedBaseFee) != 0 {
@@ -93,3 +100,12 @@ func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int {
 		return math.BigMax(baseFee, common.Big0)
 	}
 }
+
+// CalcBaseFeeDBFT calculates the basefee of the header.
+// if is neoXBurn fork, get basefee from Policy contract.
+func CalcBaseFeeDBFT(config *params.ChainConfig, parent *types.Header, state *state.StateDB) *big.Int {
+	if !config.IsNeoXBurn(parent.Number, parent.Time) {
+		return CalcBaseFee(config, parent)
+	}
+	return state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBaseFeeStateHash()).Big()
+}

core/blockchain.go

@@ -33,6 +33,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/common/prque"
 	"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/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -2452,23 +2453,35 @@ func (bc *BlockChain) GetTrieFlushInterval() time.Duration {
 	return time.Duration(bc.flushInterval.Load())
 }
 
-// ProcessState processes the state changes according to the Ethereum rules by running
-// the transaction messages using the statedb and applying any rewards to both
-// the processor (coinbase) and any included uncles. It doesn't persist any data.
-func (bc *BlockChain) ProcessState(block *types.Block) (*state.StateDB, types.Receipts, []*types.Log, uint64, error) {
+// getParentState retrieves statedb and parent header by hash or block number
+func (bc *BlockChain) getParentState(block *types.Block) (*state.StateDB, *types.Header, error) {
 	parent := bc.GetBlockByHash(block.ParentHash())
 	if parent == nil {
 		log.Error("failed to retrieve parent by hash to process block state",
 			"parent number", block.NumberU64()-1,
 			"parent hash", block.ParentHash().String())
 		parent = bc.GetBlockByNumber(block.NumberU64() - 1)
 		if parent == nil {
-			return nil, nil, nil, 0, fmt.Errorf("failed to retrieve canonical parent by number to process block state (number %d, hash %s)", block.NumberU64()-1, block.ParentHash().String())
+			return nil, nil, fmt.Errorf("failed to retrieve canonical parent by number to process block state (number %d, hash %s)", block.NumberU64()-1, block.ParentHash().String())
 		}
 	}
 	statedb, err := bc.StateAt(parent.Root())
 	if err != nil {
-		return nil, nil, nil, 0, fmt.Errorf("failed to retrieve state at %d, %s: %w", parent.NumberU64(), parent.Root(), err)
+		return nil, parent.Header(), fmt.Errorf("failed to retrieve state at %d, %s: %w", parent.NumberU64(), parent.Root(), err)
+	}
+	return statedb, parent.Header(), nil
+}
+
+// ProcessState processes the state changes according to the Ethereum rules by running
+// the transaction messages using the statedb (if given) and applying any rewards to both
+// the processor (coinbase) and any included uncles. It doesn't persist any data.
+func (bc *BlockChain) ProcessState(block *types.Block, statedb *state.StateDB) (*state.StateDB, types.Receipts, []*types.Log, uint64, error) {
+	var err error
+	if statedb == nil {
+		statedb, _, err = bc.getParentState(block)
+		if err != nil {
+			return nil, nil, nil, 0, err
+		}
 	}
 
 	receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig)
@@ -2485,7 +2498,18 @@ func (bc *BlockChain) VerifyBlock(block *types.Block) (*state.StateDB, types.Rec
 		return nil, nil, fmt.Errorf("failed to validate body: %w", err)
 	}
 
-	statedb, receipts, _, usedGas, err := bc.ProcessState(block)
+	statedb, parentHeader, err := bc.getParentState(block)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// verify baseFee
+	baseFee := eip1559.CalcBaseFeeDBFT(bc.chainConfig, parentHeader, statedb)
+	if block.BaseFee().Cmp(baseFee) != 0 {
+		return nil, nil, fmt.Errorf("failed to verify policy baseFee, expected: %v, current: %v", baseFee, block.BaseFee())
+	}
+
+	statedb, receipts, _, usedGas, err := bc.ProcessState(block, statedb)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to process block state: %w", err)
 	}

core/state_transition.go

@@ -294,13 +294,6 @@ func (st *StateTransition) preCheck() error {
 			return fmt.Errorf("%w: address %v, codehash: %s", ErrSenderNoEOA,
 				msg.From.Hex(), codeHash)
 		}
-		// Ensure the transaction is allowed by policy
-		// Apply policy minimum gas tip cap
-		var minGasTipCap = st.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash())
-		if msg.GasTipCap.Cmp(minGasTipCap.Big()) < 0 {
-			return fmt.Errorf("%w: address %v, gastipcap %v", ErrUnderpriced,
-				msg.From.Hex(), msg.GasTipCap)
-		}
 		// Apply policy blacklist
 		var blocked = st.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBlackListStateHash(msg.From))
 		if blocked != (common.Hash{}) {
@@ -331,6 +324,16 @@ func (st *StateTransition) preCheck() error {
 				return fmt.Errorf("%w: address %v, maxFeePerGas: %s, baseFee: %s", ErrFeeCapTooLow,
 					msg.From.Hex(), msg.GasFeeCap, st.evm.Context.BaseFee)
 			}
+			// Ensure the transaction is allowed by policy, only for neoXBurn fork
+			if st.evm.ChainConfig().IsNeoXBurn(st.evm.Context.BlockNumber, st.evm.Context.Time) {
+				// Apply policy minimum gas tip cap
+				// For LegacyTx, GasFeeCap and GasPrice are equal, so checking GasTipCap and GasFeeCap is enough
+				var minGasTipCap = st.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash()).Big()
+				if cmath.BigMin(msg.GasTipCap, new(big.Int).Sub(msg.GasFeeCap, st.evm.Context.BaseFee)).Cmp(minGasTipCap) < 0 {
+					return fmt.Errorf("%w: address %v, gasTipCap %v, gasFeeCap %v, policy minGasTipCap %v, baseFee %v ", ErrUnderpriced,
+						msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap, minGasTipCap, st.evm.Context.BaseFee)
+				}
+			}
 		}
 	}
 	// Check the blob version validity

core/txpool/blobpool/blobpool.go

@@ -399,7 +399,7 @@ func (p *BlobPool) Init(gasTip *big.Int, head *types.Header, reserve txpool.Addr
 		p.recheck(addr, nil)
 	}
 	var (
-		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head))
+		basefee = uint256.MustFromBig(eip1559.CalcBaseFeeDBFT(p.chain.Config(), p.head, p.state))
 		blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
 	)
 	if p.head.ExcessBlobGas != nil {
@@ -782,7 +782,7 @@ func (p *BlobPool) Reset(oldHead, newHead *types.Header) {
 	}
 	// Reset the price heap for the new set of basefee/blobfee pairs
 	var (
-		basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead))
+		basefee = uint256.MustFromBig(eip1559.CalcBaseFeeDBFT(p.chain.Config(), newHead, p.state))
 		blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
 	)
 	if newHead.ExcessBlobGas != nil {

core/txpool/legacypool/legacypool.go

@@ -1333,7 +1333,7 @@ func (pool *LegacyPool) runReorg(done chan struct{}, reset *txpoolResetRequest,
 		pool.demoteUnexecutables()
 		if reset.newHead != nil {
 			if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
-				pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead)
+				pendingBaseFee := eip1559.CalcBaseFeeDBFT(pool.chainconfig, reset.newHead, pool.currentState)
 				pool.priced.SetBaseFee(pendingBaseFee)
 			} else {
 				pool.priced.Reheap()

core/txpool/validation.go

@@ -22,6 +22,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/systemcontracts"
@@ -203,9 +204,12 @@ func ValidateTransactionWithState(tx *types.Transaction, signer types.Signer, op
 	}
 	// Ensure the transaction is allowed by policy
 	// Apply policy minimum gas tip cap
-	var minGasTipCap = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash())
-	if tx.GasTipCap().Cmp(minGasTipCap.Big()) < 0 {
-		return fmt.Errorf("%w: policy needed %v, tip permitted %v", ErrUnderpriced, minGasTipCap.Big(), tx.GasTipCap())
+	// For LegacyTx, GasFeeCap and GasPrice are equal, so checking GasTipCap and GasFeeCap is enough
+	var minGasTipCap = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash()).Big()
+	var baseFee = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBaseFeeStateHash()).Big()
+	if math.BigMin(tx.GasTipCap(), new(big.Int).Sub(tx.GasFeeCap(), baseFee)).Cmp(minGasTipCap) < 0 {
+		return fmt.Errorf("%w: policy minGasTipCap needed %v, baseFee needed %v, gasTipCap %v, gasFeeCap %v ",
+			ErrUnderpriced, minGasTipCap, baseFee, tx.GasTipCap(), tx.GasFeeCap())
 	}
 	// Apply policy blacklist
 	var blocked = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBlackListStateHash(from))