Merge branch 'develop' into feat-reject-txs-withmax-l1-data-fee-in-worker

Author: Thegaram

accounts/abi/bind/backends/simulated.go

@@ -640,7 +640,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
 	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
 	signer := types.MakeSigner(b.blockchain.Config(), head.Number, head.Time)
-	l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, head.BaseFee, b.blockchain.Config(), signer, stateDB, head.Number)
+	l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, head.BaseFee, b.blockchain.Config(), signer, stateDB, head.Number, head.Time)
 	if err != nil {
 		return nil, err
 	}

cmd/evm/internal/t8ntool/execution.go

@@ -152,6 +152,10 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	if chainConfig.CurieBlock != nil && chainConfig.CurieBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
 		misc.ApplyCurieHardFork(statedb)
 	}
+	// Apply Feynman hard fork
+	if chainConfig.IsFeynmanTransitionBlock(pre.Env.Timestamp, pre.Env.ParentTimestamp) {
+		misc.ApplyFeynmanHardFork(statedb)
+	}
 	// Apply EIP-2935
 	if pre.Env.BlockHashes != nil && chainConfig.IsFeynman(pre.Env.Timestamp) {
 		var (
@@ -180,7 +184,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		snapshot := statedb.Snapshot()
 		evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
 
-		l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, chainConfig, new(big.Int).SetUint64(pre.Env.Number))
+		l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
 		if err != nil {
 			log.Info("rejected tx due to fees.CalculateL1DataFee", "index", i, "hash", tx.Hash(), "from", msg.From(), "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})

cmd/geth/main.go

@@ -176,6 +176,8 @@ var (
 		utils.CircuitCapacityCheckWorkersFlag,
 		utils.RollupVerifyEnabledFlag,
 		utils.ShadowforkPeersFlag,
+		utils.TxGossipBroadcastDisabledFlag,
+		utils.TxGossipReceivingDisabledFlag,
 		utils.DASyncEnabledFlag,
 		utils.DABlockNativeAPIEndpointFlag,
 		utils.DABlobScanAPIEndpointFlag,

cmd/geth/usage.go

@@ -248,6 +248,8 @@ var AppHelpFlagGroups = []flags.FlagGroup{
 			utils.DARecoveryProduceBlocksFlag,
 			utils.CircuitCapacityCheckEnabledFlag,
 			utils.CircuitCapacityCheckWorkersFlag,
+			utils.TxGossipBroadcastDisabledFlag,
+			utils.TxGossipReceivingDisabledFlag,
 		},
 	},
 	{

cmd/utils/flags.go

@@ -893,6 +893,16 @@ var (
 		Usage: "peer ids of shadow fork peers",
 	}
 
+	// Tx gossip settings
+	TxGossipBroadcastDisabledFlag = cli.BoolFlag{
+		Name:  "txgossip.disablebroadcast",
+		Usage: "Disable gossip broadcast transactions to other peers",
+	}
+	TxGossipReceivingDisabledFlag = cli.BoolFlag{
+		Name:  "txgossip.disablereceiving",
+		Usage: "Disable gossip receiving transactions from other peers",
+	}
+
 	// DA syncing settings
 	DASyncEnabledFlag = cli.BoolFlag{
 		Name:  "da.sync",
@@ -1790,6 +1800,14 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		cfg.ShadowForkPeerIDs = ctx.GlobalStringSlice(ShadowforkPeersFlag.Name)
 		log.Info("Shadow fork peers", "ids", cfg.ShadowForkPeerIDs)
 	}
+	if ctx.GlobalIsSet(TxGossipBroadcastDisabledFlag.Name) {
+		cfg.TxGossipBroadcastDisabled = ctx.GlobalBool(TxGossipBroadcastDisabledFlag.Name)
+		log.Info("Transaction gossip broadcast disabled", "disabled", cfg.TxGossipBroadcastDisabled)
+	}
+	if ctx.GlobalIsSet(TxGossipReceivingDisabledFlag.Name) {
+		cfg.TxGossipReceivingDisabled = ctx.GlobalBool(TxGossipReceivingDisabledFlag.Name)
+		log.Info("Transaction gossip receiving disabled", "disabled", cfg.TxGossipReceivingDisabled)
+	}
 
 	// Cap the cache allowance and tune the garbage collector
 	mem, err := gopsutil.VirtualMemory()

consensus/misc/feynman.go

@@ -0,0 +1,22 @@
+package misc
+
+import (
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/state"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/rcfg"
+)
+
+// ApplyFeynmanHardFork modifies the state database according to the Feynman hard-fork rules,
+// updating the bytecode and storage of the L1GasPriceOracle contract.
+func ApplyFeynmanHardFork(statedb *state.StateDB) {
+	log.Info("Applying Feynman hard fork")
+
+	// update contract byte code
+	statedb.SetCode(rcfg.L1GasPriceOracleAddress, rcfg.FeynmanL1GasPriceOracleBytecode)
+
+	// initialize new storage slots
+	statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.IsFeynmanSlot, common.BytesToHash([]byte{1}))
+	statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.PenaltyThresholdSlot, common.BigToHash(rcfg.InitialPenaltyThreshold))
+	statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.PenaltyFactorSlot, common.BigToHash(rcfg.InitialPenaltyFactor))
+}

core/block_validator.go

@@ -70,13 +70,6 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 	if v.bc.HasBlockAndState(block.Hash(), block.NumberU64()) {
 		return ErrKnownBlock
 	}
-	if !v.config.Scroll.IsValidTxCount(len(block.Transactions())) {
-		return consensus.ErrInvalidTxCount
-	}
-	// Check if block payload size is smaller than the max size
-	if !v.config.Scroll.IsValidBlockSize(block.PayloadSize()) {
-		return ErrInvalidBlockPayloadSize
-	}
 	// Header validity is known at this point, check the uncles and transactions
 	header := block.Header()
 	if err := v.engine.VerifyUncles(v.bc, block); err != nil {
@@ -127,7 +120,6 @@ func (v *BlockValidator) ValidateL1Messages(block *types.Block) error {
 	blockHash := block.Hash()
 
 	if v.config.Scroll.L1Config == nil {
-		// TODO: should we allow follower nodes to skip L1 message verification?
 		panic("Running on L1Message-enabled network but no l1Config was provided")
 	}
 
@@ -204,7 +196,6 @@ func (v *BlockValidator) ValidateL1Messages(block *types.Block) error {
 		}
 
 		// skipped messages
-		// TODO: consider verifying that skipped messages overflow
 		for index := queueIndex; index < txQueueIndex; index++ {
 			if exists := it.Next(); !exists {
 				if err := it.Error(); err != nil {

core/blockchain_test.go

@@ -3186,70 +3186,6 @@ func TestFeeVault(t *testing.T) {
 	}
 }
 
-// TestTransactionCountLimit tests that the chain reject blocks with too many transactions.
-func TestTransactionCountLimit(t *testing.T) {
-	// Create config that allows at most 1 transaction per block
-	config := params.TestChainConfig
-	config.Scroll.MaxTxPerBlock = new(int)
-	*config.Scroll.MaxTxPerBlock = 1
-	defer func() {
-		config.Scroll.MaxTxPerBlock = nil
-	}()
-
-	var (
-		engine  = ethash.NewFaker()
-		db      = rawdb.NewMemoryDatabase()
-		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address = crypto.PubkeyToAddress(key.PublicKey)
-		funds   = big.NewInt(1000000000000000)
-		gspec   = &Genesis{Config: config, Alloc: GenesisAlloc{address: {Balance: funds}}}
-		genesis = gspec.MustCommit(db)
-	)
-
-	addTx := func(b *BlockGen) {
-		tx := types.NewTransaction(b.TxNonce(address), address, big.NewInt(0), 50000, b.header.BaseFee, nil)
-		signed, _ := types.SignTx(tx, types.HomesteadSigner{}, key)
-		b.AddTx(signed)
-	}
-
-	// Initialize blockchain
-	blockchain, err := NewBlockChain(db, nil, config, engine, vm.Config{}, nil, nil)
-	if err != nil {
-		t.Fatalf("failed to create new chain manager: %v", err)
-	}
-	defer blockchain.Stop()
-
-	// Insert empty block
-	block1, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		// empty
-	})
-
-	if _, err := blockchain.InsertChain(block1); err != nil {
-		t.Fatalf("failed to insert chain: %v", err)
-	}
-
-	// Insert block with 1 transaction
-	block2, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		addTx(b)
-	})
-
-	if _, err := blockchain.InsertChain(block2); err != nil {
-		t.Fatalf("failed to insert chain: %v", err)
-	}
-
-	// Insert block with 2 transactions
-	block3, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		addTx(b)
-		addTx(b)
-	})
-
-	_, err = blockchain.InsertChain(block3)
-
-	if !errors.Is(err, consensus.ErrInvalidTxCount) {
-		t.Fatalf("error mismatch: have: %v, want: %v", err, consensus.ErrInvalidTxCount)
-	}
-}
-
 // TestInsertBlocksWithL1Messages tests that the chain accepts blocks with L1MessageTx transactions.
 func TestInsertBlocksWithL1Messages(t *testing.T) {
 	var (
@@ -3443,69 +3379,6 @@ func TestL1MessageValidationFailure(t *testing.T) {
 	assert.Equal(t, uint64(4), *queueIndex)
 }
 
-func TestBlockPayloadSizeLimit(t *testing.T) {
-	// Create config that allows at most 150 bytes per block payload
-	config := params.TestChainConfig
-	config.Scroll.MaxTxPayloadBytesPerBlock = new(int)
-	*config.Scroll.MaxTxPayloadBytesPerBlock = 150
-	defer func() {
-		config.Scroll.MaxTxPayloadBytesPerBlock = nil
-	}()
-
-	var (
-		engine  = ethash.NewFaker()
-		db      = rawdb.NewMemoryDatabase()
-		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address = crypto.PubkeyToAddress(key.PublicKey)
-		funds   = big.NewInt(1000000000000000)
-		gspec   = &Genesis{Config: config, Alloc: GenesisAlloc{address: {Balance: funds}}}
-		genesis = gspec.MustCommit(db)
-	)
-
-	addTx := func(b *BlockGen) {
-		tx := types.NewTransaction(b.TxNonce(address), address, big.NewInt(0), 50000, b.header.BaseFee, nil)
-		signed, _ := types.SignTx(tx, types.HomesteadSigner{}, key)
-		b.AddTx(signed)
-	}
-
-	// Initialize blockchain
-	blockchain, err := NewBlockChain(db, nil, config, engine, vm.Config{}, nil, nil)
-	if err != nil {
-		t.Fatalf("failed to create new chain manager: %v", err)
-	}
-	defer blockchain.Stop()
-
-	// Insert empty block
-	block1, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		// empty
-	})
-
-	if _, err := blockchain.InsertChain(block1); err != nil {
-		t.Fatalf("failed to insert chain: %v", err)
-	}
-
-	// Insert block with 1 transaction
-	block2, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		addTx(b)
-	})
-
-	if _, err := blockchain.InsertChain(block2); err != nil {
-		t.Fatalf("failed to insert chain: %v", err)
-	}
-
-	// Insert block with 2 transactions
-	block3, _ := GenerateChain(config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
-		addTx(b)
-		addTx(b)
-	})
-
-	_, err = blockchain.InsertChain(block3)
-
-	if !errors.Is(err, ErrInvalidBlockPayloadSize) {
-		t.Fatalf("error mismatch: have: %v, want: %v", err, ErrInvalidBlockPayloadSize)
-	}
-}
-
 func TestEIP3651(t *testing.T) {
 	var (
 		addraa = common.HexToAddress("0x000000000000000000000000000000000000aaaa")

core/chain_makers.go

@@ -249,6 +249,9 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 		if config.CurieBlock != nil && config.CurieBlock.Cmp(b.header.Number) == 0 {
 			misc.ApplyCurieHardFork(statedb)
 		}
+		if config.IsFeynmanTransitionBlock(b.Time(), parent.Time()) {
+			misc.ApplyFeynmanHardFork(statedb)
+		}
 		// Execute any user modifications to the block
 		if gen != nil {
 			gen(i, b)

core/state_prefetcher.go

@@ -71,7 +71,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 		}
 		statedb.SetTxContext(tx.Hash(), i)
 
-		l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, p.config, block.Number())
+		l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, p.config, block.Number(), block.Time())
 		if err != nil {
 			return
 		}