Do not consider eon in sequencer syncer

This removes some unnecessary complexity. In particular, it means we can
perform an initial sequencer sync at startup, instead of only when we
receive a keyper set.

Author: jannikluhn

rolling-shutter/keyperimpl/gnosis/keyper.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	gethLog "github.com/ethereum/go-ethereum/log"
 	"github.com/jackc/pgx/v4/pgxpool"
@@ -14,7 +13,6 @@ import (
 	validatorRegistryBindings "github.com/shutter-network/gnosh-contracts/gnoshcontracts/validatorregistry"
 	"golang.org/x/exp/slog"
 
-	obskeyper "github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver/db/keyper"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/eonkeypublisher"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyper"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyper/epochkghandler"
@@ -174,67 +172,24 @@ func (kpr *Keyper) Start(ctx context.Context, runner service.Runner) error {
 // keyper set. Otherwise, the syncer will only be initialized once such a keyper set is observed to
 // be added, as only then we will know which eon(s) we are responsible for.
 func (kpr *Keyper) initSequencerSyncer(ctx context.Context) error {
-	obskeyperdb := obskeyper.New(kpr.dbpool)
-	keyperSets, err := obskeyperdb.GetKeyperSets(ctx)
-	if err != nil {
-		return errors.Wrap(err, "failed to query keyper sets from db")
-	}
-
-	keyperSetFound := false
-	minEon := uint64(0)
-	for _, keyperSet := range keyperSets {
-		for _, m := range keyperSet.Keypers {
-			mAddress := common.HexToAddress(m)
-			if mAddress.Cmp(kpr.config.GetAddress()) == 0 {
-				keyperSetFound = true
-				if minEon > uint64(keyperSet.KeyperConfigIndex) {
-					minEon = uint64(keyperSet.KeyperConfigIndex)
-				}
-				break
-			}
-		}
-	}
-
-	if keyperSetFound {
-		err := kpr.ensureSequencerSyncing(ctx, minEon)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (kpr *Keyper) ensureSequencerSyncing(ctx context.Context, eon uint64) error {
 	client, err := ethclient.DialContext(ctx, kpr.config.Gnosis.Node.ContractsURL)
 	if err != nil {
 		return errors.Wrap(err, "failed to dial Ethereum execution node")
 	}
 
-	if kpr.sequencerSyncer == nil {
-		log.Info().
-			Uint64("eon", eon).
-			Str("contract-address", kpr.config.Gnosis.Contracts.KeyperSetManager.Hex()).
-			Msg("initializing sequencer syncer")
-		contract, err := sequencerBindings.NewSequencer(kpr.config.Gnosis.Contracts.Sequencer, client)
-		if err != nil {
-			return err
-		}
-		kpr.sequencerSyncer = &SequencerSyncer{
-			Contract:             contract,
-			DBPool:               kpr.dbpool,
-			ExecutionClient:      client,
-			StartEon:             eon,
-			GenesisSlotTimestamp: kpr.config.Gnosis.GenesisSlotTimestamp,
-			SecondsPerSlot:       kpr.config.Gnosis.SecondsPerSlot,
-		}
+	log.Info().
+		Str("contract-address", kpr.config.Gnosis.Contracts.KeyperSetManager.Hex()).
+		Msg("initializing sequencer syncer")
+	contract, err := sequencerBindings.NewSequencer(kpr.config.Gnosis.Contracts.Sequencer, client)
+	if err != nil {
+		return err
 	}
-
-	if eon < kpr.sequencerSyncer.StartEon {
-		log.Info().
-			Uint64("old-start-eon", kpr.sequencerSyncer.StartEon).
-			Uint64("new-start-eon", eon).
-			Msg("decreasing sequencer syncing start eon")
-		kpr.sequencerSyncer.StartEon = eon
+	kpr.sequencerSyncer = &SequencerSyncer{
+		Contract:             contract,
+		DBPool:               kpr.dbpool,
+		ExecutionClient:      client,
+		GenesisSlotTimestamp: kpr.config.Gnosis.GenesisSlotTimestamp,
+		SecondsPerSlot:       kpr.config.Gnosis.SecondsPerSlot,
 	}
 
 	// Perform an initial sync now because it might take some time and doing so during regular

rolling-shutter/keyperimpl/gnosis/newkeyperset.go

@@ -29,12 +29,6 @@ func (kpr *Keyper) processNewKeyperSet(ctx context.Context, ev *syncevent.Keyper
 		Bool("is-member", isMember).
 		Msg("new keyper set added")
 
-	if isMember {
-		if err := kpr.ensureSequencerSyncing(ctx, ev.Eon); err != nil {
-			return err
-		}
-	}
-
 	return kpr.dbpool.BeginFunc(ctx, func(tx pgx.Tx) error {
 		obskeyperdb := obskeyper.New(tx)
 

rolling-shutter/keyperimpl/gnosis/sequencersyncer.go

@@ -24,7 +24,6 @@ type SequencerSyncer struct {
 	Contract             *sequencerBindings.Sequencer
 	DBPool               *pgxpool.Pool
 	ExecutionClient      *ethclient.Client
-	StartEon             uint64
 	GenesisSlotTimestamp uint64
 	SecondsPerSlot       uint64
 }
@@ -126,16 +125,15 @@ func (s *SequencerSyncer) filterEvents(
 ) []*sequencerBindings.SequencerTransactionSubmitted {
 	filteredEvents := []*sequencerBindings.SequencerTransactionSubmitted{}
 	for _, event := range events {
-		if event.Eon < s.StartEon ||
-			event.Eon > math.MaxInt64 ||
+		if event.Eon > math.MaxInt64 ||
 			!event.GasLimit.IsInt64() {
 			log.Debug().
 				Uint64("eon", event.Eon).
 				Uint64("block-number", event.Raw.BlockNumber).
 				Str("block-hash", event.Raw.BlockHash.Hex()).
 				Uint("tx-index", event.Raw.TxIndex).
 				Uint("log-index", event.Raw.Index).
-				Msg("ignoring transaction submitted event")
+				Msg("ignoring transaction submitted event with high eon")
 			continue
 		}
 		filteredEvents = append(filteredEvents, event)