feat: allow to configure the finality to use for l1infotree

aggsender/aggsender.go

@@ -182,7 +182,8 @@ func newAggsender(
 		return nil, fmt.Errorf("error creating verifier flow: %w", err)
 	}
 
-	l1InfoTreeQuerier, err := query.NewL1InfoTreeDataQuerier(l1Client, cfg.GlobalExitRootL1Addr, l1InfoTreeSyncer)
+	l1InfoTreeQuerier, err := query.NewL1InfoTreeDataQuerier(l1Client, cfg.GlobalExitRootL1Addr, l1InfoTreeSyncer,
+		cfg.BlockFinalityForL1InfoTree)
 	if err != nil {
 		return nil, fmt.Errorf("error creating L1 Info tree data querier: %w", err)
 	}

aggsender/aggsender_test.go

@@ -30,6 +30,7 @@ import (
 	"github.com/agglayer/aggkit/grpc"
 	"github.com/agglayer/aggkit/log"
 	treetypes "github.com/agglayer/aggkit/tree/types"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/agglayer/go_signer/signer"
 	signertypes "github.com/agglayer/go_signer/signer/types"
 	"github.com/ethereum/go-ethereum/common"
@@ -51,6 +52,7 @@ func TestConfigString(t *testing.T) {
 		EpochNotificationPercentage: 50,
 		Mode:                        "PP",
 		SovereignRollupAddr:         common.HexToAddress("0x1"),
+		BlockFinalityForL1InfoTree:  aggkittypes.FinalizedBlock,
 	}
 
 	expected := fmt.Sprintf("StoragePath: /path/to/storage\n"+
@@ -67,7 +69,8 @@ func TestConfigString(t *testing.T) {
 		"SovereignRollupAddr: 0x0000000000000000000000000000000000000001\n"+
 		"RequireNoFEPBlockGap: false\n"+
 		"RetriesToBuildAndSendCertificate: RetryPolicyConfig{Mode: , Config: RetryDelaysConfig{Delays: [], MaxRetries: NO RETRIES}}\n"+
-		"StorageRetainCertificatesPolicy: retain all certificates, keep history: false\n",
+		"StorageRetainCertificatesPolicy: retain all certificates, keep history: false\n"+
+		"BlockFinalityForL1InfoTree: FinalizedBlock\n",
 		config.AgglayerClient.String())
 
 	require.Equal(t, expected, config.String())
@@ -79,6 +82,8 @@ func TestAggSenderStart(t *testing.T) {
 	bridgeL2SyncerMock := mocks.NewL2BridgeSyncer(t)
 	rollupQuerierMock := mocks.NewRollupDataQuerier(t)
 	committeQuerierMock := mocks.NewMultisigQuerier(t)
+	mockL1InfoTreeSyncer := mocks.NewL1InfoTreeSyncer(t)
+	mockL1InfoTreeSyncer.EXPECT().Finality().Return(aggkittypes.FinalizedBlock).Maybe()
 	sendTrigger := mocks.NewCertificateSendTrigger(t)
 	sendTrigger.EXPECT().Setup(ctx)
 	ch := make(chan aggsendertypes.CertificateTriggerEvent)
@@ -102,9 +107,10 @@ func TestAggSenderStart(t *testing.T) {
 			AggsenderPrivateKey: signertypes.SignerConfig{
 				Method: signertypes.MethodNone,
 			},
+			BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 		},
 		aggLayerMock,
-		nil, // l1 info tree syncer
+		mockL1InfoTreeSyncer, // l1 info tree syncer
 		bridgeL2SyncerMock,
 		nil, // l1 client
 		nil, // l2 client
@@ -266,7 +272,7 @@ func TestSendCertificate_NoClaims(t *testing.T) {
 		},
 	}, []bridgesync.Claim{}, nil).Once()
 	mockL2BridgeQuerier.EXPECT().GetUnsetClaimsForBlockRange(mock.Anything, uint64(11), uint64(50)).Return([]bridgetypes.Unclaim{}, nil).Once()
-	mockL1Querier.EXPECT().GetLatestFinalizedL1InfoRoot(ctx).Return(&treetypes.Root{}, nil, nil).Once()
+	mockL1Querier.EXPECT().GetTargetL1InfoRoot(ctx).Return(&treetypes.Root{}, nil, nil).Once()
 	mockL2BridgeQuerier.EXPECT().GetExitRootByIndex(mock.Anything, uint32(1)).Return(common.Hash{}, nil).Once()
 	mockL2BridgeQuerier.EXPECT().OriginNetwork().Return(uint32(1)).Once()
 	mockAggLayerClient.EXPECT().SendCertificate(mock.Anything, mock.Anything).Return(common.Hash{}, nil).Once()
@@ -520,6 +526,10 @@ func TestNewAggSender(t *testing.T) {
 	mockBridgeSyncer := mocks.NewL2BridgeSyncer(t)
 	mockRollupQuerier := mocks.NewRollupDataQuerier(t)
 	mockCommitteeQuerier := mocks.NewMultisigQuerier(t)
+
+	mockL1InfoTreeSyncer := mocks.NewL1InfoTreeSyncer(t)
+	mockL1InfoTreeSyncer.EXPECT().Finality().Return(aggkittypes.FinalizedBlock).Maybe()
+
 	mockBridgeSyncer.EXPECT().OriginNetwork().Return(uint32(1)).Times(2)
 	mockRollupQuerier.EXPECT().GetRollupChainID().Return(uint64(1234), nil)
 	committee, err := aggsendertypes.NewMultisigCommittee([]*aggsendertypes.SignerInfo{aggsendertypes.NewSignerInfo("", common.Address{})},
@@ -532,10 +542,11 @@ func TestNewAggSender(t *testing.T) {
 			AggsenderPrivateKey: signertypes.SignerConfig{
 				Method: signertypes.MethodNone,
 			},
-			Mode: aggsendertypes.PessimisticProofMode,
+			Mode:                       aggsendertypes.PessimisticProofMode,
+			BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 		},
 		mockAgglayerClient,
-		nil, // l1 info tree syncer
+		mockL1InfoTreeSyncer, // l1 info tree syncer
 		mockBridgeSyncer,
 		nil, // l1 client
 		nil, // l2 client

aggsender/config/config.go

@@ -11,6 +11,7 @@ import (
 	"github.com/agglayer/aggkit/common"
 	"github.com/agglayer/aggkit/config/types"
 	"github.com/agglayer/aggkit/grpc"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	signertypes "github.com/agglayer/go_signer/signer/types"
 	ethCommon "github.com/ethereum/go-ethereum/common"
 )
@@ -96,6 +97,8 @@ type Config struct {
 	CommitteeOverride query.CommitteeOverride `mapstructure:"CommitteeOverride"`
 	// AgglayerBridgeL2Addr is the address of the bridge L2 sovereign contract on L2 sovereign chain
 	AgglayerBridgeL2Addr ethCommon.Address `mapstructure:"AgglayerBridgeL2Addr"`
+	// BlockFinalityForL1InfoTree indicates the block finality to use when querying for L1InfoRoot to use
+	BlockFinalityForL1InfoTree aggkittypes.BlockNumberFinality `jsonschema:"enum=LatestBlock, enum=SafeBlock, enum=PendingBlock, enum=FinalizedBlock, enum=EarliestBlock" mapstructure:"BlockFinalityForL1InfoTree"` //nolint:lll
 }
 
 func (c Config) CheckCertConfigBriefString() string {
@@ -118,7 +121,8 @@ func (c Config) String() string {
 		"SovereignRollupAddr: " + c.SovereignRollupAddr.Hex() + "\n" +
 		"RequireNoFEPBlockGap: " + fmt.Sprintf("%t", c.RequireNoFEPBlockGap) + "\n" +
 		"RetriesToBuildAndSendCertificate: " + c.RetriesToBuildAndSendCertificate.String() + "\n" +
-		"StorageRetainCertificatesPolicy: " + c.StorageRetainCertificatesPolicy.String() + "\n"
+		"StorageRetainCertificatesPolicy: " + c.StorageRetainCertificatesPolicy.String() + "\n" +
+		"BlockFinalityForL1InfoTree: " + c.BlockFinalityForL1InfoTree.String() + "\n"
 }
 
 // Validate checks if the configuration is valid
@@ -138,5 +142,8 @@ func (c Config) Validate() error {
 	if err := c.StorageRetainCertificatesPolicy.Validate(); err != nil {
 		return fmt.Errorf("invalid StorageRetainCertificatesPolicy config: %w", err)
 	}
+	if err := c.BlockFinalityForL1InfoTree.Validate(); err != nil {
+		return fmt.Errorf("invalid BlockFinalityForL1InfoTree configuration: %w", err)
+	}
 	return nil
 }

aggsender/config/config_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/agglayer/aggkit/common"
 	"github.com/agglayer/aggkit/config/types"
 	"github.com/agglayer/aggkit/grpc"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	signertypes "github.com/agglayer/go_signer/signer/types"
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
@@ -29,6 +30,7 @@ func TestValidate(t *testing.T) {
 					URL: "",
 				},
 				},
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 			expectedErr: "invalid agglayer client config",
 		},
@@ -44,6 +46,7 @@ func TestValidate(t *testing.T) {
 				AggkitProverClient: &grpc.ClientConfig{
 					URL: "",
 				},
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 			expectedErr: "invalid aggkit prover client config",
 		},
@@ -59,8 +62,24 @@ func TestValidate(t *testing.T) {
 				AggkitProverClient: &grpc.ClientConfig{
 					URL: "",
 				},
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 		},
+		{
+			name: "BlockFinalityForL1InfoTree not set",
+			config: Config{
+				Mode: aggsendertypes.PessimisticProofMode,
+				AgglayerClient: agglayer.ClientConfig{GRPC: &grpc.ClientConfig{
+					URL:               "http://localhost:9090",
+					MinConnectTimeout: types.NewDuration(5 * time.Second),
+				},
+				},
+				AggkitProverClient: &grpc.ClientConfig{
+					URL: "",
+				},
+			},
+			expectedErr: "BlockFinalityForL1InfoTree",
+		},
 	}
 
 	for _, tc := range testCases {

aggsender/flows/builder_flow_aggchain_prover_test.go

@@ -191,7 +191,7 @@ func Test_AggchainProverFlow_GetCertificateBuildParams(t *testing.T) {
 				ger := l1infotreesync.CalculateGER(mer, rer)
 				mockStorage.EXPECT().GetLastSentCertificateHeaderWithProofIfInError(ctx).Return(nil, nil, nil).Once()
 				mockStorage.EXPECT().GetLastSentCertificateHeader().Return(nil, nil).Once()
-				mockL1InfoDataQuery.EXPECT().GetLatestFinalizedL1InfoRoot(mock.Anything).Return(
+				mockL1InfoDataQuery.EXPECT().GetTargetL1InfoRoot(mock.Anything).Return(
 					&treetypes.Root{Hash: finalizedL1Root, BlockNum: 10}, nil, nil)
 				mockL2BridgeQuerier.On("GetLastProcessedBlock", ctx).Return(uint64(10), nil)
 				mockL2BridgeQuerier.EXPECT().GetBridgesAndClaims(ctx, uint64(1), uint64(10)).Return([]bridgesync.Bridge{{}}, []bridgesync.Claim{
@@ -217,7 +217,7 @@ func Test_AggchainProverFlow_GetCertificateBuildParams(t *testing.T) {
 				mockStorage.EXPECT().GetLastSentCertificateHeaderWithProofIfInError(ctx).Return(nil, nil, nil).Once()
 				mockStorage.EXPECT().GetLastSentCertificateHeader().Return(nil, nil).Once()
 				mockL2BridgeQuerier.EXPECT().GetLastProcessedBlock(ctx).Return(uint64(10), nil)
-				mockL1InfoDataQuery.EXPECT().GetLatestFinalizedL1InfoRoot(mock.Anything).Return(
+				mockL1InfoDataQuery.EXPECT().GetTargetL1InfoRoot(mock.Anything).Return(
 					&treetypes.Root{Hash: finalizedL1Root, BlockNum: 10}, nil, nil)
 				mockL2BridgeQuerier.EXPECT().GetBridgesAndClaims(ctx, uint64(1), uint64(10)).Return([]bridgesync.Bridge{}, []bridgesync.Claim{}, nil)
 				mockL2BridgeQuerier.EXPECT().GetUnsetClaimsForBlockRange(ctx, uint64(1), uint64(10)).Return([]bridgesynctypes.Unclaim{}, nil)
@@ -239,7 +239,7 @@ func Test_AggchainProverFlow_GetCertificateBuildParams(t *testing.T) {
 				ger := l1infotreesync.CalculateGER(mer, rer)
 				mockStorage.EXPECT().GetLastSentCertificateHeaderWithProofIfInError(ctx).Return(&types.CertificateHeader{ToBlock: 5, Status: agglayertypes.Settled}, nil, nil).Once()
 				mockStorage.EXPECT().GetLastSentCertificateHeader().Return(&types.CertificateHeader{ToBlock: 5}, nil).Once()
-				mockL1InfoDataQuery.EXPECT().GetLatestFinalizedL1InfoRoot(mock.Anything).Return(
+				mockL1InfoDataQuery.EXPECT().GetTargetL1InfoRoot(mock.Anything).Return(
 					&treetypes.Root{Hash: finalizedL1Root, BlockNum: 10, Index: 10}, nil, nil)
 				mockL2BridgeQuerier.On("GetLastProcessedBlock", ctx).Return(uint64(10), nil)
 				mockL2BridgeQuerier.EXPECT().GetBridgesAndClaims(ctx, uint64(6), uint64(10)).Return([]bridgesync.Bridge{{}}, []bridgesync.Claim{{
@@ -294,7 +294,7 @@ func Test_AggchainProverFlow_GetCertificateBuildParams(t *testing.T) {
 				ger := l1infotreesync.CalculateGER(mer, rer)
 				mockStorage.EXPECT().GetLastSentCertificateHeaderWithProofIfInError(ctx).Return(&types.CertificateHeader{ToBlock: 5, Status: agglayertypes.Settled}, nil, nil).Once()
 				mockStorage.EXPECT().GetLastSentCertificateHeader().Return(&types.CertificateHeader{ToBlock: 5}, nil).Once()
-				mockL1InfoDataQuery.EXPECT().GetLatestFinalizedL1InfoRoot(mock.Anything).Return(
+				mockL1InfoDataQuery.EXPECT().GetTargetL1InfoRoot(mock.Anything).Return(
 					&treetypes.Root{Hash: finalizedL1Root, BlockNum: 10, Index: 10}, nil, nil)
 				mockL2BridgeQuerier.On("GetLastProcessedBlock", ctx).Return(uint64(10), nil)
 				mockL2BridgeQuerier.EXPECT().GetBridgesAndClaims(ctx, uint64(6), uint64(10)).Return(

aggsender/flows/builder_flow_factory.go

@@ -52,6 +52,7 @@ func NewBuilderFlow(
 			cfg.RequireCommitteeMembershipCheck,
 			cfg.AgglayerBridgeL2Addr,
 			cfg.GlobalExitRootL1Addr,
+			cfg.BlockFinalityForL1InfoTree,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create common flow components: %w", err)
@@ -100,6 +101,7 @@ func NewBuilderFlow(
 			cfg.RequireCommitteeMembershipCheck,
 			cfg.AgglayerBridgeL2Addr,
 			cfg.GlobalExitRootL1Addr,
+			cfg.BlockFinalityForL1InfoTree,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create common flow components: %w", err)
@@ -166,6 +168,7 @@ func CreateCommonFlowComponents(
 	requireCommitteeMembershipCheck bool,
 	agglayerBridgeL2Addr ethCommon.Address,
 	globalExitRootL1Addr ethCommon.Address,
+	blockFinalityForL1InfoTree aggkittypes.BlockNumberFinality,
 ) (*CommonFlowComponents, error) {
 	l2ChainID, err := rollupDataQuerier.GetRollupChainID()
 	if err != nil {
@@ -184,7 +187,8 @@ func CreateCommonFlowComponents(
 	}
 
 	l2BridgeQuerier := query.NewBridgeDataQuerier(logger, l2Syncer, delayBetweenRetries, agglayerBridgeL2Reader)
-	l1InfoTreeQuerier, err := query.NewL1InfoTreeDataQuerier(l1Client, globalExitRootL1Addr, l1InfoTreeSyncer)
+	l1InfoTreeQuerier, err := query.NewL1InfoTreeDataQuerier(l1Client, globalExitRootL1Addr, l1InfoTreeSyncer,
+		blockFinalityForL1InfoTree)
 	if err != nil {
 		return nil, fmt.Errorf("error creating L1 Info tree data querier: %w", err)
 	}

aggsender/flows/builder_flow_factory_test.go

@@ -12,6 +12,7 @@ import (
 	cfgtypes "github.com/agglayer/aggkit/config/types"
 	aggkitgrpc "github.com/agglayer/aggkit/grpc"
 	"github.com/agglayer/aggkit/log"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	typesmocks "github.com/agglayer/aggkit/types/mocks"
 	signertypes "github.com/agglayer/go_signer/signer/types"
 	"github.com/ethereum/go-ethereum/common"
@@ -33,10 +34,11 @@ func TestNewFlow(t *testing.T) {
 		{
 			name: "success with PessimisticProofMode",
 			cfg: config.Config{
-				Mode:                types.PessimisticProofMode,
-				AggsenderPrivateKey: signertypes.SignerConfig{Method: signertypes.MethodNone},
-				MaxCertSize:         100,
-				AggkitProverClient:  aggkitgrpc.DefaultConfig(),
+				Mode:                       types.PessimisticProofMode,
+				AggsenderPrivateKey:        signertypes.SignerConfig{Method: signertypes.MethodNone},
+				MaxCertSize:                100,
+				AggkitProverClient:         aggkitgrpc.DefaultConfig(),
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 			mockFn: func(mockCommittee *mocks.MultisigQuerier) {
 				committee, err := types.NewMultisigCommittee([]*types.SignerInfo{types.NewSignerInfo("", common.Address{})}, 1)
@@ -53,6 +55,7 @@ func TestNewFlow(t *testing.T) {
 				MaxCertSize:                     100,
 				AggkitProverClient:              aggkitgrpc.DefaultConfig(),
 				RequireCommitteeMembershipCheck: true,
+				BlockFinalityForL1InfoTree:      aggkittypes.FinalizedBlock,
 			},
 			mockFn: func(mockCommittee *mocks.MultisigQuerier) {
 				mockCommittee.EXPECT().GetMultisigCommittee(mock.Anything, mock.Anything).Return(nil, errors.New("test error")).Maybe()
@@ -67,6 +70,7 @@ func TestNewFlow(t *testing.T) {
 				MaxCertSize:                     100,
 				AggkitProverClient:              aggkitgrpc.DefaultConfig(),
 				RequireCommitteeMembershipCheck: false,
+				BlockFinalityForL1InfoTree:      aggkittypes.FinalizedBlock,
 			},
 			mockFn: func(mockCommittee *mocks.MultisigQuerier) {
 				mockCommittee.EXPECT().GetMultisigCommittee(mock.Anything, mock.Anything).Return(nil, errors.New("test error")).Maybe()
@@ -80,6 +84,7 @@ func TestNewFlow(t *testing.T) {
 				MaxCertSize:                     100,
 				AggkitProverClient:              aggkitgrpc.DefaultConfig(),
 				RequireCommitteeMembershipCheck: false,
+				BlockFinalityForL1InfoTree:      aggkittypes.FinalizedBlock,
 			},
 			mockFn: func(mockCommittee *mocks.MultisigQuerier) {
 				signers := []*types.SignerInfo{
@@ -101,6 +106,7 @@ func TestNewFlow(t *testing.T) {
 				MaxCertSize:                     100,
 				AggkitProverClient:              aggkitgrpc.DefaultConfig(),
 				RequireCommitteeMembershipCheck: true,
+				BlockFinalityForL1InfoTree:      aggkittypes.FinalizedBlock,
 			},
 			mockFn: func(mockCommittee *mocks.MultisigQuerier) {
 				signers := []*types.SignerInfo{
@@ -122,7 +128,8 @@ func TestNewFlow(t *testing.T) {
 				AggsenderPrivateKey: signertypes.SignerConfig{
 					Method: signertypes.MethodLocal,
 				},
-				AggkitProverClient: aggkitgrpc.DefaultConfig(),
+				AggkitProverClient:         aggkitgrpc.DefaultConfig(),
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 			expectedError: "error signer.Initialize",
 		},
@@ -146,6 +153,7 @@ func TestNewFlow(t *testing.T) {
 					TrustedSequencerKey:             keyConfig,
 					RequireKeyMatchTrustedSequencer: true,
 				},
+				BlockFinalityForL1InfoTree: aggkittypes.FinalizedBlock,
 			},
 			expectedError: "failed to fetch the aggchain signers from the AggchainFEP contract",
 		},
@@ -166,7 +174,7 @@ func TestNewFlow(t *testing.T) {
 
 			mockL2BridgeSyncer.EXPECT().OriginNetwork().Return(1).Maybe()
 			mockLogger := log.WithFields("test", "NewFlow")
-
+			mockL1InfoTreeSyncer.EXPECT().Finality().Return(aggkittypes.FinalizedBlock).Maybe()
 			mockL1Client.EXPECT().CallContract(mock.Anything, mock.Anything, mock.Anything).Return([]byte{1, 2, 3}, nil).Maybe()
 			mockL1Client.EXPECT().CodeAt(mock.Anything, mock.Anything, mock.Anything).Return([]byte{1, 2, 3}, nil).Maybe()
 			mockL2Client.EXPECT().CallContract(mock.Anything, mock.Anything, mock.Anything).Return([]byte{1, 2, 3}, nil).Maybe()