diff --git a/agglayer/types.go b/agglayer/types.go
index 9a56d878..09697d3d 100644
--- a/agglayer/types.go
+++ b/agglayer/types.go
@@ -563,6 +563,15 @@ func (c *ImportedBridgeExit) Hash() common.Hash {
 	)
 }
 
+type GenericPPError struct {
+	Key   string
+	Value string
+}
+
+func (p *GenericPPError) String() string {
+	return fmt.Sprintf("Generic error: %s: %s", p.Key, p.Value)
+}
+
 // CertificateHeader is the structure returned by the interop_getCertificateHeader RPC call
 type CertificateHeader struct {
 	NetworkID        uint32            `json:"network_id"`
@@ -654,7 +663,12 @@ func (c *CertificateHeader) UnmarshalJSON(data []byte) error {
 
 				ppError = p
 			default:
-				return fmt.Errorf("invalid error type: %s", key)
+				valueStr, err := json.Marshal(value)
+				if err != nil {
+					ppError = &GenericPPError{Key: key, Value: "error marshalling value"}
+				} else {
+					ppError = &GenericPPError{Key: key, Value: string(valueStr)}
+				}
 			}
 		}
 
diff --git a/agglayer/types_test.go b/agglayer/types_test.go
index f2133923..ecef4bca 100644
--- a/agglayer/types_test.go
+++ b/agglayer/types_test.go
@@ -15,6 +15,11 @@ const (
 	expectedSignedCertificateyMetadataJSON     = `{"network_id":1,"height":1,"prev_local_exit_root":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"new_local_exit_root":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bridge_exits":[{"leaf_type":"Transfer","token_info":null,"dest_network":0,"dest_address":"0x0000000000000000000000000000000000000000","amount":"1","metadata":[1,2,3]}],"imported_bridge_exits":[{"bridge_exit":{"leaf_type":"Transfer","token_info":null,"dest_network":0,"dest_address":"0x0000000000000000000000000000000000000000","amount":"1","metadata":[]},"claim_data":null,"global_index":{"mainnet_flag":false,"rollup_index":1,"leaf_index":1}}],"metadata":"0x0000000000000000000000000000000000000000000000000000000000000000","signature":{"r":"0x0000000000000000000000000000000000000000000000000000000000000000","s":"0x0000000000000000000000000000000000000000000000000000000000000000","odd_y_parity":false}}`
 )
 
+func TestMGenericPPError(t *testing.T) {
+	err := GenericPPError{"test", "value"}
+	require.Equal(t, "Generic error: test: value", err.String())
+}
+
 func TestMarshalJSON(t *testing.T) {
 	cert := SignedCertificate{
 		Certificate: &Certificate{
@@ -251,3 +256,14 @@ func TestGlobalIndex_UnmarshalFromMap(t *testing.T) {
 		})
 	}
 }
+
+func TestUnmarshalCertificateHeaderUnknownError(t *testing.T) {
+	str := "{\"network_id\":14,\"height\":0,\"epoch_number\":null,\"certificate_index\":null,\"certificate_id\":\"0x3af88c9ca106822bd141fdc680dcb888f4e9d4997fad1645ba3d5d747059eb32\",\"new_local_exit_root\":\"0x625e889ced3c31277c6653229096374d396a2fd3564a8894aaad2ff935d2fc8c\",\"metadata\":\"0x0000000000000000000000000000000000000000000000000000000000002f3d\",\"status\":{\"InError\":{\"error\":{\"ProofVerificationFailed\":{\"Plonk\":\"the verifying key does not match the inner plonk bn254 proof's committed verifying key\"}}}}}"
+	data := []byte(str)
+	var result *CertificateHeader
+	err := json.Unmarshal(data, &result)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	ppError := result.Error.String()
+	require.Equal(t, `Generic error: ProofVerificationFailed: {"Plonk":"the verifying key does not match the inner plonk bn254 proof's committed verifying key"}`, ppError)
+}
diff --git a/aggsender/aggsender.go b/aggsender/aggsender.go
index 39cd6867..eea9f125 100644
--- a/aggsender/aggsender.go
+++ b/aggsender/aggsender.go
@@ -93,9 +93,9 @@ func (a *AggSender) checkInitialStatus(ctx context.Context) {
 
 	for {
 		if err := a.checkLastCertificateFromAgglayer(ctx); err != nil {
-			log.Errorf("error checking initial status: %w, retrying in %s", err, a.cfg.DelayBeetweenRetries.String())
+			a.log.Errorf("error checking initial status: %w, retrying in %s", err, a.cfg.DelayBeetweenRetries.String())
 		} else {
-			log.Info("Initial status checked successfully")
+			a.log.Info("Initial status checked successfully")
 			return
 		}
 		select {
@@ -116,7 +116,7 @@ func (a *AggSender) sendCertificates(ctx context.Context) {
 			thereArePendingCerts := a.checkPendingCertificatesStatus(ctx)
 			if !thereArePendingCerts {
 				if _, err := a.sendCertificate(ctx); err != nil {
-					log.Error(err)
+					a.log.Error(err)
 				}
 			} else {
 				log.Infof("Skipping epoch %s because there are pending certificates",
@@ -202,7 +202,6 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif
 
 	a.saveCertificateToFile(signedCertificate)
 	a.log.Infof("certificate ready to be send to AggLayer: %s", signedCertificate.String())
-
 	certificateHash, err := a.aggLayerClient.SendCertificate(signedCertificate)
 	if err != nil {
 		return nil, fmt.Errorf("error sending certificate: %w", err)
@@ -584,7 +583,7 @@ func (a *AggSender) updateCertificateStatus(ctx context.Context,
 		localCert.String())
 
 	// That is a strange situation
-	if agglayerCert.Status.IsOpen() == localCert.Status.IsClosed() {
+	if agglayerCert.Status.IsOpen() && localCert.Status.IsClosed() {
 		a.log.Warnf("certificate %s is reopen! from [%s] to [%s]",
 			localCert.ID(), localCert.Status, agglayerCert.Status)
 	}
@@ -638,6 +637,11 @@ func (a *AggSender) checkLastCertificateFromAgglayer(ctx context.Context) error
 		}
 		return nil
 	}
+	// CASE 2.1: certificate in storage but not in agglayer
+	// this is a non-sense, so thrown an error
+	if localLastCert != nil && aggLayerLastCert == nil {
+		return fmt.Errorf("recovery: certificate in storage but not in agglayer. Inconsistency")
+	}
 	// CASE 3: aggsender stopped between sending to agglayer and storing on DB
 	if aggLayerLastCert.Height == localLastCert.Height+1 {
 		a.log.Infof("recovery: AggLayer have next cert (height:%d), so is a recovery case: storing cert: %s",
@@ -673,7 +677,7 @@ func (a *AggSender) checkLastCertificateFromAgglayer(ctx context.Context) error
 func (a *AggSender) updateLocalStorageWithAggLayerCert(ctx context.Context,
 	aggLayerCert *agglayer.CertificateHeader) (*types.CertificateInfo, error) {
 	certInfo := NewCertificateInfoFromAgglayerCertHeader(aggLayerCert)
-	log.Infof("setting initial certificate from AggLayer: %s", certInfo.String())
+	a.log.Infof("setting initial certificate from AggLayer: %s", certInfo.String())
 	return certInfo, a.storage.SaveLastSentCertificate(ctx, *certInfo)
 }
 
diff --git a/aggsender/aggsender_test.go b/aggsender/aggsender_test.go
index 6d84c683..9185050f 100644
--- a/aggsender/aggsender_test.go
+++ b/aggsender/aggsender_test.go
@@ -1717,6 +1717,19 @@ func TestCheckLastCertificateFromAgglayer_Case2NoCertLocalCertRemoteErrorStorage
 	require.Error(t, err)
 }
 
+// CASE 2.1: certificate in storage but not in agglayer
+// sub case of previous one that fails to update local storage
+func TestCheckLastCertificateFromAgglayer_Case2_1NoCertRemoteButCertLocal(t *testing.T) {
+	testData := newAggsenderTestData(t, testDataFlagMockStorage)
+	testData.l2syncerMock.EXPECT().OriginNetwork().Return(networkIDTest).Once()
+	testData.agglayerClientMock.EXPECT().GetLatestKnownCertificateHeader(networkIDTest).
+		Return(nil, nil).Once()
+	testData.storageMock.EXPECT().GetLastSentCertificate().Return(&testData.testCerts[0], nil)
+	err := testData.sut.checkLastCertificateFromAgglayer(testData.ctx)
+
+	require.Error(t, err)
+}
+
 // CASE 3: AggSender and AggLayer not same certificateID. AggLayer has a new certificate
 func TestCheckLastCertificateFromAgglayer_Case3Mismatch(t *testing.T) {
 	testData := newAggsenderTestData(t, testDataFlagMockStorage)
diff --git a/aggsender/block_notifier_polling.go b/aggsender/block_notifier_polling.go
index 17dafefa..dbae1a38 100644
--- a/aggsender/block_notifier_polling.go
+++ b/aggsender/block_notifier_polling.go
@@ -158,7 +158,7 @@ func (b *BlockNotifierPolling) step(ctx context.Context,
 	newState := previousState.incommingNewBlock(currentBlock.Number.Uint64())
 	b.logger.Debugf("New block seen [finality:%s]: %d. blockRate:%s",
 		b.config.BlockFinalityType, currentBlock.Number.Uint64(), newState.previousBlockTime)
-
+	eventToEmit.BlockRate = *newState.previousBlockTime
 	return b.nextBlockRequestDelay(newState, nil), newState, eventToEmit
 }
 
diff --git a/aggsender/epoch_notifier_per_block.go b/aggsender/epoch_notifier_per_block.go
index 3b560731..80494cc0 100644
--- a/aggsender/epoch_notifier_per_block.go
+++ b/aggsender/epoch_notifier_per_block.go
@@ -31,6 +31,14 @@ type ConfigEpochNotifierPerBlock struct {
 	EpochNotificationPercentage uint
 }
 
+func (c *ConfigEpochNotifierPerBlock) String() string {
+	if c == nil {
+		return "nil"
+	}
+	return fmt.Sprintf("{startEpochBlock=%d, sizeEpoch=%d, threshold=%d%%}",
+		c.StartingEpochBlock, c.NumBlockPerEpoch, c.EpochNotificationPercentage)
+}
+
 func NewConfigEpochNotifierPerBlock(aggLayer agglayer.AggLayerClientGetEpochConfiguration,
 	epochNotificationPercentage uint) (*ConfigEpochNotifierPerBlock, error) {
 	if aggLayer == nil {
@@ -89,9 +97,7 @@ func NewEpochNotifierPerBlock(blockNotifier types.BlockNotifier,
 }
 
 func (e *EpochNotifierPerBlock) String() string {
-	return fmt.Sprintf("EpochNotifierPerBlock: startingEpochBlock=%d, numBlockPerEpoch=%d,"+
-		" EpochNotificationPercentage=%d",
-		e.Config.StartingEpochBlock, e.Config.NumBlockPerEpoch, e.Config.EpochNotificationPercentage)
+	return fmt.Sprintf("EpochNotifierPerBlock: config: %s", e.Config.String())
 }
 
 // StartAsync starts the notifier in a goroutine
@@ -147,6 +153,14 @@ func (e *EpochNotifierPerBlock) step(status internalStatus,
 	status.lastBlockSeen = currentBlock
 
 	needNotify, closingEpoch := e.isNotificationRequired(currentBlock, status.waitingForEpoch)
+	percentEpoch := e.percentEpoch(currentBlock)
+	logFunc := e.logger.Debugf
+	if needNotify {
+		logFunc = e.logger.Infof
+	}
+	logFunc("New block seen [finality:%s]: %d. blockRate:%s Epoch:%d Percent:%f%% notify:%v config:%s",
+		newBlock.BlockFinalityType, newBlock.BlockNumber, newBlock.BlockRate, closingEpoch,
+		percentEpoch*maxPercent, needNotify, e.Config.String())
 	if needNotify {
 		// Notify the epoch has started
 		info := e.infoEpoch(currentBlock, closingEpoch)
@@ -179,7 +193,6 @@ func (e *EpochNotifierPerBlock) isNotificationRequired(currentBlock, lastEpochNo
 		thresholdPercent = maxTresholdPercent
 	}
 	if percentEpoch < thresholdPercent {
-		e.logger.Debugf("Block %d is at %f%% of the epoch no notify", currentBlock, percentEpoch*maxPercent)
 		return false, e.epochNumber(currentBlock)
 	}
 	nextEpoch := e.epochNumber(currentBlock) + 1
diff --git a/aggsender/epoch_notifier_per_block_test.go b/aggsender/epoch_notifier_per_block_test.go
index 203116d0..ac35350e 100644
--- a/aggsender/epoch_notifier_per_block_test.go
+++ b/aggsender/epoch_notifier_per_block_test.go
@@ -14,6 +14,17 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestConfigEpochNotifierPerBlockString(t *testing.T) {
+	cfg := ConfigEpochNotifierPerBlock{
+		StartingEpochBlock:          123,
+		NumBlockPerEpoch:            456,
+		EpochNotificationPercentage: 789,
+	}
+	require.Equal(t, "{startEpochBlock=123, sizeEpoch=456, threshold=789%}", cfg.String())
+	var cfg2 *ConfigEpochNotifierPerBlock
+	require.Equal(t, "nil", cfg2.String())
+}
+
 func TestStartingBlockEpoch(t *testing.T) {
 	testData := newNotifierPerBlockTestData(t, &ConfigEpochNotifierPerBlock{
 		StartingEpochBlock:          9,
diff --git a/aggsender/types/block_notifier.go b/aggsender/types/block_notifier.go
index 475abc1b..5dde2702 100644
--- a/aggsender/types/block_notifier.go
+++ b/aggsender/types/block_notifier.go
@@ -1,10 +1,15 @@
 package types
 
-import "github.com/0xPolygon/cdk/etherman"
+import (
+	"time"
+
+	"github.com/0xPolygon/cdk/etherman"
+)
 
 type EventNewBlock struct {
 	BlockNumber       uint64
 	BlockFinalityType etherman.BlockNumberFinality
+	BlockRate         time.Duration
 }
 
 // BlockNotifier is the interface that wraps the basic methods to notify a new block.
diff --git a/sync/evmdownloader.go b/sync/evmdownloader.go
index 74b8ec7c..2c32b7ea 100644
--- a/sync/evmdownloader.go
+++ b/sync/evmdownloader.go
@@ -3,6 +3,7 @@ package sync
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"time"
 
@@ -229,6 +230,11 @@ func (d *EVMDownloaderImplementation) GetEventsByBlockRange(ctx context.Context,
 	}
 }
 
+func filterQueryToString(query ethereum.FilterQuery) string {
+	return fmt.Sprintf("FromBlock: %s, ToBlock: %s, Addresses: %s, Topics: %s",
+		query.FromBlock.String(), query.ToBlock.String(), query.Addresses, query.Topics)
+}
+
 func (d *EVMDownloaderImplementation) GetLogs(ctx context.Context, fromBlock, toBlock uint64) []types.Log {
 	query := ethereum.FilterQuery{
 		FromBlock: new(big.Int).SetUint64(fromBlock),
@@ -249,7 +255,10 @@ func (d *EVMDownloaderImplementation) GetLogs(ctx context.Context, fromBlock, to
 			}
 
 			attempts++
-			d.log.Error("error calling FilterLogs to eth client: ", err)
+			d.log.Errorf("error calling FilterLogs to eth client: filter: %s err:%w ",
+				filterQueryToString(query),
+				err,
+			)
 			d.rh.Handle("getLogs", attempts)
 			continue
 		}
diff --git a/sync/evmdownloader_test.go b/sync/evmdownloader_test.go
index 04c92e72..f654db05 100644
--- a/sync/evmdownloader_test.go
+++ b/sync/evmdownloader_test.go
@@ -381,6 +381,44 @@ func TestGetBlockHeader(t *testing.T) {
 	assert.False(t, isCanceled)
 }
 
+func TestFilterQueryToString(t *testing.T) {
+	addr1 := common.HexToAddress("0xf000")
+	addr2 := common.HexToAddress("0xabcd")
+	query := ethereum.FilterQuery{
+		FromBlock: new(big.Int).SetUint64(1000),
+		Addresses: []common.Address{addr1, addr2},
+		ToBlock:   new(big.Int).SetUint64(1100),
+	}
+
+	assert.Equal(t, "FromBlock: 1000, ToBlock: 1100, Addresses: [0x000000000000000000000000000000000000f000 0x000000000000000000000000000000000000ABcD], Topics: []", filterQueryToString(query))
+
+	query = ethereum.FilterQuery{
+		FromBlock: new(big.Int).SetUint64(1000),
+		Addresses: []common.Address{addr1, addr2},
+		ToBlock:   new(big.Int).SetUint64(1100),
+		Topics:    [][]common.Hash{{common.HexToHash("0x1234"), common.HexToHash("0x5678")}},
+	}
+	assert.Equal(t, "FromBlock: 1000, ToBlock: 1100, Addresses: [0x000000000000000000000000000000000000f000 0x000000000000000000000000000000000000ABcD], Topics: [[0x0000000000000000000000000000000000000000000000000000000000001234 0x0000000000000000000000000000000000000000000000000000000000005678]]", filterQueryToString(query))
+}
+
+func TestGetLogs(t *testing.T) {
+	mockEthClient := NewL2Mock(t)
+	sut := EVMDownloaderImplementation{
+		ethClient:        mockEthClient,
+		adressessToQuery: []common.Address{contractAddr},
+		log:              log.WithFields("test", "EVMDownloaderImplementation"),
+		rh: &RetryHandler{
+			RetryAfterErrorPeriod:      time.Millisecond,
+			MaxRetryAttemptsAfterError: 5,
+		},
+	}
+	ctx := context.TODO()
+	mockEthClient.EXPECT().FilterLogs(ctx, mock.Anything).Return(nil, errors.New("foo")).Once()
+	mockEthClient.EXPECT().FilterLogs(ctx, mock.Anything).Return(nil, nil).Once()
+	logs := sut.GetLogs(ctx, 0, 1)
+	require.Equal(t, []types.Log{}, logs)
+}
+
 func buildAppender() LogAppenderMap {
 	appender := make(LogAppenderMap)
 	appender[eventSignature] = func(b *EVMBlock, l types.Log) error {
diff --git a/sync/mock_downloader_test.go b/sync/mock_downloader_test.go
index f28045b5..45a53b84 100644
--- a/sync/mock_downloader_test.go
+++ b/sync/mock_downloader_test.go
@@ -1,4 +1,4 @@
-// Code generated by mockery v2.45.0. DO NOT EDIT.
+// Code generated by mockery. DO NOT EDIT.
 
 package sync
 
@@ -14,11 +14,49 @@ type EVMDownloaderMock struct {
 	mock.Mock
 }
 
+type EVMDownloaderMock_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *EVMDownloaderMock) EXPECT() *EVMDownloaderMock_Expecter {
+	return &EVMDownloaderMock_Expecter{mock: &_m.Mock}
+}
+
 // Download provides a mock function with given fields: ctx, fromBlock, downloadedCh
 func (_m *EVMDownloaderMock) Download(ctx context.Context, fromBlock uint64, downloadedCh chan EVMBlock) {
 	_m.Called(ctx, fromBlock, downloadedCh)
 }
 
+// EVMDownloaderMock_Download_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Download'
+type EVMDownloaderMock_Download_Call struct {
+	*mock.Call
+}
+
+// Download is a helper method to define mock.On call
+//   - ctx context.Context
+//   - fromBlock uint64
+//   - downloadedCh chan EVMBlock
+func (_e *EVMDownloaderMock_Expecter) Download(ctx interface{}, fromBlock interface{}, downloadedCh interface{}) *EVMDownloaderMock_Download_Call {
+	return &EVMDownloaderMock_Download_Call{Call: _e.mock.On("Download", ctx, fromBlock, downloadedCh)}
+}
+
+func (_c *EVMDownloaderMock_Download_Call) Run(run func(ctx context.Context, fromBlock uint64, downloadedCh chan EVMBlock)) *EVMDownloaderMock_Download_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(chan EVMBlock))
+	})
+	return _c
+}
+
+func (_c *EVMDownloaderMock_Download_Call) Return() *EVMDownloaderMock_Download_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *EVMDownloaderMock_Download_Call) RunAndReturn(run func(context.Context, uint64, chan EVMBlock)) *EVMDownloaderMock_Download_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetBlockHeader provides a mock function with given fields: ctx, blockNum
 func (_m *EVMDownloaderMock) GetBlockHeader(ctx context.Context, blockNum uint64) (EVMBlockHeader, bool) {
 	ret := _m.Called(ctx, blockNum)
@@ -47,6 +85,35 @@ func (_m *EVMDownloaderMock) GetBlockHeader(ctx context.Context, blockNum uint64
 	return r0, r1
 }
 
+// EVMDownloaderMock_GetBlockHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlockHeader'
+type EVMDownloaderMock_GetBlockHeader_Call struct {
+	*mock.Call
+}
+
+// GetBlockHeader is a helper method to define mock.On call
+//   - ctx context.Context
+//   - blockNum uint64
+func (_e *EVMDownloaderMock_Expecter) GetBlockHeader(ctx interface{}, blockNum interface{}) *EVMDownloaderMock_GetBlockHeader_Call {
+	return &EVMDownloaderMock_GetBlockHeader_Call{Call: _e.mock.On("GetBlockHeader", ctx, blockNum)}
+}
+
+func (_c *EVMDownloaderMock_GetBlockHeader_Call) Run(run func(ctx context.Context, blockNum uint64)) *EVMDownloaderMock_GetBlockHeader_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64))
+	})
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetBlockHeader_Call) Return(_a0 EVMBlockHeader, _a1 bool) *EVMDownloaderMock_GetBlockHeader_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetBlockHeader_Call) RunAndReturn(run func(context.Context, uint64) (EVMBlockHeader, bool)) *EVMDownloaderMock_GetBlockHeader_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetEventsByBlockRange provides a mock function with given fields: ctx, fromBlock, toBlock
 func (_m *EVMDownloaderMock) GetEventsByBlockRange(ctx context.Context, fromBlock uint64, toBlock uint64) []EVMBlock {
 	ret := _m.Called(ctx, fromBlock, toBlock)
@@ -67,6 +134,36 @@ func (_m *EVMDownloaderMock) GetEventsByBlockRange(ctx context.Context, fromBloc
 	return r0
 }
 
+// EVMDownloaderMock_GetEventsByBlockRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEventsByBlockRange'
+type EVMDownloaderMock_GetEventsByBlockRange_Call struct {
+	*mock.Call
+}
+
+// GetEventsByBlockRange is a helper method to define mock.On call
+//   - ctx context.Context
+//   - fromBlock uint64
+//   - toBlock uint64
+func (_e *EVMDownloaderMock_Expecter) GetEventsByBlockRange(ctx interface{}, fromBlock interface{}, toBlock interface{}) *EVMDownloaderMock_GetEventsByBlockRange_Call {
+	return &EVMDownloaderMock_GetEventsByBlockRange_Call{Call: _e.mock.On("GetEventsByBlockRange", ctx, fromBlock, toBlock)}
+}
+
+func (_c *EVMDownloaderMock_GetEventsByBlockRange_Call) Run(run func(ctx context.Context, fromBlock uint64, toBlock uint64)) *EVMDownloaderMock_GetEventsByBlockRange_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64))
+	})
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetEventsByBlockRange_Call) Return(_a0 []EVMBlock) *EVMDownloaderMock_GetEventsByBlockRange_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetEventsByBlockRange_Call) RunAndReturn(run func(context.Context, uint64, uint64) []EVMBlock) *EVMDownloaderMock_GetEventsByBlockRange_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // GetLogs provides a mock function with given fields: ctx, fromBlock, toBlock
 func (_m *EVMDownloaderMock) GetLogs(ctx context.Context, fromBlock uint64, toBlock uint64) []types.Log {
 	ret := _m.Called(ctx, fromBlock, toBlock)
@@ -87,6 +184,36 @@ func (_m *EVMDownloaderMock) GetLogs(ctx context.Context, fromBlock uint64, toBl
 	return r0
 }
 
+// EVMDownloaderMock_GetLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogs'
+type EVMDownloaderMock_GetLogs_Call struct {
+	*mock.Call
+}
+
+// GetLogs is a helper method to define mock.On call
+//   - ctx context.Context
+//   - fromBlock uint64
+//   - toBlock uint64
+func (_e *EVMDownloaderMock_Expecter) GetLogs(ctx interface{}, fromBlock interface{}, toBlock interface{}) *EVMDownloaderMock_GetLogs_Call {
+	return &EVMDownloaderMock_GetLogs_Call{Call: _e.mock.On("GetLogs", ctx, fromBlock, toBlock)}
+}
+
+func (_c *EVMDownloaderMock_GetLogs_Call) Run(run func(ctx context.Context, fromBlock uint64, toBlock uint64)) *EVMDownloaderMock_GetLogs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64), args[2].(uint64))
+	})
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetLogs_Call) Return(_a0 []types.Log) *EVMDownloaderMock_GetLogs_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *EVMDownloaderMock_GetLogs_Call) RunAndReturn(run func(context.Context, uint64, uint64) []types.Log) *EVMDownloaderMock_GetLogs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // WaitForNewBlocks provides a mock function with given fields: ctx, lastBlockSeen
 func (_m *EVMDownloaderMock) WaitForNewBlocks(ctx context.Context, lastBlockSeen uint64) uint64 {
 	ret := _m.Called(ctx, lastBlockSeen)
@@ -105,6 +232,35 @@ func (_m *EVMDownloaderMock) WaitForNewBlocks(ctx context.Context, lastBlockSeen
 	return r0
 }
 
+// EVMDownloaderMock_WaitForNewBlocks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitForNewBlocks'
+type EVMDownloaderMock_WaitForNewBlocks_Call struct {
+	*mock.Call
+}
+
+// WaitForNewBlocks is a helper method to define mock.On call
+//   - ctx context.Context
+//   - lastBlockSeen uint64
+func (_e *EVMDownloaderMock_Expecter) WaitForNewBlocks(ctx interface{}, lastBlockSeen interface{}) *EVMDownloaderMock_WaitForNewBlocks_Call {
+	return &EVMDownloaderMock_WaitForNewBlocks_Call{Call: _e.mock.On("WaitForNewBlocks", ctx, lastBlockSeen)}
+}
+
+func (_c *EVMDownloaderMock_WaitForNewBlocks_Call) Run(run func(ctx context.Context, lastBlockSeen uint64)) *EVMDownloaderMock_WaitForNewBlocks_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64))
+	})
+	return _c
+}
+
+func (_c *EVMDownloaderMock_WaitForNewBlocks_Call) Return(newLastBlock uint64) *EVMDownloaderMock_WaitForNewBlocks_Call {
+	_c.Call.Return(newLastBlock)
+	return _c
+}
+
+func (_c *EVMDownloaderMock_WaitForNewBlocks_Call) RunAndReturn(run func(context.Context, uint64) uint64) *EVMDownloaderMock_WaitForNewBlocks_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewEVMDownloaderMock creates a new instance of EVMDownloaderMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewEVMDownloaderMock(t interface {
diff --git a/sync/mock_l2_test.go b/sync/mock_l2_test.go
index 7a4bae36..955af0db 100644
--- a/sync/mock_l2_test.go
+++ b/sync/mock_l2_test.go
@@ -1,4 +1,4 @@
-// Code generated by mockery v2.39.0. DO NOT EDIT.
+// Code generated by mockery. DO NOT EDIT.
 
 package sync
 
@@ -20,6 +20,14 @@ type L2Mock struct {
 	mock.Mock
 }
 
+type L2Mock_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *L2Mock) EXPECT() *L2Mock_Expecter {
+	return &L2Mock_Expecter{mock: &_m.Mock}
+}
+
 // BlockByHash provides a mock function with given fields: ctx, hash
 func (_m *L2Mock) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
 	ret := _m.Called(ctx, hash)
@@ -50,6 +58,35 @@ func (_m *L2Mock) BlockByHash(ctx context.Context, hash common.Hash) (*types.Blo
 	return r0, r1
 }
 
+// L2Mock_BlockByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByHash'
+type L2Mock_BlockByHash_Call struct {
+	*mock.Call
+}
+
+// BlockByHash is a helper method to define mock.On call
+//   - ctx context.Context
+//   - hash common.Hash
+func (_e *L2Mock_Expecter) BlockByHash(ctx interface{}, hash interface{}) *L2Mock_BlockByHash_Call {
+	return &L2Mock_BlockByHash_Call{Call: _e.mock.On("BlockByHash", ctx, hash)}
+}
+
+func (_c *L2Mock_BlockByHash_Call) Run(run func(ctx context.Context, hash common.Hash)) *L2Mock_BlockByHash_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Hash))
+	})
+	return _c
+}
+
+func (_c *L2Mock_BlockByHash_Call) Return(_a0 *types.Block, _a1 error) *L2Mock_BlockByHash_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_BlockByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Block, error)) *L2Mock_BlockByHash_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // BlockByNumber provides a mock function with given fields: ctx, number
 func (_m *L2Mock) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
 	ret := _m.Called(ctx, number)
@@ -80,6 +117,35 @@ func (_m *L2Mock) BlockByNumber(ctx context.Context, number *big.Int) (*types.Bl
 	return r0, r1
 }
 
+// L2Mock_BlockByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockByNumber'
+type L2Mock_BlockByNumber_Call struct {
+	*mock.Call
+}
+
+// BlockByNumber is a helper method to define mock.On call
+//   - ctx context.Context
+//   - number *big.Int
+func (_e *L2Mock_Expecter) BlockByNumber(ctx interface{}, number interface{}) *L2Mock_BlockByNumber_Call {
+	return &L2Mock_BlockByNumber_Call{Call: _e.mock.On("BlockByNumber", ctx, number)}
+}
+
+func (_c *L2Mock_BlockByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *L2Mock_BlockByNumber_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*big.Int))
+	})
+	return _c
+}
+
+func (_c *L2Mock_BlockByNumber_Call) Return(_a0 *types.Block, _a1 error) *L2Mock_BlockByNumber_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_BlockByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Block, error)) *L2Mock_BlockByNumber_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // BlockNumber provides a mock function with given fields: ctx
 func (_m *L2Mock) BlockNumber(ctx context.Context) (uint64, error) {
 	ret := _m.Called(ctx)
@@ -108,6 +174,34 @@ func (_m *L2Mock) BlockNumber(ctx context.Context) (uint64, error) {
 	return r0, r1
 }
 
+// L2Mock_BlockNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockNumber'
+type L2Mock_BlockNumber_Call struct {
+	*mock.Call
+}
+
+// BlockNumber is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *L2Mock_Expecter) BlockNumber(ctx interface{}) *L2Mock_BlockNumber_Call {
+	return &L2Mock_BlockNumber_Call{Call: _e.mock.On("BlockNumber", ctx)}
+}
+
+func (_c *L2Mock_BlockNumber_Call) Run(run func(ctx context.Context)) *L2Mock_BlockNumber_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *L2Mock_BlockNumber_Call) Return(_a0 uint64, _a1 error) *L2Mock_BlockNumber_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_BlockNumber_Call) RunAndReturn(run func(context.Context) (uint64, error)) *L2Mock_BlockNumber_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // CallContract provides a mock function with given fields: ctx, call, blockNumber
 func (_m *L2Mock) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
 	ret := _m.Called(ctx, call, blockNumber)
@@ -138,6 +232,36 @@ func (_m *L2Mock) CallContract(ctx context.Context, call ethereum.CallMsg, block
 	return r0, r1
 }
 
+// L2Mock_CallContract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CallContract'
+type L2Mock_CallContract_Call struct {
+	*mock.Call
+}
+
+// CallContract is a helper method to define mock.On call
+//   - ctx context.Context
+//   - call ethereum.CallMsg
+//   - blockNumber *big.Int
+func (_e *L2Mock_Expecter) CallContract(ctx interface{}, call interface{}, blockNumber interface{}) *L2Mock_CallContract_Call {
+	return &L2Mock_CallContract_Call{Call: _e.mock.On("CallContract", ctx, call, blockNumber)}
+}
+
+func (_c *L2Mock_CallContract_Call) Run(run func(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int)) *L2Mock_CallContract_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(ethereum.CallMsg), args[2].(*big.Int))
+	})
+	return _c
+}
+
+func (_c *L2Mock_CallContract_Call) Return(_a0 []byte, _a1 error) *L2Mock_CallContract_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_CallContract_Call) RunAndReturn(run func(context.Context, ethereum.CallMsg, *big.Int) ([]byte, error)) *L2Mock_CallContract_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // CodeAt provides a mock function with given fields: ctx, contract, blockNumber
 func (_m *L2Mock) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
 	ret := _m.Called(ctx, contract, blockNumber)
@@ -168,6 +292,36 @@ func (_m *L2Mock) CodeAt(ctx context.Context, contract common.Address, blockNumb
 	return r0, r1
 }
 
+// L2Mock_CodeAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CodeAt'
+type L2Mock_CodeAt_Call struct {
+	*mock.Call
+}
+
+// CodeAt is a helper method to define mock.On call
+//   - ctx context.Context
+//   - contract common.Address
+//   - blockNumber *big.Int
+func (_e *L2Mock_Expecter) CodeAt(ctx interface{}, contract interface{}, blockNumber interface{}) *L2Mock_CodeAt_Call {
+	return &L2Mock_CodeAt_Call{Call: _e.mock.On("CodeAt", ctx, contract, blockNumber)}
+}
+
+func (_c *L2Mock_CodeAt_Call) Run(run func(ctx context.Context, contract common.Address, blockNumber *big.Int)) *L2Mock_CodeAt_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Address), args[2].(*big.Int))
+	})
+	return _c
+}
+
+func (_c *L2Mock_CodeAt_Call) Return(_a0 []byte, _a1 error) *L2Mock_CodeAt_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_CodeAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]byte, error)) *L2Mock_CodeAt_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // EstimateGas provides a mock function with given fields: ctx, call
 func (_m *L2Mock) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
 	ret := _m.Called(ctx, call)
@@ -196,6 +350,35 @@ func (_m *L2Mock) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint6
 	return r0, r1
 }
 
+// L2Mock_EstimateGas_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateGas'
+type L2Mock_EstimateGas_Call struct {
+	*mock.Call
+}
+
+// EstimateGas is a helper method to define mock.On call
+//   - ctx context.Context
+//   - call ethereum.CallMsg
+func (_e *L2Mock_Expecter) EstimateGas(ctx interface{}, call interface{}) *L2Mock_EstimateGas_Call {
+	return &L2Mock_EstimateGas_Call{Call: _e.mock.On("EstimateGas", ctx, call)}
+}
+
+func (_c *L2Mock_EstimateGas_Call) Run(run func(ctx context.Context, call ethereum.CallMsg)) *L2Mock_EstimateGas_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(ethereum.CallMsg))
+	})
+	return _c
+}
+
+func (_c *L2Mock_EstimateGas_Call) Return(_a0 uint64, _a1 error) *L2Mock_EstimateGas_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_EstimateGas_Call) RunAndReturn(run func(context.Context, ethereum.CallMsg) (uint64, error)) *L2Mock_EstimateGas_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // FilterLogs provides a mock function with given fields: ctx, q
 func (_m *L2Mock) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
 	ret := _m.Called(ctx, q)
@@ -226,6 +409,35 @@ func (_m *L2Mock) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]typ
 	return r0, r1
 }
 
+// L2Mock_FilterLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterLogs'
+type L2Mock_FilterLogs_Call struct {
+	*mock.Call
+}
+
+// FilterLogs is a helper method to define mock.On call
+//   - ctx context.Context
+//   - q ethereum.FilterQuery
+func (_e *L2Mock_Expecter) FilterLogs(ctx interface{}, q interface{}) *L2Mock_FilterLogs_Call {
+	return &L2Mock_FilterLogs_Call{Call: _e.mock.On("FilterLogs", ctx, q)}
+}
+
+func (_c *L2Mock_FilterLogs_Call) Run(run func(ctx context.Context, q ethereum.FilterQuery)) *L2Mock_FilterLogs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(ethereum.FilterQuery))
+	})
+	return _c
+}
+
+func (_c *L2Mock_FilterLogs_Call) Return(_a0 []types.Log, _a1 error) *L2Mock_FilterLogs_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_FilterLogs_Call) RunAndReturn(run func(context.Context, ethereum.FilterQuery) ([]types.Log, error)) *L2Mock_FilterLogs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // HeaderByHash provides a mock function with given fields: ctx, hash
 func (_m *L2Mock) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
 	ret := _m.Called(ctx, hash)
@@ -256,6 +468,35 @@ func (_m *L2Mock) HeaderByHash(ctx context.Context, hash common.Hash) (*types.He
 	return r0, r1
 }
 
+// L2Mock_HeaderByHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByHash'
+type L2Mock_HeaderByHash_Call struct {
+	*mock.Call
+}
+
+// HeaderByHash is a helper method to define mock.On call
+//   - ctx context.Context
+//   - hash common.Hash
+func (_e *L2Mock_Expecter) HeaderByHash(ctx interface{}, hash interface{}) *L2Mock_HeaderByHash_Call {
+	return &L2Mock_HeaderByHash_Call{Call: _e.mock.On("HeaderByHash", ctx, hash)}
+}
+
+func (_c *L2Mock_HeaderByHash_Call) Run(run func(ctx context.Context, hash common.Hash)) *L2Mock_HeaderByHash_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Hash))
+	})
+	return _c
+}
+
+func (_c *L2Mock_HeaderByHash_Call) Return(_a0 *types.Header, _a1 error) *L2Mock_HeaderByHash_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_HeaderByHash_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Header, error)) *L2Mock_HeaderByHash_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // HeaderByNumber provides a mock function with given fields: ctx, number
 func (_m *L2Mock) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
 	ret := _m.Called(ctx, number)
@@ -286,6 +527,35 @@ func (_m *L2Mock) HeaderByNumber(ctx context.Context, number *big.Int) (*types.H
 	return r0, r1
 }
 
+// L2Mock_HeaderByNumber_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderByNumber'
+type L2Mock_HeaderByNumber_Call struct {
+	*mock.Call
+}
+
+// HeaderByNumber is a helper method to define mock.On call
+//   - ctx context.Context
+//   - number *big.Int
+func (_e *L2Mock_Expecter) HeaderByNumber(ctx interface{}, number interface{}) *L2Mock_HeaderByNumber_Call {
+	return &L2Mock_HeaderByNumber_Call{Call: _e.mock.On("HeaderByNumber", ctx, number)}
+}
+
+func (_c *L2Mock_HeaderByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *L2Mock_HeaderByNumber_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*big.Int))
+	})
+	return _c
+}
+
+func (_c *L2Mock_HeaderByNumber_Call) Return(_a0 *types.Header, _a1 error) *L2Mock_HeaderByNumber_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_HeaderByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Header, error)) *L2Mock_HeaderByNumber_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // PendingCodeAt provides a mock function with given fields: ctx, account
 func (_m *L2Mock) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
 	ret := _m.Called(ctx, account)
@@ -316,6 +586,35 @@ func (_m *L2Mock) PendingCodeAt(ctx context.Context, account common.Address) ([]
 	return r0, r1
 }
 
+// L2Mock_PendingCodeAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingCodeAt'
+type L2Mock_PendingCodeAt_Call struct {
+	*mock.Call
+}
+
+// PendingCodeAt is a helper method to define mock.On call
+//   - ctx context.Context
+//   - account common.Address
+func (_e *L2Mock_Expecter) PendingCodeAt(ctx interface{}, account interface{}) *L2Mock_PendingCodeAt_Call {
+	return &L2Mock_PendingCodeAt_Call{Call: _e.mock.On("PendingCodeAt", ctx, account)}
+}
+
+func (_c *L2Mock_PendingCodeAt_Call) Run(run func(ctx context.Context, account common.Address)) *L2Mock_PendingCodeAt_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Address))
+	})
+	return _c
+}
+
+func (_c *L2Mock_PendingCodeAt_Call) Return(_a0 []byte, _a1 error) *L2Mock_PendingCodeAt_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_PendingCodeAt_Call) RunAndReturn(run func(context.Context, common.Address) ([]byte, error)) *L2Mock_PendingCodeAt_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // PendingNonceAt provides a mock function with given fields: ctx, account
 func (_m *L2Mock) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
 	ret := _m.Called(ctx, account)
@@ -344,6 +643,35 @@ func (_m *L2Mock) PendingNonceAt(ctx context.Context, account common.Address) (u
 	return r0, r1
 }
 
+// L2Mock_PendingNonceAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PendingNonceAt'
+type L2Mock_PendingNonceAt_Call struct {
+	*mock.Call
+}
+
+// PendingNonceAt is a helper method to define mock.On call
+//   - ctx context.Context
+//   - account common.Address
+func (_e *L2Mock_Expecter) PendingNonceAt(ctx interface{}, account interface{}) *L2Mock_PendingNonceAt_Call {
+	return &L2Mock_PendingNonceAt_Call{Call: _e.mock.On("PendingNonceAt", ctx, account)}
+}
+
+func (_c *L2Mock_PendingNonceAt_Call) Run(run func(ctx context.Context, account common.Address)) *L2Mock_PendingNonceAt_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Address))
+	})
+	return _c
+}
+
+func (_c *L2Mock_PendingNonceAt_Call) Return(_a0 uint64, _a1 error) *L2Mock_PendingNonceAt_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_PendingNonceAt_Call) RunAndReturn(run func(context.Context, common.Address) (uint64, error)) *L2Mock_PendingNonceAt_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // SendTransaction provides a mock function with given fields: ctx, tx
 func (_m *L2Mock) SendTransaction(ctx context.Context, tx *types.Transaction) error {
 	ret := _m.Called(ctx, tx)
@@ -362,6 +690,35 @@ func (_m *L2Mock) SendTransaction(ctx context.Context, tx *types.Transaction) er
 	return r0
 }
 
+// L2Mock_SendTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendTransaction'
+type L2Mock_SendTransaction_Call struct {
+	*mock.Call
+}
+
+// SendTransaction is a helper method to define mock.On call
+//   - ctx context.Context
+//   - tx *types.Transaction
+func (_e *L2Mock_Expecter) SendTransaction(ctx interface{}, tx interface{}) *L2Mock_SendTransaction_Call {
+	return &L2Mock_SendTransaction_Call{Call: _e.mock.On("SendTransaction", ctx, tx)}
+}
+
+func (_c *L2Mock_SendTransaction_Call) Run(run func(ctx context.Context, tx *types.Transaction)) *L2Mock_SendTransaction_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*types.Transaction))
+	})
+	return _c
+}
+
+func (_c *L2Mock_SendTransaction_Call) Return(_a0 error) *L2Mock_SendTransaction_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *L2Mock_SendTransaction_Call) RunAndReturn(run func(context.Context, *types.Transaction) error) *L2Mock_SendTransaction_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // SubscribeFilterLogs provides a mock function with given fields: ctx, q, ch
 func (_m *L2Mock) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
 	ret := _m.Called(ctx, q, ch)
@@ -392,6 +749,36 @@ func (_m *L2Mock) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuer
 	return r0, r1
 }
 
+// L2Mock_SubscribeFilterLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeFilterLogs'
+type L2Mock_SubscribeFilterLogs_Call struct {
+	*mock.Call
+}
+
+// SubscribeFilterLogs is a helper method to define mock.On call
+//   - ctx context.Context
+//   - q ethereum.FilterQuery
+//   - ch chan<- types.Log
+func (_e *L2Mock_Expecter) SubscribeFilterLogs(ctx interface{}, q interface{}, ch interface{}) *L2Mock_SubscribeFilterLogs_Call {
+	return &L2Mock_SubscribeFilterLogs_Call{Call: _e.mock.On("SubscribeFilterLogs", ctx, q, ch)}
+}
+
+func (_c *L2Mock_SubscribeFilterLogs_Call) Run(run func(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log)) *L2Mock_SubscribeFilterLogs_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(ethereum.FilterQuery), args[2].(chan<- types.Log))
+	})
+	return _c
+}
+
+func (_c *L2Mock_SubscribeFilterLogs_Call) Return(_a0 ethereum.Subscription, _a1 error) *L2Mock_SubscribeFilterLogs_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_SubscribeFilterLogs_Call) RunAndReturn(run func(context.Context, ethereum.FilterQuery, chan<- types.Log) (ethereum.Subscription, error)) *L2Mock_SubscribeFilterLogs_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // SubscribeNewHead provides a mock function with given fields: ctx, ch
 func (_m *L2Mock) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
 	ret := _m.Called(ctx, ch)
@@ -422,6 +809,35 @@ func (_m *L2Mock) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header)
 	return r0, r1
 }
 
+// L2Mock_SubscribeNewHead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeNewHead'
+type L2Mock_SubscribeNewHead_Call struct {
+	*mock.Call
+}
+
+// SubscribeNewHead is a helper method to define mock.On call
+//   - ctx context.Context
+//   - ch chan<- *types.Header
+func (_e *L2Mock_Expecter) SubscribeNewHead(ctx interface{}, ch interface{}) *L2Mock_SubscribeNewHead_Call {
+	return &L2Mock_SubscribeNewHead_Call{Call: _e.mock.On("SubscribeNewHead", ctx, ch)}
+}
+
+func (_c *L2Mock_SubscribeNewHead_Call) Run(run func(ctx context.Context, ch chan<- *types.Header)) *L2Mock_SubscribeNewHead_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(chan<- *types.Header))
+	})
+	return _c
+}
+
+func (_c *L2Mock_SubscribeNewHead_Call) Return(_a0 ethereum.Subscription, _a1 error) *L2Mock_SubscribeNewHead_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_SubscribeNewHead_Call) RunAndReturn(run func(context.Context, chan<- *types.Header) (ethereum.Subscription, error)) *L2Mock_SubscribeNewHead_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // SuggestGasPrice provides a mock function with given fields: ctx
 func (_m *L2Mock) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
 	ret := _m.Called(ctx)
@@ -452,6 +868,34 @@ func (_m *L2Mock) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
 	return r0, r1
 }
 
+// L2Mock_SuggestGasPrice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuggestGasPrice'
+type L2Mock_SuggestGasPrice_Call struct {
+	*mock.Call
+}
+
+// SuggestGasPrice is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *L2Mock_Expecter) SuggestGasPrice(ctx interface{}) *L2Mock_SuggestGasPrice_Call {
+	return &L2Mock_SuggestGasPrice_Call{Call: _e.mock.On("SuggestGasPrice", ctx)}
+}
+
+func (_c *L2Mock_SuggestGasPrice_Call) Run(run func(ctx context.Context)) *L2Mock_SuggestGasPrice_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *L2Mock_SuggestGasPrice_Call) Return(_a0 *big.Int, _a1 error) *L2Mock_SuggestGasPrice_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_SuggestGasPrice_Call) RunAndReturn(run func(context.Context) (*big.Int, error)) *L2Mock_SuggestGasPrice_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // SuggestGasTipCap provides a mock function with given fields: ctx
 func (_m *L2Mock) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
 	ret := _m.Called(ctx)
@@ -482,6 +926,34 @@ func (_m *L2Mock) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
 	return r0, r1
 }
 
+// L2Mock_SuggestGasTipCap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuggestGasTipCap'
+type L2Mock_SuggestGasTipCap_Call struct {
+	*mock.Call
+}
+
+// SuggestGasTipCap is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *L2Mock_Expecter) SuggestGasTipCap(ctx interface{}) *L2Mock_SuggestGasTipCap_Call {
+	return &L2Mock_SuggestGasTipCap_Call{Call: _e.mock.On("SuggestGasTipCap", ctx)}
+}
+
+func (_c *L2Mock_SuggestGasTipCap_Call) Run(run func(ctx context.Context)) *L2Mock_SuggestGasTipCap_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *L2Mock_SuggestGasTipCap_Call) Return(_a0 *big.Int, _a1 error) *L2Mock_SuggestGasTipCap_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_SuggestGasTipCap_Call) RunAndReturn(run func(context.Context) (*big.Int, error)) *L2Mock_SuggestGasTipCap_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // TransactionCount provides a mock function with given fields: ctx, blockHash
 func (_m *L2Mock) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error) {
 	ret := _m.Called(ctx, blockHash)
@@ -510,6 +982,35 @@ func (_m *L2Mock) TransactionCount(ctx context.Context, blockHash common.Hash) (
 	return r0, r1
 }
 
+// L2Mock_TransactionCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionCount'
+type L2Mock_TransactionCount_Call struct {
+	*mock.Call
+}
+
+// TransactionCount is a helper method to define mock.On call
+//   - ctx context.Context
+//   - blockHash common.Hash
+func (_e *L2Mock_Expecter) TransactionCount(ctx interface{}, blockHash interface{}) *L2Mock_TransactionCount_Call {
+	return &L2Mock_TransactionCount_Call{Call: _e.mock.On("TransactionCount", ctx, blockHash)}
+}
+
+func (_c *L2Mock_TransactionCount_Call) Run(run func(ctx context.Context, blockHash common.Hash)) *L2Mock_TransactionCount_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Hash))
+	})
+	return _c
+}
+
+func (_c *L2Mock_TransactionCount_Call) Return(_a0 uint, _a1 error) *L2Mock_TransactionCount_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_TransactionCount_Call) RunAndReturn(run func(context.Context, common.Hash) (uint, error)) *L2Mock_TransactionCount_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // TransactionInBlock provides a mock function with given fields: ctx, blockHash, index
 func (_m *L2Mock) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error) {
 	ret := _m.Called(ctx, blockHash, index)
@@ -540,6 +1041,36 @@ func (_m *L2Mock) TransactionInBlock(ctx context.Context, blockHash common.Hash,
 	return r0, r1
 }
 
+// L2Mock_TransactionInBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransactionInBlock'
+type L2Mock_TransactionInBlock_Call struct {
+	*mock.Call
+}
+
+// TransactionInBlock is a helper method to define mock.On call
+//   - ctx context.Context
+//   - blockHash common.Hash
+//   - index uint
+func (_e *L2Mock_Expecter) TransactionInBlock(ctx interface{}, blockHash interface{}, index interface{}) *L2Mock_TransactionInBlock_Call {
+	return &L2Mock_TransactionInBlock_Call{Call: _e.mock.On("TransactionInBlock", ctx, blockHash, index)}
+}
+
+func (_c *L2Mock_TransactionInBlock_Call) Run(run func(ctx context.Context, blockHash common.Hash, index uint)) *L2Mock_TransactionInBlock_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(common.Hash), args[2].(uint))
+	})
+	return _c
+}
+
+func (_c *L2Mock_TransactionInBlock_Call) Return(_a0 *types.Transaction, _a1 error) *L2Mock_TransactionInBlock_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *L2Mock_TransactionInBlock_Call) RunAndReturn(run func(context.Context, common.Hash, uint) (*types.Transaction, error)) *L2Mock_TransactionInBlock_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewL2Mock creates a new instance of L2Mock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewL2Mock(t interface {
diff --git a/sync/mock_processor_test.go b/sync/mock_processor_test.go
index afbb34cb..96ece8d4 100644
--- a/sync/mock_processor_test.go
+++ b/sync/mock_processor_test.go
@@ -1,4 +1,4 @@
-// Code generated by mockery v2.39.0. DO NOT EDIT.
+// Code generated by mockery. DO NOT EDIT.
 
 package sync
 
@@ -13,6 +13,14 @@ type ProcessorMock struct {
 	mock.Mock
 }
 
+type ProcessorMock_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ProcessorMock) EXPECT() *ProcessorMock_Expecter {
+	return &ProcessorMock_Expecter{mock: &_m.Mock}
+}
+
 // GetLastProcessedBlock provides a mock function with given fields: ctx
 func (_m *ProcessorMock) GetLastProcessedBlock(ctx context.Context) (uint64, error) {
 	ret := _m.Called(ctx)
@@ -41,6 +49,34 @@ func (_m *ProcessorMock) GetLastProcessedBlock(ctx context.Context) (uint64, err
 	return r0, r1
 }
 
+// ProcessorMock_GetLastProcessedBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLastProcessedBlock'
+type ProcessorMock_GetLastProcessedBlock_Call struct {
+	*mock.Call
+}
+
+// GetLastProcessedBlock is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *ProcessorMock_Expecter) GetLastProcessedBlock(ctx interface{}) *ProcessorMock_GetLastProcessedBlock_Call {
+	return &ProcessorMock_GetLastProcessedBlock_Call{Call: _e.mock.On("GetLastProcessedBlock", ctx)}
+}
+
+func (_c *ProcessorMock_GetLastProcessedBlock_Call) Run(run func(ctx context.Context)) *ProcessorMock_GetLastProcessedBlock_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *ProcessorMock_GetLastProcessedBlock_Call) Return(_a0 uint64, _a1 error) *ProcessorMock_GetLastProcessedBlock_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *ProcessorMock_GetLastProcessedBlock_Call) RunAndReturn(run func(context.Context) (uint64, error)) *ProcessorMock_GetLastProcessedBlock_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // ProcessBlock provides a mock function with given fields: ctx, block
 func (_m *ProcessorMock) ProcessBlock(ctx context.Context, block Block) error {
 	ret := _m.Called(ctx, block)
@@ -59,6 +95,35 @@ func (_m *ProcessorMock) ProcessBlock(ctx context.Context, block Block) error {
 	return r0
 }
 
+// ProcessorMock_ProcessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessBlock'
+type ProcessorMock_ProcessBlock_Call struct {
+	*mock.Call
+}
+
+// ProcessBlock is a helper method to define mock.On call
+//   - ctx context.Context
+//   - block Block
+func (_e *ProcessorMock_Expecter) ProcessBlock(ctx interface{}, block interface{}) *ProcessorMock_ProcessBlock_Call {
+	return &ProcessorMock_ProcessBlock_Call{Call: _e.mock.On("ProcessBlock", ctx, block)}
+}
+
+func (_c *ProcessorMock_ProcessBlock_Call) Run(run func(ctx context.Context, block Block)) *ProcessorMock_ProcessBlock_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(Block))
+	})
+	return _c
+}
+
+func (_c *ProcessorMock_ProcessBlock_Call) Return(_a0 error) *ProcessorMock_ProcessBlock_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProcessorMock_ProcessBlock_Call) RunAndReturn(run func(context.Context, Block) error) *ProcessorMock_ProcessBlock_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Reorg provides a mock function with given fields: ctx, firstReorgedBlock
 func (_m *ProcessorMock) Reorg(ctx context.Context, firstReorgedBlock uint64) error {
 	ret := _m.Called(ctx, firstReorgedBlock)
@@ -77,6 +142,35 @@ func (_m *ProcessorMock) Reorg(ctx context.Context, firstReorgedBlock uint64) er
 	return r0
 }
 
+// ProcessorMock_Reorg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reorg'
+type ProcessorMock_Reorg_Call struct {
+	*mock.Call
+}
+
+// Reorg is a helper method to define mock.On call
+//   - ctx context.Context
+//   - firstReorgedBlock uint64
+func (_e *ProcessorMock_Expecter) Reorg(ctx interface{}, firstReorgedBlock interface{}) *ProcessorMock_Reorg_Call {
+	return &ProcessorMock_Reorg_Call{Call: _e.mock.On("Reorg", ctx, firstReorgedBlock)}
+}
+
+func (_c *ProcessorMock_Reorg_Call) Run(run func(ctx context.Context, firstReorgedBlock uint64)) *ProcessorMock_Reorg_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(uint64))
+	})
+	return _c
+}
+
+func (_c *ProcessorMock_Reorg_Call) Return(_a0 error) *ProcessorMock_Reorg_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ProcessorMock_Reorg_Call) RunAndReturn(run func(context.Context, uint64) error) *ProcessorMock_Reorg_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewProcessorMock creates a new instance of ProcessorMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewProcessorMock(t interface {
diff --git a/sync/mock_reorgdetector_test.go b/sync/mock_reorgdetector_test.go
index 9689f7e7..43551baa 100644
--- a/sync/mock_reorgdetector_test.go
+++ b/sync/mock_reorgdetector_test.go
@@ -1,4 +1,4 @@
-// Code generated by mockery v2.39.0. DO NOT EDIT.
+// Code generated by mockery. DO NOT EDIT.
 
 package sync
 
@@ -17,6 +17,14 @@ type ReorgDetectorMock struct {
 	mock.Mock
 }
 
+type ReorgDetectorMock_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *ReorgDetectorMock) EXPECT() *ReorgDetectorMock_Expecter {
+	return &ReorgDetectorMock_Expecter{mock: &_m.Mock}
+}
+
 // AddBlockToTrack provides a mock function with given fields: ctx, id, blockNum, blockHash
 func (_m *ReorgDetectorMock) AddBlockToTrack(ctx context.Context, id string, blockNum uint64, blockHash common.Hash) error {
 	ret := _m.Called(ctx, id, blockNum, blockHash)
@@ -35,6 +43,37 @@ func (_m *ReorgDetectorMock) AddBlockToTrack(ctx context.Context, id string, blo
 	return r0
 }
 
+// ReorgDetectorMock_AddBlockToTrack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBlockToTrack'
+type ReorgDetectorMock_AddBlockToTrack_Call struct {
+	*mock.Call
+}
+
+// AddBlockToTrack is a helper method to define mock.On call
+//   - ctx context.Context
+//   - id string
+//   - blockNum uint64
+//   - blockHash common.Hash
+func (_e *ReorgDetectorMock_Expecter) AddBlockToTrack(ctx interface{}, id interface{}, blockNum interface{}, blockHash interface{}) *ReorgDetectorMock_AddBlockToTrack_Call {
+	return &ReorgDetectorMock_AddBlockToTrack_Call{Call: _e.mock.On("AddBlockToTrack", ctx, id, blockNum, blockHash)}
+}
+
+func (_c *ReorgDetectorMock_AddBlockToTrack_Call) Run(run func(ctx context.Context, id string, blockNum uint64, blockHash common.Hash)) *ReorgDetectorMock_AddBlockToTrack_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string), args[2].(uint64), args[3].(common.Hash))
+	})
+	return _c
+}
+
+func (_c *ReorgDetectorMock_AddBlockToTrack_Call) Return(_a0 error) *ReorgDetectorMock_AddBlockToTrack_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *ReorgDetectorMock_AddBlockToTrack_Call) RunAndReturn(run func(context.Context, string, uint64, common.Hash) error) *ReorgDetectorMock_AddBlockToTrack_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Subscribe provides a mock function with given fields: id
 func (_m *ReorgDetectorMock) Subscribe(id string) (*reorgdetector.Subscription, error) {
 	ret := _m.Called(id)
@@ -65,6 +104,34 @@ func (_m *ReorgDetectorMock) Subscribe(id string) (*reorgdetector.Subscription,
 	return r0, r1
 }
 
+// ReorgDetectorMock_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
+type ReorgDetectorMock_Subscribe_Call struct {
+	*mock.Call
+}
+
+// Subscribe is a helper method to define mock.On call
+//   - id string
+func (_e *ReorgDetectorMock_Expecter) Subscribe(id interface{}) *ReorgDetectorMock_Subscribe_Call {
+	return &ReorgDetectorMock_Subscribe_Call{Call: _e.mock.On("Subscribe", id)}
+}
+
+func (_c *ReorgDetectorMock_Subscribe_Call) Run(run func(id string)) *ReorgDetectorMock_Subscribe_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(string))
+	})
+	return _c
+}
+
+func (_c *ReorgDetectorMock_Subscribe_Call) Return(_a0 *reorgdetector.Subscription, _a1 error) *ReorgDetectorMock_Subscribe_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *ReorgDetectorMock_Subscribe_Call) RunAndReturn(run func(string) (*reorgdetector.Subscription, error)) *ReorgDetectorMock_Subscribe_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // NewReorgDetectorMock creates a new instance of ReorgDetectorMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewReorgDetectorMock(t interface {
diff --git a/test/Makefile b/test/Makefile
index d4e3c274..05823e66 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -45,10 +45,11 @@ generate-mocks-helpers: ## Generates mocks for helpers , using mockery tool
 
 .PHONY: generate-mocks-sync
 generate-mocks-sync: ## Generates mocks for sync, using mockery tool
-	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=EthClienter --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=L2Mock --filename=mock_l2_test.go
-	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=evmDownloaderFull --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=EVMDownloaderMock --filename=mock_downloader_test.go
-	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=processorInterface --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ProcessorMock --filename=mock_processor_test.go
-	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=ReorgDetector --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ReorgDetectorMock --filename=mock_reorgdetector_test.go
+	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=EthClienter --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=L2Mock --filename=mock_l2_test.go ${COMMON_MOCKERY_PARAMS}
+	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=evmDownloaderFull --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=EVMDownloaderMock --filename=mock_downloader_test.go ${COMMON_MOCKERY_PARAMS}
+	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=processorInterface --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ProcessorMock --filename=mock_processor_test.go ${COMMON_MOCKERY_PARAMS}
+	export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/mockery --name=ReorgDetector --dir=../sync --output=../sync --outpkg=sync --inpackage --structname=ReorgDetectorMock --filename=mock_reorgdetector_test.go ${COMMON_MOCKERY_PARAMS}
+	
 
 .PHONY: generate-mocks-aggregator	
 generate-mocks-aggregator: ## Generates mocks for aggregator, using mockery tool
diff --git a/test/bats/pp/bridge-e2e.bats b/test/bats/pp/bridge-e2e.bats
index 953082a9..18ed5c86 100644
--- a/test/bats/pp/bridge-e2e.bats
+++ b/test/bats/pp/bridge-e2e.bats
@@ -55,7 +55,7 @@ setup() {
     echo "=== Running LxLy deposit on L1 to network: $l2_rpc_network_id native_token: $native_token_addr" >&3
     
     destination_net=$l2_rpc_network_id
-    run bridgeAsset "$native_token_addr" "$l1_rpc_url"
+    run bridge_asset "$native_token_addr" "$l1_rpc_url"
     assert_success
 
     echo "=== Running LxLy claim on L2" >&3
@@ -70,7 +70,7 @@ setup() {
     echo "=== bridgeAsset L2 WETH: $weth_token_addr to L1 ETH" >&3
     destination_addr=$sender_addr
     destination_net=0
-    run bridgeAsset "$weth_token_addr" "$l2_rpc_url"
+    run bridge_asset "$weth_token_addr" "$l2_rpc_url"
     assert_success
 }