The new economic system and support required by the gas fee are added to the contract

Author: eric

consensus/parlia/abi.go

@@ -1054,12 +1054,15 @@ func (p *Parlia) getCurrentValidators(blockHash common.Hash) ([]common.Address,
 }
 func (p *Parlia) BlockRewards(blockNumber *big.Int) *big.Int {
 	if rules := p.chainConfig.Rules(blockNumber); rules.HasBlockRewards {
+		if p.chainConfig.Parlia.StopMintBlock.Cmp(blockNumber) >= 0 {
+			return big.NewInt(0)
+		}
 		blockRewards := p.chainConfig.Parlia.BlockRewards
 		if blockRewards != nil && blockRewards.Cmp(common.Big0) > 0 {
 			return blockRewards
 		}
 	}
-	return nil
+	return big.NewInt(0)
 }
 
 // slash spoiled validators
@@ -1070,17 +1073,15 @@ func (p *Parlia) distributeIncoming(val common.Address, state *state.StateDB, he
 	state.SetBalance(consensus.SystemAddress, big.NewInt(0))
 	state.AddBalance(coinbase, balance)
 	rewards := big.NewInt(0).Abs(balance)
-	if rules := p.chainConfig.Rules(header.Number); rules.HasBlockRewards {
-		blockRewards := p.chainConfig.Parlia.BlockRewards
-		// if we have enabled block rewards and rewards are greater than 0 then
-		if blockRewards != nil && blockRewards.Cmp(common.Big0) > 0 {
-			state.AddBalance(coinbase, blockRewards)
-			rewards = rewards.Add(rewards, blockRewards)
-		}
-	}
+	blockRewards := p.BlockRewards(header.Number)
+	rewards = rewards.Add(rewards, blockRewards)
 	if rewards.Cmp(common.Big0) <= 0 {
 		return nil
 	}
+	if p.chainConfig.IsFncy2(header.Number) {
+
+		return p.distributeRewards(rewards, blockRewards, balance, val, state, header, chain, txs, receipts, receivedTxs, usedGas, mining)
+	}
 	// remove 1/16 reward according to netmarble
 	//doDistributeSysReward := state.GetBalance(common.HexToAddress(systemcontract.SystemRewardContract)).Cmp(maxSystemBalance) < 0
 	//if doDistributeSysReward {
@@ -1160,6 +1161,27 @@ func (p *Parlia) distributeToSystem(amount *big.Int, state *state.StateDB, heade
 	return p.applyTransaction(msg, state, header, chain, txs, receipts, receivedTxs, usedGas, mining)
 }
 
+// slash spoiled validators
+func (p *Parlia) distributeRewards(amount *big.Int, blockRewards *big.Int, gasFee *big.Int, validator common.Address,
+	state *state.StateDB, header *types.Header, chain core.ChainContext,
+	txs *[]*types.Transaction, receipts *[]*types.Receipt, receivedTxs *[]*types.Transaction, usedGas *uint64, mining bool) error {
+	// method
+	method := "distributeRewards"
+
+	// get packed data
+	data, err := p.validatorSetABI.Pack(method,
+		validator, blockRewards, gasFee,
+	)
+	if err != nil {
+		log.Error("Unable to pack tx for distributeRewards", "error", err)
+		return err
+	}
+	// get system message
+	msg := p.getSystemMessage(header.Coinbase, common.HexToAddress(systemcontract.ValidatorContract), data, amount)
+	// apply message
+	return p.applyTransaction(msg, state, header, chain, txs, receipts, receivedTxs, usedGas, mining)
+}
+
 // slash spoiled validators
 func (p *Parlia) distributeToValidator(amount *big.Int, validator common.Address,
 	state *state.StateDB, header *types.Header, chain core.ChainContext,

consensus/parlia/parlia.go

@@ -253,6 +253,7 @@ type TxPool struct {
 
 	gasFreeAddressMap     map[common.Address]uint                            // from address that can join tx_pool for free
 	gasFreeAddressMapFunc func(common.Hash) (map[common.Address]uint, error) // add func to get gasFreeAddressMap
+	gasPriceFunc          func(common.Hash) (*big.Int, error)                // add func to get gas price, do nothing when return 0
 
 	pending map[common.Address]*txList   // All currently processable transactions
 	queue   map[common.Address]*txList   // Queued but non-processable transactions
@@ -283,11 +284,17 @@ func getNoGasFreeAddressMapFunc() func(common.Hash) (map[common.Address]uint, er
 		return gasFreeToAddressMap, nil
 	}
 }
+func getGasPriceFunc() func(common.Hash) (*big.Int, error) {
+	return func(blockHash common.Hash) (*big.Int, error) {
+		return big.NewInt(0), nil
+	}
+}
+
 func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain blockChain) *TxPool {
 
-	return NewEnhanceTxPool(config, chainconfig, chain, getNoGasFreeAddressMapFunc())
+	return NewEnhanceTxPool(config, chainconfig, chain, getNoGasFreeAddressMapFunc(), getGasPriceFunc())
 }
-func NewEnhanceTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain blockChain, gasFreeAddressMapFunc func(common.Hash) (map[common.Address]uint, error)) *TxPool {
+func NewEnhanceTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain blockChain, gasFreeAddressMapFunc func(common.Hash) (map[common.Address]uint, error), gasPriceFunc func(common.Hash) (*big.Int, error)) *TxPool {
 	// Sanitize the input to ensure no vulnerable gas prices are set
 	config = (&config).sanitize()
 	// Create the transaction pool with its initial settings
@@ -309,6 +316,7 @@ func NewEnhanceTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chai
 		gasPrice:              new(big.Int).SetUint64(config.PriceLimit),
 		gasFreeAddressMap:     make(map[common.Address]uint),
 		gasFreeAddressMapFunc: gasFreeAddressMapFunc,
+		gasPriceFunc:          gasPriceFunc,
 	}
 	pool.locals = newAccountSet(pool.signer)
 	for _, addr := range config.Locals {
@@ -1283,7 +1291,16 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 			}
 		}
 	}
-
+	gasPrice, err := pool.gasPriceFunc(pool.chain.CurrentBlock().Hash())
+	if err != nil {
+		log.Warn("Failed to get gasPrice", "err", err)
+	} else {
+		if gasPrice != nil && gasPrice.Cmp(common.Big0) > 0 {
+			if pool.gasPrice.Cmp(gasPrice) != 0 {
+				pool.SetGasPrice(gasPrice)
+			}
+		}
+	}
 	// Inject any transactions discarded due to reorgs
 	log.Debug("Reinjecting stale transactions", "count", len(reinject))
 	senderCacher.recover(pool.signer, reinject)

core/tx_pool.go

@@ -515,7 +515,11 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 	ret, err := run(evm, contract, nil, false)
 
 	// Check whether the max code size has been exceeded, assign err if the case.
-	if err == nil && evm.chainRules.IsEIP158 && len(ret) > params.MaxCodeSize {
+	maxCodeSize := params.MaxCodeSize
+	if evm.chainRules.IsEIP3860 {
+		maxCodeSize = params.MaxCodeSize * 2
+	}
+	if err == nil && evm.chainRules.IsEIP158 && len(ret) > maxCodeSize {
 		err = ErrMaxCodeSizeExceeded
 	}