feat: decouple validator from metadata

Author: goran-ethernal

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

@@ -43,12 +43,7 @@ func NewFlow(
 		}
 		logger.Infof("Initializing RollupManager contract at address: %s. Genesis block: %d",
 			cfg.RollupManagerAddr, cfg.RollupCreationBlockL1)
-		lerQuerier, err := query.NewLERDataQuerier(
-			cfg.RollupManagerAddr, cfg.RollupCreationBlockL1, rollupDataQuerier)
-		if err != nil {
-			return nil, fmt.Errorf("error creating LER data querier: %w", err)
-		}
-
+		lerQuerier := query.NewLERDataQuerier(cfg.RollupCreationBlockL1, rollupDataQuerier)
 		l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, cfg.DelayBetweenRetries.Duration)
 		l1InfoTreeQuerier := query.NewL1InfoTreeDataQuerier(l1Client, l1InfoTreeSyncer)
 		logger.Infof("Aggsender signer address: %s", signer.PublicAddress().Hex())
@@ -90,12 +85,7 @@ func NewFlow(
 			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)
-		}
-
+		lerQuerier := query.NewLERDataQuerier(cfg.RollupCreationBlockL1, rollupDataQuerier)
 		aggchainFEPQuerier, err := query.NewAggchainFEPQuerier(logger, types.AggchainProofMode,
 			cfg.SovereignRollupAddr, l1Client)
 		if err != nil {

aggsender/flows/flow_aggchain_prover_test.go

@@ -507,7 +507,7 @@ func Test_AggchainProverFlow_BuildCertificate(t *testing.T) {
 		{
 			name: "error building certificate",
 			mockFn: func(mockL2BridgeQuerier *mocks.BridgeQuerier, mockLERQuerier *mocks.LERQuerier, mockSigner *mocks.Signer) {
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(types.EmptyLER, nil)
+				mockLERQuerier.EXPECT().GetStartLER().Return(types.EmptyLER, nil)
 				mockL2BridgeQuerier.EXPECT().GetExitRootByIndex(mock.Anything, uint32(0)).Return(common.Hash{}, errors.New("some error"))
 			},
 			buildParams: &types.CertificateBuildParams{
@@ -525,7 +525,7 @@ func Test_AggchainProverFlow_BuildCertificate(t *testing.T) {
 				mockL2BridgeQuerier.EXPECT().OriginNetwork().Return(uint32(1))
 				mockSigner.EXPECT().PublicAddress().Return(common.HexToAddress("0x123"))
 				mockSigner.EXPECT().SignHash(mock.Anything, mock.Anything).Return([]byte("signature"), nil)
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(types.EmptyLER, nil)
+				mockLERQuerier.EXPECT().GetStartLER().Return(types.EmptyLER, nil)
 			},
 			buildParams: &types.CertificateBuildParams{
 				FromBlock:                      1,

aggsender/flows/flow_base.go

@@ -339,25 +339,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.GetStartLER()
 		return uint64(0), ler, err
 	}
 	if !lastSentCertificateInfo.Status.IsClosed() {
@@ -375,7 +361,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.GetStartLER()
 			return uint64(0), ler, err
 		}
 		// We get previous certificate that must be settled

aggsender/flows/flow_base_test.go

@@ -334,7 +334,7 @@ func Test_baseFlow_getNextHeightAndPreviousLER(t *testing.T) {
 			expectedHeight: 0,
 			expectedLER:    types.EmptyLER,
 			mockFn: func(mockLERQuerier *mocks.LERQuerier, mockStorage *mocks.AggSenderStorage) {
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(aggkitcommon.ZeroHash, nil)
+				mockLERQuerier.EXPECT().GetStartLER().Return(types.EmptyLER, nil)
 			},
 		},
 		{
@@ -343,17 +343,17 @@ func Test_baseFlow_getNextHeightAndPreviousLER(t *testing.T) {
 			expectedHeight: 0,
 			expectedLER:    common.HexToHash("0x1"),
 			mockFn: func(mockLERQuerier *mocks.LERQuerier, mockStorage *mocks.AggSenderStorage) {
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(common.HexToHash("0x1"), nil)
+				mockLERQuerier.EXPECT().GetStartLER().Return(common.HexToHash("0x1"), nil)
 			},
 		},
 		{
 			name:           "ler querier returns error",
 			lastSentCert:   nil,
 			expectedHeight: 0,
 			expectedLER:    aggkitcommon.ZeroHash,
-			expectedError:  "error getting last local exit root: some error",
+			expectedError:  "some error",
 			mockFn: func(mockLERQuerier *mocks.LERQuerier, mockStorage *mocks.AggSenderStorage) {
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(common.Hash{}, errors.New("some error"))
+				mockLERQuerier.EXPECT().GetStartLER().Return(common.Hash{}, errors.New("some error"))
 			},
 		},
 		{
@@ -397,7 +397,7 @@ func Test_baseFlow_getNextHeightAndPreviousLER(t *testing.T) {
 			expectedHeight: 0,
 			expectedLER:    types.EmptyLER,
 			mockFn: func(mockLERQuerier *mocks.LERQuerier, mockStorage *mocks.AggSenderStorage) {
-				mockLERQuerier.EXPECT().GetLastLocalExitRoot().Return(types.EmptyLER, nil)
+				mockLERQuerier.EXPECT().GetStartLER().Return(types.EmptyLER, nil)
 			},
 		},
 		{