Trigger decryption based on blocks and slots

Before this commit, decryption for slot n was triggered at the start of
slot n. As validators are supposed to propose at the start of their
slot, this gives them no time to receive the decryption keys.

This commit changes the condition to trigger decryption for slot n
either when the block for slot n-1 has been observed or when 1/3 of slot
n-1 has passed, whatever is first.

Author: jannikluhn

rolling-shutter/keyperimpl/gnosis/keyper.go

@@ -30,14 +30,23 @@ import (
 
 var ErrParseKeyperSet = errors.New("cannot parse KeyperSet")
 
+// The relative proposal timeout specifies for how long we wait for a block proposal to appear in
+// a block. If we don't receive one in this time, we assume the slot is empty. The timeout is
+// given as a fraction of the slot duration.
+const (
+	relativeProposalTimeoutNumerator   = 1
+	relativeProposalTimeoutDenominator = 3
+)
+
 type Keyper struct {
-	core            *keyper.KeyperCore
-	config          *Config
-	dbpool          *pgxpool.Pool
-	client          *ethclient.Client
-	chainSyncClient *chainsync.Client
-	sequencerSyncer *SequencerSyncer
-	eonKeyPublisher *eonkeypublisher.EonKeyPublisher
+	core                *keyper.KeyperCore
+	config              *Config
+	dbpool              *pgxpool.Pool
+	client              *ethclient.Client
+	chainSyncClient     *chainsync.Client
+	sequencerSyncer     *SequencerSyncer
+	eonKeyPublisher     *eonkeypublisher.EonKeyPublisher
+	latestTriggeredSlot *uint64
 
 	// input events
 	newBlocks        chan *syncevent.LatestBlock
@@ -67,9 +76,15 @@ func (kpr *Keyper) Start(ctx context.Context, runner service.Runner) error {
 	runner.Defer(func() { close(kpr.newEonPublicKeys) })
 	runner.Defer(func() { close(kpr.decryptionTriggerChannel) })
 
+	kpr.latestTriggeredSlot = nil
+
+	offset := -(time.Duration(kpr.config.Gnosis.SecondsPerSlot) * time.Second) *
+		(relativeProposalTimeoutDenominator - relativeProposalTimeoutNumerator) /
+		relativeProposalTimeoutDenominator
 	kpr.slotTicker = slotticker.NewSlotTicker(
 		time.Duration(kpr.config.Gnosis.SecondsPerSlot*uint64(time.Second)),
 		time.Unix(int64(kpr.config.Gnosis.GenesisSlotTimestamp), 0),
+		offset,
 	)
 
 	kpr.dbpool, err = db.Connect(ctx, runner, kpr.config.DatabaseURL, database.Definition.Name())

rolling-shutter/keyperimpl/gnosis/newblock.go

@@ -3,6 +3,7 @@ package gnosis
 import (
 	"context"
 
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley"
 	syncevent "github.com/shutter-network/rolling-shutter/rolling-shutter/medley/chainsync/event"
 )
 
@@ -12,5 +13,10 @@ func (kpr *Keyper) processNewBlock(ctx context.Context, ev *syncevent.LatestBloc
 			return err
 		}
 	}
-	return nil
+	slot := medley.BlockTimestampToSlot(
+		ev.Header.Time,
+		kpr.config.Gnosis.GenesisSlotTimestamp,
+		kpr.config.Gnosis.SecondsPerSlot,
+	)
+	return kpr.maybeTriggerDecryption(ctx, slot+1)
 }

rolling-shutter/keyperimpl/gnosis/newslot.go

@@ -28,9 +28,21 @@ const maxTxPointerAge = 2
 var errZeroTxPointerAge = errors.New("tx pointer has age 0")
 
 func (kpr *Keyper) processNewSlot(ctx context.Context, slot slotticker.Slot) error {
+	return kpr.maybeTriggerDecryption(ctx, slot.Number)
+}
+
+// maybeTriggerDecryption triggers decryption for the given slot if
+// - it hasn't been triggered for this slot before and
+// - the keyper is part of the corresponding keyper set.
+func (kpr *Keyper) maybeTriggerDecryption(ctx context.Context, slot uint64) error {
+	if kpr.latestTriggeredSlot != nil && slot <= *kpr.latestTriggeredSlot {
+		return nil
+	}
+	kpr.latestTriggeredSlot = &slot
+
 	fmt.Println("")
 	fmt.Println("")
-	fmt.Println(slot.Number)
+	fmt.Println(slot)
 	fmt.Println("")
 	fmt.Println("")
 
@@ -39,20 +51,20 @@ func (kpr *Keyper) processNewSlot(ctx context.Context, slot slotticker.Slot) err
 	if err != nil {
 		return errors.Wrap(err, "failed to query synced until from db")
 	}
-	if syncedUntil.Slot >= int64(slot.Number) {
+	if syncedUntil.Slot >= int64(slot) {
 		// If we already synced the block for slot n before this slot has started on our clock,
 		// either the previous block proposer proposed early (ie is malicious) or our clocks are
 		// out of sync. In any case, it does not make sense to produce keys as the block has
 		// already been built, so we return an error.
-		return errors.Errorf("processing slot %d for which a block has already been processed", slot.Number)
+		return errors.Errorf("processing slot %d for which a block has already been processed", slot)
 	}
 	nextBlock := syncedUntil.BlockNumber + 1
 
 	queries := obskeyper.New(kpr.dbpool)
 	keyperSet, err := queries.GetKeyperSet(ctx, nextBlock)
 	if err == pgx.ErrNoRows {
 		log.Debug().
-			Uint64("slot", slot.Number).
+			Uint64("slot", slot).
 			Int64("block-number", nextBlock).
 			Msg("skipping slot as no keyper set has been found for it")
 		return nil
@@ -64,7 +76,7 @@ func (kpr *Keyper) processNewSlot(ctx context.Context, slot slotticker.Slot) err
 		return kpr.triggerDecryption(ctx, slot, nextBlock, &keyperSet)
 	}
 	log.Debug().
-		Uint64("slot", slot.Number).
+		Uint64("slot", slot).
 		Int64("block-number", nextBlock).
 		Int64("keyper-set-index", keyperSet.KeyperConfigIndex).
 		Str("address", kpr.config.GetAddress().Hex()).
@@ -134,7 +146,7 @@ func (kpr *Keyper) getTxPointer(ctx context.Context, eon int64, slot int64, keyp
 
 func (kpr *Keyper) triggerDecryption(
 	ctx context.Context,
-	slot slotticker.Slot,
+	slot uint64,
 	nextBlock int64,
 	keyperSet *obskeyper.KeyperSet,
 ) error {
@@ -147,10 +159,10 @@ func (kpr *Keyper) triggerDecryption(
 	}
 	eon := eonStruct.Eon
 
-	txPointer, err := kpr.getTxPointer(ctx, eon, int64(slot.Number), keyperSet.KeyperConfigIndex)
+	txPointer, err := kpr.getTxPointer(ctx, eon, int64(slot), keyperSet.KeyperConfigIndex)
 	if err == errZeroTxPointerAge {
 		log.Warn().
-			Uint64("slot", slot.Number).
+			Uint64("slot", slot).
 			Int64("block-number", nextBlock).
 			Int64("eon", eon).
 			Int64("tx-pointer", txPointer).
@@ -166,7 +178,7 @@ func (kpr *Keyper) triggerDecryption(
 	}
 	err = gnosisKeyperDB.SetCurrentDecryptionTrigger(ctx, gnosisdatabase.SetCurrentDecryptionTriggerParams{
 		Eon:            eon,
-		Slot:           int64(slot.Number),
+		Slot:           int64(slot),
 		TxPointer:      txPointer,
 		IdentitiesHash: computeIdentitiesHash(identityPreimages),
 	})
@@ -179,7 +191,7 @@ func (kpr *Keyper) triggerDecryption(
 	}
 	event := broker.NewEvent(&trigger)
 	log.Debug().
-		Uint64("slot", slot.Number).
+		Uint64("slot", slot).
 		Uint64("block-number", uint64(nextBlock)).
 		Int("num-identities", len(trigger.IdentityPreimages)).
 		Int64("tx-pointer", txPointer).
@@ -190,7 +202,7 @@ func (kpr *Keyper) triggerDecryption(
 }
 
 func (kpr *Keyper) getDecryptionIdentityPreimages(
-	ctx context.Context, slot slotticker.Slot, eon int64, txPointer int64,
+	ctx context.Context, slot uint64, eon int64, txPointer int64,
 ) ([]identitypreimage.IdentityPreimage, error) {
 	identityPreimages := []identitypreimage.IdentityPreimage{}
 
@@ -243,13 +255,13 @@ func transactionSubmittedEventToIdentityPreimage(
 	return identitypreimage.IdentityPreimage(buf.Bytes()), nil
 }
 
-func makeSlotIdentityPreimage(slot slotticker.Slot) identitypreimage.IdentityPreimage {
+func makeSlotIdentityPreimage(slot uint64) identitypreimage.IdentityPreimage {
 	// 32 bytes of zeros plus the block number as big endian (ie starting with lots of zeros as well)
 	// this ensures the block identity preimage is always alphanumerically before any transaction
 	// identity preimages.
 	var buf bytes.Buffer
 	buf.Write(common.BigToHash(common.Big0).Bytes())
-	buf.Write(common.BigToHash(new(big.Int).SetUint64(slot.Number)).Bytes())
+	buf.Write(common.BigToHash(new(big.Int).SetUint64(slot)).Bytes())
 
 	return identitypreimage.IdentityPreimage(buf.Bytes())
 }

rolling-shutter/medley/slots.go

@@ -1,5 +1,5 @@
 package medley
 
-func BlockTimestampToSlot(blockTimestamp uint64, secondsPerSlot uint64, genesisSlotTimestamp uint64) uint64 {
+func BlockTimestampToSlot(blockTimestamp uint64, genesisSlotTimestamp uint64, secondsPerSlot uint64) uint64 {
 	return (blockTimestamp - genesisSlotTimestamp) / secondsPerSlot
 }

rolling-shutter/medley/slotticker/slotticker.go

@@ -24,14 +24,16 @@ type SlotTicker struct {
 	C               chan Slot
 	slotDuration    time.Duration
 	genesisSlotTime time.Time
+	offset          time.Duration
 }
 
-func NewSlotTicker(slotDuration time.Duration, genesisSlotTime time.Time) *SlotTicker {
+func NewSlotTicker(slotDuration time.Duration, genesisSlotTime time.Time, offset time.Duration) *SlotTicker {
 	c := make(chan Slot, 1)
 	return &SlotTicker{
 		C:               c,
 		slotDuration:    slotDuration,
 		genesisSlotTime: genesisSlotTime,
+		offset:          offset,
 	}
 }
 
@@ -64,14 +66,7 @@ func (t *SlotTicker) run(ctx context.Context) error {
 
 	for {
 		now := time.Now()
-		timeSinceGenesis := now.Sub(t.genesisSlotTime)
-
-		var nextSlotNumber uint64
-		if timeSinceGenesis < 0 {
-			nextSlotNumber = 0
-		} else {
-			nextSlotNumber = uint64(timeSinceGenesis/t.slotDuration) + 1
-		}
+		nextSlotNumber, nextTickTime := calcNextTick(now, t.genesisSlotTime, t.slotDuration, t.offset)
 
 		if prevSlotNumber != nil {
 			expectedNextSlotNumber := *prevSlotNumber + 1
@@ -95,8 +90,7 @@ func (t *SlotTicker) run(ctx context.Context) error {
 			}
 		}
 
-		nextSlotTime := t.genesisSlotTime.Add(t.slotDuration * time.Duration(nextSlotNumber))
-		timeToNextSlot := nextSlotTime.Sub(now)
+		timeToNextSlot := nextTickTime.Sub(now)
 		timer.Reset(timeToNextSlot)
 		<-timer.C
 
@@ -107,3 +101,13 @@ func (t *SlotTicker) run(ctx context.Context) error {
 		prevSlotNumber = &nextSlotNumber
 	}
 }
+
+func calcNextTick(now time.Time, genesisSlotTime time.Time, slotDuration time.Duration, offset time.Duration) (uint64, time.Time) {
+	firstTick := genesisSlotTime.Add(offset)
+	if now.Before(firstTick) {
+		return 0, firstTick
+	}
+	slot := uint64((now.Sub(genesisSlotTime) - offset + slotDuration - 1) / slotDuration)
+	tick := genesisSlotTime.Add(slotDuration * time.Duration(slot)).Add(offset)
+	return slot, tick
+}

rolling-shutter/medley/slotticker/slotticker_test.go

@@ -0,0 +1,44 @@
+package slotticker
+
+import (
+	"testing"
+	"time"
+
+	"gotest.tools/assert"
+)
+
+func TestCalcNextSlot(t *testing.T) {
+	duration := time.Second * 5
+	genesisTime := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
+
+	epsilon := time.Millisecond
+
+	for _, testCase := range []struct {
+		timeSinceGenesis time.Duration
+		offset           time.Duration
+		slot             uint64
+	}{
+		{0, 0, 0},
+		{-time.Second * 100, 0, 0},
+		{epsilon, 0, 1},
+		{duration / 2, 0, 1},
+		{duration, 0, 1},
+		{2 * duration, 0, 2},
+		{100*duration - epsilon, 0, 100},
+
+		{-time.Second, -time.Second, 0},
+		{0, -time.Second, 1},
+		{4 * time.Second, -time.Second, 1},
+		{4*time.Second + epsilon, -time.Second, 2},
+		{100*duration - time.Second, -time.Second, 100},
+		{100*duration - time.Second + epsilon, -time.Second, 101},
+	} {
+		t.Run("", func(t *testing.T) {
+			now := genesisTime.Add(testCase.timeSinceGenesis)
+			slot, tick := calcNextTick(now, genesisTime, duration, testCase.offset)
+			assert.Equal(t, testCase.slot, slot)
+			expectedTick := genesisTime.Add(duration * time.Duration(testCase.slot)).Add(testCase.offset)
+			assert.Equal(t, tick, expectedTick)
+		})
+	}
+}