feat: add aggchain params verification

aggsender/aggsender.go

@@ -53,7 +53,7 @@ type AggSender struct {
 	cfg config.Config
 
 	status *types.AggsenderStatus
-	flow   types.AggsenderFlow
+	flow   types.AggsenderBuilderFlow
 
 	l2OriginNetwork uint32
 }
@@ -92,7 +92,7 @@ func New(
 		return nil, err
 	}
 
-	flowManager, err := flows.NewFlow(
+	flowManager, err := flows.NewBuilderFlow(
 		ctx,
 		cfg,
 		logger,
@@ -132,12 +132,22 @@ func New(
 		aggLayerClient,
 	)
 
+	verifierFlow, err := flows.NewLocalVerifier(
+		ctx,
+		cfg,
+		l1Client,
+		flowManager,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error creating verifier flow: %w", err)
+	}
+
 	localValidator := validator.NewLocalValidator(
 		logger,
 		storage,
 		validator.NewAggsenderValidator(
 			logger,
-			flowManager,
+			verifierFlow,
 			query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer),
 			certQuerier,
 			query.NewLERDataQuerier(cfg.RollupCreationBlockL1, rollupDataQuerier),

aggsender/aggsender_test.go

@@ -228,7 +228,7 @@ func TestSendCertificate_NoClaims(t *testing.T) {
 		cfg:             config.Config{},
 		validatorPoller: mockValidatorPoller,
 		localValidator:  mockLocalValidator,
-		flow: flows.NewPPFlow(logger,
+		flow: flows.NewPPBuilderFlow(logger,
 			flows.NewBaseFlow(logger, mockL2BridgeQuerier, mockStorage,
 				mockL1Querier, mockLERQuerier, flows.NewBaseFlowConfigDefault()),
 			mockStorage, mockL1Querier, mockL2BridgeQuerier, signer, true, 0),
@@ -281,14 +281,14 @@ func TestSendCertificate(t *testing.T) {
 
 	testCases := []struct {
 		name            string
-		mockFn          func(*mocks.AggSenderStorage, *mocks.AggsenderFlow, *agglayermocks.AgglayerClientMock)
+		mockFn          func(*mocks.AggSenderStorage, *mocks.AggsenderBuilderFlow, *agglayermocks.AgglayerClientMock)
 		mockValidatorFn func() (*mocks.ValidatorPoller, *mocks.CertificateValidateAndSigner)
 		expectedError   string
 	}{
 		{
 			name: "error getting certificate build params",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(nil, errors.New("some error")).Once()
 			},
@@ -297,15 +297,15 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "no new blocks consumed",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(nil, nil).Once()
 			},
 		},
 		{
 			name: "error building certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -317,7 +317,7 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "error sending certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -347,7 +347,7 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "error saving certificate to storage",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -377,7 +377,7 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "error getting validator signature",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -403,7 +403,7 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "successful validation and sending of a certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -432,7 +432,7 @@ func TestSendCertificate(t *testing.T) {
 		{
 			name: "successful sending and saving of a certificate",
 			mockFn: func(mockStorage *mocks.AggSenderStorage,
-				mockFlow *mocks.AggsenderFlow,
+				mockFlow *mocks.AggsenderBuilderFlow,
 				mockAgglayerClient *agglayermocks.AgglayerClientMock) {
 				mockFlow.EXPECT().GetCertificateBuildParams(mock.Anything).Return(&aggsendertypes.CertificateBuildParams{
 					Bridges: []bridgesync.Bridge{{}},
@@ -465,7 +465,7 @@ func TestSendCertificate(t *testing.T) {
 			t.Parallel()
 
 			mockStorage := mocks.NewAggSenderStorage(t)
-			mockAggsenderFlow := mocks.NewAggsenderFlow(t)
+			mockAggsenderFlow := mocks.NewAggsenderBuilderFlow(t)
 			mockAgglayerClient := agglayermocks.NewAgglayerClientMock(t)
 			mockEpochNotifier := mocks.NewEpochNotifier(t)
 			tt.mockFn(mockStorage, mockAggsenderFlow, mockAgglayerClient)
@@ -560,7 +560,7 @@ func TestSendCertificatesRetry(t *testing.T) {
 	mockCertStatusChecker := mocks.NewCertificateStatusChecker(t)
 	mockEpochNotifier := mocks.NewEpochNotifier(t)
 	mockStorage := mocks.NewAggSenderStorage(t)
-	mockFlow := mocks.NewAggsenderFlow(t)
+	mockFlow := mocks.NewAggsenderBuilderFlow(t)
 
 	logger := log.WithFields("aggsender-test", "TestSendCertificatesRetry")
 	aggSender := &AggSender{
@@ -612,20 +612,20 @@ func TestSendCertificates(t *testing.T) {
 
 	tests := []struct {
 		name                    string
-		mockFn                  func(*mocks.CertificateStatusChecker, *mocks.EpochNotifier, *mocks.AggSenderStorage, *mocks.AggsenderFlow)
+		mockFn                  func(*mocks.CertificateStatusChecker, *mocks.EpochNotifier, *mocks.AggSenderStorage, *mocks.AggsenderBuilderFlow)
 		returnAfterNIterations  int
 		certStatusCheckInterval time.Duration
 	}{
 		{
 			name: "context canceled",
-			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderFlow) {
+			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderBuilderFlow) {
 				mockEpochNotifier.EXPECT().Subscribe("aggsender").Return(make(chan aggsendertypes.EpochEvent)).Once()
 			},
 			returnAfterNIterations: 0,
 		},
 		{
 			name: "retry certificate after in-error",
-			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderFlow) {
+			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderBuilderFlow) {
 				mockCertStatusChecker.EXPECT().CheckPendingCertificatesStatus(mock.Anything).Return(aggsendertypes.CertStatus{
 					ExistPendingCerts:   false,
 					ExistNewInErrorCert: true,
@@ -639,7 +639,7 @@ func TestSendCertificates(t *testing.T) {
 		},
 		{
 			name: "epoch received with no pending certificates",
-			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderFlow) {
+			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderBuilderFlow) {
 				chEpoch := make(chan aggsendertypes.EpochEvent, 1)
 				chEpoch <- aggsendertypes.EpochEvent{Epoch: 1}
 				mockEpochNotifier.EXPECT().Subscribe("aggsender").Return(chEpoch).Once()
@@ -653,7 +653,7 @@ func TestSendCertificates(t *testing.T) {
 		},
 		{
 			name: "epoch received with pending certificates",
-			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderFlow) {
+			mockFn: func(mockCertStatusChecker *mocks.CertificateStatusChecker, mockEpochNotifier *mocks.EpochNotifier, mockStorage *mocks.AggSenderStorage, mockFlow *mocks.AggsenderBuilderFlow) {
 				chEpoch := make(chan aggsendertypes.EpochEvent, 1)
 				chEpoch <- aggsendertypes.EpochEvent{Epoch: 1}
 				mockEpochNotifier.EXPECT().Subscribe("aggsender").Return(chEpoch).Once()
@@ -674,7 +674,7 @@ func TestSendCertificates(t *testing.T) {
 			mockCertStatusChecker := mocks.NewCertificateStatusChecker(t)
 			mockEpochNotifier := mocks.NewEpochNotifier(t)
 			mockStorage := mocks.NewAggSenderStorage(t)
-			mockFlow := mocks.NewAggsenderFlow(t)
+			mockFlow := mocks.NewAggsenderBuilderFlow(t)
 
 			tt.mockFn(mockCertStatusChecker, mockEpochNotifier, mockStorage, mockFlow)
 
@@ -727,7 +727,7 @@ type aggsenderTestData struct {
 	l2BridgeQuerier         *mocks.BridgeQuerier
 	storageMock             *mocks.AggSenderStorage
 	epochNotifierMock       *mocks.EpochNotifier
-	flowMock                *mocks.AggsenderFlow
+	flowMock                *mocks.AggsenderBuilderFlow
 	compatibilityChekerMock *mocksdb.CompatibilityChecker
 	certStatusCheckerMock   *mocks.CertificateStatusChecker
 	sut                     *AggSender
@@ -805,14 +805,14 @@ func newAggsenderTestData(t *testing.T, creationFlags testDataFlags) *aggsenderT
 			DelayBetweenRetries: types.Duration{Duration: time.Millisecond},
 		},
 		epochNotifier: epochNotifierMock,
-		flow: flows.NewPPFlow(logger,
+		flow: flows.NewPPBuilderFlow(logger,
 			flows.NewBaseFlow(logger, l2BridgeQuerier, storage,
 				l1InfoTreeQuerierMock, lerQuerier, flows.NewBaseFlowConfigDefault()),
 			storage, l1InfoTreeQuerierMock, l2BridgeQuerier, signer, true, 0),
 	}
-	var flowMock *mocks.AggsenderFlow
+	var flowMock *mocks.AggsenderBuilderFlow
 	if creationFlags&testDataFlagMockFlow != 0 {
-		flowMock = mocks.NewAggsenderFlow(t)
+		flowMock = mocks.NewAggsenderBuilderFlow(t)
 		sut.flow = flowMock
 	}
 

aggsender/aggsender_validator.go

@@ -28,10 +28,11 @@ type AggsenderValidator struct {
 func NewAggsenderValidator(ctx context.Context,
 	logger aggkitcommon.Logger,
 	cfg validator.Config,
-	flow validator.FlowInterface,
+	flow types.AggsenderVerifierFlow,
 	l1InfoTreeDataQuerier validator.L1InfoTreeRootByLeafQuerier,
 	aggLayerClient agglayer.AggLayerClientCertificateIDQuerier,
 	certQuerier types.CertificateQuerier,
+	aggchainFEPQuerier types.AggchainFEPRollupQuerier,
 	lerQuerier types.LERQuerier,
 	signer signertypes.Signer) (*AggsenderValidator, error) {
 	validatorCert := validator.NewAggsenderValidator(

aggsender/flows/flow_aggchain_prover.go → aggsender/flows/builder_flow_aggchain_prover.go

@@ -15,10 +15,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-var _ types.AggsenderFlow = (*AggchainProverFlow)(nil)
+var _ types.AggsenderBuilderFlow = (*AggchainProverBuilderFlow)(nil)
 
-// AggchainProverFlow is a struct that holds the logic for the AggchainProver prover type flow
-type AggchainProverFlow struct {
+// AggchainProverBuilderFlow is a struct that holds the logic for the AggchainProver prover type flow
+type AggchainProverBuilderFlow struct {
 	baseFlow types.AggsenderFlowBaser
 
 	log                   types.Logger
@@ -69,9 +69,9 @@ func NewAggchainProverFlowConfig(
 	}
 }
 
-// NewAggchainProverFlow returns a new instance of the AggchainProverFlow injecting baseFlow instead of
+// NewAggchainProverBuilderFlow returns a new instance of the AggchainProverBuilderFlow injecting baseFlow instead of
 // creating it
-func NewAggchainProverFlow(
+func NewAggchainProverBuilderFlow(
 	log types.Logger,
 	aggChainProverConfig AggchainProverFlowConfig,
 	baseFlow types.AggsenderFlowBaser,
@@ -82,14 +82,14 @@ func NewAggchainProverFlow(
 	signer signertypes.Signer,
 	optimisticModeQuerier types.OptimisticModeQuerier,
 	aggchainProofQuerier types.AggchainProofQuerier,
-) *AggchainProverFlow {
+) *AggchainProverBuilderFlow {
 	feature := NewMaxL2BlockNumberLimiter(
 		aggChainProverConfig.maxL2BlockNumber,
 		log,
 		false, // AggchainProverFlow allows to resize retry certs
 		false, // AggchainProverFlow allows to send no bridges certs
 	)
-	return &AggchainProverFlow{
+	return &AggchainProverBuilderFlow{
 		log:                   log,
 		storage:               storage,
 		l1InfoTreeDataQuerier: l1InfoTreeQuerier,
@@ -105,7 +105,7 @@ func NewAggchainProverFlow(
 
 // CheckInitialStatus checks that initial status is correct.
 // For AggchainProverFlow checks that starting block and last certificate match
-func (a *AggchainProverFlow) CheckInitialStatus(ctx context.Context) error {
+func (a *AggchainProverBuilderFlow) CheckInitialStatus(ctx context.Context) error {
 	lastSentCertificate, err := a.storage.GetLastSentCertificateHeader()
 	if err != nil {
 		return fmt.Errorf("aggchainProverFlow - error getting last sent certificate: %w", err)
@@ -130,7 +130,7 @@ func (a *AggchainProverFlow) CheckInitialStatus(ctx context.Context) error {
 }
 
 // getCertificateTypeToGenerate returns the type of certificate to generate
-func (a *AggchainProverFlow) getCertificateTypeToGenerate() (types.CertificateType, error) {
+func (a *AggchainProverBuilderFlow) getCertificateTypeToGenerate() (types.CertificateType, error) {
 	// AggchainProverFlow only supports FEP certificates
 	optimisticMode, err := a.optimisticModeQuerier.IsOptimisticModeOn()
 	if err != nil {
@@ -145,7 +145,7 @@ func (a *AggchainProverFlow) getCertificateTypeToGenerate() (types.CertificateTy
 
 // GeneratePreBuildParams generates the pre-build parameters for the AggchainProverFlow
 // Only used in aggsender validator
-func (a *AggchainProverFlow) GenerateBuildParams(ctx context.Context,
+func (a *AggchainProverBuilderFlow) GenerateBuildParams(ctx context.Context,
 	preParams *types.CertificatePreBuildParams) (*types.CertificateBuildParams, error) {
 	if preParams == nil {
 		return nil, fmt.Errorf("aggchainProverFlow - preParams is nil")
@@ -169,7 +169,8 @@ func (a *AggchainProverFlow) GenerateBuildParams(ctx context.Context,
 // What differentiates this function from the regular PP flow is that,
 // if the last sent certificate is in error, we need to resend the exact same certificate
 // also, it calls the aggchain prover to get the aggchain proof
-func (a *AggchainProverFlow) GetCertificateBuildParams(ctx context.Context) (*types.CertificateBuildParams, error) {
+func (a *AggchainProverBuilderFlow) GetCertificateBuildParams(
+	ctx context.Context) (*types.CertificateBuildParams, error) {
 	lastSentCert, proof, err := a.storage.GetLastSentCertificateHeaderWithProofIfInError(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("aggchainProverFlow - error checking if last sent certificate is InError: %w", err)
@@ -269,7 +270,7 @@ func (a *AggchainProverFlow) GetCertificateBuildParams(ctx context.Context) (*ty
 
 // verifyBuildParams verifies the certificate build params and returns an error if they are not valid
 // it also calls the prover to get the aggchain proof
-func (a *AggchainProverFlow) verifyBuildParamsAndGenerateProof(
+func (a *AggchainProverBuilderFlow) verifyBuildParamsAndGenerateProof(
 	ctx context.Context, buildParams *types.CertificateBuildParams) (*types.CertificateBuildParams, error) {
 	if err := a.baseFlow.VerifyBuildParams(ctx, buildParams); err != nil {
 		return nil, fmt.Errorf("aggchainProverFlow - error verifying build params: %w", err)
@@ -304,7 +305,7 @@ func (a *AggchainProverFlow) verifyBuildParamsAndGenerateProof(
 
 // BuildCertificate builds a certificate based on the buildParams
 // this function is the implementation of the FlowManager interface
-func (a *AggchainProverFlow) BuildCertificate(ctx context.Context,
+func (a *AggchainProverBuilderFlow) BuildCertificate(ctx context.Context,
 	buildParams *types.CertificateBuildParams) (*agglayertypes.Certificate, error) {
 	cert, err := a.baseFlow.BuildCertificate(ctx, buildParams, buildParams.LastSentCertificate, true)
 	if err != nil {
@@ -329,7 +330,7 @@ func (a *AggchainProverFlow) BuildCertificate(ctx context.Context,
 }
 
 // UpdateAggchainData updates the AggchainData field in certificate with the multisig if provided.
-func (a *AggchainProverFlow) UpdateAggchainData(
+func (a *AggchainProverBuilderFlow) UpdateAggchainData(
 	cert *agglayertypes.Certificate,
 	multisig *agglayertypes.Multisig,
 ) error {
@@ -373,7 +374,8 @@ func adjustBlockRange(buildParams *types.CertificateBuildParams,
 	return buildParams, nil
 }
 
-func (a *AggchainProverFlow) getLastProvenBlock(fromBlock uint64, lastCertificate *types.CertificateHeader) uint64 {
+func (a *AggchainProverBuilderFlow) getLastProvenBlock(
+	fromBlock uint64, lastCertificate *types.CertificateHeader) uint64 {
 	if fromBlock == 0 {
 		// if this is the first certificate, we need to start from the starting L2 block
 		// that we got from the sovereign rollup
@@ -398,6 +400,6 @@ func (a *AggchainProverFlow) getLastProvenBlock(fromBlock uint64, lastCertificat
 }
 
 // Signer returns the signer used to sign the certificate
-func (a *AggchainProverFlow) Signer() signertypes.Signer {
+func (a *AggchainProverBuilderFlow) Signer() signertypes.Signer {
 	return a.certificateSigner
 }

aggsender/flows/flow_aggchain_prover_optimistic_test.go → aggsender/flows/builder_flow_aggchain_prover_optimistic_test.go

@@ -115,7 +115,7 @@ type AggchainProverFlowTestData struct {
 
 	ctx context.Context
 
-	sut *AggchainProverFlow
+	sut *AggchainProverBuilderFlow
 }
 
 func NewAggchainProverFlowTestData(t *testing.T, cfgBase BaseFlowConfig) *AggchainProverFlowTestData {
@@ -135,7 +135,7 @@ func NewAggchainProverFlowTestData(t *testing.T, cfgBase BaseFlowConfig) *Aggcha
 	// Simulate the access to baseFlow variables
 	res.mockFlowBase.EXPECT().StartL2Block().Return(cfgBase.StartL2Block).Maybe()
 
-	res.sut = NewAggchainProverFlow(
+	res.sut = NewAggchainProverBuilderFlow(
 		log.WithFields("flowManager", "AggchainProverFlowTestData"),
 		NewAggchainProverFlowConfigDefault(),
 		res.mockFlowBase,