feat: added v2 message handling

Author: blockchainluffy

rolling-shutter/keyperimpl/gnosis/validatorsyncer.go

@@ -2,6 +2,7 @@ package gnosis
 
 import (
 	"context"
+	"fmt"
 	"math"
 	"math/big"
 
@@ -24,8 +25,7 @@ import (
 )
 
 const (
-	ValidatorRegistrationMessageVersion = 0
-	maxRequestBlockRange                = 10_000
+	maxRequestBlockRange = 10_000
 )
 
 type ValidatorSyncer struct {
@@ -150,61 +150,83 @@ func (v *ValidatorSyncer) filterEvents(
 			Uint("log-index", event.Raw.Index).
 			Logger()
 
-		msg := new(validatorregistry.LegacyRegistrationMessage)
+		msg := new(validatorregistry.AggregateRegistrationMessage)
 		err := msg.Unmarshal(event.Message)
 		if err != nil {
 			evLog.Warn().
 				Err(err).
 				Msg("failed to unmarshal registration message")
 			continue
 		}
-		evLog = evLog.With().Uint64("validator-index", msg.ValidatorIndex).Logger()
 
 		if !checkStaticRegistrationMessageFields(msg, v.ChainID, event.Raw.Address, evLog) {
 			continue
 		}
 
-		latestNonce, err := db.GetValidatorRegistrationNonceBefore(ctx, database.GetValidatorRegistrationNonceBeforeParams{
-			ValidatorIndex: int64(msg.ValidatorIndex),
-			BlockNumber:    int64(event.Raw.BlockNumber),
-			TxIndex:        int64(event.Raw.TxIndex),
-			LogIndex:       int64(event.Raw.Index),
-		})
-		if err != nil && err != pgx.ErrNoRows {
-			return nil, errors.Wrapf(err, "failed to query latest nonce for validator %d", msg.ValidatorIndex)
-		}
-		if err == pgx.ErrNoRows {
-			latestNonce = -1
-		}
-		if msg.Nonce > math.MaxInt64 || int64(msg.Nonce) <= latestNonce {
-			evLog.Warn().
-				Uint64("nonce", msg.Nonce).
-				Int64("latest-nonce", latestNonce).
-				Msg("ignoring registration message with invalid nonce")
-			continue
-		}
+		pubKeys := make([]*blst.P1Affine, 0)
+		for _, validatorIndex := range msg.ValidatorIndices() {
+			evLog = evLog.With().Int64("validator-index", validatorIndex).Logger()
+			latestNonce, err := db.GetValidatorRegistrationNonceBefore(ctx, database.GetValidatorRegistrationNonceBeforeParams{
+				ValidatorIndex: validatorIndex,
+				BlockNumber:    int64(event.Raw.BlockNumber),
+				TxIndex:        int64(event.Raw.TxIndex),
+				LogIndex:       int64(event.Raw.Index),
+			})
+			if err != nil && err != pgx.ErrNoRows {
+				return nil, errors.Wrapf(err, "failed to query latest nonce for validator %d", msg.ValidatorIndex)
+			}
+			if err == pgx.ErrNoRows {
+				latestNonce = -1
+			}
 
-		validator, err := v.BeaconAPIClient.GetValidatorByIndex(ctx, "head", msg.ValidatorIndex)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to get validator %d", msg.ValidatorIndex)
-		}
-		if validator == nil {
-			evLog.Warn().Msg("ignoring registration message for unknown validator")
-			continue
-		}
-		pubkey, err := validator.Data.Validator.GetPubkey()
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to get pubkey of validator %d", msg.ValidatorIndex)
+			if msg.Nonce > math.MaxInt32 || int64(msg.Nonce) <= latestNonce {
+				evLog.Warn().
+					Uint32("nonce", msg.Nonce).
+					Int64("latest-nonce", latestNonce).
+					Msg("ignoring registration message with invalid nonce")
+				continue
+			}
+
+			validator, err := v.BeaconAPIClient.GetValidatorByIndex(ctx, "head", uint64(validatorIndex))
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to get validator %d", msg.ValidatorIndex)
+			}
+			if validator == nil {
+				evLog.Warn().Msg("ignoring registration message for unknown validator")
+				continue
+			}
+			pubkey, err := validator.Data.Validator.GetPubkey()
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to get pubkey of validator %d", msg.ValidatorIndex)
+			}
+			pubKeys = append(pubKeys, pubkey)
 		}
+
 		sig := new(blst.P2Affine).Uncompress(event.Signature)
 		if sig == nil {
 			evLog.Warn().Msg("ignoring registration message with undecodable signature")
 			continue
 		}
-		validSignature := validatorregistry.VerifySignature(sig, pubkey, msg)
-		if !validSignature {
-			evLog.Warn().Msg("ignoring registration message with invalid signature")
-			continue
+
+		if msg.Version == validatorregistry.LegacyValidatorRegistrationMessageVersion {
+			msg := new(validatorregistry.LegacyRegistrationMessage)
+			err := msg.Unmarshal(event.Message)
+			if err != nil {
+				evLog.Warn().
+					Err(err).
+					Msg("failed to unmarshal registration message")
+				continue
+			}
+			if validSignature := validatorregistry.VerifySignature(sig, pubKeys[0], msg); !validSignature {
+				evLog.Warn().Msg("ignoring registration message with invalid signature")
+				continue
+			}
+		} else {
+			validSignature := validatorregistry.VerifyAggregateSignature(sig, pubKeys, msg)
+			if !validSignature {
+				evLog.Warn().Msg("ignoring registration message with invalid signature")
+				continue
+			}
 		}
 
 		filteredEvents = append(filteredEvents, event)
@@ -215,37 +237,41 @@ func (v *ValidatorSyncer) filterEvents(
 func (v *ValidatorSyncer) insertEvents(ctx context.Context, tx pgx.Tx, events []*validatorRegistryBindings.ValidatorregistryUpdated) error {
 	db := database.New(tx)
 	for _, event := range events {
-		msg := new(validatorregistry.LegacyRegistrationMessage)
+		msg := new(validatorregistry.AggregateRegistrationMessage)
 		err := msg.Unmarshal(event.Message)
 		if err != nil {
 			return errors.Wrap(err, "failed to unmarshal registration message")
 		}
-		err = db.InsertValidatorRegistration(ctx, database.InsertValidatorRegistrationParams{
-			BlockNumber:    int64(event.Raw.BlockNumber),
-			BlockHash:      event.Raw.BlockHash.Bytes(),
-			TxIndex:        int64(event.Raw.TxIndex),
-			LogIndex:       int64(event.Raw.Index),
-			ValidatorIndex: int64(msg.ValidatorIndex),
-			Nonce:          int64(msg.Nonce),
-			IsRegistration: msg.IsRegistration,
-		})
-		if err != nil {
-			return errors.Wrap(err, "failed to insert validator registration into db")
+		for _, validatorIndex := range msg.ValidatorIndices() {
+			err = db.InsertValidatorRegistration(ctx, database.InsertValidatorRegistrationParams{
+				BlockNumber:    int64(event.Raw.BlockNumber),
+				BlockHash:      event.Raw.BlockHash.Bytes(),
+				TxIndex:        int64(event.Raw.TxIndex),
+				LogIndex:       int64(event.Raw.Index),
+				ValidatorIndex: validatorIndex,
+				Nonce:          int64(msg.Nonce),
+				IsRegistration: msg.IsRegistration,
+			})
+			if err != nil {
+				return errors.Wrap(err, "failed to insert validator registration into db")
+			}
 		}
 	}
 	return nil
 }
 
 func checkStaticRegistrationMessageFields(
-	msg *validatorregistry.LegacyRegistrationMessage,
+	msg *validatorregistry.AggregateRegistrationMessage,
 	chainID uint64,
 	validatorRegistryAddress common.Address,
 	logger zerolog.Logger,
 ) bool {
-	if msg.Version != ValidatorRegistrationMessageVersion {
+	if msg.Version != validatorregistry.AggregateValidatorRegistrationMessageVersion &&
+		msg.Version != validatorregistry.LegacyValidatorRegistrationMessageVersion {
 		logger.Warn().
 			Uint8("version", msg.Version).
-			Uint8("expected-version", ValidatorRegistrationMessageVersion).
+			Str("expected-version", fmt.Sprintf("%d or %d", validatorregistry.LegacyValidatorRegistrationMessageVersion,
+				validatorregistry.AggregateValidatorRegistrationMessageVersion)).
 			Uint64("validator-index", msg.ValidatorIndex).
 			Msg("ignoring registration message with invalid version")
 		return false

rolling-shutter/keyperimpl/gnosis/validatorsyncer_test.go

@@ -0,0 +1,138 @@
+package gnosis
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	validatorRegistryBindings "github.com/shutter-network/gnosh-contracts/gnoshcontracts/validatorregistry"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/gnosis/database"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/beaconapiclient"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/testsetup"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/validatorregistry"
+	blst "github.com/supranational/blst/bindings/go"
+	"gotest.tools/assert"
+)
+
+func TestLegacyValidatorRegisterFilterEvent(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test")
+	}
+	msg := &validatorregistry.LegacyRegistrationMessage{
+		Version:                  0,
+		ChainID:                  2,
+		ValidatorRegistryAddress: common.HexToAddress("0x1234567890123456789012345678901234567890"),
+		ValidatorIndex:           3,
+		Nonce:                    0,
+		IsRegistration:           true,
+	}
+	ctx := context.Background()
+
+	var ikm [32]byte
+	privkey := blst.KeyGen(ikm[:])
+	pubkey := new(blst.P1Affine).From(privkey)
+
+	sig := validatorregistry.CreateSignature(privkey, msg)
+	url := mockBeaconClient(t, hex.EncodeToString(pubkey.Compress()))
+
+	cl, err := beaconapiclient.New(url)
+	assert.NilError(t, err)
+
+	dbpool, dbclose := testsetup.NewTestDBPool(ctx, t, database.Definition)
+	t.Cleanup(dbclose)
+
+	vs := ValidatorSyncer{
+		BeaconAPIClient: cl,
+		DBPool:          dbpool,
+		ChainID:         msg.ChainID,
+	}
+
+	events := []*validatorRegistryBindings.ValidatorregistryUpdated{&validatorRegistryBindings.ValidatorregistryUpdated{
+		Signature: sig.Compress(),
+		Message:   msg.Marshal(),
+		Raw: types.Log{
+			Address: common.HexToAddress("0x1234567890123456789012345678901234567890"),
+		},
+	}}
+
+	finalEvents, err := vs.filterEvents(ctx, events)
+	assert.NilError(t, err)
+
+	assert.DeepEqual(t, finalEvents, events)
+}
+
+func TestAggregateValidatorRegisterFilterEvent(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test")
+	}
+	msg := &validatorregistry.AggregateRegistrationMessage{
+		Version:                  1,
+		ChainID:                  2,
+		ValidatorRegistryAddress: common.HexToAddress("0x1234567890123456789012345678901234567890"),
+		ValidatorIndex:           3,
+		Nonce:                    0,
+		Count:                    1,
+		IsRegistration:           true,
+	}
+	ctx := context.Background()
+
+	var ikm [32]byte
+	var sks []*blst.SecretKey
+	var pks []*blst.P1Affine
+	for i := 0; i < int(msg.Count); i++ {
+		privkey := blst.KeyGen(ikm[:])
+		pubkey := new(blst.P1Affine).From(privkey)
+		sks = append(sks, privkey)
+		pks = append(pks, pubkey)
+	}
+
+	sig := validatorregistry.CreateAggregateSignature(sks, msg)
+	url := mockBeaconClient(t, hex.EncodeToString(pks[0].Compress()))
+
+	cl, err := beaconapiclient.New(url)
+	assert.NilError(t, err)
+
+	dbpool, dbclose := testsetup.NewTestDBPool(ctx, t, database.Definition)
+	t.Cleanup(dbclose)
+
+	vs := ValidatorSyncer{
+		BeaconAPIClient: cl,
+		DBPool:          dbpool,
+		ChainID:         msg.ChainID,
+	}
+
+	events := []*validatorRegistryBindings.ValidatorregistryUpdated{&validatorRegistryBindings.ValidatorregistryUpdated{
+		Signature: sig.Compress(),
+		Message:   msg.Marshal(),
+		Raw: types.Log{
+			Address: common.HexToAddress("0x1234567890123456789012345678901234567890"),
+		},
+	}}
+
+	finalEvents, err := vs.filterEvents(ctx, events)
+	assert.NilError(t, err)
+
+	assert.DeepEqual(t, finalEvents, events)
+}
+
+func mockBeaconClient(t *testing.T, pubKeyHex string) string {
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		x := beaconapiclient.GetValidatorByIndexResponse{
+			Finalized: true,
+			Data: beaconapiclient.ValidatorData{
+				Validator: beaconapiclient.Validator{
+					PubkeyHex: pubKeyHex,
+				},
+			},
+		}
+		res, err := json.Marshal(x)
+		assert.NilError(t, err)
+		w.WriteHeader(http.StatusOK)
+		w.Write(res)
+	})).URL
+}

rolling-shutter/medley/validatorregistry/signature.go

@@ -1,20 +1,17 @@
 package validatorregistry
 
 import (
-	"fmt"
-
 	"github.com/ethereum/go-ethereum/crypto"
 	blst "github.com/supranational/blst/bindings/go"
 )
 
 var dst = []byte("BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_")
 
 func VerifyAggregateSignature(sig *blst.P2Affine, pks []*blst.P1Affine, msg *AggregateRegistrationMessage) bool {
-	if msg.Version < 1 {
+	if msg.Version < AggregateValidatorRegistrationMessageVersion {
 		return false
 	}
 	if len(pks) != int(msg.Count) {
-		fmt.Println(len(pks), int(msg.Count))
 		return false
 	}
 	msgHash := crypto.Keccak256(msg.Marshal())
@@ -38,7 +35,7 @@ func CreateAggregateSignature(sks []*blst.SecretKey, msg *AggregateRegistrationM
 		sig := aff.Sign(sk, msgHash, dst)
 		ok := aggregate.Add(sig, true)
 		if !ok {
-			panic("failure")
+			return nil
 		}
 	}
 	return aggregate.ToAffine()

rolling-shutter/medley/validatorregistry/signature_test.go

@@ -46,7 +46,6 @@ func TestAggSignature(t *testing.T) {
 	var sks []*blst.SecretKey
 	var pks []*blst.P1Affine
 	for i := 0; i < int(msg.Count); i++ {
-
 		privkey := blst.KeyGen(ikm[:])
 		pubkey := new(blst.P1Affine).From(privkey)
 		sks = append(sks, privkey)