Merge pull request #548 from blockchainluffy/feat/agg_msg_handling

Feat: bls aggregate signature and message

Author: blockchainluffy

rolling-shutter/README-dev.md

@@ -19,6 +19,8 @@ can install them to the `bin` directory by running
 
 Run `make test` to run the tests
 
+For any static test data, please use `../testdata` folder.
+
 ## Linting
 
 Run `make lint` to run `golangci-lint`. Run `make lint-changes` to run

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.RegistrationMessage)
+		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.RegistrationMessage)
+		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.RegistrationMessage,
+	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_integration_test.go

@@ -0,0 +1,103 @@
+package gnosis
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	validatorRegistryBindings "github.com/shutter-network/gnosh-contracts/gnoshcontracts/validatorregistry"
+	"gotest.tools/assert"
+
+	"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"
+)
+
+func TestAggregateValidationWithData(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping integration test")
+	}
+	ctx := context.Background()
+	url := mockBeaconClientWithJSONData(t)
+	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:         10200,
+	}
+
+	msg := readMsg(t)
+
+	message, err := hex.DecodeString(msg["message"][2:])
+	assert.NilError(t, err)
+
+	signature, err := hex.DecodeString(msg["signature"][2:])
+	assert.NilError(t, err)
+
+	events := []*validatorRegistryBindings.ValidatorregistryUpdated{{
+		Signature: signature,
+		Message:   message,
+		Raw: types.Log{
+			Address: common.HexToAddress("0xa9289A3Dd14FEBe10611119bE81E5d35eAaC3084"),
+		},
+	}}
+
+	finalEvents, err := vs.filterEvents(ctx, events)
+	assert.NilError(t, err)
+
+	assert.DeepEqual(t, len(finalEvents), 1)
+}
+
+func mockBeaconClientWithJSONData(t *testing.T) string {
+	t.Helper()
+	jsonFile, err := os.Open("../../../testdata/validatorInfo_0x01.json")
+	assert.NilError(t, err)
+	defer jsonFile.Close()
+
+	byteValue, _ := io.ReadAll(jsonFile)
+	var result map[string]string
+	err = json.Unmarshal(byteValue, &result)
+	assert.NilError(t, err)
+
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		parts := strings.Split(r.URL.Path, "/")
+
+		x := beaconapiclient.GetValidatorByIndexResponse{
+			Finalized: true,
+			Data: beaconapiclient.ValidatorData{
+				Validator: beaconapiclient.Validator{
+					PubkeyHex: result[parts[len(parts)-1]],
+				},
+			},
+		}
+		res, err := json.Marshal(x)
+		assert.NilError(t, err)
+		w.WriteHeader(http.StatusOK)
+		_, err = w.Write(res)
+		assert.NilError(t, err)
+	})).URL
+}
+
+func readMsg(t *testing.T) map[string]string {
+	t.Helper()
+	jsonFile, err := os.Open("../../../testdata/signedRegistrations_0x01.json")
+	assert.NilError(t, err)
+	defer jsonFile.Close()
+
+	byteValue, _ := io.ReadAll(jsonFile)
+	var result map[string]string
+	err = json.Unmarshal(byteValue, &result)
+	assert.NilError(t, err)
+	return result
+}