diff --git a/models/transaction.go b/models/transaction.go
index 9b39daa70..c8cb97152 100644
--- a/models/transaction.go
+++ b/models/transaction.go
@@ -10,9 +10,24 @@ import (
 	"github.com/onflow/cadence"
 	"github.com/onflow/flow-go/fvm/evm/types"
 	"github.com/onflow/go-ethereum/common"
+	"github.com/onflow/go-ethereum/core/txpool"
 	gethTypes "github.com/onflow/go-ethereum/core/types"
 )
 
+const (
+	// txSlotSize is used to calculate how many data slots a single transaction
+	// takes up based on its size. The slots are used as DoS protection, ensuring
+	// that validating a new transaction remains a constant operation (in reality
+	// O(maxslots), where max slots are 4 currently).
+	TxSlotSize = 32 * 1024
+
+	// txMaxSize is the maximum size a single transaction can have. This field has
+	// non-trivial consequences: larger transactions are significantly harder and
+	// more expensive to propagate; larger transactions also take more resources
+	// to validate whether they fit into the pool or not.
+	TxMaxSize = 4 * TxSlotSize // 128KB
+)
+
 type Transaction interface {
 	Hash() common.Hash
 	RawSignatureValues() (v *big.Int, r *big.Int, s *big.Int)
@@ -204,7 +219,12 @@ func UnmarshalTransaction(value []byte) (Transaction, error) {
 	return TransactionCall{Transaction: tx}, nil
 }
 
-func ValidateTransaction(tx *gethTypes.Transaction) error {
+func ValidateTransaction(
+	tx *gethTypes.Transaction,
+	head *gethTypes.Header,
+	signer gethTypes.Signer,
+	opts *txpool.ValidationOptions,
+) error {
 	txDataLen := len(tx.Data())
 
 	// Contract creation doesn't validate call data, handle first
@@ -255,5 +275,9 @@ func ValidateTransaction(tx *gethTypes.Transaction) error {
 		}
 	}
 
+	if err := txpool.ValidateTransaction(tx, head, signer, opts); err != nil {
+		return err
+	}
+
 	return nil
 }
diff --git a/models/transaction_test.go b/models/transaction_test.go
index e5979e608..d9be007c4 100644
--- a/models/transaction_test.go
+++ b/models/transaction_test.go
@@ -1,16 +1,27 @@
 package models
 
 import (
+	"crypto/ecdsa"
+	crand "crypto/rand"
 	_ "embed"
 	"encoding/hex"
+	"fmt"
 	"math/big"
 	"testing"
+	"time"
+
+	"math/rand"
 
 	"github.com/onflow/cadence"
 	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/flow-go/fvm/evm/emulator"
 	"github.com/onflow/flow-go/fvm/evm/types"
 	gethCommon "github.com/onflow/go-ethereum/common"
+	"github.com/onflow/go-ethereum/core"
+	"github.com/onflow/go-ethereum/core/txpool"
 	gethTypes "github.com/onflow/go-ethereum/core/types"
+	"github.com/onflow/go-ethereum/crypto"
+	"github.com/onflow/go-ethereum/params"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -388,9 +399,41 @@ func TestValidateTransaction(t *testing.T) {
 		},
 	}
 
+	head := &gethTypes.Header{
+		Number:   big.NewInt(20_182_324),
+		Time:     uint64(time.Now().Unix()),
+		GasLimit: 30_000_000,
+	}
+	emulatorConfig := emulator.NewConfig(
+		emulator.WithChainID(types.FlowEVMPreviewNetChainID),
+		emulator.WithBlockNumber(head.Number),
+		emulator.WithBlockTime(head.Time),
+	)
+	signer := emulator.GetSigner(emulatorConfig)
+	opts := &txpool.ValidationOptions{
+		Config: emulatorConfig.ChainConfig,
+		Accept: 0 |
+			1<<gethTypes.LegacyTxType |
+			1<<gethTypes.AccessListTxType |
+			1<<gethTypes.DynamicFeeTxType |
+			1<<gethTypes.BlobTxType,
+		MaxSize: TxMaxSize,
+		MinTip:  new(big.Int),
+	}
+
+	key, err := crypto.GenerateKey()
+	require.NoError(t, err)
+
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
-			err := ValidateTransaction(tc.tx)
+			tx, err := gethTypes.SignTx(
+				tc.tx,
+				signer,
+				key,
+			)
+			require.NoError(t, err)
+
+			err = ValidateTransaction(tx, head, signer, opts)
 			if tc.valid {
 				require.NoError(t, err)
 			} else {
@@ -401,3 +444,350 @@ func TestValidateTransaction(t *testing.T) {
 	}
 
 }
+
+func TestValidateConsensusRules(t *testing.T) {
+
+	head := &gethTypes.Header{
+		Number:   big.NewInt(20_182_324),
+		Time:     uint64(time.Now().Unix()),
+		GasLimit: 30_000_000,
+	}
+	emulatorConfig := emulator.NewConfig(
+		emulator.WithChainID(types.FlowEVMPreviewNetChainID),
+		emulator.WithBlockNumber(head.Number),
+		emulator.WithBlockTime(head.Time),
+	)
+	signer := emulator.GetSigner(emulatorConfig)
+	chainConfig := emulatorConfig.ChainConfig
+	opts := &txpool.ValidationOptions{
+		Config: chainConfig,
+		Accept: 0 |
+			1<<gethTypes.LegacyTxType |
+			1<<gethTypes.AccessListTxType |
+			1<<gethTypes.DynamicFeeTxType |
+			1<<gethTypes.BlobTxType,
+		MaxSize: TxMaxSize,
+		MinTip:  new(big.Int),
+	}
+
+	key, err := crypto.GenerateKey()
+	require.NoError(t, err)
+
+	t.Run("not supported tx type", func(t *testing.T) {
+		// We do not accept `gethTypes.LegacyTx` in the options below
+		opts := &txpool.ValidationOptions{
+			Config: chainConfig,
+			Accept: 0 |
+				1<<gethTypes.AccessListTxType |
+				1<<gethTypes.DynamicFeeTxType,
+			MaxSize: TxMaxSize,
+			MinTip:  new(big.Int),
+		}
+
+		tx := makeSignedTx(53_000, 0, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"transaction type not supported: tx type 0 not supported by this pool",
+		)
+	})
+
+	t.Run("tx size limits", func(t *testing.T) {
+		// Compute maximal data size for transactions (lower bound).
+		//
+		// It is assumed the fields in the transaction (except of the data) are:
+		//   - nonce     <= 32 bytes
+		//   - gasTip    <= 32 bytes
+		//   - gasLimit  <= 32 bytes
+		//   - recipient == 20 bytes
+		//   - value     <= 32 bytes
+		//   - signature == 65 bytes
+		// All those fields are summed up to at most 213 bytes.
+		baseSize := uint64(213)
+		dataSize := TxMaxSize - baseSize
+		gasLimit := uint64(2_500_000)
+
+		// Try adding a transaction with maximal allowed size
+		tx := makeSignedTx(gasLimit, dataSize, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+		require.NoError(t, err)
+
+		// Try adding a transaction with random allowed size
+		tx = makeSignedTx(gasLimit, uint64(rand.Intn(int(dataSize))), key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+		require.NoError(t, err)
+
+		// Try adding a transaction of minimal not allowed size
+		tx = makeSignedTx(gasLimit, TxMaxSize, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			fmt.Sprintf("oversized data: transaction size %d, limit 131072", tx.Size()),
+		)
+
+		// Try adding a transaction of random not allowed size
+		txSize := dataSize + 1 + uint64(rand.Intn(10*TxMaxSize))
+		tx = makeSignedTx(gasLimit, txSize, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			fmt.Sprintf("oversized data: transaction size %d, limit 131072", tx.Size()),
+		)
+	})
+
+	t.Run("check only fork-enabled transactions are accepted", func(t *testing.T) {
+		// We are not yet in Berlin fork
+		chainConfig.BerlinBlock = big.NewInt(19_182_324)
+		head.Number = big.NewInt(18_182_324)
+
+		tx := dynamicFeeTx(100, big.NewInt(1), big.NewInt(2), key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"transaction type not supported: type 2 rejected, pool not yet in Berlin",
+		)
+
+		// We are in Berlin fork, but not in London
+		chainConfig.BerlinBlock = big.NewInt(17_182_324)
+		chainConfig.LondonBlock = big.NewInt(19_182_524)
+		head.Number = big.NewInt(18_182_324)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"transaction type not supported: type 2 rejected, pool not yet in London",
+		)
+
+		// TODO(m-Peter): Add assertions for BlobTxType
+
+		// Cleanup
+		chainConfig.BerlinBlock = big.NewInt(0)
+		chainConfig.LondonBlock = big.NewInt(0)
+		head.Number = big.NewInt(20_182_324)
+	})
+
+	t.Run("init code size exceeded", func(t *testing.T) {
+		dataLen := params.MaxInitCodeSize + 5_000
+		data := make([]byte, dataLen)
+		n, err := crand.Read(data)
+		require.Equal(t, n, dataLen)
+		require.NoError(t, err)
+
+		tx, err := gethTypes.SignTx(
+			gethTypes.NewTx(
+				&gethTypes.LegacyTx{
+					Nonce:    1,
+					To:       nil,
+					Value:    big.NewInt(0),
+					Gas:      7_500_000,
+					GasPrice: big.NewInt(0),
+					Data:     data,
+				},
+			),
+			signer,
+			key,
+		)
+		require.NoError(t, err)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"max initcode size exceeded: code size 54152, limit 49152",
+		)
+	})
+
+	t.Run("negative value", func(t *testing.T) {
+		tx, err := gethTypes.SignTx(
+			gethTypes.NewTx(
+				&gethTypes.LegacyTx{
+					Nonce:    1,
+					To:       nil,
+					Value:    big.NewInt(-1500),
+					Gas:      7_500_000,
+					GasPrice: big.NewInt(0),
+					Data:     []byte{},
+				},
+			),
+			signer,
+			key,
+		)
+		require.NoError(t, err)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			txpool.ErrNegativeValue.Error(),
+		)
+	})
+
+	t.Run("tx gas limit higher than block gas limit", func(t *testing.T) {
+		head.GasLimit = 5_000_000
+		tx := makeSignedTx(7_500_000, 5_000, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"exceeds block gas limit",
+		)
+
+		// Cleanup
+		head.GasLimit = 30_000_000
+	})
+
+	t.Run("very high fee values", func(t *testing.T) {
+		veryBigNumber := big.NewInt(1)
+		veryBigNumber.Lsh(veryBigNumber, 300)
+
+		tx := dynamicFeeTx(100, big.NewInt(1), veryBigNumber, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			core.ErrTipVeryHigh.Error(),
+		)
+
+		tx2 := dynamicFeeTx(100, veryBigNumber, big.NewInt(1), key, signer)
+
+		err = txpool.ValidateTransaction(tx2, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			core.ErrFeeCapVeryHigh.Error(),
+		)
+	})
+
+	t.Run("gas tip above gas fee cap", func(t *testing.T) {
+		tx := dynamicFeeTx(100, big.NewInt(1), big.NewInt(2), key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			core.ErrTipAboveFeeCap.Error(),
+		)
+	})
+
+	t.Run("invalid sender", func(t *testing.T) {
+		tx := makeSignedTx(55_000, 5_000, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, gethTypes.FrontierSigner{}, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			"invalid sender",
+		)
+	})
+
+	t.Run("intrinsic gas too low", func(t *testing.T) {
+		gasLimit := uint64(100)
+		tx := makeSignedTx(gasLimit, 0, key, signer)
+
+		err = txpool.ValidateTransaction(tx, head, signer, opts)
+
+		require.Error(t, err)
+		assert.ErrorContains(
+			t,
+			err,
+			fmt.Sprintf("%s: needed %v, allowed %v", core.ErrIntrinsicGas.Error(), 21_000, gasLimit),
+		)
+	})
+}
+
+func makeSignedTx(
+	gasLimit uint64,
+	dataBytes uint64,
+	key *ecdsa.PrivateKey,
+	signer gethTypes.Signer,
+) *gethTypes.Transaction {
+	data := make([]byte, dataBytes)
+	_, err := crand.Read(data)
+	if err != nil {
+		panic(err)
+	}
+
+	tx, err := gethTypes.SignTx(
+		gethTypes.NewTransaction(
+			0,
+			gethCommon.Address{},
+			big.NewInt(100),
+			gasLimit,
+			big.NewInt(150),
+			data,
+		),
+		signer,
+		key,
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	return tx
+}
+
+func dynamicFeeTx(
+	gasLimit uint64,
+	gasFeeCap *big.Int,
+	gasTipCap *big.Int,
+	key *ecdsa.PrivateKey,
+	signer gethTypes.Signer,
+) *gethTypes.Transaction {
+	tx, err := gethTypes.SignNewTx(
+		key,
+		signer,
+		&gethTypes.DynamicFeeTx{
+			ChainID:    emulator.DefaultChainConfig.ChainID,
+			Nonce:      0,
+			GasTipCap:  gasTipCap,
+			GasFeeCap:  gasFeeCap,
+			Gas:        gasLimit,
+			To:         nil,
+			Value:      big.NewInt(100),
+			Data:       []byte{},
+			AccessList: gethTypes.AccessList{},
+		},
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	return tx
+}
diff --git a/services/requester/requester.go b/services/requester/requester.go
index 080f0b67e..6b5493b25 100644
--- a/services/requester/requester.go
+++ b/services/requester/requester.go
@@ -9,14 +9,17 @@ import (
 	"math"
 	"math/big"
 	"strings"
+	"time"
 
 	"github.com/onflow/cadence"
 	"github.com/onflow/flow-go-sdk"
 	"github.com/onflow/flow-go-sdk/crypto"
+	"github.com/onflow/flow-go/fvm/evm/emulator"
 	"github.com/onflow/flow-go/fvm/evm/stdlib"
 	evmTypes "github.com/onflow/flow-go/fvm/evm/types"
 	"github.com/onflow/flow-go/fvm/systemcontracts"
 	"github.com/onflow/go-ethereum/common"
+	"github.com/onflow/go-ethereum/core/txpool"
 	"github.com/onflow/go-ethereum/core/types"
 	"github.com/rs/zerolog"
 	"golang.org/x/sync/errgroup"
@@ -94,6 +97,10 @@ type EVM struct {
 	txPool *TxPool
 	logger zerolog.Logger
 	blocks storage.BlockIndexer
+
+	head              *types.Header
+	evmSigner         types.Signer
+	validationOptions *txpool.ValidationOptions
 }
 
 func NewEVM(
@@ -125,13 +132,38 @@ func NewEVM(
 		)
 	}
 
+	head := &types.Header{
+		Number:   big.NewInt(20_182_324),
+		Time:     uint64(time.Now().Unix()),
+		GasLimit: 30_000_000,
+	}
+	emulatorConfig := emulator.NewConfig(
+		emulator.WithChainID(config.EVMNetworkID),
+		emulator.WithBlockNumber(head.Number),
+		emulator.WithBlockTime(head.Time),
+	)
+	evmSigner := emulator.GetSigner(emulatorConfig)
+	validationOptions := &txpool.ValidationOptions{
+		Config: emulatorConfig.ChainConfig,
+		Accept: 0 |
+			1<<types.LegacyTxType |
+			1<<types.AccessListTxType |
+			1<<types.DynamicFeeTxType |
+			1<<types.BlobTxType,
+		MaxSize: models.TxMaxSize,
+		MinTip:  new(big.Int),
+	}
+
 	evm := &EVM{
-		client: client,
-		config: config,
-		signer: signer,
-		logger: logger,
-		blocks: blocks,
-		txPool: NewTxPool(client, logger),
+		client:            client,
+		config:            config,
+		signer:            signer,
+		logger:            logger,
+		blocks:            blocks,
+		txPool:            NewTxPool(client, logger),
+		head:              head,
+		evmSigner:         evmSigner,
+		validationOptions: validationOptions,
 	}
 
 	// create COA on the account
@@ -159,13 +191,10 @@ func (e *EVM) SendRawTransaction(ctx context.Context, data []byte) (common.Hash,
 		return common.Hash{}, err
 	}
 
-	err := models.ValidateTransaction(tx)
-	if err != nil {
+	if err := models.ValidateTransaction(tx, e.head, e.evmSigner, e.validationOptions); err != nil {
 		return common.Hash{}, err
 	}
 
-	// todo do further validation
-
 	from, err := types.Sender(types.LatestSignerForChainID(tx.ChainId()), tx)
 	if err != nil {
 		return common.Hash{}, fmt.Errorf("failed to derive the sender: %w", err)
diff --git a/tests/integration_test.go b/tests/integration_test.go
index a9db7d1d2..377d2d4ce 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -64,7 +64,7 @@ func Test_ConcurrentTransactionSubmission(t *testing.T) {
 		RPCPort:           8545,
 		RPCHost:           "127.0.0.1",
 		FlowNetworkID:     "flow-emulator",
-		EVMNetworkID:      types.FlowEVMTestNetChainID,
+		EVMNetworkID:      types.FlowEVMPreviewNetChainID,
 		Coinbase:          eoaTestAccount,
 		COAAddress:        *createdAddr,
 		COAKeys:           keys,
@@ -200,7 +200,7 @@ func Test_CloudKMSConcurrentTransactionSubmission(t *testing.T) {
 		RPCPort:           8545,
 		RPCHost:           "127.0.0.1",
 		FlowNetworkID:     "flow-emulator",
-		EVMNetworkID:      types.FlowEVMTestNetChainID,
+		EVMNetworkID:      types.FlowEVMPreviewNetChainID,
 		Coinbase:          eoaTestAccount,
 		COAAddress:        *createdAddr,
 		COACloudKMSKeys:   kmsKeys,