diff --git a/cmd/run.go b/cmd/run.go
index b6abc66d0f..2bea4d0714 100644
--- a/cmd/run.go
+++ b/cmd/run.go
@@ -401,8 +401,9 @@ func startProfilingHttpServer(c metrics.Config) {
 	mux.HandleFunc(metrics.ProfilingSymbolEndpoint, pprof.Symbol)
 	mux.HandleFunc(metrics.ProfilingTraceEndpoint, pprof.Trace)
 	profilingServer := &http.Server{
-		Handler:     mux,
-		ReadTimeout: two * time.Minute,
+		Handler:           mux,
+		ReadHeaderTimeout: two * time.Minute,
+		ReadTimeout:       two * time.Minute,
 	}
 	log.Infof("profiling server listening on port %d", c.ProfilingPort)
 	if err := profilingServer.Serve(lis); err != nil {
@@ -426,8 +427,9 @@ func startMetricsHttpServer(c metrics.Config) {
 	mux.Handle(metrics.Endpoint, promhttp.Handler())
 
 	metricsServer := &http.Server{
-		Handler:     mux,
-		ReadTimeout: ten * time.Second,
+		Handler:           mux,
+		ReadHeaderTimeout: ten * time.Second,
+		ReadTimeout:       ten * time.Second,
 	}
 	log.Infof("metrics server listening on port %d", c.Port)
 	if err := metricsServer.Serve(lis); err != nil {
diff --git a/config/default.go b/config/default.go
index 2f3ee051d4..e8af7f70eb 100644
--- a/config/default.go
+++ b/config/default.go
@@ -20,6 +20,7 @@ MaxConns = 200
 
 [Pool]
 FreeClaimGasLimit = 150000
+IntervalToRefreshBlockedAddresses = "5m"
 MaxTxBytesSize=30132
 MaxTxDataBytesSize=30000
 DefaultMinGasPriceAllowed = 1000000000
diff --git a/config/environments/local/local.node.config.toml b/config/environments/local/local.node.config.toml
index bd4cf37821..ab6c98e264 100644
--- a/config/environments/local/local.node.config.toml
+++ b/config/environments/local/local.node.config.toml
@@ -16,6 +16,7 @@ MaxConns = 200
 
 [Pool]
 FreeClaimGasLimit = 1500000
+IntervalToRefreshBlockedAddresses = "5m"
 MaxTxBytesSize=30132
 MaxTxDataBytesSize=30000
 DefaultMinGasPriceAllowed = 1000000000
diff --git a/config/environments/public/public.node.config.toml b/config/environments/public/public.node.config.toml
index 6a968cd9d1..32f6d8a3fe 100644
--- a/config/environments/public/public.node.config.toml
+++ b/config/environments/public/public.node.config.toml
@@ -14,6 +14,7 @@ MaxConns = 200
 
 [Pool]
 FreeClaimGasLimit = 1500000
+IntervalToRefreshBlockedAddresses = "5m"
 MaxTxBytesSize=30132
 MaxTxDataBytesSize=30000
 DefaultMinGasPriceAllowed = 1000000000
diff --git a/db/migrations/pool/0006.sql b/db/migrations/pool/0006.sql
index 6589c121cd..561252ca3a 100644
--- a/db/migrations/pool/0006.sql
+++ b/db/migrations/pool/0006.sql
@@ -4,4 +4,4 @@ ADD COLUMN deposit_count BIGINT;
 
 -- +migrate Down
 ALTER TABLE pool.transaction
-DROP COLUMN deposit_count;
\ No newline at end of file
+DROP COLUMN deposit_count;
diff --git a/db/migrations/pool/0007.sql b/db/migrations/pool/0007.sql
new file mode 100644
index 0000000000..20349062b7
--- /dev/null
+++ b/db/migrations/pool/0007.sql
@@ -0,0 +1,8 @@
+-- +migrate Up
+CREATE TABLE pool.blocked
+(
+    addr varchar NOT NULL PRIMARY KEY
+);
+
+-- +migrate Down
+DROP TABLE pool.blocked;
diff --git a/jsonrpc/server.go b/jsonrpc/server.go
index d3892c656c..3a9d18bd47 100644
--- a/jsonrpc/server.go
+++ b/jsonrpc/server.go
@@ -123,9 +123,10 @@ func (s *Server) startHTTP() error {
 	mux.Handle("/", tollbooth.LimitFuncHandler(lmt, s.handle))
 
 	s.srv = &http.Server{
-		Handler:      mux,
-		ReadTimeout:  s.config.ReadTimeoutInSec * time.Second,
-		WriteTimeout: s.config.WriteTimeoutInSec * time.Second,
+		Handler:           mux,
+		ReadHeaderTimeout: s.config.ReadTimeoutInSec * time.Second,
+		ReadTimeout:       s.config.ReadTimeoutInSec * time.Second,
+		WriteTimeout:      s.config.WriteTimeoutInSec * time.Second,
 	}
 	log.Infof("http server started: %s", address)
 	if err := s.srv.Serve(lis); err != nil {
@@ -160,9 +161,10 @@ func (s *Server) startWS() {
 	mux.HandleFunc("/", s.handleWs)
 
 	s.wsSrv = &http.Server{
-		Handler:      mux,
-		ReadTimeout:  s.config.ReadTimeoutInSec * time.Second,
-		WriteTimeout: s.config.WriteTimeoutInSec * time.Second,
+		Handler:           mux,
+		ReadHeaderTimeout: s.config.ReadTimeoutInSec * time.Second,
+		ReadTimeout:       s.config.ReadTimeoutInSec * time.Second,
+		WriteTimeout:      s.config.WriteTimeoutInSec * time.Second,
 	}
 	s.wsUpgrader = websocket.Upgrader{
 		ReadBufferSize:  wsBufferSizeLimitInBytes,
diff --git a/pool/config.go b/pool/config.go
index 3e672bcb60..273ed8719c 100644
--- a/pool/config.go
+++ b/pool/config.go
@@ -10,6 +10,10 @@ type Config struct {
 	// FreeClaimGasLimit is the max gas allowed use to do a free claim
 	FreeClaimGasLimit uint64 `mapstructure:"FreeClaimGasLimit"`
 
+	// IntervalToRefreshBlockedAddresses is the time it takes to sync the
+	// blocked address list from db to memory
+	IntervalToRefreshBlockedAddresses types.Duration `mapstructure:"IntervalToRefreshBlockedAddresses"`
+
 	// MaxTxBytesSize is the max size of a transaction in bytes
 	MaxTxBytesSize uint64 `mapstructure:"MaxTxBytesSize"`
 
diff --git a/pool/errors.go b/pool/errors.go
index 879971c983..6f373ad206 100644
--- a/pool/errors.go
+++ b/pool/errors.go
@@ -27,6 +27,9 @@ var (
 	// ErrInvalidSender is returned if the transaction contains an invalid signature.
 	ErrInvalidSender = errors.New("invalid sender")
 
+	// ErrBlockedSender is returned if the transaction is sent by a blocked account.
+	ErrBlockedSender = errors.New("blocked sender")
+
 	// ErrNonceTooLow is returned if the nonce of a transaction is lower than the
 	// one present in the local chain.
 	ErrNonceTooLow = errors.New("nonce too low")
diff --git a/pool/interfaces.go b/pool/interfaces.go
index 4b6fb73001..848690e7a5 100644
--- a/pool/interfaces.go
+++ b/pool/interfaces.go
@@ -32,6 +32,7 @@ type storage interface {
 	GetTxZkCountersByHash(ctx context.Context, hash common.Hash) (*state.ZKCounters, error)
 	DeleteTransactionByHash(ctx context.Context, hash common.Hash) error
 	MarkWIPTxsAsPending(ctx context.Context) error
+	GetAllAddressesBlocked(ctx context.Context) ([]common.Address, error)
 	MinGasPriceSince(ctx context.Context, timestamp time.Time) (uint64, error)
 	DepositCountExists(ctx context.Context, depositCount uint64) (bool, error)
 }
diff --git a/pool/pgpoolstorage/pgpoolstorage.go b/pool/pgpoolstorage/pgpoolstorage.go
index 35e5f6a791..883b597de2 100644
--- a/pool/pgpoolstorage/pgpoolstorage.go
+++ b/pool/pgpoolstorage/pgpoolstorage.go
@@ -656,6 +656,33 @@ func (p *PostgresPoolStorage) UpdateTxWIPStatus(ctx context.Context, hash common
 	return nil
 }
 
+// GetAllAddressesBlocked get all addresses blocked
+func (p *PostgresPoolStorage) GetAllAddressesBlocked(ctx context.Context) ([]common.Address, error) {
+	sql := `SELECT addr FROM pool.blocked`
+
+	rows, err := p.db.Query(ctx, sql)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, nil
+		} else {
+			return nil, err
+		}
+	}
+	defer rows.Close()
+
+	var addrs []common.Address
+	for rows.Next() {
+		var addr string
+		err := rows.Scan(&addr)
+		if err != nil {
+			return nil, err
+		}
+		addrs = append(addrs, common.HexToAddress(addr))
+	}
+
+	return addrs, nil
+}
+
 // DepositCountExists checks if already exists a transaction in the pool with the
 // provided deposit count
 func (p *PostgresPoolStorage) DepositCountExists(ctx context.Context, depositCount uint64) (bool, error) {
diff --git a/pool/pool.go b/pool/pool.go
index 8a504d84d5..28c678bcfe 100644
--- a/pool/pool.go
+++ b/pool/pool.go
@@ -44,6 +44,7 @@ type Pool struct {
 	l2BridgeAddr            common.Address
 	chainID                 uint64
 	cfg                     Config
+	blockedAddresses        sync.Map
 	minSuggestedGasPrice    *big.Int
 	minSuggestedGasPriceMux *sync.RWMutex
 	eventLog                *event.EventLog
@@ -58,15 +59,56 @@ type preExecutionResponse struct {
 
 // NewPool creates and initializes an instance of Pool
 func NewPool(cfg Config, s storage, st stateInterface, l2BridgeAddr common.Address, chainID uint64, eventLog *event.EventLog) *Pool {
-	return &Pool{
+	p := &Pool{
 		cfg:                     cfg,
 		storage:                 s,
 		state:                   st,
 		l2BridgeAddr:            l2BridgeAddr,
 		chainID:                 chainID,
+		blockedAddresses:        sync.Map{},
 		minSuggestedGasPriceMux: new(sync.RWMutex),
 		eventLog:                eventLog,
 	}
+
+	p.refreshBlockedAddresses()
+	go func(cfg *Config, p *Pool) {
+		for {
+			time.Sleep(cfg.IntervalToRefreshBlockedAddresses.Duration)
+			p.refreshBlockedAddresses()
+		}
+	}(&cfg, p)
+	return p
+}
+
+// refreshBlockedAddresses refreshes the list of blocked addresses for the provided instance of pool
+func (p *Pool) refreshBlockedAddresses() {
+	blockedAddresses, err := p.storage.GetAllAddressesBlocked(context.Background())
+	if err != nil {
+		log.Error("failed to load blocked addresses")
+		return
+	}
+
+	blockedAddressesMap := sync.Map{}
+	for _, blockedAddress := range blockedAddresses {
+		blockedAddressesMap.Store(blockedAddress.String(), 1)
+		p.blockedAddresses.Store(blockedAddress.String(), 1)
+	}
+
+	unblockedAddresses := []string{}
+	p.blockedAddresses.Range(func(key, value any) bool {
+		addrHex := key.(string)
+		_, found := blockedAddressesMap.Load(addrHex)
+		if found {
+			return true
+		}
+
+		unblockedAddresses = append(unblockedAddresses, addrHex)
+		return true
+	})
+
+	for _, unblockedAddress := range unblockedAddresses {
+		p.blockedAddresses.Delete(unblockedAddress)
+	}
 }
 
 // StartPollingMinSuggestedGasPrice starts polling the minimum suggested gas price
@@ -300,6 +342,12 @@ func (p *Pool) validateTx(ctx context.Context, poolTx Transaction) error {
 		return ErrInvalidSender
 	}
 
+	// check if sender is blocked
+	_, blocked := p.blockedAddresses.Load(from.String())
+	if blocked {
+		return ErrBlockedSender
+	}
+
 	lastL2Block, err := p.state.GetLastL2Block(ctx, nil)
 	if err != nil {
 		return err
diff --git a/pool/pool_test.go b/pool/pool_test.go
index cfd86f8da0..a1e7bd4870 100644
--- a/pool/pool_test.go
+++ b/pool/pool_test.go
@@ -30,7 +30,7 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/test/testutils"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
+	ethTypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/jackc/pgx/v4/pgxpool"
 	"github.com/stretchr/testify/assert"
@@ -59,12 +59,13 @@ var (
 		},
 	}
 	cfg = pool.Config{
-		FreeClaimGasLimit:              150000,
-		MaxTxBytesSize:                 30132,
-		MaxTxDataBytesSize:             30000,
-		MinAllowedGasPriceInterval:     cfgTypes.NewDuration(5 * time.Minute),
-		PollMinAllowedGasPriceInterval: cfgTypes.NewDuration(15 * time.Second),
-		DefaultMinGasPriceAllowed:      1000000000,
+		FreeClaimGasLimit:                 150000,
+		MaxTxBytesSize:                    30132,
+		MaxTxDataBytesSize:                30000,
+		MinAllowedGasPriceInterval:        cfgTypes.NewDuration(5 * time.Minute),
+		PollMinAllowedGasPriceInterval:    cfgTypes.NewDuration(15 * time.Second),
+		DefaultMinGasPriceAllowed:         1000000000,
+		IntervalToRefreshBlockedAddresses: cfgTypes.NewDuration(5 * time.Minute),
 	}
 	gasPrice = big.NewInt(1000000000)
 	gasLimit = uint64(21000)
@@ -82,18 +83,15 @@ func TestMain(m *testing.M) {
 }
 
 func Test_AddTx(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
+
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -118,40 +116,30 @@ func Test_AddTx(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	const chainID = 2576980377
-	p := setupPool(t, s, st, chainID, ctx, eventLog)
+	p := setupPool(t, cfg, s, st, chainID, ctx, eventLog)
 
-	tx := new(types.Transaction)
+	tx := new(ethTypes.Transaction)
 	expectedTxEncoded := "0xf86880843b9aca008252089400000000000000000000000000000000000000008080850133333355a03ee24709870c8dbc67884c9c8acb864c1aceaaa7332b9a3db0d7a5d7c68eb8e4a0302980b070f5e3ffca3dc27b07daf69d66ab27d4df648e0b3ed059cf23aa168d"
 	b, err := hex.DecodeHex(expectedTxEncoded)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	tx.UnmarshalBinary(b) //nolint:gosec,errcheck
 
 	err = p.AddTx(ctx, *tx, "")
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	rows, err := poolSqlDB.Query(ctx, "SELECT hash, encoded, decoded, status, used_steps FROM pool.transaction")
+	require.NoError(t, err)
 	defer rows.Close() // nolint:staticcheck
-	if err != nil {
-		t.Error(err)
-	}
 
 	c := 0
 	for rows.Next() {
 		var hash, encoded, decoded, status string
 		var usedSteps int
 		err := rows.Scan(&hash, &encoded, &decoded, &status, &usedSteps)
-		if err != nil {
-			t.Error(err)
-		}
+		require.NoError(t, err)
 		b, _ := tx.MarshalJSON()
 
 		assert.Equal(t, "0x3c499a6308dbf4e67bd4e949b0b609e3a0a5a7fd6a497acb23e37ae7f0a923cc", hash, "invalid hash")
@@ -166,7 +154,7 @@ func Test_AddTx(t *testing.T) {
 }
 
 func Test_AddTx_OversizedData(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
 	if err != nil {
@@ -175,9 +163,7 @@ func Test_AddTx_OversizedData(t *testing.T) {
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -211,16 +197,14 @@ func Test_AddTx_OversizedData(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	const chainID = 2576980377
 	p := pool.NewPool(cfg, s, st, common.Address{}, chainID, eventLog)
 
 	b := make([]byte, cfg.MaxTxBytesSize+1)
 	to := common.HexToAddress(operations.DefaultSequencerAddress)
-	tx := types.NewTransaction(0, to, big.NewInt(0), gasLimit, big.NewInt(0), b)
+	tx := ethTypes.NewTransaction(0, to, big.NewInt(0), gasLimit, big.NewInt(0), b)
 
 	// GetAuth configures and returns an auth object.
 	auth, err := operations.GetAuth(operations.DefaultSequencerPrivateKey, chainID)
@@ -233,18 +217,14 @@ func Test_AddTx_OversizedData(t *testing.T) {
 }
 
 func Test_AddPreEIP155Tx(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -283,12 +263,10 @@ func Test_AddPreEIP155Tx(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	const chainID = 2576980377
-	p := setupPool(t, s, st, chainID, ctx, eventLog)
+	p := setupPool(t, cfg, s, st, chainID, ctx, eventLog)
 
 	batchL2Data := "0xe580843b9aca00830186a0941275fbb540c8efc58b812ba83b0d0b8b9917ae98808464fbb77c6b39bdc5f8e458aba689f2a1ff8c543a94e4817bda40f3fe34080c4ab26c1e3c2fc2cda93bc32f0a79940501fd505dcf48d94abfde932ebf1417f502cb0d9de81b"
 	b, err := hex.DecodeHex(batchL2Data)
@@ -302,8 +280,8 @@ func Test_AddPreEIP155Tx(t *testing.T) {
 	require.NoError(t, err)
 
 	rows, err := poolSqlDB.Query(ctx, "SELECT hash, encoded, decoded, status FROM pool.transaction")
-	defer rows.Close() // nolint:staticcheck
 	require.NoError(t, err)
+	defer rows.Close() // nolint:staticcheck
 
 	c := 0
 	for rows.Next() {
@@ -328,12 +306,10 @@ func Test_AddPreEIP155Tx(t *testing.T) {
 }
 
 func Test_GetPendingTxs(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -358,10 +334,8 @@ func Test_GetPendingTxs(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	const txsCount = 10
 	const limit = 5
@@ -374,18 +348,16 @@ func Test_GetPendingTxs(t *testing.T) {
 
 	// insert pending transactions
 	for i := 0; i < txsCount; i++ {
-		tx := types.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+		tx := ethTypes.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 		signedTx, err := auth.Signer(auth.From, tx)
 		require.NoError(t, err)
-		if err := p.AddTx(ctx, *signedTx, ""); err != nil {
-			t.Error(err)
-		}
+		err = p.AddTx(ctx, *signedTx, "")
+		require.NoError(t, err)
 	}
 
 	txs, err := p.GetPendingTxs(ctx, false, limit)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
+
 	assert.Equal(t, limit, len(txs))
 
 	for i := 0; i < txsCount; i++ {
@@ -394,12 +366,10 @@ func Test_GetPendingTxs(t *testing.T) {
 }
 
 func Test_GetPendingTxsZeroPassed(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -424,10 +394,8 @@ func Test_GetPendingTxsZeroPassed(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	const txsCount = 10
 	const limit = 0
@@ -440,18 +408,15 @@ func Test_GetPendingTxsZeroPassed(t *testing.T) {
 
 	// insert pending transactions
 	for i := 0; i < txsCount; i++ {
-		tx := types.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+		tx := ethTypes.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 		signedTx, err := auth.Signer(auth.From, tx)
 		require.NoError(t, err)
-		if err := p.AddTx(ctx, *signedTx, ""); err != nil {
-			t.Error(err)
-		}
+		err = p.AddTx(ctx, *signedTx, "")
+		require.NoError(t, err)
 	}
 
 	txs, err := p.GetPendingTxs(ctx, false, limit)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	assert.Equal(t, txsCount, len(txs))
 
@@ -462,12 +427,10 @@ func Test_GetPendingTxsZeroPassed(t *testing.T) {
 
 func Test_GetTopPendingTxByProfitabilityAndZkCounters(t *testing.T) {
 	ctx := context.Background()
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close()
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -491,10 +454,8 @@ func Test_GetTopPendingTxByProfitabilityAndZkCounters(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	const txsCount = 10
 
@@ -506,12 +467,11 @@ func Test_GetTopPendingTxByProfitabilityAndZkCounters(t *testing.T) {
 
 	// insert pending transactions
 	for i := 0; i < txsCount; i++ {
-		tx := types.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, big.NewInt(gasPrice.Int64()+int64(i)), []byte{})
+		tx := ethTypes.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, big.NewInt(gasPrice.Int64()+int64(i)), []byte{})
 		signedTx, err := auth.Signer(auth.From, tx)
 		require.NoError(t, err)
-		if err := p.AddTx(ctx, *signedTx, ""); err != nil {
-			t.Error(err)
-		}
+		err = p.AddTx(ctx, *signedTx, "")
+		require.NoError(t, err)
 	}
 
 	txs, err := p.GetTxs(ctx, pool.TxStatusPending, false, 1, 10)
@@ -523,18 +483,14 @@ func Test_GetTopPendingTxByProfitabilityAndZkCounters(t *testing.T) {
 func Test_UpdateTxsStatus(t *testing.T) {
 	ctx := context.Background()
 
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -558,10 +514,8 @@ func Test_UpdateTxsStatus(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -569,48 +523,38 @@ func Test_UpdateTxsStatus(t *testing.T) {
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
 	require.NoError(t, err)
 
-	tx1 := types.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+	tx1 := ethTypes.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 	signedTx1, err := auth.Signer(auth.From, tx1)
 	require.NoError(t, err)
-	if err := p.AddTx(ctx, *signedTx1, ""); err != nil {
-		t.Error(err)
-	}
+	err = p.AddTx(ctx, *signedTx1, "")
+	require.NoError(t, err)
 
-	tx2 := types.NewTransaction(uint64(1), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+	tx2 := ethTypes.NewTransaction(uint64(1), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 	signedTx2, err := auth.Signer(auth.From, tx2)
 	require.NoError(t, err)
-	if err := p.AddTx(ctx, *signedTx2, ""); err != nil {
-		t.Error(err)
-	}
+	err = p.AddTx(ctx, *signedTx2, "")
+	require.NoError(t, err)
 
 	err = p.UpdateTxsStatus(ctx, []string{signedTx1.Hash().String(), signedTx2.Hash().String()}, pool.TxStatusInvalid)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	var count int
 	err = poolSqlDB.QueryRow(ctx, "SELECT COUNT(*) FROM pool.transaction WHERE status = $1", pool.TxStatusInvalid).Scan(&count)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 2, count)
 }
 
 func Test_UpdateTxStatus(t *testing.T) {
 	ctx := context.Background()
 
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -634,87 +578,67 @@ func Test_UpdateTxStatus(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
 
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
 	require.NoError(t, err)
-	tx := types.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+	tx := ethTypes.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 	signedTx, err := auth.Signer(auth.From, tx)
 	require.NoError(t, err)
-	if err := p.AddTx(ctx, *signedTx, ""); err != nil {
-		t.Error(err)
-	}
+	err = p.AddTx(ctx, *signedTx, "")
+	require.NoError(t, err)
 
 	err = p.UpdateTxStatus(ctx, signedTx.Hash(), pool.TxStatusInvalid, false)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	rows, err := poolSqlDB.Query(ctx, "SELECT status FROM pool.transaction WHERE hash = $1", signedTx.Hash().Hex())
+	require.NoError(t, err)
 	defer rows.Close() // nolint:staticcheck
-	if err != nil {
-		t.Error(err)
-	}
 
 	var state string
 	rows.Next()
-	if err := rows.Scan(&state); err != nil {
-		t.Error(err)
-	}
+	err = rows.Scan(&state)
+	require.NoError(t, err)
 
 	assert.Equal(t, pool.TxStatusInvalid, pool.TxStatus(state))
 }
 
 func Test_SetAndGetGasPrice(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
-	if err != nil {
-		log.Fatal(err)
-	}
+	require.NoError(t, err)
 	eventLog := event.NewEventLog(event.Config{}, eventStorage)
 
 	p := pool.NewPool(cfg, s, nil, common.Address{}, chainID.Uint64(), eventLog)
 
 	nBig, err := rand.Int(rand.Reader, big.NewInt(0).SetUint64(math.MaxUint64))
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	expectedGasPrice := nBig.Uint64()
 
 	ctx := context.Background()
 
 	err = p.SetGasPrice(ctx, expectedGasPrice)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	gasPrice, err := p.GetGasPrice(ctx)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	assert.Equal(t, expectedGasPrice, gasPrice)
 }
 
 func TestGetPendingTxSince(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -739,10 +663,8 @@ func TestGetPendingTxSince(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	const txsCount = 10
 
@@ -758,30 +680,25 @@ func TestGetPendingTxSince(t *testing.T) {
 	timeBeforeTxs := time.Now()
 	// insert pending transactions
 	for i := 0; i < txsCount; i++ {
-		tx := types.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+		tx := ethTypes.NewTransaction(uint64(i), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 		signedTx, err := auth.Signer(auth.From, tx)
 		require.NoError(t, err)
 		txsAddedTime = append(txsAddedTime, time.Now())
-		if err := p.AddTx(ctx, *signedTx, ""); err != nil {
-			t.Error(err)
-		}
+		err = p.AddTx(ctx, *signedTx, "")
+		require.NoError(t, err)
 		txsAddedHashes = append(txsAddedHashes, signedTx.Hash())
 		time.Sleep(1 * time.Second)
 	}
 
 	txHashes, err := p.GetPendingTxHashesSince(ctx, timeBeforeTxs)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, txsCount, len(txHashes))
 	for i, txHash := range txHashes {
 		assert.Equal(t, txHash.Hex(), txsAddedHashes[i].Hex())
 	}
 
 	txHashes, err = p.GetPendingTxHashesSince(ctx, txsAddedTime[5])
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 5, len(txHashes))
 	assert.Equal(t, txHashes[0].Hex(), txsAddedHashes[5].Hex())
 	assert.Equal(t, txHashes[1].Hex(), txsAddedHashes[6].Hex())
@@ -790,40 +707,30 @@ func TestGetPendingTxSince(t *testing.T) {
 	assert.Equal(t, txHashes[4].Hex(), txsAddedHashes[9].Hex())
 
 	txHashes, err = p.GetPendingTxHashesSince(ctx, txsAddedTime[8])
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 2, len(txHashes))
 	assert.Equal(t, txHashes[0].Hex(), txsAddedHashes[8].Hex())
 	assert.Equal(t, txHashes[1].Hex(), txsAddedHashes[9].Hex())
 
 	txHashes, err = p.GetPendingTxHashesSince(ctx, txsAddedTime[9])
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(txHashes))
 	assert.Equal(t, txHashes[0].Hex(), txsAddedHashes[9].Hex())
 
 	txHashes, err = p.GetPendingTxHashesSince(ctx, txsAddedTime[9].Add(1*time.Second))
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(txHashes))
 }
 
 func Test_DeleteTransactionsByHashes(t *testing.T) {
 	ctx := context.Background()
-	initOrResetDB()
+	initOrResetDB(t)
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -848,10 +755,8 @@ func Test_DeleteTransactionsByHashes(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -859,46 +764,36 @@ func Test_DeleteTransactionsByHashes(t *testing.T) {
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
 	require.NoError(t, err)
 
-	tx1 := types.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+	tx1 := ethTypes.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 	signedTx1, err := auth.Signer(auth.From, tx1)
 	require.NoError(t, err)
-	if err := p.AddTx(ctx, *signedTx1, ""); err != nil {
-		t.Error(err)
-	}
+	err = p.AddTx(ctx, *signedTx1, "")
+	require.NoError(t, err)
 
-	tx2 := types.NewTransaction(uint64(1), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
+	tx2 := ethTypes.NewTransaction(uint64(1), common.Address{}, big.NewInt(10), gasLimit, gasPrice, []byte{})
 	signedTx2, err := auth.Signer(auth.From, tx2)
 	require.NoError(t, err)
-	if err := p.AddTx(ctx, *signedTx2, ""); err != nil {
-		t.Error(err)
-	}
+	err = p.AddTx(ctx, *signedTx2, "")
+	require.NoError(t, err)
 
 	err = p.DeleteTransactionsByHashes(ctx, []common.Hash{signedTx1.Hash(), signedTx2.Hash()})
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	var count int
 	err = poolSqlDB.QueryRow(ctx, "SELECT COUNT(*) FROM pool.transaction").Scan(&count)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	assert.Equal(t, 0, count)
 }
 
 func Test_TryAddIncompatibleTxs(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -935,13 +830,11 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 
 	type testCase struct {
 		name                 string
-		createIncompatibleTx func() types.Transaction
+		createIncompatibleTx func() ethTypes.Transaction
 		expectedError        error
 	}
 
@@ -962,8 +855,8 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 	testCases := []testCase{
 		{
 			name: "Gas price over 256 bits",
-			createIncompatibleTx: func() types.Transaction {
-				tx := types.NewTransaction(uint64(0),
+			createIncompatibleTx: func() ethTypes.Transaction {
+				tx := ethTypes.NewTransaction(uint64(0),
 					common.HexToAddress("0x1"),
 					big.NewInt(1), gasLimit, bigIntOver256Bits, nil)
 				signedTx, err := auth.Signer(auth.From, tx)
@@ -974,8 +867,8 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 		},
 		{
 			name: "Value over 256 bits",
-			createIncompatibleTx: func() types.Transaction {
-				tx := types.NewTransaction(uint64(0),
+			createIncompatibleTx: func() ethTypes.Transaction {
+				tx := ethTypes.NewTransaction(uint64(0),
 					common.HexToAddress("0x1"),
 					bigIntOver256Bits, gasLimit, gasPrice, nil)
 				signedTx, err := auth.Signer(auth.From, tx)
@@ -986,9 +879,9 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 		},
 		{
 			name: "data over 30k bytes",
-			createIncompatibleTx: func() types.Transaction {
+			createIncompatibleTx: func() ethTypes.Transaction {
 				data := [30001]byte{}
-				tx := types.NewTransaction(uint64(0),
+				tx := ethTypes.NewTransaction(uint64(0),
 					common.HexToAddress("0x1"),
 					big.NewInt(1), 141004, gasPrice, data[:])
 				signedTx, err := auth.Signer(auth.From, tx)
@@ -999,8 +892,8 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 		},
 		{
 			name: "chain id over 64 bits",
-			createIncompatibleTx: func() types.Transaction {
-				tx := types.NewTransaction(uint64(0),
+			createIncompatibleTx: func() ethTypes.Transaction {
+				tx := ethTypes.NewTransaction(uint64(0),
 					common.HexToAddress("0x1"),
 					big.NewInt(1), gasLimit, gasPrice, nil)
 				signedTx, err := authChainIdOver64Bits.Signer(authChainIdOver64Bits.From, tx)
@@ -1013,7 +906,7 @@ func Test_TryAddIncompatibleTxs(t *testing.T) {
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			incompatibleTx := testCase.createIncompatibleTx()
-			p := setupPool(t, s, st, incompatibleTx.ChainId().Uint64(), ctx, eventLog)
+			p := setupPool(t, cfg, s, st, incompatibleTx.ChainId().Uint64(), ctx, eventLog)
 			err = p.AddTx(ctx, incompatibleTx, "")
 			assert.Equal(t, testCase.expectedError, err)
 		})
@@ -1040,22 +933,19 @@ func newState(sqlDB *pgxpool.Pool, eventLog *event.EventLog) *state.State {
 	return st
 }
 
-func initOrResetDB() {
-	if err := dbutils.InitOrResetState(stateDBCfg); err != nil {
-		panic(err)
-	}
-	if err := dbutils.InitOrResetPool(poolDBCfg); err != nil {
-		panic(err)
-	}
+func initOrResetDB(t *testing.T) {
+	err := dbutils.InitOrResetState(stateDBCfg)
+	require.NoError(t, err)
+
+	err = dbutils.InitOrResetPool(poolDBCfg)
+	require.NoError(t, err)
 }
 
 func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -1080,10 +970,8 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -1092,7 +980,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.NoError(t, err)
 
 	// insert transaction
-	tx := types.NewTx(&types.LegacyTx{
+	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(0),
 		To:       &common.Address{},
 		Value:    big.NewInt(0),
@@ -1106,7 +994,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.Error(t, err)
 	assert.Equal(t, err.Error(), pool.ErrIntrinsicGas.Error())
 
-	tx = types.NewTx(&types.LegacyTx{
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(0),
 		To:       nil,
 		Value:    big.NewInt(10),
@@ -1120,7 +1008,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.Error(t, err)
 	assert.Equal(t, err.Error(), pool.ErrIntrinsicGas.Error())
 
-	tx = types.NewTx(&types.LegacyTx{
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(0),
 		To:       &common.Address{},
 		Value:    big.NewInt(10),
@@ -1133,7 +1021,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	err = p.AddTx(ctx, *signedTx, "")
 	require.NoError(t, err)
 
-	tx = types.NewTx(&types.LegacyTx{
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(1),
 		To:       &common.Address{},
 		Value:    big.NewInt(10),
@@ -1147,7 +1035,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.Error(t, err)
 	assert.Equal(t, err.Error(), pool.ErrIntrinsicGas.Error())
 
-	tx = types.NewTx(&types.LegacyTx{
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(1),
 		To:       &common.Address{},
 		Value:    big.NewInt(10),
@@ -1161,7 +1049,7 @@ func Test_AddTxWithIntrinsicGasTooLow(t *testing.T) {
 	require.Error(t, err)
 	assert.Equal(t, err.Error(), pool.ErrIntrinsicGas.Error())
 
-	tx = types.NewTx(&types.LegacyTx{
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(1),
 		To:       &common.Address{},
 		Value:    big.NewInt(10),
@@ -1241,7 +1129,7 @@ func Test_AddTx_GasPriceErr(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			initOrResetDB()
+			initOrResetDB(t)
 
 			stateSqlDB, err := db.NewSQLDB(stateDBCfg)
 			if err != nil {
@@ -1250,9 +1138,7 @@ func Test_AddTx_GasPriceErr(t *testing.T) {
 			defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 			poolSqlDB, err := db.NewSQLDB(poolDBCfg)
-			if err != nil {
-				t.Error(err)
-			}
+			require.NoError(t, err)
 			defer poolSqlDB.Close() //nolint:gosec,errcheck
 
 			st := newState(stateSqlDB, eventLog)
@@ -1280,13 +1166,11 @@ func Test_AddTx_GasPriceErr(t *testing.T) {
 			require.NoError(t, dbTx.Commit(ctx))
 
 			s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-			if err != nil {
-				t.Error(err)
-			}
+			require.NoError(t, err)
 
 			const chainID = 2576980377
-			p := setupPool(t, s, st, chainID, ctx, eventLog)
-			tx := types.NewTx(&types.LegacyTx{
+			p := setupPool(t, cfg, s, st, chainID, ctx, eventLog)
+			tx := ethTypes.NewTx(&ethTypes.LegacyTx{
 				Nonce:    tc.nonce,
 				To:       tc.to,
 				Value:    big.NewInt(0),
@@ -1314,12 +1198,10 @@ func Test_AddTx_GasPriceErr(t *testing.T) {
 }
 
 func Test_AddRevertedTx(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -1344,10 +1226,9 @@ func Test_AddRevertedTx(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
@@ -1358,7 +1239,7 @@ func Test_AddRevertedTx(t *testing.T) {
 	// insert transaction
 	revertScData, err := hex.DecodeHex(Revert.RevertBin)
 	require.NoError(t, err)
-	tx := types.NewTx(&types.LegacyTx{
+	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
 		Nonce:    uint64(0),
 		Gas:      uint64(1000000),
 		GasPrice: gasPrice,
@@ -1379,23 +1260,131 @@ func Test_AddRevertedTx(t *testing.T) {
 	}
 }
 
-func setupPool(t *testing.T, s *pgpoolstorage.PostgresPoolStorage, st *state.State, chainID uint64, ctx context.Context, eventLog *event.EventLog) *pool.Pool {
-	p := pool.NewPool(cfg, s, st, l2BridgeAddr, chainID, eventLog)
-	err := p.SetGasPrice(ctx, gasPrice.Uint64())
+func Test_BlockedAddress(t *testing.T) {
+	initOrResetDB(t)
+
+	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
+	require.NoError(t, err)
+	defer stateSqlDB.Close() //nolint:gosec,errcheck
+
+	poolSqlDB, err := db.NewSQLDB(poolDBCfg)
+	require.NoError(t, err)
+	defer poolSqlDB.Close() //nolint:gosec,errcheck
+
+	eventStorage, err := nileventstorage.NewNilEventStorage()
 	if err != nil {
-		t.Error(err)
+		log.Fatal(err)
+	}
+	eventLog := event.NewEventLog(event.Config{}, eventStorage)
+
+	st := newState(stateSqlDB, eventLog)
+
+	const chainID = 2576980377
+	auth := operations.MustGetAuth(operations.DefaultSequencerPrivateKey, chainID)
+
+	genesisBlock := state.Block{
+		BlockNumber: 0,
+		BlockHash:   state.ZeroHash,
+		ParentHash:  state.ZeroHash,
+		ReceivedAt:  time.Now(),
+	}
+
+	genesis := state.Genesis{
+		Actions: []*state.GenesisAction{
+			{
+				Address: auth.From.String(),
+				Type:    int(merkletree.LeafTypeBalance),
+				Value:   "1000000000000000000000",
+			},
+		},
+	}
+	ctx := context.Background()
+	dbTx, err := st.BeginStateTransaction(ctx)
+	require.NoError(t, err)
+
+	_, err = st.SetGenesis(ctx, genesisBlock, genesis, dbTx)
+	require.NoError(t, err)
+	require.NoError(t, dbTx.Commit(ctx))
+
+	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
+
+	require.NoError(t, err)
+
+	cfg := pool.Config{
+		FreeClaimGasLimit:                 150000,
+		MaxTxBytesSize:                    30132,
+		MaxTxDataBytesSize:                30000,
+		MinAllowedGasPriceInterval:        cfgTypes.NewDuration(5 * time.Minute),
+		PollMinAllowedGasPriceInterval:    cfgTypes.NewDuration(15 * time.Second),
+		DefaultMinGasPriceAllowed:         1000000000,
+		IntervalToRefreshBlockedAddresses: cfgTypes.NewDuration(5 * time.Second),
 	}
+	p := setupPool(t, cfg, s, st, chainID, ctx, eventLog)
+
+	gasPrice, err := p.GetGasPrice(ctx)
+	require.NoError(t, err)
+
+	// Add tx while address is not blocked
+	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
+		Nonce:    0,
+		GasPrice: big.NewInt(0).SetInt64(int64(gasPrice)),
+		Gas:      24000,
+		To:       &auth.From,
+		Value:    big.NewInt(1000),
+	})
+	signedTx, err := auth.Signer(auth.From, tx)
+	require.NoError(t, err)
+
+	err = p.AddTx(ctx, *signedTx, "")
+	require.NoError(t, err)
+
+	// block address
+	_, err = poolSqlDB.Exec(ctx, "INSERT INTO pool.blocked(addr) VALUES($1)", auth.From.String())
+	require.NoError(t, err)
+
+	// wait it to refresh
+	time.Sleep(cfg.IntervalToRefreshBlockedAddresses.Duration)
+
+	// get blocked when try to add new tx
+	tx = ethTypes.NewTx(&ethTypes.LegacyTx{
+		Nonce:    1,
+		GasPrice: big.NewInt(0).SetInt64(int64(gasPrice)),
+		Gas:      24000,
+		To:       &auth.From,
+		Value:    big.NewInt(1000),
+	})
+	signedTx, err = auth.Signer(auth.From, tx)
+	require.NoError(t, err)
+
+	err = p.AddTx(ctx, *signedTx, "")
+	require.Equal(t, pool.ErrBlockedSender, err)
+
+	// remove block
+	_, err = poolSqlDB.Exec(ctx, "DELETE FROM pool.blocked WHERE addr = $1", auth.From.String())
+	require.NoError(t, err)
+
+	// wait it to refresh
+	time.Sleep(cfg.IntervalToRefreshBlockedAddresses.Duration)
+
+	// allowed to add tx again
+	err = p.AddTx(ctx, *signedTx, "")
+	require.NoError(t, err)
+}
+
+func setupPool(t *testing.T, cfg pool.Config, s *pgpoolstorage.PostgresPoolStorage, st *state.State, chainID uint64, ctx context.Context, eventLog *event.EventLog) *pool.Pool {
+	p := pool.NewPool(cfg, s, st, l2BridgeAddr, chainID, eventLog)
+
+	err := p.SetGasPrice(ctx, gasPrice.Uint64())
+	require.NoError(t, err)
 	p.StartPollingMinSuggestedGasPrice(ctx)
 	return p
 }
 
 func Test_AvoidDuplicatedClaims(t *testing.T) {
-	initOrResetDB()
+	initOrResetDB(t)
 
 	stateSqlDB, err := db.NewSQLDB(stateDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
+	require.NoError(t, err)
 	defer stateSqlDB.Close() //nolint:gosec,errcheck
 
 	eventStorage, err := nileventstorage.NewNilEventStorage()
@@ -1412,6 +1401,7 @@ func Test_AvoidDuplicatedClaims(t *testing.T) {
 		ParentHash:  state.ZeroHash,
 		ReceivedAt:  time.Now(),
 	}
+
 	ctx := context.Background()
 	dbTx, err := st.BeginStateTransaction(ctx)
 	require.NoError(t, err)
@@ -1421,10 +1411,9 @@ func Test_AvoidDuplicatedClaims(t *testing.T) {
 	require.NoError(t, dbTx.Commit(ctx))
 
 	s, err := pgpoolstorage.NewPostgresPoolStorage(poolDBCfg)
-	if err != nil {
-		t.Error(err)
-	}
-	p := setupPool(t, s, st, chainID.Uint64(), ctx, eventLog)
+
+	require.NoError(t, err)
+	p := setupPool(t, cfg, s, st, chainID.Uint64(), ctx, eventLog)
 
 	privateKey, err := crypto.HexToECDSA(strings.TrimPrefix(senderPrivateKey, "0x"))
 	require.NoError(t, err)
diff --git a/test/config/debug.node.config.toml b/test/config/debug.node.config.toml
index 75e0991720..7fe30c4dd6 100644
--- a/test/config/debug.node.config.toml
+++ b/test/config/debug.node.config.toml
@@ -16,6 +16,7 @@ MaxConns = 10
 
 [Pool]
 FreeClaimGasLimit = 1500000
+IntervalToRefreshBlockedAddresses = "5m"
 MaxTxBytesSize=30132
 MaxTxDataBytesSize=30000
 DefaultMinGasPriceAllowed = 1000000000
diff --git a/test/config/test.node.config.toml b/test/config/test.node.config.toml
index 4b880611ae..0fbb079c3a 100644
--- a/test/config/test.node.config.toml
+++ b/test/config/test.node.config.toml
@@ -16,6 +16,7 @@ MaxConns = 200
 
 [Pool]
 FreeClaimGasLimit = 1500000
+IntervalToRefreshBlockedAddresses = "5m"
 MaxTxBytesSize=30132
 MaxTxDataBytesSize=30000
 DefaultMinGasPriceAllowed = 1000000000