feat: support FEP in aggsender-validator (#876)

## 🔄 Changes Summary
This PR adds support for FEP certificates validation in
`aggsender-validator`.

## ⚠️ Breaking Changes
NA

## 📋 Config Updates
Added new config parameters to `Validator` config:
- `Mode` - mode of the validator. Similar to regular `aggsender`
(proposer) it can be `PessimisticProof` or `AggchainProof` based on if
the network is a `PP` or `FEP`.
- `FEPConfig` - `FEP` (`AggchainProof` mode) network specific
configuration:
   - `SovereignRollupAddr` - address of the `AggchainFEP` contract.
- `RequireNoFEPBlockGap` - true if the AggSender should not accept a gap
between last block from last certificate and first block of `FEP`
network.

- 🧾 **Diff/Config snippet**:
```toml
[Validator]
# PessimisticProof or AggchainProof
Mode = "PessimisticProof"
[Validator.FEPConfig]
   SovereignRollupAddr = "{{AggSender.SovereignRollupAddr}}"
   RequireNoFEPBlockGap = "{{AggSender.RequireNoFEPBlockGap}}"
```

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

## 🐞 Issues
- Closes #803

Author: goran-ethernal

aggsender/aggsender_validator.go

@@ -31,14 +31,14 @@ type AggsenderValidator struct {
 func NewAggsenderValidator(ctx context.Context,
 	logger aggkitcommon.Logger,
 	cfg validator.Config,
-	flowPP validator.FlowInterface,
+	flow validator.FlowInterface,
 	l1InfoTreeDataQuerier validator.L1InfoTreeRootByLeafQuerier,
 	aggLayerClient agglayer.AggLayerClientCertificateIDQuerier,
 	certQuerier types.CertificateQuerier,
 	lerQuerier types.LERQuerier,
 	signer signertypes.Signer) (*AggsenderValidator, error) {
 	validatorCert := validator.NewAggsenderValidator(
-		logger, flowPP, l1InfoTreeDataQuerier, certQuerier, lerQuerier)
+		logger, flow, l1InfoTreeDataQuerier, certQuerier, lerQuerier)
 	grpcServer, err := grpc.NewServer(cfg.ServerConfig)
 	if err != nil {
 		return nil, err

aggsender/config/config.go

@@ -119,8 +119,11 @@ func (c Config) String() string {
 // Validate checks if the configuration is valid
 func (c Config) Validate() error {
 	if c.RequireValidatorCall {
-		if c.Mode != aggsendertypes.PessimisticProofMode.String() {
-			return fmt.Errorf("RequireValidatorCall can only be true in PessimisticProof mode, got %s", c.Mode)
+		if c.Mode != aggsendertypes.PessimisticProofMode.String() &&
+			c.Mode != aggsendertypes.AggchainProofMode.String() {
+			return fmt.Errorf(
+				"RequireValidatorCall can only be true in PessimisticProof or AggchainProof mode, got %s",
+				c.Mode)
 		}
 
 		if c.ValidatorClient == nil || c.ValidatorClient.URL == "" {

aggsender/config/config_test.go

@@ -20,16 +20,16 @@ func TestValidate(t *testing.T) {
 		expectedErr string
 	}{
 		{
-			name: "RequireValidatorCall not PP mode",
+			name: "RequireValidatorCall not PP or FEP mode",
 			config: Config{
-				Mode:                 aggsendertypes.AggchainProofMode.String(),
+				Mode:                 "some-other-mode",
 				RequireValidatorCall: true,
 				ValidatorClient: &grpc.ClientConfig{
 					URL:               "http://localhost:8080",
 					MinConnectTimeout: types.NewDuration(5 * time.Second),
 				},
 			},
-			expectedErr: "RequireValidatorCall can only be true in PessimisticProof mode",
+			expectedErr: "RequireValidatorCall can only be true in PessimisticProof or AggchainProof mode",
 		},
 		{
 			name: "RequireValidatorCall is true with ValidatorClient URL set",

aggsender/flows/factory.go

@@ -3,6 +3,7 @@ package flows
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/agglayer/aggkit/aggsender/aggchainproofclient"
 	"github.com/agglayer/aggkit/aggsender/config"
@@ -15,15 +16,14 @@ import (
 	"github.com/agglayer/aggkit/log"
 	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/agglayer/go_signer/signer"
-	signerTypes "github.com/agglayer/go_signer/signer/types"
+	signertypes "github.com/agglayer/go_signer/signer/types"
 )
 
 var (
 	// l2GERReaderFactory is a factory function to create L2 GER reader
 	l2GERReaderFactory = l2gersync.NewL2EVMGERReader
 )
 
-// NewFlow creates a new Aggsender flow based on the provided configuration.
 func NewFlow(
 	ctx context.Context,
 	cfg config.Config,
@@ -37,28 +37,25 @@ func NewFlow(
 ) (types.AggsenderFlow, error) {
 	switch types.AggsenderMode(cfg.Mode) {
 	case types.PessimisticProofMode:
-		commonFlowComponents, err := createCommonComponents(
-			ctx, cfg, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier, 0, false,
+		commonFlowComponents, err := CreateCommonFlowComponents(
+			ctx, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier, 0, false,
+			cfg.MaxCertSize, cfg.RollupCreationBlockL1, cfg.DelayBetweenRetries.Duration, cfg.AggsenderPrivateKey,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create common flow components: %w", err)
 		}
 
 		return NewPPFlow(
 			logger,
-			commonFlowComponents.baseFlow,
+			commonFlowComponents.BaseFlow,
 			storage,
-			commonFlowComponents.l1InfoTreeDataQuerier,
-			commonFlowComponents.l2BridgeQuerier,
-			commonFlowComponents.signer,
+			commonFlowComponents.L1InfoTreeDataQuerier,
+			commonFlowComponents.L2BridgeQuerier,
+			commonFlowComponents.Signer,
 			cfg.RequireOneBridgeInPPCertificate,
 			cfg.MaxL2BlockNumber,
 		), nil
 	case types.AggchainProofMode:
-		if err := cfg.AggkitProverClient.Validate(); err != nil {
-			return nil, fmt.Errorf("invalid aggkit prover client config: %w", err)
-		}
-
 		aggchainProofClient, err := aggchainproofclient.NewAggchainProofClient(cfg.AggkitProverClient)
 		if err != nil {
 			return nil, fmt.Errorf("aggchainProverFlow - error creating aggkit prover client: %w", err)
@@ -76,9 +73,10 @@ func NewFlow(
 			return nil, fmt.Errorf("aggchainProverFlow - error creating aggchain FEP querier: %w", err)
 		}
 
-		commonFlowComponents, err := createCommonComponents(
-			ctx, cfg, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier,
+		commonFlowComponents, err := CreateCommonFlowComponents(
+			ctx, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier,
 			aggchainFEPQuerier.StartL2Block(), cfg.RequireNoFEPBlockGap,
+			cfg.MaxCertSize, cfg.RollupCreationBlockL1, cfg.DelayBetweenRetries.Duration, cfg.AggsenderPrivateKey,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create common flow components: %w", err)
@@ -89,27 +87,24 @@ func NewFlow(
 			return nil, fmt.Errorf("failed to create L2 GER reader: %w", err)
 		}
 
-		gerQuerier := query.NewGERDataQuerier(commonFlowComponents.l1InfoTreeDataQuerier, l2GERReader)
-
 		aggchainProofQuerier := query.NewAggchainProofQuery(
 			logger,
 			aggchainProofClient,
-			commonFlowComponents.l1InfoTreeDataQuerier,
+			commonFlowComponents.L1InfoTreeDataQuerier,
 			optimisticSigner,
-			commonFlowComponents.baseFlow,
-			gerQuerier,
+			commonFlowComponents.BaseFlow,
+			query.NewGERDataQuerier(commonFlowComponents.L1InfoTreeDataQuerier, l2GERReader),
 		)
 
 		return NewAggchainProverFlow(
 			logger,
 			NewAggchainProverFlowConfig(cfg.MaxL2BlockNumber),
-			commonFlowComponents.baseFlow,
+			commonFlowComponents.BaseFlow,
 			storage,
-			commonFlowComponents.l1InfoTreeDataQuerier,
-			commonFlowComponents.l2BridgeQuerier,
-			gerQuerier,
+			commonFlowComponents.L1InfoTreeDataQuerier,
+			commonFlowComponents.L2BridgeQuerier,
 			l1Client,
-			commonFlowComponents.signer,
+			commonFlowComponents.Signer,
 			optimisticModeQuerier,
 			aggchainProofQuerier,
 		), nil
@@ -119,17 +114,16 @@ func NewFlow(
 	}
 }
 
-type commonFlowComponents struct {
-	l2BridgeQuerier       types.BridgeQuerier
-	l1InfoTreeDataQuerier types.L1InfoTreeDataQuerier
-	lerQuerier            types.LERQuerier
-	baseFlow              types.AggsenderFlowBaser
-	signer                signerTypes.Signer
+type CommonFlowComponents struct {
+	L2BridgeQuerier       types.BridgeQuerier
+	L1InfoTreeDataQuerier types.L1InfoTreeDataQuerier
+	LERQuerier            types.LERQuerier
+	BaseFlow              types.AggsenderFlowBaser
+	Signer                signertypes.Signer
 }
 
-func createCommonComponents(
+func CreateCommonFlowComponents(
 	ctx context.Context,
-	cfg config.Config,
 	logger *log.Logger,
 	storage db.AggSenderStorage,
 	l1Client aggkittypes.BaseEthereumClienter,
@@ -138,35 +132,39 @@ func createCommonComponents(
 	rollupDataQuerier types.RollupDataQuerier,
 	startL2Block uint64,
 	requireNoFEPBlockGap bool,
-) (commonFlowComponents, error) {
-	signer, err := initializeSigner(ctx, cfg.AggsenderPrivateKey, logger)
+	maxCertSize uint,
+	rollupCreationBlockL1 uint64,
+	delayBetweenRetries time.Duration,
+	signerCfg signertypes.SignerConfig,
+) (*CommonFlowComponents, error) {
+	signer, err := initializeSigner(ctx, signerCfg, logger)
 	if err != nil {
-		return commonFlowComponents{}, err
+		return nil, err
 	}
 
-	l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, cfg.DelayBetweenRetries.Duration)
+	l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, delayBetweenRetries)
 	l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
-	lerQuerier := query.NewLERDataQuerier(cfg.RollupCreationBlockL1, rollupDataQuerier)
+	lerQuerier := query.NewLERDataQuerier(rollupCreationBlockL1, rollupDataQuerier)
 
 	baseFlow := NewBaseFlow(
 		logger, l2BridgeQuerier, storage, l1InfoTreeQuerier, lerQuerier,
-		NewBaseFlowConfig(cfg.MaxCertSize, startL2Block, requireNoFEPBlockGap),
+		NewBaseFlowConfig(maxCertSize, startL2Block, requireNoFEPBlockGap),
 	)
 
-	return commonFlowComponents{
-		l2BridgeQuerier:       l2BridgeQuerier,
-		l1InfoTreeDataQuerier: l1InfoTreeQuerier,
-		lerQuerier:            lerQuerier,
-		baseFlow:              baseFlow,
-		signer:                signer,
+	return &CommonFlowComponents{
+		L2BridgeQuerier:       l2BridgeQuerier,
+		L1InfoTreeDataQuerier: l1InfoTreeQuerier,
+		LERQuerier:            lerQuerier,
+		BaseFlow:              baseFlow,
+		Signer:                signer,
 	}, nil
 }
 
 func initializeSigner(
 	ctx context.Context,
-	signerCfg signerTypes.SignerConfig,
+	signerCfg signertypes.SignerConfig,
 	logger *log.Logger,
-) (signerTypes.Signer, error) {
+) (signertypes.Signer, error) {
 	signer, err := signer.NewSigner(ctx, 0, signerCfg, aggkitcommon.AGGSENDER, logger)
 	if err != nil {
 		return nil, fmt.Errorf("error NewSigner. Err: %w", err)

aggsender/flows/factory_test.go

@@ -48,14 +48,6 @@ func TestNewFlow(t *testing.T) {
 			},
 			expectedError: "error signer.Initialize",
 		},
-		{
-			name: "error missing AggkitProverClient in AggchainProofMode",
-			cfg: config.Config{
-				Mode:                string(types.AggchainProofMode),
-				AggsenderPrivateKey: signertypes.SignerConfig{Method: signertypes.MethodNone},
-			},
-			expectedError: "invalid aggkit prover client config: gRPC client configuration cannot be nil",
-		},
 		{
 			name: "unsupported Aggsender mode",
 			cfg: config.Config{

aggsender/flows/flow_aggchain_prover.go

@@ -15,6 +15,8 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+var _ types.AggsenderFlow = (*AggchainProverFlow)(nil)
+
 // AggchainProverFlow is a struct that holds the logic for the AggchainProver prover type flow
 type AggchainProverFlow struct {
 	baseFlow types.AggsenderFlowBaser
@@ -24,7 +26,6 @@ type AggchainProverFlow struct {
 	l1InfoTreeDataQuerier types.L1InfoTreeDataQuerier
 	l2BridgeQuerier       types.BridgeQuerier
 
-	gerQuerier            types.GERQuerier
 	certificateSigner     signertypes.Signer
 	optimisticModeQuerier types.OptimisticModeQuerier
 	aggchainProofQuerier  types.AggchainProofQuerier
@@ -77,7 +78,6 @@ func NewAggchainProverFlow(
 	storage db.AggSenderStorage,
 	l1InfoTreeQuerier types.L1InfoTreeDataQuerier,
 	l2BridgeQuerier types.BridgeQuerier,
-	gerQuerier types.GERQuerier,
 	l1Client aggkittypes.BaseEthereumClienter,
 	signer signertypes.Signer,
 	optimisticModeQuerier types.OptimisticModeQuerier,
@@ -94,7 +94,6 @@ func NewAggchainProverFlow(
 		storage:               storage,
 		l1InfoTreeDataQuerier: l1InfoTreeQuerier,
 		l2BridgeQuerier:       l2BridgeQuerier,
-		gerQuerier:            gerQuerier,
 		config:                aggChainProverConfig,
 		certificateSigner:     signer,
 		optimisticModeQuerier: optimisticModeQuerier,
@@ -144,9 +143,25 @@ func (a *AggchainProverFlow) getCertificateTypeToGenerate() (types.CertificateTy
 	return types.CertificateTypeFEP, nil
 }
 
+// GeneratePreBuildParams generates the pre-build parameters for the AggchainProverFlow
+// Only used in aggsender validator
 func (a *AggchainProverFlow) GenerateBuildParams(ctx context.Context,
 	preParams *types.CertificatePreBuildParams) (*types.CertificateBuildParams, error) {
-	return nil, fmt.Errorf("aggchainProverFlow - GenerateBuildParams is not implemented")
+	if preParams == nil {
+		return nil, fmt.Errorf("ppFlow - preParams is nil")
+	}
+
+	params, err := a.baseFlow.GenerateBuildParams(ctx, *preParams)
+	if err != nil {
+		return nil, fmt.Errorf("ppFlow - error generating build params: %w", err)
+	}
+
+	// we do not limit the size of the certificate in FEP flow,
+	// it was already resized and limited by the prover when proposer called it
+	// when building the certificate, so the block range is already limited
+	// when it gets to the validator
+
+	return params, nil
 }
 
 // GetCertificateBuildParams returns the parameters to build a certificate
@@ -296,15 +311,19 @@ func (a *AggchainProverFlow) BuildCertificate(ctx context.Context,
 		return nil, fmt.Errorf("aggchainProverFlow - error building certificate: %w", err)
 	}
 
-	cert.AggchainData = &agglayertypes.AggchainDataProof{
-		Proof:          buildParams.AggchainProof.SP1StarkProof.Proof,
-		Version:        buildParams.AggchainProof.SP1StarkProof.Version,
-		Vkey:           buildParams.AggchainProof.SP1StarkProof.Vkey,
-		AggchainParams: buildParams.AggchainProof.AggchainParams,
-		Context:        buildParams.AggchainProof.Context,
-	}
+	if buildParams.AggchainProof != nil {
+		// this case can happen only when aggsender validator calls this function
+		// since the validator does not call the aggchain prover to get the proof
+		cert.AggchainData = &agglayertypes.AggchainDataProof{
+			Proof:          buildParams.AggchainProof.SP1StarkProof.Proof,
+			Version:        buildParams.AggchainProof.SP1StarkProof.Version,
+			Vkey:           buildParams.AggchainProof.SP1StarkProof.Vkey,
+			AggchainParams: buildParams.AggchainProof.AggchainParams,
+			Context:        buildParams.AggchainProof.Context,
+		}
 
-	cert.CustomChainData = buildParams.AggchainProof.CustomChainData
+		cert.CustomChainData = buildParams.AggchainProof.CustomChainData
+	}
 
 	signedCert, err := a.signCertificate(ctx, cert)
 	if err != nil {
@@ -381,3 +400,17 @@ func (a *AggchainProverFlow) signCertificate(
 
 	return cert, nil
 }
+
+// ValidateCertificate validates the certificate for the FEP specific things
+func (a *AggchainProverFlow) ValidateCertificate(ctx context.Context, cert *agglayertypes.Certificate) error {
+	if cert == nil {
+		return fmt.Errorf("aggchainProverFlow - ValidateCertificate - certificate is nil")
+	}
+
+	_, ok := cert.AggchainData.(*agglayertypes.AggchainDataProof)
+	if !ok {
+		return fmt.Errorf("aggchainProverFlow - ValidateCertificate - AggchainData is not of type AggchainDataProof")
+	}
+
+	return nil
+}

aggsender/flows/flow_aggchain_prover_optimistic_test.go

@@ -107,7 +107,6 @@ type AggchainProverFlowTestData struct {
 	mockStorage               *mocks.AggSenderStorage
 	mockL2BridgeQuerier       *mocks.BridgeQuerier
 	mockL1InfoTreeQuerier     *mocks.L1InfoTreeDataQuerier
-	mockGERQuerier            *mocks.GERQuerier
 	mockL1Client              *aggkittypesmocks.BaseEthereumClienter
 	mockOptimisticModeQuerier *mocks.OptimisticModeQuerier
 	mockSigner                *mocks.Signer
@@ -125,7 +124,6 @@ func NewAggchainProverFlowTestData(t *testing.T, cfgBase BaseFlowConfig) *Aggcha
 		mockStorage:               mocks.NewAggSenderStorage(t),
 		mockL2BridgeQuerier:       mocks.NewBridgeQuerier(t),
 		mockL1InfoTreeQuerier:     mocks.NewL1InfoTreeDataQuerier(t),
-		mockGERQuerier:            mocks.NewGERQuerier(t),
 		mockL1Client:              aggkittypesmocks.NewBaseEthereumClienter(t),
 		mockOptimisticModeQuerier: mocks.NewOptimisticModeQuerier(t),
 		mockSigner:                mocks.NewSigner(t),
@@ -144,7 +142,6 @@ func NewAggchainProverFlowTestData(t *testing.T, cfgBase BaseFlowConfig) *Aggcha
 		res.mockStorage,
 		res.mockL1InfoTreeQuerier,
 		res.mockL2BridgeQuerier,
-		res.mockGERQuerier,
 		res.mockL1Client,
 		res.mockSigner,
 		res.mockOptimisticModeQuerier,