R4R: metatx add from field into MetaTxSignData, so that to sign hash with from's addr

cmd/evm/internal/t8ntool/execution.go

@@ -162,8 +162,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		misc.ApplyDAOHardFork(statedb)
 	}
 
+	rules := chainConfig.Rules(new(big.Int).SetUint64(pre.Env.Number), false, pre.Env.Timestamp)
 	for i, tx := range txs {
-		msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee)
+		msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee, &rules)
 		if err != nil {
 			log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})

core/genesis.go

@@ -311,6 +311,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, gen
 			if mantleUpgradeChainConfig != nil {
 				config.BaseFeeTime = mantleUpgradeChainConfig.BaseFeeTime
 				config.BVMETHMintUpgradeTime = mantleUpgradeChainConfig.BVMETHMintUpgradeTime
+				config.MetaTxUpgradeTime = mantleUpgradeChainConfig.MetaTxUpgradeTime
 			}
 
 			if overrides != nil && overrides.OverrideShanghai != nil {

core/mantle_upgrade.go

@@ -11,21 +11,25 @@ var (
 		ChainID:               params.MantleMainnetChainId,
 		BaseFeeTime:           u64Ptr(0),
 		BVMETHMintUpgradeTime: u64Ptr(0),
+		MetaTxUpgradeTime:     u64Ptr(0),
 	}
 
 	MantleSepoliaUpgradeConfig = MantleUpgradeChainConfig{
 		ChainID:               params.MantleSepoliaChainId,
 		BaseFeeTime:           u64Ptr(1_704_891_600),
 		BVMETHMintUpgradeTime: nil, //TODO set upgrade timestamp
+		MetaTxUpgradeTime:     nil, //TODO set upgrade timestamp
 	}
 	MantleLocalUpgradeConfig = MantleUpgradeChainConfig{
 		ChainID:               params.MantleLocalChainId,
 		BaseFeeTime:           u64Ptr(0),
 		BVMETHMintUpgradeTime: u64Ptr(0),
+		MetaTxUpgradeTime:     u64Ptr(0),
 	}
 	MantleDefaultUpgradeConfig = MantleUpgradeChainConfig{
 		BaseFeeTime:           u64Ptr(0),
 		BVMETHMintUpgradeTime: u64Ptr(0),
+		MetaTxUpgradeTime:     u64Ptr(0),
 	}
 )
 
@@ -34,6 +38,7 @@ type MantleUpgradeChainConfig struct {
 
 	BaseFeeTime           *uint64 `json:"BaseFeeTime"`           // Mantle BaseFee switch time (nil = no fork, 0 = already on mantle baseFee)
 	BVMETHMintUpgradeTime *uint64 `json:"BVMETHMintUpgradeTime"` // BVM_ETH mint upgrade switch time (nil = no fork, 0 = already on)
+	MetaTxUpgradeTime     *uint64 `json:"metaTxUpgradeTime"`     // MetaTxUpgradeBlock identifies the current block height is using metaTx with MetaTxSignDataV2
 }
 
 func GetUpgradeConfigForMantle(chainID *big.Int) *MantleUpgradeChainConfig {

core/state_prefetcher.go

@@ -57,13 +57,15 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 	)
 	// Iterate over and process the individual transactions
 	byzantium := p.config.IsByzantium(block.Number())
+	rules := evm.ChainConfig().Rules(block.Number(), false, header.Time)
+
 	for i, tx := range block.Transactions() {
 		// If block precaching was interrupted, abort
 		if interrupt != nil && atomic.LoadUint32(interrupt) == 1 {
 			return
 		}
 		// Convert the transaction into an executable message and pre-cache its sender
-		msg, err := TransactionToMessage(tx, signer, header.BaseFee)
+		msg, err := TransactionToMessage(tx, signer, header.BaseFee, &rules)
 		if err != nil {
 			return // Also invalid block, bail out
 		}

core/state_processor.go

@@ -72,9 +72,11 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	}
 	blockContext := NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
 	vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
+	rules := vmenv.ChainConfig().Rules(header.Number, false, header.Time)
+
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
-		msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee)
+		msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee, &rules)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
@@ -171,7 +173,8 @@ func applyTransaction(msg *Message, config *params.ChainConfig, gp *GasPool, sta
 // for the transaction, gas used and an error if the transaction failed,
 // indicating the block was invalid.
 func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) {
-	msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number), header.BaseFee)
+	rules := config.Rules(header.Number, false, header.Time)
+	msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number), header.BaseFee, &rules)
 	if err != nil {
 		return nil, err
 	}

core/state_transition.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"math/big"
@@ -170,8 +171,11 @@ type Message struct {
 }
 
 // TransactionToMessage converts a transaction into a Message.
-func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) {
-	metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx)
+func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, rules *params.Rules) (*Message, error) {
+	if rules == nil {
+		return nil, errors.New("param rules is nil pointer")
+	}
+	metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx, rules.IsMetaTxV2)
 	if err != nil {
 		return nil, err
 	}

core/txpool/txpool.go

@@ -689,7 +689,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		cost = cost.Add(cost, l1Cost)
 	}
 
-	metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx)
+	metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx, pool.chainconfig.IsMetaTxV2(pool.chain.CurrentBlock().Time))
 	if err != nil {
 		return err
 	}
@@ -1480,7 +1480,7 @@ func (pool *TxPool) validateMetaTxList(list *list) ([]*types.Transaction, *big.I
 	var invalidMetaTxs []*types.Transaction
 	sponsorCostSum := big.NewInt(0)
 	for _, tx := range list.txs.Flatten() {
-		metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx)
+		metaTxParams, err := types.DecodeAndVerifyMetaTxParams(tx, pool.chainconfig.IsMetaTxV2(pool.chain.CurrentBlock().Time))
 		if err != nil {
 			invalidMetaTxs = append(invalidMetaTxs, tx)
 			continue

core/types/meta_transaction.go

@@ -57,6 +57,21 @@ type MetaTxSignData struct {
 	SponsorPercent uint64
 }
 
+type MetaTxSignDataV2 struct {
+	From           common.Address
+	ChainID        *big.Int
+	Nonce          uint64
+	GasTipCap      *big.Int
+	GasFeeCap      *big.Int
+	Gas            uint64
+	To             *common.Address `rlp:"nil"`
+	Value          *big.Int
+	Data           []byte
+	AccessList     AccessList
+	ExpireHeight   uint64
+	SponsorPercent uint64
+}
+
 func CalculateSponsorPercentAmount(mxParams *MetaTxParams, amount *big.Int) (*big.Int, *big.Int) {
 	if mxParams == nil {
 		return nil, nil
@@ -89,7 +104,7 @@ func DecodeMetaTxParams(txData []byte) (*MetaTxParams, error) {
 	return &metaTxParams, nil
 }
 
-func DecodeAndVerifyMetaTxParams(tx *Transaction) (*MetaTxParams, error) {
+func DecodeAndVerifyMetaTxParams(tx *Transaction, isMetaTxUpgraded bool) (*MetaTxParams, error) {
 	if tx.Type() != DynamicFeeTxType {
 		return nil, nil
 	}
@@ -117,27 +132,8 @@ func DecodeAndVerifyMetaTxParams(tx *Transaction) (*MetaTxParams, error) {
 		return nil, ErrInvalidSponsorPercent
 	}
 
-	metaTxSignData := &MetaTxSignData{
-		ChainID:        tx.ChainId(),
-		Nonce:          tx.Nonce(),
-		GasTipCap:      tx.GasTipCap(),
-		GasFeeCap:      tx.GasFeeCap(),
-		Gas:            tx.Gas(),
-		To:             tx.To(),
-		Value:          tx.Value(),
-		Data:           metaTxParams.Payload,
-		AccessList:     tx.AccessList(),
-		ExpireHeight:   metaTxParams.ExpireHeight,
-		SponsorPercent: metaTxParams.SponsorPercent,
-	}
-
-	gasFeeSponsorSigner, err := recoverPlain(metaTxSignData.Hash(), metaTxParams.R, metaTxParams.S, metaTxParams.V, true)
-	if err != nil {
-		return nil, ErrInvalidGasFeeSponsorSig
-	}
-
-	if gasFeeSponsorSigner != metaTxParams.GasFeeSponsor {
-		return nil, ErrGasFeeSponsorMismatch
+	if err = checkSponsorSignature(tx, metaTxParams, isMetaTxUpgraded); err != nil {
+		return nil, err
 	}
 
 	tx.metaTxParams.Store(&MetaTxParamsCache{
@@ -147,6 +143,67 @@ func DecodeAndVerifyMetaTxParams(tx *Transaction) (*MetaTxParams, error) {
 	return metaTxParams, nil
 }
 
+func checkSponsorSignature(tx *Transaction, metaTxParams *MetaTxParams, isMetaTxUpgraded bool) error {
+	var (
+		txSender, gasFeeSponsorSigner common.Address
+		err                           error
+	)
+
+	txSender, err = Sender(LatestSignerForChainID(tx.ChainId()), tx)
+	if err != nil {
+		return err
+	}
+
+	if isMetaTxUpgraded {
+		metaTxSignData := &MetaTxSignDataV2{
+			From:           txSender,
+			ChainID:        tx.ChainId(),
+			Nonce:          tx.Nonce(),
+			GasTipCap:      tx.GasTipCap(),
+			GasFeeCap:      tx.GasFeeCap(),
+			Gas:            tx.Gas(),
+			To:             tx.To(),
+			Value:          tx.Value(),
+			Data:           metaTxParams.Payload,
+			AccessList:     tx.AccessList(),
+			ExpireHeight:   metaTxParams.ExpireHeight,
+			SponsorPercent: metaTxParams.SponsorPercent,
+		}
+
+		gasFeeSponsorSigner, err = recoverPlain(metaTxSignData.Hash(), metaTxParams.R, metaTxParams.S, metaTxParams.V, true)
+		if err != nil {
+			return ErrInvalidGasFeeSponsorSig
+		}
+	} else {
+		metaTxSignData := &MetaTxSignData{
+			ChainID:        tx.ChainId(),
+			Nonce:          tx.Nonce(),
+			GasTipCap:      tx.GasTipCap(),
+			GasFeeCap:      tx.GasFeeCap(),
+			Gas:            tx.Gas(),
+			To:             tx.To(),
+			Value:          tx.Value(),
+			Data:           metaTxParams.Payload,
+			AccessList:     tx.AccessList(),
+			ExpireHeight:   metaTxParams.ExpireHeight,
+			SponsorPercent: metaTxParams.SponsorPercent,
+		}
+
+		gasFeeSponsorSigner, err = recoverPlain(metaTxSignData.Hash(), metaTxParams.R, metaTxParams.S, metaTxParams.V, true)
+		if err != nil {
+			return ErrInvalidGasFeeSponsorSig
+		}
+	}
+
+	if gasFeeSponsorSigner != metaTxParams.GasFeeSponsor {
+		return ErrGasFeeSponsorMismatch
+	}
+	return nil
+}
+
 func (metaTxSignData *MetaTxSignData) Hash() common.Hash {
 	return rlpHash(metaTxSignData)
 }
+func (metaTxSignData *MetaTxSignDataV2) Hash() common.Hash {
+	return rlpHash(metaTxSignData)
+}