feat: decouple aggsender-validator from metadata field

aggsender/aggsender.go

@@ -41,6 +41,8 @@ type AggSender struct {
 	aggLayerClient               agglayer.AgglayerClientInterface
 	compatibilityStoragedChecker compatibility.CompatibilityChecker
 	certStatusChecker            types.CertificateStatusChecker
+	certQuerier                  types.CertificateQuerier
+	rollupDataQuerier            types.RollupDataQuerier
 
 	cfg config.Config
 
@@ -126,6 +128,7 @@ func New(
 		rateLimiter:                  rateLimit,
 		compatibilityStoragedChecker: compatibilityStoragedChecker,
 		l2OriginNetwork:              l2OriginNetwork,
+		certQuerier:                  certQuerier,
 		certStatusChecker: statuschecker.NewCertStatusChecker(
 			logger, storage, aggLayerClient, certQuerier, l2OriginNetwork),
 	}, nil
@@ -149,6 +152,14 @@ func (a *AggSender) GetFlow() types.AggsenderFlow {
 	return a.flow
 }
 
+func (a *AggSender) GetCertQuerier() types.CertificateQuerier {
+	return a.certQuerier
+}
+
+func (a *AggSender) GetLERQuerier() types.LERQuerier {
+	return query.NewLERDataQuerier(a.cfg.RollupCreationBlockL1, a.rollupDataQuerier)
+}
+
 func (a *AggSender) Info() types.AggsenderInfo {
 	res := types.AggsenderInfo{
 		AggsenderStatus:          *a.status,

aggsender/aggsender_validator.go

@@ -34,9 +34,11 @@ func NewAggsenderValidator(ctx context.Context,
 	flowPP 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)
+		logger, flowPP, l1InfoTreeDataQuerier, certQuerier, lerQuerier)
 	grpcServer, err := grpc.NewServer(cfg.ServerConfig)
 	if err != nil {
 		return nil, err

aggsender/aggsender_validator_test.go

@@ -23,7 +23,7 @@ func TestNewAggsenderValidator(t *testing.T) {
 	}
 	// Call the function
 	validator, err := NewAggsenderValidator(ctx, mockLogger, cfg, mockFlowPP, mockL1InfoTreeDataQuerier,
-		mockAggLayerClient, nil)
+		mockAggLayerClient, nil, nil, nil)
 
 	// Assertions
 	require.NoError(t, err, "Expected no error when creating AggsenderValidator")

aggsender/converters/cert_header_converter.go

@@ -5,20 +5,27 @@ import (
 
 	agglayertypes "github.com/agglayer/aggkit/agglayer/types"
 	"github.com/agglayer/aggkit/aggsender/types"
+	aggkitcommon "github.com/agglayer/aggkit/common"
 )
 
 // ConvertAgglayerCertHeaderToAggsender converts an agglayer CertificateHeader to an aggsender CertificateHeader
 func ConvertAgglayerCertHeaderToAggsender(cert *agglayertypes.CertificateHeader) (*types.CertificateHeader, error) {
 	if cert == nil {
 		return nil, nil
 	}
-	metadataUnmarshal, err := types.NewCertificateMetadataFromHash(cert.Metadata)
-	if err != nil {
-		return nil, fmt.Errorf("error parsing cert metadata. Err: %w", err)
-	}
-	blockRange, err := metadataUnmarshal.BlockRange()
-	if err != nil {
-		return nil, fmt.Errorf("cant get blockRange from certificate metadata. Err: %w", err)
+
+	blockRange := types.BlockRangeZero
+	if cert.Metadata != aggkitcommon.ZeroHash {
+		// TODO - remove this once we completely decouple metadata from the certificate
+		metadataUnmarshal, err := types.NewCertificateMetadataFromHash(cert.Metadata)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing cert metadata. Err: %w", err)
+		}
+		br, err := metadataUnmarshal.BlockRange()
+		if err != nil {
+			return nil, fmt.Errorf("cant get blockRange from certificate metadata. Err: %w", err)
+		}
+		blockRange = br
 	}
 
 	return &types.CertificateHeader{
@@ -33,7 +40,6 @@ func ConvertAgglayerCertHeaderToAggsender(cert *agglayertypes.CertificateHeader)
 		CreatedAt:               0,
 		UpdatedAt:               0,
 		FinalizedL1InfoTreeRoot: nil,
-		CertType:                metadataUnmarshal.CertificateType(),
 		CertSource:              types.CertificateSourceAggLayer,
 	}, nil
 }

aggsender/converters/cert_header_converter_test.go

@@ -27,17 +27,6 @@ func TestAgglayerCertificateHeaderToAggsender(t *testing.T) {
 		require.ErrorContains(t, err, "unsupported certificate metadata")
 	})
 
-	t.Run("Can't get blockRange'", func(t *testing.T) {
-		badMetadata := make([]byte, common.HashLength)
-		badMetadata[0] = 0x0 // Version = 0x0 doesn't have blockrange
-		cert := &agglayertypes.CertificateHeader{
-			Metadata: common.Hash(badMetadata),
-		}
-		result, err := ConvertAgglayerCertHeaderToAggsender(cert)
-		require.Nil(t, result)
-		require.Error(t, err)
-	})
-
 	t.Run("ok", func(t *testing.T) {
 		badMetadata := make([]byte, common.HashLength)
 		badMetadata[0] = 0x1 // Version = 0xff

aggsender/flows/factory.go

@@ -37,32 +37,20 @@ func NewFlow(
 ) (types.AggsenderFlow, error) {
 	switch types.AggsenderMode(cfg.Mode) {
 	case types.PessimisticProofMode:
-		signer, err := initializeSigner(ctx, cfg.AggsenderPrivateKey, logger)
-		if err != nil {
-			return nil, err
-		}
-		logger.Infof("Initializing RollupManager contract at address: %s. Genesis block: %d",
-			cfg.RollupManagerAddr, cfg.RollupCreationBlockL1)
-		lerQuerier, err := query.NewLERDataQuerier(
-			cfg.RollupManagerAddr, cfg.RollupCreationBlockL1, rollupDataQuerier)
+		commonFlowComponents, err := createCommonComponents(
+			ctx, cfg, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier, 0, false,
+		)
 		if err != nil {
-			return nil, fmt.Errorf("error creating LER data querier: %w", err)
+			return nil, fmt.Errorf("failed to create common flow components: %w", err)
 		}
 
-		l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, cfg.DelayBetweenRetries.Duration)
-		l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
-		logger.Infof("Aggsender signer address: %s", signer.PublicAddress().Hex())
-		baseFlow := NewBaseFlow(
-			logger, l2BridgeQuerier, storage, l1InfoTreeQuerier, lerQuerier,
-			NewBaseFlowConfig(cfg.MaxCertSize, 0, false),
-		)
 		return NewPPFlow(
 			logger,
-			baseFlow,
+			commonFlowComponents.baseFlow,
 			storage,
-			l1InfoTreeQuerier,
-			l2BridgeQuerier,
-			signer,
+			commonFlowComponents.l1InfoTreeDataQuerier,
+			commonFlowComponents.l2BridgeQuerier,
+			commonFlowComponents.signer,
 			cfg.RequireOneBridgeInPPCertificate,
 			cfg.MaxL2BlockNumber,
 		), nil
@@ -71,69 +59,57 @@ func NewFlow(
 			return nil, fmt.Errorf("invalid aggkit prover client config: %w", err)
 		}
 
-		signer, err := initializeSigner(ctx, cfg.AggsenderPrivateKey, logger)
-		if err != nil {
-			return nil, err
-		}
-		logger.Infof("Aggsender signer address: %s", signer.PublicAddress().Hex())
-
 		aggchainProofClient, err := aggchainproofclient.NewAggchainProofClient(cfg.AggkitProverClient)
 		if err != nil {
 			return nil, fmt.Errorf("aggchainProverFlow - error creating aggkit prover client: %w", err)
 		}
 
-		l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
-
 		optimisticSigner, optimisticModeQuerier, err := optimistic.NewOptimistic(
 			ctx, logger, l1Client, cfg.OptimisticModeConfig)
 		if err != nil {
 			return nil, fmt.Errorf("aggchainProverFlow - error creating optimistic mode querier: %w", err)
 		}
 
-		lerQuerier, err := query.NewLERDataQuerier(
-			cfg.RollupManagerAddr, cfg.RollupCreationBlockL1, rollupDataQuerier)
-		if err != nil {
-			return nil, fmt.Errorf("aggchainProverFlow - error creating LER data querier: %w", err)
-		}
-
 		aggchainFEPQuerier, err := query.NewAggchainFEPQuerier(logger, types.AggchainProofMode,
 			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, aggchainFEPQuerier.StartL2Block(), cfg.RequireNoFEPBlockGap),
+		commonFlowComponents, err := createCommonComponents(
+			ctx, cfg, logger, storage, l1Client, l1InfoTreeSyncer, l2Syncer, rollupDataQuerier,
+			aggchainFEPQuerier.StartL2Block(), cfg.RequireNoFEPBlockGap,
 		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create common flow components: %w", err)
+		}
 
 		l2GERReader, err := l2GERReaderFactory(cfg.GlobalExitRootL2Addr, l2Client, l1InfoTreeSyncer)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create L2 GER reader: %w", err)
 		}
 
-		gerQuerier := query.NewGERDataQuerier(l1InfoTreeQuerier, l2GERReader)
+		gerQuerier := query.NewGERDataQuerier(commonFlowComponents.l1InfoTreeDataQuerier, l2GERReader)
 
 		aggchainProofQuerier := query.NewAggchainProofQuery(
 			logger,
 			aggchainProofClient,
-			l1InfoTreeQuerier,
+			commonFlowComponents.l1InfoTreeDataQuerier,
 			optimisticSigner,
-			baseFlow,
+			commonFlowComponents.baseFlow,
 			gerQuerier,
 		)
 
 		return NewAggchainProverFlow(
 			logger,
 			NewAggchainProverFlowConfig(cfg.MaxL2BlockNumber),
-			baseFlow,
+			commonFlowComponents.baseFlow,
 			storage,
-			l1InfoTreeQuerier,
-			l2BridgeQuerier,
+			commonFlowComponents.l1InfoTreeDataQuerier,
+			commonFlowComponents.l2BridgeQuerier,
 			gerQuerier,
 			l1Client,
-			signer,
+			commonFlowComponents.signer,
 			optimisticModeQuerier,
 			aggchainProofQuerier,
 		), nil
@@ -143,6 +119,49 @@ func NewFlow(
 	}
 }
 
+type commonFlowComponents struct {
+	l2BridgeQuerier       types.BridgeQuerier
+	l1InfoTreeDataQuerier types.L1InfoTreeDataQuerier
+	lerQuerier            types.LERQuerier
+	baseFlow              types.AggsenderFlowBaser
+	signer                signerTypes.Signer
+}
+
+func createCommonComponents(
+	ctx context.Context,
+	cfg config.Config,
+	logger *log.Logger,
+	storage db.AggSenderStorage,
+	l1Client aggkittypes.BaseEthereumClienter,
+	l1InfoTreeSyncer types.L1InfoTreeSyncer,
+	l2Syncer types.L2BridgeSyncer,
+	rollupDataQuerier types.RollupDataQuerier,
+	startL2Block uint64,
+	requireNoFEPBlockGap bool,
+) (commonFlowComponents, error) {
+	signer, err := initializeSigner(ctx, cfg.AggsenderPrivateKey, logger)
+	if err != nil {
+		return commonFlowComponents{}, err
+	}
+
+	l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, cfg.DelayBetweenRetries.Duration)
+	l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
+	lerQuerier := query.NewLERDataQuerier(cfg.RollupCreationBlockL1, rollupDataQuerier)
+
+	baseFlow := NewBaseFlow(
+		logger, l2BridgeQuerier, storage, l1InfoTreeQuerier, lerQuerier,
+		NewBaseFlowConfig(cfg.MaxCertSize, startL2Block, requireNoFEPBlockGap),
+	)
+
+	return commonFlowComponents{
+		l2BridgeQuerier:       l2BridgeQuerier,
+		l1InfoTreeDataQuerier: l1InfoTreeQuerier,
+		lerQuerier:            lerQuerier,
+		baseFlow:              baseFlow,
+		signer:                signer,
+	}, nil
+}
+
 func initializeSigner(
 	ctx context.Context,
 	signerCfg signerTypes.SignerConfig,

aggsender/flows/factory_test.go

@@ -48,17 +48,6 @@ func TestNewFlow(t *testing.T) {
 			},
 			expectedError: "error signer.Initialize",
 		},
-		{
-			name: "error creating signer in AggchainProofMode",
-			cfg: config.Config{
-				Mode: string(types.AggchainProofMode),
-				AggsenderPrivateKey: signertypes.SignerConfig{
-					Method: signertypes.MethodLocal,
-				},
-				AggkitProverClient: aggkitgrpc.DefaultConfig(),
-			},
-			expectedError: "error signer.Initialize",
-		},
 		{
 			name: "error missing AggkitProverClient in AggchainProofMode",
 			cfg: config.Config{

aggsender/flows/flow_aggchain_prover_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/agglayer/aggkit/aggsender/query"
 	"github.com/agglayer/aggkit/aggsender/types"
 	"github.com/agglayer/aggkit/bridgesync"
+	aggkitcommon "github.com/agglayer/aggkit/common"
 	"github.com/agglayer/aggkit/log"
 	treetypes "github.com/agglayer/aggkit/tree/types"
 	aggkittypesmocks "github.com/agglayer/aggkit/types/mocks"
@@ -556,7 +557,7 @@ func Test_AggchainProverFlow_BuildCertificate(t *testing.T) {
 				Height:              0,
 				NewLocalExitRoot:    types.EmptyLER,
 				CustomChainData:     []byte("some-data"),
-				Metadata:            types.NewCertificateMetadata(1, 9, uint32(createdAt.Unix()), types.CertificateTypeFEP.ToInt()).ToHash(),
+				Metadata:            aggkitcommon.ZeroHash,
 				BridgeExits:         []*agglayertypes.BridgeExit{},
 				ImportedBridgeExits: []*agglayertypes.ImportedBridgeExit{},
 				PrevLocalExitRoot:   types.EmptyLER,

aggsender/flows/flow_base.go

@@ -280,21 +280,14 @@ func (f *baseFlow) BuildCertificate(ctx context.Context,
 		return nil, fmt.Errorf("error getting new local exit root: %w", err)
 	}
 
-	meta := types.NewCertificateMetadata(
-		certParams.FromBlock,
-		uint32(certParams.ToBlock-certParams.FromBlock),
-		certParams.CreatedAt,
-		certParams.CertificateType.ToInt(),
-	)
-
 	return &agglayertypes.Certificate{
 		NetworkID:           f.l2BridgeQuerier.OriginNetwork(),
 		PrevLocalExitRoot:   previousLER,
 		NewLocalExitRoot:    newLER,
 		BridgeExits:         bridgeExits,
 		ImportedBridgeExits: importedBridgeExits,
 		Height:              height,
-		Metadata:            meta.ToHash(),
+		Metadata:            aggkitcommon.ZeroHash, // Metadata is deprecated, but will be kept as ZeroHash
 		L1InfoTreeLeafCount: certParams.L1InfoTreeLeafCount,
 	}, nil
 }
@@ -339,25 +332,11 @@ func (f *baseFlow) getImportedBridgeExits(
 		ctx, claims, rootFromWhichToProve, f.l1InfoTreeDataQuerier)
 }
 
-// getStartLER returns the last local exit root (LER) based on the configuration
-func (f *baseFlow) getStartLER() (common.Hash, error) {
-	ler, err := f.lerQuerier.GetLastLocalExitRoot()
-	if err != nil {
-		return common.Hash{}, fmt.Errorf("error getting last local exit root: %w", err)
-	}
-
-	if ler == aggkitcommon.ZeroHash {
-		return types.EmptyLER, nil
-	}
-
-	return ler, nil
-}
-
 // getNextHeightAndPreviousLER returns the height and previous LER for the new certificate
 func (f *baseFlow) getNextHeightAndPreviousLER(
 	lastSentCertificateInfo *types.CertificateHeader) (uint64, common.Hash, error) {
 	if lastSentCertificateInfo == nil {
-		ler, err := f.getStartLER()
+		ler, err := f.lerQuerier.GetLastLocalExitRoot()
 		return uint64(0), ler, err
 	}
 	if !lastSentCertificateInfo.Status.IsClosed() {
@@ -375,7 +354,7 @@ func (f *baseFlow) getNextHeightAndPreviousLER(
 		}
 		// Is the first one, so we can set the zeroLER
 		if lastSentCertificateInfo.Height == 0 {
-			ler, err := f.getStartLER()
+			ler, err := f.lerQuerier.GetLastLocalExitRoot()
 			return uint64(0), ler, err
 		}
 		// We get previous certificate that must be settled