Alan/pre fork share

cli/operator/node.go

@@ -4,13 +4,14 @@ import (
 	"context"
 	"encoding/base64"
 	"fmt"
-	genesisssvtypes "github.com/ssvlabs/ssv/protocol/genesis/types"
 	"log"
 	"math/big"
 	"net/http"
 	"os"
 	"time"
 
+	genesisssvtypes "github.com/ssvlabs/ssv/protocol/genesis/types"
+
 	ethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ilyakaznacheev/cleanenv"
 	"github.com/pkg/errors"
@@ -266,8 +267,7 @@ var StartNodeCmd = &cobra.Command{
 		cfg.SSVOptions.ValidatorOptions.RecipientsStorage = nodeStorage
 		cfg.SSVOptions.ValidatorOptions.GasLimit = cfg.ConsensusClient.GasLimit
 
-		genesisKeyManager := &ekm.GenesisKeyManagerAdapter{KeyManager: keyManager}
-		cfg.SSVOptions.ValidatorOptions.GenesisControllerOptions.KeyManager = genesisKeyManager
+		cfg.SSVOptions.ValidatorOptions.GenesisControllerOptions.KeyManager = &ekm.GenesisKeyManagerAdapter{KeyManager: keyManager}
 
 		if cfg.WsAPIPort != 0 {
 			ws := exporterapi.NewWsServer(cmd.Context(), nil, http.NewServeMux(), cfg.WithPing)

ekm/genesis_adapter.go

@@ -4,6 +4,7 @@ import (
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	ssz "github.com/ferranbt/fastssz"
 	"github.com/herumi/bls-eth-go-binary/bls"
+	"github.com/pkg/errors"
 	genesisspectypes "github.com/ssvlabs/ssv-spec-pre-cc/types"
 	spectypes "github.com/ssvlabs/ssv-spec/types"
 )
@@ -13,6 +14,37 @@ type GenesisKeyManagerAdapter struct {
 }
 
 func (k *GenesisKeyManagerAdapter) SignBeaconObject(obj ssz.HashRoot, domain phase0.Domain, pk []byte, domainType phase0.DomainType) (genesisspectypes.Signature, [32]byte, error) {
+	// Convert genesisspectypes to spectypes before passing on to KeyManager.
+	switch domainType {
+	case genesisspectypes.DomainAttester:
+	case genesisspectypes.DomainProposer:
+	case genesisspectypes.DomainVoluntaryExit:
+	case genesisspectypes.DomainAggregateAndProof:
+	case genesisspectypes.DomainSelectionProof:
+		data, ok := obj.(genesisspectypes.SSZUint64)
+		if !ok {
+			return nil, [32]byte{}, errors.New("could not cast obj to SSZUint64")
+		}
+		obj = spectypes.SSZUint64(data)
+	case genesisspectypes.DomainRandao:
+		data, ok := obj.(genesisspectypes.SSZUint64)
+		if !ok {
+			return nil, [32]byte{}, errors.New("could not cast obj to SSZUint64")
+		}
+		obj = spectypes.SSZUint64(data)
+	case genesisspectypes.DomainSyncCommittee:
+		data, ok := obj.(genesisspectypes.SSZBytes)
+		if !ok {
+			return nil, [32]byte{}, errors.New("could not cast obj to SSZBytes")
+		}
+		obj = spectypes.SSZBytes(data)
+	case genesisspectypes.DomainSyncCommitteeSelectionProof:
+	case genesisspectypes.DomainContributionAndProof:
+	case genesisspectypes.DomainApplicationBuilder:
+	default:
+		return nil, [32]byte{}, errors.New("domain unknown")
+	}
+
 	signature, root, err := k.KeyManager.SignBeaconObject(obj, domain, pk, domainType)
 	if err != nil {
 		return nil, [32]byte{}, err

ibft/genesisstorage/store_test.go

@@ -24,7 +24,7 @@ func TestCleanInstances(t *testing.T) {
 
 	generateInstance := func(id genesisspectypes.MessageID, h genesisspecqbft.Height) *genesisqbftstorage.StoredInstance {
 		return &genesisqbftstorage.StoredInstance{
-			State: &types.State{
+			State: &genesisspecqbft.State{
 				ID:                   id[:],
 				Round:                1,
 				Height:               h,
@@ -96,8 +96,8 @@ func TestSaveAndFetchLastState(t *testing.T) {
 	identifier := genesisspectypes.NewMsgID(types.GetDefaultDomain(), []byte("pk"), genesisspectypes.BNRoleAttester)
 
 	instance := &genesisqbftstorage.StoredInstance{
-		State: &types.State{
-			CommitteeMember:                 nil,
+		State: &genesisspecqbft.State{
+			Share:                           nil,
 			ID:                              identifier[:],
 			Round:                           1,
 			Height:                          1,
@@ -134,8 +134,8 @@ func TestSaveAndFetchState(t *testing.T) {
 	identifier := genesisspectypes.NewMsgID(types.GetDefaultDomain(), []byte("pk"), genesisspectypes.BNRoleAttester)
 
 	instance := &genesisqbftstorage.StoredInstance{
-		State: &types.State{
-			CommitteeMember:                 nil,
+		State: &genesisspecqbft.State{
+			Share:                           nil,
 			ID:                              identifier[:],
 			Round:                           1,
 			Height:                          1,

ibft/genesisstorage/stores_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ssvlabs/ssv/logging"
 	genesisqbftstorage "github.com/ssvlabs/ssv/protocol/genesis/qbft/storage"
-	"github.com/ssvlabs/ssv/protocol/genesis/types"
 	"github.com/ssvlabs/ssv/storage/basedb"
 	"github.com/ssvlabs/ssv/storage/kv"
 )
@@ -39,7 +38,7 @@ func TestQBFTStores(t *testing.T) {
 	id := []byte{1, 2, 3}
 
 	qbftMap.Each(func(role genesisspectypes.BeaconRole, store genesisqbftstorage.QBFTStore) error {
-		return store.SaveInstance(&genesisqbftstorage.StoredInstance{State: &types.State{Height: 1, ID: id}})
+		return store.SaveInstance(&genesisqbftstorage.StoredInstance{State: &genesisspecqbft.State{Height: 1, ID: id}})
 	})
 
 	instance, err := qbftMap.Get(genesisspectypes.BNRoleAttester).GetInstance(id, 1)

network/p2p/p2p_pubsub.go

@@ -68,17 +68,6 @@ func (n *p2pNetwork) Broadcast(msgID spectypes.MessageID, msg *spectypes.SignedS
 		return fmt.Errorf("operator ID is not ready")
 	}
 
-	// TODO: (genesis) old encoding
-	// encodedMsg, err := commons.EncodeNetworkMsg(msg)
-	// if err != nil {
-	// 	return errors.Wrap(err, "could not decode msg")
-	// }
-	// signature, err := n.operatorSigner.Sign(encodedMsg)
-	// if err != nil {
-	// 	return err
-	// }
-	// encodedMsg = commons.EncodeSignedSSVMessage(encodedMsg, n.operatorDataStore.GetOperatorID(), signature)
-
 	encodedMsg, err := msg.Encode()
 	if err != nil {
 		return fmt.Errorf("could not encode signed ssv message: %w", err)
@@ -234,10 +223,18 @@ func (n *p2pNetwork) handlePubsubMessages(logger *zap.Logger) func(ctx context.C
 			m, ok := msg.ValidatorData.(*queue.SSVMessage)
 			if ok {
 				decodedMsg = m
+				logger.With(
+					zap.String("pubKey", hex.EncodeToString(m.SSVMessage.MsgID.GetDutyExecutorID())),
+					zap.String("role", m.SSVMessage.MsgID.GetRoleType().String()),
+				).Debug("handlePubsubMessages - alan")
 			} else {
 				m, ok := msg.ValidatorData.(*genesisqueue.GenesisSSVMessage)
 				if ok {
 					decodedMsg = m
+					logger.With(
+						zap.String("pubKey", hex.EncodeToString(m.SSVMessage.MsgID.GetPubKey())),
+						zap.String("role", m.SSVMessage.MsgID.GetRoleType().String()),
+					).Debug("handlePubsubMessages - genesis")
 				}
 			}
 

operator/validator/controller.go

@@ -1461,14 +1461,16 @@ func SetupGenesisRunners(ctx context.Context, logger *zap.Logger, options valida
 		genesisspectypes.BNRoleVoluntaryExit,
 	}
 
+	share := genesisssvtypes.ConvertToGenesisShare(&options.SSVShare.Share, options.Operator)
+
 	buildController := func(role genesisspectypes.BeaconRole, valueCheckF genesisspecqbft.ProposedValueCheckF) *genesisqbftcontroller.Controller {
 		config := &genesisqbft.Config{
 			Signer:      options.GenesisOptions.Signer,
 			SigningPK:   options.SSVShare.ValidatorPubKey[:],
 			Domain:      genesisssvtypes.GetDefaultDomain(),
 			ValueCheckF: nil, // sets per role type
-			ProposerF: func(state *genesisssvtypes.State, round genesisspecqbft.Round) genesisspectypes.OperatorID {
-				leader := genesisssvtypes.RoundRobinProposer(state, round)
+			ProposerF: func(state *genesisspecqbft.State, round genesisspecqbft.Round) genesisspectypes.OperatorID {
+				leader := genesisspecqbft.RoundRobinProposer(state, round)
 				//logger.Debug("leader", zap.Int("operator_id", int(leader)))
 				return leader
 			},
@@ -1481,7 +1483,7 @@ func SetupGenesisRunners(ctx context.Context, logger *zap.Logger, options valida
 		config.ValueCheckF = valueCheckF
 
 		identifier := genesisspectypes.NewMsgID(genesisssvtypes.GetDefaultDomain(), options.SSVShare.Share.ValidatorPubKey[:], role)
-		qbftCtrl := genesisqbftcontroller.NewController(identifier[:], options.Operator, config, options.FullNode)
+		qbftCtrl := genesisqbftcontroller.NewController(identifier[:], share, config, options.FullNode)
 		qbftCtrl.NewDecidedHandler = options.GenesisOptions.NewDecidedHandler
 		return qbftCtrl
 	}
@@ -1494,29 +1496,29 @@ func SetupGenesisRunners(ctx context.Context, logger *zap.Logger, options valida
 		case genesisspectypes.BNRoleAttester:
 			valCheck := genesisspecssv.AttesterValueCheckF(options.GenesisOptions.Signer, genesisBeaconNetwork, options.SSVShare.Share.ValidatorPubKey[:], options.SSVShare.BeaconMetadata.Index, options.SSVShare.SharePubKey)
 			qbftCtrl := buildController(genesisspectypes.BNRoleAttester, valCheck)
-			runners[role] = genesisrunner.NewAttesterRunnner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, valCheck, 0, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewAttesterRunnner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, valCheck, 0, options.Operator.OperatorID)
 		case genesisspectypes.BNRoleProposer:
 			proposedValueCheck := genesisspecssv.ProposerValueCheckF(options.GenesisOptions.Signer, genesisBeaconNetwork, options.SSVShare.Share.ValidatorPubKey[:], options.SSVShare.BeaconMetadata.Index, options.SSVShare.SharePubKey)
 			qbftCtrl := buildController(genesisspectypes.BNRoleProposer, proposedValueCheck)
-			runners[role] = genesisrunner.NewProposerRunner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, proposedValueCheck, 0, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewProposerRunner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, proposedValueCheck, 0, options.Operator.OperatorID)
 			runners[role].(*genesisrunner.ProposerRunner).ProducesBlindedBlocks = options.BuilderProposals // apply blinded block flag
 		case genesisspectypes.BNRoleAggregator:
 			aggregatorValueCheckF := genesisspecssv.AggregatorValueCheckF(options.GenesisOptions.Signer, genesisBeaconNetwork, options.SSVShare.Share.ValidatorPubKey[:], options.SSVShare.BeaconMetadata.Index)
 			qbftCtrl := buildController(genesisspectypes.BNRoleAggregator, aggregatorValueCheckF)
-			runners[role] = genesisrunner.NewAggregatorRunner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, aggregatorValueCheckF, 0, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewAggregatorRunner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, aggregatorValueCheckF, 0, options.Operator.OperatorID)
 		case genesisspectypes.BNRoleSyncCommittee:
 			syncCommitteeValueCheckF := genesisspecssv.SyncCommitteeValueCheckF(options.GenesisOptions.Signer, genesisBeaconNetwork, options.SSVShare.ValidatorPubKey[:], options.SSVShare.BeaconMetadata.Index)
 			qbftCtrl := buildController(genesisspectypes.BNRoleSyncCommittee, syncCommitteeValueCheckF)
-			runners[role] = genesisrunner.NewSyncCommitteeRunner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, syncCommitteeValueCheckF, 0, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewSyncCommitteeRunner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, syncCommitteeValueCheckF, 0, options.Operator.OperatorID)
 		case genesisspectypes.BNRoleSyncCommitteeContribution:
 			syncCommitteeContributionValueCheckF := genesisspecssv.SyncCommitteeContributionValueCheckF(options.GenesisOptions.Signer, genesisBeaconNetwork, options.SSVShare.Share.ValidatorPubKey[:], options.SSVShare.BeaconMetadata.Index)
 			qbftCtrl := buildController(genesisspectypes.BNRoleSyncCommitteeContribution, syncCommitteeContributionValueCheckF)
-			runners[role] = genesisrunner.NewSyncCommitteeAggregatorRunner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, syncCommitteeContributionValueCheckF, 0, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewSyncCommitteeAggregatorRunner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, syncCommitteeContributionValueCheckF, 0, options.Operator.OperatorID)
 		case genesisspectypes.BNRoleValidatorRegistration:
 			qbftCtrl := buildController(genesisspectypes.BNRoleValidatorRegistration, nil)
-			runners[role] = genesisrunner.NewValidatorRegistrationRunner(genesisBeaconNetwork, &options.SSVShare.Share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewValidatorRegistrationRunner(genesisBeaconNetwork, share, qbftCtrl, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, options.Operator.OperatorID)
 		case genesisspectypes.BNRoleVoluntaryExit:
-			runners[role] = genesisrunner.NewVoluntaryExitRunner(genesisBeaconNetwork, &options.SSVShare.Share, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, options.Operator.OperatorID)
+			runners[role] = genesisrunner.NewVoluntaryExitRunner(genesisBeaconNetwork, share, options.Beacon, options.GenesisOptions.Network, options.GenesisOptions.Signer, options.Operator.OperatorID)
 		}
 	}
 	return runners

operator/validator/controller_test.go

@@ -27,6 +27,7 @@ import (
 	genesisibftstorage "github.com/ssvlabs/ssv/ibft/genesisstorage"
 	ibftstorage "github.com/ssvlabs/ssv/ibft/storage"
 	"github.com/ssvlabs/ssv/logging"
+	"github.com/ssvlabs/ssv/network"
 	"github.com/ssvlabs/ssv/networkconfig"
 	operatordatastore "github.com/ssvlabs/ssv/operator/datastore"
 	"github.com/ssvlabs/ssv/operator/keys"
@@ -280,7 +281,7 @@ func TestHandleNonCommitteeMessages(t *testing.T) {
 
 	var wg sync.WaitGroup
 
-	ctr.messageWorker.UseHandler(func(msg *queue.DecodedSSVMessage) error {
+	ctr.messageWorker.UseHandler(func(msg network.SSVMessageInterface) error {
 		wg.Done()
 		return nil
 	})
@@ -289,39 +290,39 @@ func TestHandleNonCommitteeMessages(t *testing.T) {
 
 	identifier := spectypes.NewMsgID(networkconfig.TestNetwork.DomainType(), []byte("pk"), spectypes.RoleCommittee)
 
-	ctr.messageRouter.Route(context.TODO(), &queue.DecodedSSVMessage{
+	ctr.messageRouter.Route(context.TODO(), &queue.SSVMessage{
 		SSVMessage: &spectypes.SSVMessage{ // checks that not process unnecessary message
 			MsgType: spectypes.SSVConsensusMsgType,
 			MsgID:   identifier,
 			Data:    generateDecidedMessage(t, identifier),
 		},
 	})
 
-	ctr.messageRouter.Route(context.TODO(), &queue.DecodedSSVMessage{
+	ctr.messageRouter.Route(context.TODO(), &queue.SSVMessage{
 		SSVMessage: &spectypes.SSVMessage{ // checks that not process unnecessary message
 			MsgType: spectypes.SSVConsensusMsgType,
 			MsgID:   identifier,
 			Data:    generateChangeRoundMsg(t, identifier),
 		},
 	})
 
-	ctr.messageRouter.Route(context.TODO(), &queue.DecodedSSVMessage{
+	ctr.messageRouter.Route(context.TODO(), &queue.SSVMessage{
 		SSVMessage: &spectypes.SSVMessage{ // checks that not process unnecessary message
 			MsgType: message.SSVSyncMsgType,
 			MsgID:   identifier,
 			Data:    []byte("data"),
 		},
 	})
 
-	ctr.messageRouter.Route(context.TODO(), &queue.DecodedSSVMessage{
+	ctr.messageRouter.Route(context.TODO(), &queue.SSVMessage{
 		SSVMessage: &spectypes.SSVMessage{
 			MsgType: spectypes.SSVPartialSignatureMsgType,
 			MsgID:   identifier,
 			Data:    []byte("data"),
 		},
 	})
 
-	ctr.messageRouter.Route(context.TODO(), &queue.DecodedSSVMessage{
+	ctr.messageRouter.Route(context.TODO(), &queue.SSVMessage{
 		SSVMessage: &spectypes.SSVMessage{
 			MsgType: spectypes.SSVPartialSignatureMsgType,
 			MsgID:   identifier,

operator/validator/router_test.go

@@ -41,7 +41,7 @@ func TestRouter(t *testing.T) {
 	}()
 
 	for i := 0; i < expectedCount; i++ {
-		msg := &queue.DecodedSSVMessage{
+		msg := &queue.SSVMessage{
 			SSVMessage: &spectypes.SSVMessage{
 				MsgType: spectypes.MsgType(i % 3),
 				MsgID:   spectypes.NewMsgID(networkconfig.TestNetwork.DomainType(), []byte{1, 1, 1, 1, 1}, spectypes.RoleCommittee),

protocol/genesis/qbft/config.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/ssvlabs/ssv/protocol/genesis/qbft/roundtimer"
 	qbftstorage "github.com/ssvlabs/ssv/protocol/genesis/qbft/storage"
-	"github.com/ssvlabs/ssv/protocol/genesis/types"
 )
 
 type signing interface {
@@ -21,7 +20,7 @@ type IConfig interface {
 	// GetValueCheckF returns value check function
 	GetValueCheckF() genesisspecqbft.ProposedValueCheckF
 	// GetProposerF returns func used to calculate proposer
-	GetProposerF() func(state *types.State, round genesisspecqbft.Round) genesisspectypes.OperatorID
+	GetProposerF() genesisspecqbft.ProposerF
 	// GetNetwork returns a p2p Network instance
 	GetNetwork() genesisspecqbft.Network
 	// GetStorage returns a storage instance
@@ -39,7 +38,7 @@ type Config struct {
 	SigningPK             []byte
 	Domain                genesisspectypes.DomainType
 	ValueCheckF           genesisspecqbft.ProposedValueCheckF
-	ProposerF             func(state *types.State, round genesisspecqbft.Round) genesisspectypes.OperatorID
+	ProposerF             genesisspecqbft.ProposerF
 	Storage               qbftstorage.QBFTStore
 	Network               genesisspecqbft.Network
 	Timer                 roundtimer.Timer
@@ -68,7 +67,7 @@ func (c *Config) GetValueCheckF() genesisspecqbft.ProposedValueCheckF {
 }
 
 // GetProposerF returns func used to calculate proposer
-func (c *Config) GetProposerF() func(state *types.State, round genesisspecqbft.Round) genesisspectypes.OperatorID {
+func (c *Config) GetProposerF() genesisspecqbft.ProposerF {
 	return c.ProposerF
 }