feat: run the l1 info tree syncer with safe block finality

aggoracle/config.go

@@ -17,7 +17,6 @@ var (
 
 type Config struct {
 	TargetChainType          TargetChainType          `mapstructure:"TargetChainType"`
-	URLRPCL1                 string                   `mapstructure:"URLRPCL1"`
 	WaitPeriodNextGER        types.Duration           `mapstructure:"WaitPeriodNextGER"`
 	EVMSender                chaingersender.EVMConfig `mapstructure:"EVMSender"`
 	EnableAggOracleCommittee bool                     `mapstructure:"EnableAggOracleCommittee"`

aggoracle/e2e_test.go

@@ -46,7 +46,7 @@ func TestEVM_GERInjection(t *testing.T) {
 			cfg.AggOracleCommitteeCfg.EnableAggOracleCommittee = tt.enableAggOracleCommittee
 			l1, l2 := helpers.NewSimulatedEVMEnvironment(t, cfg)
 
-			for i := 0; i < 10; i++ {
+			for i := range 10 {
 				rootHash := common.HexToHash(strconv.Itoa(i))
 				_, err := l1.GERContract.UpdateExitRoot(l1.Auth, rootHash)
 				require.NoError(t, err)

aggoracle/oracle.go

@@ -13,7 +13,7 @@ import (
 
 // L1InfoTreeSyncer is an interface that defines the methods required to interact with the L1 info tree syncer
 type L1InfoTreeSyncer interface {
-	GetLatestL1InfoLeaf(ctx context.Context) (*l1infotreesync.L1InfoTreeLeaf, error)
+	GetLatestL1InfoGER(ctx context.Context) (common.Hash, error)
 }
 
 // ChainSender is an interface that defines the methods required to send Global Exit Roots (GERs) to the chain
@@ -71,14 +71,12 @@ func (a *AggOracle) Start(ctx context.Context) {
 func (a *AggOracle) processLatestGER(ctx context.Context) error {
 	a.logger.Debugf("checking for new GERs...")
 	// Fetch the latest GER
-	latestL1InfoLeaf, err := a.l1Info.GetLatestL1InfoLeaf(ctx)
+	latestGER, err := a.l1Info.GetLatestL1InfoGER(ctx)
 	if err != nil {
 		return err
 	}
 
-	a.logger.Debugf("latest l1 info leaf retrieved: %s", latestL1InfoLeaf.String())
-
-	latestGER := latestL1InfoLeaf.GlobalExitRoot
+	a.logger.Debugf("latest GER retrieved: %s", latestGER.String())
 
 	go func() {
 		err := a.chainSender.ProcessGER(ctx, latestGER)

cmd/run.go

@@ -40,6 +40,7 @@ import (
 	"github.com/agglayer/aggkit/pprof"
 	"github.com/agglayer/aggkit/prometheus"
 	"github.com/agglayer/aggkit/reorgdetector"
+	aggkitsync "github.com/agglayer/aggkit/sync"
 	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -107,7 +108,7 @@ func start(cliCtx *cli.Context) error {
 	// Create WaitGroup for backfill goroutines synchronization
 	var backfillWg sync.WaitGroup
 	var rpcServices []jRPC.Service
-	l1InfoTreeSync := runL1InfoTreeSyncerIfNeeded(ctx, components, *cfg, l1Client)
+	l1InfoTreeSync := runL1InfoTreeSyncerIfNeeded(ctx, components, *cfg, reorgDetectorL1, l1Client)
 	if l1InfoTreeSync != nil {
 		rpcServices = append(rpcServices, l1InfoTreeSync.GetRPCServices()...)
 	}
@@ -374,14 +375,14 @@ func createAggSender(
 }
 
 func createAggoracle(
-	ethermanClient *etherman.RollupDataQuerier,
+	rollupDataQuerier *etherman.RollupDataQuerier,
 	cfg config.Config,
-	l1Client,
+	l1Client aggkittypes.BaseEthereumClienter,
 	l2Client aggkittypes.BaseEthereumClienter,
-	l1InfoTreeSyncer *l1infotreesync.L1InfoTreeSync,
+	l1InfoTreeSyncer aggoracle.L1InfoTreeSyncer,
 ) *aggoracle.AggOracle {
 	logger := log.WithFields("module", aggkitcommon.AGGORACLE)
-	l2ChainID, err := ethermanClient.GetRollupChainID()
+	l2ChainID, err := rollupDataQuerier.GetRollupChainID()
 	if err != nil {
 		logger.Errorf("Failed to retrieve L2ChainID: %v", err)
 	}
@@ -515,6 +516,7 @@ func runL1InfoTreeSyncerIfNeeded(
 	ctx context.Context,
 	components []string,
 	cfg config.Config,
+	reorgDetectorL1 aggkitsync.ReorgDetector,
 	l1Client aggkittypes.BaseEthereumClienter,
 ) *l1infotreesync.L1InfoTreeSync {
 	if !isNeeded([]string{
@@ -526,10 +528,9 @@ func runL1InfoTreeSyncerIfNeeded(
 	l1InfoTreeSync, err := l1infotreesync.New(
 		ctx,
 		cfg.L1InfoTreeSync,
-		aggkittypes.FinalizedBlock,
 		l1Client,
+		reorgDetectorL1,
 		l1infotreesync.FlagNone,
-		aggkittypes.FinalizedBlock,
 	)
 	if err != nil {
 		log.Fatal(err)
@@ -595,12 +596,14 @@ func runReorgDetectorL1IfNeeded(
 	cfg *reorgdetector.Config,
 ) (*reorgdetector.ReorgDetector, chan error) {
 	if !isNeeded([]string{
-		aggkitcommon.BRIDGE, aggkitcommon.L1BRIDGESYNC},
+		aggkitcommon.AGGORACLE, aggkitcommon.AGGSENDER, aggkitcommon.AGGSENDERVALIDATOR,
+		aggkitcommon.BRIDGE, aggkitcommon.L1BRIDGESYNC, aggkitcommon.L1INFOTREESYNC,
+		aggkitcommon.L2GERSYNC, aggkitcommon.AGGCHAINPROOFGEN},
 		components) {
 		return nil, nil
 	}
-	rd := newReorgDetector(cfg, l1Client, reorgdetector.L1)
 
+	rd := newReorgDetector(cfg, l1Client, reorgdetector.L1)
 	errChan := make(chan error)
 	go func() {
 		if err := rd.Start(ctx); err != nil {
@@ -674,7 +677,7 @@ func runBridgeSyncL1IfNeeded(
 	ctx context.Context,
 	components []string,
 	cfg bridgesync.Config,
-	reorgDetectorL1 *reorgdetector.ReorgDetector,
+	reorgDetectorL1 bridgesync.ReorgDetector,
 	l1Client aggkittypes.EthClienter,
 	rollupID uint32,
 	wg *sync.WaitGroup,

config/config.go

@@ -66,7 +66,6 @@ const (
 	delayBetweenRetriesHint               = "AggSender.DelayBeetweenRetries is deprecated, " +
 		"use AggSender.DelayBetweenRetries instead"
 	aggOracleBlockFinalityDeprecated       = "AggOracle.BlockFinality is deprecated, remove it from configuration"
-	l1InfoTreeSyncBlockFinalityDeprecated  = "L1InfoTreeSync.BlockFinality is deprecated, remove it from configuration"
 	lastGERSyncDeprecatedHint              = "LastGERSync is deprecated, use L2GERSync instead"
 	lastGERSyncSyncModeDeprecatedHint      = "LastGERSync.SyncMode is deprecated, remove it from configuration"
 	l1NetworkConfigURLDeprecatedHint       = "L1NetworkConfig.URL is deprecated, use L1NetworkConfig.RPC.URL instead"
@@ -191,10 +190,6 @@ var (
 			FieldNamePattern: "AggOracle.BlockFinality",
 			Reason:           aggOracleBlockFinalityDeprecated,
 		},
-		{
-			FieldNamePattern: "L1InfoTreeSync.BlockFinality",
-			Reason:           l1InfoTreeSyncBlockFinalityDeprecated,
-		},
 		{
 			FieldNamePattern: "LastGERSync.SyncMode",
 			Reason:           lastGERSyncSyncModeDeprecatedHint,

config/config_test.go

@@ -155,9 +155,6 @@ func TestLoadConfigWithDeprecatedFields(t *testing.T) {
 	PolAddr="{{L1Config.polTokenAddress}}"
 	ZkEVMAddr="{{L1Config.polygonZkEVMAddress}}"
 
-	[L1InfoTreeSync]
-	BlockFinality = "LatestBlock"
-
 	[Etherman]
 	URL = "{{L1URL}}"
 	[Etherman.EthermanConfig]
@@ -198,7 +195,6 @@ func TestLoadConfigWithDeprecatedFields(t *testing.T) {
 	require.ErrorContains(t, err, l1NetworkConfigUseRollupAddrHint)
 	require.ErrorContains(t, err, delayBetweenRetriesHint)
 	require.ErrorContains(t, err, aggOracleBlockFinalityDeprecated)
-	require.ErrorContains(t, err, l1InfoTreeSyncBlockFinalityDeprecated)
 	require.ErrorContains(t, err, lastGERSyncDeprecatedHint)
 	require.ErrorContains(t, err, lastGERSyncSyncModeDeprecatedHint)
 	require.ErrorContains(t, err, l1NetworkConfigURLDeprecatedHint)

config/default.go

@@ -93,8 +93,8 @@ FinalizedBlock = "LatestBlock"
 DBPath = "{{PathRWData}}/L1InfoTreeSync.sqlite"
 GlobalExitRootAddr = "{{L1NetworkConfig.GlobalExitRootManagerAddr}}"
 RollupManagerAddr = "{{L1NetworkConfig.RollupManagerAddr}}"
+BlockFinality = "SafeBlock"
 SyncBlockChunkSize = 100
-URLRPCL1 = "{{L1URL}}"
 WaitForNewBlocksPeriod = "100ms"
 InitialBlock = {{genesisBlockNumber}}
 RetryAfterErrorPeriod = "1s"
@@ -103,7 +103,6 @@ RequireStorageContentCompatibility = {{RequireStorageContentCompatibility}}
 
 [AggOracle]
 TargetChainType = "EVM"
-URLRPCL1 = "{{L1URL}}"
 WaitPeriodNextGER = "10s"
 EnableAggOracleCommittee = false
 	[AggOracle.EVMSender]

go.mod

@@ -37,7 +37,6 @@ require (
 	github.com/urfave/cli/v2 v2.27.7
 	github.com/valyala/fasttemplate v1.2.2
 	go.uber.org/zap v1.27.0
-	golang.org/x/crypto v0.43.0
 	golang.org/x/net v0.46.0
 	golang.org/x/sync v0.17.0
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b
@@ -210,6 +209,7 @@ require (
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/arch v0.20.0 // indirect
+	golang.org/x/crypto v0.43.0 // indirect
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
 	golang.org/x/lint v0.0.0-20200302205851-738671d3881b // indirect
 	golang.org/x/mod v0.28.0 // indirect

l1infotreesync/config.go

@@ -2,19 +2,29 @@ package l1infotreesync
 
 import (
 	"github.com/agglayer/aggkit/config/types"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type Config struct {
-	DBPath                     string         `mapstructure:"DBPath"`
-	GlobalExitRootAddr         common.Address `mapstructure:"GlobalExitRootAddr"`
-	RollupManagerAddr          common.Address `mapstructure:"RollupManagerAddr"`
-	SyncBlockChunkSize         uint64         `mapstructure:"SyncBlockChunkSize"`
-	URLRPCL1                   string         `mapstructure:"URLRPCL1"`
-	WaitForNewBlocksPeriod     types.Duration `mapstructure:"WaitForNewBlocksPeriod"`
-	InitialBlock               uint64         `mapstructure:"InitialBlock"`
-	RetryAfterErrorPeriod      types.Duration `mapstructure:"RetryAfterErrorPeriod"`
-	MaxRetryAttemptsAfterError int            `mapstructure:"MaxRetryAttemptsAfterError"`
+	// DBPath is the path of the database where the L1 Info Tree data will be stored
+	DBPath string `mapstructure:"DBPath"`
+	// GlobalExitRootAddr is the address of the GlobalExitRoot manager contract on L1
+	GlobalExitRootAddr common.Address `mapstructure:"GlobalExitRootAddr"`
+	// RollupManagerAddr is the address of the RollupManager/AgglayerManager contract
+	RollupManagerAddr common.Address `mapstructure:"RollupManagerAddr"`
+	// Possible values: LatestBlock, SafeBlock, PendingBlock, FinalizedBlock, EarliestBlock
+	BlockFinality aggkittypes.BlockNumberFinality `jsonschema:"enum=LatestBlock,enum=SafeBlock,enum=PendingBlock,enum=FinalizedBlock,enum=EarliestBlock" mapstructure:"BlockFinality"` //nolint:lll
+	// SyncBlockChunkSize is the amount of blocks that will be queried to the client on each request
+	SyncBlockChunkSize uint64 `mapstructure:"SyncBlockChunkSize"`
+	// WaitForNewBlocksPeriod time that will be waited when the synchronizer has queries for new blocks
+	WaitForNewBlocksPeriod types.Duration `mapstructure:"WaitForNewBlocksPeriod"`
+	// InitialBlock is the first block that will be queried when starting the synchronization from scratch
+	InitialBlock uint64 `mapstructure:"InitialBlock"`
+	// RetryAfterErrorPeriod is the time that will be waited when an unexpected error happens before retry
+	RetryAfterErrorPeriod types.Duration `mapstructure:"RetryAfterErrorPeriod"`
+	// MaxRetryAttemptsAfterError is the maximum number of consecutive attempts that will happen before panicing
+	MaxRetryAttemptsAfterError int `mapstructure:"MaxRetryAttemptsAfterError"`
 	// RequireStorageContentCompatibility is true it's mandatory that data stored in the database
 	// is compatible with the running environment
 	RequireStorageContentCompatibility bool `mapstructure:"RequireStorageContentCompatibility"`