fix: use params.Rules for core.IntrinsicGas() args

Author: ARR4N

libevm/precompiles/parallel/parallel.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ava-labs/libevm/core"
 	"github.com/ava-labs/libevm/core/types"
 	"github.com/ava-labs/libevm/core/vm"
+	"github.com/ava-labs/libevm/params"
 )
 
 // A Handler is responsible for processing [types.Transactions] in an
@@ -106,7 +107,7 @@ func (p *Processor[R]) Close() {
 // StartBlock dispatches transactions to the [Handler] and returns immediately.
 // It MUST be paired with a call to [Processor.FinishBlock], without overlap of
 // blocks.
-func (p *Processor[R]) StartBlock(b *types.Block) error {
+func (p *Processor[R]) StartBlock(b *types.Block, rules params.Rules) error {
 	txs := b.Transactions()
 	jobs := make([]*job, 0, len(txs))
 
@@ -117,7 +118,7 @@ func (p *Processor[R]) StartBlock(b *types.Block) error {
 	}
 
 	for i, tx := range txs {
-		switch do, err := p.shouldProcess(tx); {
+		switch do, err := p.shouldProcess(tx, rules); {
 		case err != nil:
 			return err
 
@@ -184,7 +185,7 @@ func (p *Processor[R]) Result(i int) (R, bool) {
 	return *r.val, true
 }
 
-func (p *Processor[R]) shouldProcess(tx *types.Transaction) (ok bool, err error) {
+func (p *Processor[R]) shouldProcess(tx *types.Transaction, rules params.Rules) (ok bool, err error) {
 	cost, ok := p.handler.Gas(tx)
 	if !ok {
 		return false, nil
@@ -199,9 +200,9 @@ func (p *Processor[R]) shouldProcess(tx *types.Transaction) (ok bool, err error)
 		tx.Data(),
 		tx.AccessList(),
 		tx.To() == nil,
-		true, // Homestead
-		true, // EIP-2028 (Istanbul)
-		true, // EIP-3860 (Shanghai)
+		rules.IsHomestead,
+		rules.IsIstanbul, // EIP-2028
+		rules.IsShanghai, // EIP-3860
 	)
 	if err != nil {
 		return false, fmt.Errorf("calculating intrinsic gas of %v: %v", tx.Hash(), err)

libevm/precompiles/parallel/parallel_test.go

@@ -77,7 +77,7 @@ func TestProcessor(t *testing.T) {
 
 	// Each set of params is effectively a test case, but they are all run on
 	// the same [Processor].
-	params := []blockParams{
+	tests := []blockParams{
 		{
 			numTxs: 0,
 		},
@@ -108,39 +108,40 @@ func TestProcessor(t *testing.T) {
 
 	rng := rand.New(rand.NewPCG(0, 0)) //nolint:gosec // Reproducibility is useful for testing
 	for range 100 {
-		params = append(params, blockParams{
+		tests = append(tests, blockParams{
 			numTxs:             rng.IntN(1000),
 			sendToAddrEvery:    1 + rng.IntN(30),
 			sufficientGasEvery: 1 + rng.IntN(30),
 		})
 	}
 
-	for _, tc := range params {
+	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
-			t.Logf("%+v", tc)
+			t.Logf("%+v", tt)
 
-			txs := make(types.Transactions, tc.numTxs)
-			wantProcessed := make([]bool, tc.numTxs)
+			var rules params.Rules
+			txs := make(types.Transactions, tt.numTxs)
+			wantProcessed := make([]bool, tt.numTxs)
 			for i := range len(txs) {
 				var (
 					to       common.Address
 					extraGas uint64
 				)
 
 				wantProcessed[i] = true
-				if i%tc.sendToAddrEvery == 0 {
+				if i%tt.sendToAddrEvery == 0 {
 					to = handler.addr
 				} else {
 					wantProcessed[i] = false
 				}
-				if i%tc.sufficientGasEvery == 0 {
+				if i%tt.sufficientGasEvery == 0 {
 					extraGas = handler.gas
 				} else {
 					wantProcessed[i] = false
 				}
 
 				data := binary.BigEndian.AppendUint64(nil, uint64(i))
-				gas, err := core.IntrinsicGas(data, nil, false, true, true, true)
+				gas, err := core.IntrinsicGas(data, nil, false, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai)
 				require.NoError(t, err, "core.IntrinsicGas(%#x, nil, false, true, true, true)", data)
 
 				txs[i] = types.NewTx(&types.LegacyTx{
@@ -151,7 +152,7 @@ func TestProcessor(t *testing.T) {
 			}
 
 			block := types.NewBlock(&types.Header{}, txs, nil, nil, trie.NewStackTrie(nil))
-			require.NoError(t, p.StartBlock(block), "BeforeBlock()")
+			require.NoError(t, p.StartBlock(block, rules), "StartBlock()")
 			defer p.FinishBlock(block)
 
 			for i, tx := range txs {
@@ -285,7 +286,8 @@ func TestIntegration(t *testing.T) {
 	}
 
 	block := types.NewBlock(&types.Header{}, txs, nil, nil, trie.NewStackTrie(nil))
-	require.NoError(t, sut.StartBlock(block), "StartBlock()")
+	rules := evm.ChainConfig().Rules(block.Number(), true, block.Time())
+	require.NoError(t, sut.StartBlock(block, rules), "StartBlock()")
 	defer sut.FinishBlock(block)
 
 	pool := core.GasPool(math.MaxUint64)