feat: mechanism to calculate last settled block by not using metadata (#838)

## 🔄 Changes Summary
This PR introduces a new interface called `CertificateQuerier` which,
for now, has only one function called `GetLastSettledCertificateToBlock`
which calculates the last settled block from a previously settled
certificate.

This will be used on the validator, to calculate what was the last
settled block, so we can figure out from which block a new certificate
that is being verified is built.

It will also be used on startup from scratch, when `aggsender` syncs its
state with `agglayer`, so we can save the `ToBlock` of the last settled
certificate in the `db`.

The motivation behind this PR is to not use the `Metadata` field on the
certificate, since it will not be signed by the proposer and validators,
hence, it can be faked, but deduce the block range from other
certificate data.

## How the last settled block is calculated

The last settled block in the `CertificateQuerier` is calculated like
this:
- First it will check the `NewLocalExitRoot` field on the certificate,
if it is not the first `empty` LER, meaning, there were some bridge
exits in the certificate, or in certificates before it, it will get the
block num on which the `NewLocalExitRoot` hash was added on `L2` by
calling the `L2 bridge syncer`.
- Secondly, it will call the `agglayer` endpoint to get the latest
settled imported bridge exit. Note that this PR added only the endpoint
sceleton, since this is not yet implemented on `agglayer`. This endpoint
will return the `GlobalIndex` of the last settled imported bridge exit
(claim), and we will use that to get the claim from the `L2 bridge
syncer` since `GlobalIndex` is unique per claim.
- Thirdly, it will ping the `AggchainFEP` rollup contract to get the
last settled `L2` block from it (which is gotten from the `aggchain
proof` in the `FEP` certificates). If the network is not `FEP` this call
will just return 0.
- At the end, it will compare the 3 blocks gotten in previous steps, and
choose the max value from it.

We need all three values because, PP certificates can either contain
only bridge exits, or only imported bridge exits, and FEP certificates
can be empty.

**IMPORTANT NOTE**: This code is not used anywhere. It will be used in
subsequent PRs.
 

## ⚠️ Breaking Changes
NA

## 📋 Config Updates
NA

## ✅ Testing
- 🤖 **Automatic**: aggkit CI

Author: goran-ethernal

.mockery.yaml

@@ -9,8 +9,7 @@ packages:
   github.com/agglayer/aggkit/agglayer:
     config:
       inpackage: true
-      dir: "{{ .InterfaceDir }}"
-      outpkg: "{{ .PackageName }}"
+      dir: "{{ .InterfaceDir }}/mocks"
     interfaces:
       AgglayerClientInterface:
         config:

agglayer/agglayer_client_cache.go

@@ -125,3 +125,10 @@ func (c *AgglayerClientCache) GetLatestPendingCertificateHeader(ctx context.Cont
 	networkID uint32) (*agglayertypes.CertificateHeader, error) {
 	return c.agglayerClient.GetLatestPendingCertificateHeader(ctx, networkID)
 }
+
+// GetLatestSettledImportedBridgeExit retrieves the latest settled
+// imported bridge exit from the Agglayer client. (no cache)
+func (c *AgglayerClientCache) GetLatestSettledImportedBridgeExit(
+	ctx context.Context) (*agglayertypes.GlobalIndex, error) {
+	return c.agglayerClient.GetLatestSettledImportedBridgeExit(ctx)
+}

agglayer/agglayer_client_cache_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/agglayer/aggkit/agglayer/mocks"
 	agglayertypes "github.com/agglayer/aggkit/agglayer/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/jellydator/ttlcache/v3"
@@ -40,7 +41,7 @@ func TestGetCertificateHeader(t *testing.T) {
 		Status:        agglayertypes.Settled,
 	}
 
-	mockAgglayerClient := NewAgglayerClientMock(t)
+	mockAgglayerClient := mocks.NewAgglayerClientMock(t)
 	certCache := NewCertificateCache(mockAgglayerClient, ttl, capacity)
 
 	// Test cache doesn't have the certificate header initially
@@ -88,7 +89,7 @@ func TestExpiration(t *testing.T) {
 		Status:        agglayertypes.Settled,
 	}
 
-	mockAgglayerClient := NewAgglayerClientMock(t)
+	mockAgglayerClient := mocks.NewAgglayerClientMock(t)
 	certCache := NewCertificateCache(mockAgglayerClient, ttl, capacity)
 
 	mockAgglayerClient.EXPECT().GetCertificateHeader(t.Context(), certificateID).Return(certificateHeader, nil).Times(2)

agglayer/client.go

@@ -30,6 +30,7 @@ type AggLayerClientCertificateIDQuerier interface {
 type AgglayerClientInterface interface {
 	SendCertificate(ctx context.Context, certificate *types.Certificate, validatorSignature []byte) (common.Hash, error)
 	GetCertificateHeader(ctx context.Context, certificateHash common.Hash) (*types.CertificateHeader, error)
+	GetLatestSettledImportedBridgeExit(ctx context.Context) (*types.GlobalIndex, error)
 	AggLayerClientGetEpochConfiguration
 	AggLayerClientRecoveryQuerier
 	AggLayerClientCertificateIDQuerier

agglayer/grpc/agglayer_grpc_client.go

@@ -156,6 +156,11 @@ func (a *AgglayerGRPCClient) GetCertificateHeader(
 	return convertProtoCertificateHeader(response.CertificateHeader), nil
 }
 
+func (a *AgglayerGRPCClient) GetLatestSettledImportedBridgeExit(ctx context.Context) (*types.GlobalIndex, error) {
+	// TODO - implement this method once agglayer supports it
+	return &types.GlobalIndex{}, nil
+}
+
 // ConvertCertToProtoCertificate converts a types.Certificate to a grpc v1nodetypes.Certificate
 func ConvertCertToProtoCertificate(
 	certificate *types.Certificate,

agglayer/mock_agglayer_client.go renamed to agglayer/mocks/mock_agglayer_client.go

@@ -471,6 +471,11 @@ type GlobalIndex struct {
 	LeafIndex   uint32 `json:"leaf_index"`
 }
 
+// ToBigInt converts the GlobalIndex to a big.Int representation
+func (g *GlobalIndex) ToBigInt() *big.Int {
+	return bridgesync.GenerateGlobalIndex(g.MainnetFlag, g.RollupIndex, g.LeafIndex)
+}
+
 func (g *GlobalIndex) Validate() error {
 	if g == nil {
 		return errors.New("globalIndex is nil")

agglayer/types/types.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/agglayer/aggkit/agglayer"
+	agglayermocks "github.com/agglayer/aggkit/agglayer/mocks"
 	agglayertypes "github.com/agglayer/aggkit/agglayer/types"
 	"github.com/agglayer/aggkit/aggsender/config"
 	"github.com/agglayer/aggkit/aggsender/db"
@@ -72,7 +73,7 @@ func TestConfigString(t *testing.T) {
 }
 
 func TestAggSenderStart(t *testing.T) {
-	aggLayerMock := agglayer.NewAgglayerClientMock(t)
+	aggLayerMock := agglayermocks.NewAgglayerClientMock(t)
 	epochNotifierMock := mocks.NewEpochNotifier(t)
 	bridgeL2SyncerMock := mocks.NewL2BridgeSyncer(t)
 	rollupQuerierMock := mocks.NewRollupDataQuerier(t)
@@ -204,7 +205,7 @@ func TestSendCertificate_NoClaims(t *testing.T) {
 	mockStorage := mocks.NewAggSenderStorage(t)
 	mockL2BridgeQuerier := mocks.NewBridgeQuerier(t)
 	mockL1Querier := mocks.NewL1InfoTreeDataQuerier(t)
-	mockAggLayerClient := agglayer.NewAgglayerClientMock(t)
+	mockAggLayerClient := agglayermocks.NewAgglayerClientMock(t)
 	mockEpochNotifier := mocks.NewEpochNotifier(t)
 	mockLERQuerier := mocks.NewLERQuerier(t)
 	logger := log.WithFields("aggsender-test", "no claims test")
@@ -313,15 +314,15 @@ func TestSendCertificate(t *testing.T) {
 
 	testCases := []struct {
 		name            string
-		mockFn          func(*mocks.AggSenderStorage, *mocks.AggsenderFlow, *agglayer.AgglayerClientMock)
+		mockFn          func(*mocks.AggSenderStorage, *mocks.AggsenderFlow, *agglayermocks.AgglayerClientMock)
 		mockValidatorFn func() *mocks.CertificateValidateAndSigner
 		expectedError   string
 	}{
 		{
 			name: "error getting certificate build params",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(nil, errors.New("some error")).Once()
 			},
 			expectedError: "error getting certificate build params",
@@ -330,15 +331,15 @@ func TestSendCertificate(t *testing.T) {
 			name: "no new blocks consumed",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(nil, nil).Once()
 			},
 		},
 		{
 			name: "error building certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -350,7 +351,7 @@ func TestSendCertificate(t *testing.T) {
 			name: "error sending certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -369,7 +370,7 @@ func TestSendCertificate(t *testing.T) {
 			name: "error saving certificate to storage",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -388,7 +389,7 @@ func TestSendCertificate(t *testing.T) {
 			name: "error getting validator signature",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -411,7 +412,7 @@ func TestSendCertificate(t *testing.T) {
 			name: "successful validation and sending of a certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -434,7 +435,7 @@ func TestSendCertificate(t *testing.T) {
 			name: "successful sending and saving of a certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
 				mockFlow *mocks.AggsenderFlow,
-				mockAgglayerClient *agglayer.AgglayerClientMock) {
+				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
 				}, nil).Once()
@@ -456,7 +457,7 @@ func TestSendCertificate(t *testing.T) {
 
 			mockStorage := mocks.NewAggSenderStorage(t)
 			mockAggsenderFlow := mocks.NewAggsenderFlow(t)
-			mockAgglayerClient := agglayer.NewAgglayerClientMock(t)
+			mockAgglayerClient := agglayermocks.NewAgglayerClientMock(t)
 			mockEpochNotifier := mocks.NewEpochNotifier(t)
 			tt.mockFn(mockStorage, mockAggsenderFlow, mockAgglayerClient)
 
@@ -699,7 +700,7 @@ const (
 
 type aggsenderTestData struct {
 	ctx                     context.Context
-	agglayerClientMock      *agglayer.AgglayerClientMock
+	agglayerClientMock      *agglayermocks.AgglayerClientMock
 	l1InfoQuerier           *mocks.L1InfoTreeDataQuerier
 	l2BridgeQuerier         *mocks.BridgeQuerier
 	storageMock             *mocks.AggSenderStorage
@@ -745,7 +746,7 @@ func NewClaimData(t *testing.T, num int, blockNum []uint64) []bridgesync.Claim {
 func newAggsenderTestData(t *testing.T, creationFlags testDataFlags) *aggsenderTestData {
 	t.Helper()
 	l2BridgeQuerier := mocks.NewBridgeQuerier(t)
-	agglayerClientMock := agglayer.NewAgglayerClientMock(t)
+	agglayerClientMock := agglayermocks.NewAgglayerClientMock(t)
 	l1InfoTreeQuerierMock := mocks.NewL1InfoTreeDataQuerier(t)
 	lerQuerier := mocks.NewLERQuerier(t)
 	epochNotifierMock := mocks.NewEpochNotifier(t)

aggsender/aggsender_test.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/agglayer/aggkit/agglayer"
+	agglayermocks "github.com/agglayer/aggkit/agglayer/mocks"
 	agglayertypes "github.com/agglayer/aggkit/agglayer/types"
 	"github.com/agglayer/aggkit/aggsender/mocks"
 	"github.com/agglayer/aggkit/aggsender/types"
@@ -118,7 +118,7 @@ func TestNewConfigEpochNotifierPerBlock(t *testing.T) {
 	ctx := context.Background()
 	_, err := NewConfigEpochNotifierPerBlock(ctx, nil, 1)
 	require.Error(t, err)
-	aggLayerMock := agglayer.NewAgglayerClientMock(t)
+	aggLayerMock := agglayermocks.NewAgglayerClientMock(t)
 	aggLayerMock.On("GetEpochConfiguration", mock.Anything).Return(nil, fmt.Errorf("error")).Once()
 	_, err = NewConfigEpochNotifierPerBlock(ctx, aggLayerMock, 1)
 	require.Error(t, err)

aggsender/epoch_notifier_per_block_test.go

@@ -19,9 +19,6 @@ import (
 )
 
 var (
-	// funcGetL2StartBlock is a intermediate func that allow to override this call in UT
-	funcGetL2StartBlock = getL2StartBlock
-
 	// l2GERReaderFactory is a factory function to create L2 GER reader
 	l2GERReaderFactory = l2gersync.NewL2EVMGERReader
 )
@@ -87,10 +84,6 @@ func NewFlow(
 
 		l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
 
-		startL2Block, err := funcGetL2StartBlock(cfg.SovereignRollupAddr, l1Client)
-		if err != nil {
-			return nil, fmt.Errorf("aggchainProverFlow - error reading sovereign rollup: %w", err)
-		}
 		optimisticSigner, optimisticModeQuerier, err := optimistic.NewOptimistic(
 			ctx, logger, l1Client, cfg.OptimisticModeConfig)
 		if err != nil {
@@ -103,10 +96,15 @@ func NewFlow(
 			return nil, fmt.Errorf("aggchainProverFlow - error creating LER data querier: %w", err)
 		}
 
+		aggchainFEPQuerier, err := query.NewAggchainFEPQuerier(logger, cfg.SovereignRollupAddr, l1Client)
+		if err != nil {
+			return nil, fmt.Errorf("aggchainProverFlow - error creating aggchain FEP querier: %w", err)
+		}
+
 		l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, cfg.DelayBetweenRetries.Duration)
 		baseFlow := NewBaseFlow(
 			logger, l2BridgeQuerier, storage, l1InfoTreeQuerier, lerQuerier,
-			NewBaseFlowConfig(cfg.MaxCertSize, startL2Block, cfg.RequireNoFEPBlockGap),
+			NewBaseFlowConfig(cfg.MaxCertSize, aggchainFEPQuerier.StartL2Block(), cfg.RequireNoFEPBlockGap),
 		)
 
 		l2GERReader, err := l2GERReaderFactory(cfg.GlobalExitRootL2Addr, l2Client, l1InfoTreeSyncer)