Only generate keys for registered proposers

Author: jannikluhn

rolling-shutter/keyperimpl/gnosis/config.go

@@ -100,6 +100,7 @@ type GnosisConfig struct {
 	EncryptedGasLimit    uint64                       `shconfig:",required"`
 	MinGasPerTransaction uint64                       `shconfig:",required"`
 	SecondsPerSlot       uint64                       `shconfig:",required"`
+	SlotsPerEpoch        uint64                       `shconfig:",required"`
 	GenesisSlotTimestamp uint64                       `shconfig:",required"`
 }
 
@@ -110,6 +111,7 @@ func NewGnosisConfig() *GnosisConfig {
 		EncryptedGasLimit:    0,
 		MinGasPerTransaction: 0,
 		SecondsPerSlot:       0,
+		SlotsPerEpoch:        0,
 		GenesisSlotTimestamp: 0,
 	}
 	c.Init()
@@ -140,6 +142,7 @@ func (c *GnosisConfig) SetExampleValues() error {
 	c.EncryptedGasLimit = 1_000_000
 	c.MinGasPerTransaction = 21_000
 	c.SecondsPerSlot = 5
+	c.SlotsPerEpoch = 16
 	c.GenesisSlotTimestamp = 1665410700
 	return nil
 }

rolling-shutter/keyperimpl/gnosis/keyper.go

@@ -41,10 +41,11 @@ const (
 )
 
 type Keyper struct {
-	core                *keyper.KeyperCore
-	config              *Config
-	dbpool              *pgxpool.Pool
-	client              *ethclient.Client
+	core            *keyper.KeyperCore
+	config          *Config
+	dbpool          *pgxpool.Pool
+	beaconAPIClient *beaconapiclient.Client
+
 	chainSyncClient     *chainsync.Client
 	sequencerSyncer     *SequencerSyncer
 	validatorSyncer     *ValidatorSyncer
@@ -94,7 +95,7 @@ func (kpr *Keyper) Start(ctx context.Context, runner service.Runner) error {
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to database")
 	}
-	beaconAPIClient, err := beaconapiclient.New(kpr.config.BeaconAPIURL)
+	kpr.beaconAPIClient, err = beaconapiclient.New(kpr.config.BeaconAPIURL)
 	if err != nil {
 		return errors.Wrap(err, "failed to initialize beacon API client")
 	}
@@ -117,7 +118,7 @@ func (kpr *Keyper) Start(ctx context.Context, runner service.Runner) error {
 	kpr.validatorSyncer = &ValidatorSyncer{
 		Contract:        validatorRegistryContract,
 		DBPool:          kpr.dbpool,
-		BeaconAPIClient: beaconAPIClient,
+		BeaconAPIClient: kpr.beaconAPIClient,
 		ChainID:         chainID.Uint64(),
 	}
 

rolling-shutter/keyperimpl/gnosis/newslot.go

@@ -16,6 +16,7 @@ import (
 	corekeyperdatabase "github.com/shutter-network/rolling-shutter/rolling-shutter/keyper/database"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyper/epochkghandler"
 	gnosisdatabase "github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/gnosis/database"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/broker"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/identitypreimage"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/slotticker"
@@ -72,16 +73,60 @@ func (kpr *Keyper) maybeTriggerDecryption(ctx context.Context, slot uint64) erro
 	if err != nil {
 		return errors.Wrapf(err, "failed to query keyper set for block %d", nextBlock)
 	}
-	if keyperSet.Contains(kpr.config.GetAddress()) {
-		return kpr.triggerDecryption(ctx, slot, nextBlock, &keyperSet)
+
+	// don't trigger if we're not part of the keyper set
+	if !keyperSet.Contains(kpr.config.GetAddress()) {
+		log.Debug().
+			Uint64("slot", slot).
+			Int64("block-number", nextBlock).
+			Int64("keyper-set-index", keyperSet.KeyperConfigIndex).
+			Str("address", kpr.config.GetAddress().Hex()).
+			Msg("skipping slot as not part of keyper set")
+		return nil
 	}
-	log.Debug().
-		Uint64("slot", slot).
-		Int64("block-number", nextBlock).
-		Int64("keyper-set-index", keyperSet.KeyperConfigIndex).
-		Str("address", kpr.config.GetAddress().Hex()).
-		Msg("skipping slot as not part of keyper set")
-	return nil
+
+	// don't trigger if the block proposer is not part of the validator registry
+	isRegistered, err := kpr.isProposerRegistered(ctx, slot)
+	if err != nil {
+		return err
+	}
+	if !isRegistered {
+		log.Debug().
+			Uint64("slot", slot).
+			Msg("skipping slot as proposer is not registered")
+		return nil
+	}
+
+	return kpr.triggerDecryption(ctx, slot, nextBlock, &keyperSet)
+}
+
+func (kpr *Keyper) isProposerRegistered(ctx context.Context, slot uint64) (bool, error) {
+	epoch := medley.SlotToEpoch(slot, kpr.config.Gnosis.SlotsPerEpoch)
+	proposerDuties, err := kpr.beaconAPIClient.GetProposerDutiesByEpoch(ctx, epoch)
+	if err != nil {
+		return false, err
+	}
+	if proposerDuties == nil {
+		return false, errors.Errorf("no proposer duties found for slot %d in epoch %d", slot, epoch)
+	}
+	proposerDuty, err := proposerDuties.GetDutyForSlot(slot)
+	if err != nil {
+		return false, err
+	}
+	proposerIndex := proposerDuty.ValidatorIndex
+	if proposerIndex > math.MaxInt64 {
+		return false, errors.New("proposer index too big")
+	}
+
+	db := gnosisdatabase.New(kpr.dbpool)
+	isRegistered, err := db.IsValidatorRegistered(ctx, int64(proposerDuty.ValidatorIndex))
+	if err == pgx.ErrNoRows {
+		return false, nil
+	}
+	if err != nil {
+		return false, errors.Wrapf(err, "failed to query registration status for validator %d", proposerDuty.ValidatorIndex)
+	}
+	return isRegistered, nil
 }
 
 func (kpr *Keyper) getTxPointer(ctx context.Context, eon int64, slot int64, keyperConfigIndex int64) (int64, error) {

rolling-shutter/medley/beaconapiclient/getproposerduties.go

@@ -0,0 +1,69 @@
+package beaconapiclient
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+type GetProposerDutiesResponse struct {
+	ExecutionOptimistic bool           `json:"execution_optimistic"`
+	DependentRoot       string         `json:"dependent_root"`
+	Data                []ProposerDuty `json:"data"`
+}
+
+type ProposerDuty struct {
+	// Pubkey         blst.P1Affine `json:"pubkey"`
+	Pubkey         string `json:"pubkey"`
+	ValidatorIndex uint64 `json:"validator_index,string"`
+	Slot           uint64 `json:"slot,string"`
+}
+
+func (c *Client) GetProposerDutiesByEpoch(
+	ctx context.Context,
+	epoch uint64,
+) (*GetProposerDutiesResponse, error) {
+	path := c.url.JoinPath("/eth/v1/validator/duties/proposer/", fmt.Sprint(epoch))
+	req, err := http.NewRequestWithContext(ctx, "GET", path.String(), http.NoBody)
+	if err != nil {
+		return nil, err
+	}
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get proposer duties for epoch %d from consensus node", epoch)
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode == http.StatusNotFound {
+		return nil, nil
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.Wrapf(err, "failed to get proposer duties for epoch %d from consensus node", epoch)
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to read consensus client response body")
+	}
+
+	response := new(GetProposerDutiesResponse)
+	err = json.Unmarshal(body, response)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to unmarshal consensus client response body")
+	}
+
+	return response, nil
+}
+
+func (r *GetProposerDutiesResponse) GetDutyForSlot(slot uint64) (ProposerDuty, error) {
+	for _, duty := range r.Data {
+		if duty.Slot == slot {
+			return duty, nil
+		}
+	}
+	return ProposerDuty{}, errors.Errorf("consensus client response does not contain duty for slot %d", slot)
+}

rolling-shutter/medley/slots.go

@@ -3,3 +3,7 @@ package medley
 func BlockTimestampToSlot(blockTimestamp uint64, genesisSlotTimestamp uint64, secondsPerSlot uint64) uint64 {
 	return (blockTimestamp - genesisSlotTimestamp) / secondsPerSlot
 }
+
+func SlotToEpoch(slot uint64, slotsPerEpoch uint64) uint64 {
+	return slot / slotsPerEpoch
+}