Pre consensus fix

qbft/round_change.go

@@ -318,7 +318,9 @@ func getRoundChangeData(state *State, config IConfig, instanceStartValue []byte)
 
 		return state.LastPreparedRound, r, state.LastPreparedValue, justifications, nil
 	}
-	return NoRound, [32]byte{}, nil, nil, nil
+
+	// If not previously prepared, return start value as full value for pre-consensus justification
+	return NoRound, [32]byte{}, instanceStartValue, nil, nil
 }
 
 // CreateRoundChange

ssv/aggregator.go

@@ -27,15 +27,13 @@ func NewAggregatorRunner(
 	network Network,
 	signer types.KeyManager,
 	valCheck qbft.ProposedValueCheckF,
-	highestDecidedSlot phase0.Slot,
 ) Runner {
 	return &AggregatorRunner{
 		BaseRunner: &BaseRunner{
-			BeaconRoleType:     types.BNRoleAggregator,
-			BeaconNetwork:      beaconNetwork,
-			Share:              share,
-			QBFTController:     qbftController,
-			highestDecidedSlot: highestDecidedSlot,
+			BeaconRoleType: types.BNRoleAggregator,
+			BeaconNetwork:  beaconNetwork,
+			Share:          share,
+			QBFTController: qbftController,
 		},
 
 		beacon:   beacon,
@@ -55,13 +53,13 @@ func (r *AggregatorRunner) HasRunningDuty() bool {
 }
 
 func (r *AggregatorRunner) ProcessPreConsensus(signedMsg *types.SignedPartialSignatureMessage) error {
-	quorum, roots, err := r.BaseRunner.basePreConsensusMsgProcessing(r, signedMsg)
+	shouldProcess, roots, err := r.BaseRunner.basePreConsensusMsgProcessing(r, signedMsg)
 	if err != nil {
 		return errors.Wrap(err, "failed processing selection proof message")
 	}
 
-	// quorum returns true only once (first time quorum achieved)
-	if !quorum {
+	// shouldProcess returns true only once (first time shouldProcess achieved)
+	if !shouldProcess {
 		return nil
 	}
 
@@ -88,9 +86,10 @@ func (r *AggregatorRunner) ProcessPreConsensus(signedMsg *types.SignedPartialSig
 		return errors.Wrap(err, "could not marshal aggregate and proof")
 	}
 	input := &types.ConsensusData{
-		Duty:    *duty,
-		Version: ver,
-		DataSSZ: byts,
+		Duty:                       *duty,
+		PreConsensusJustifications: r.BaseRunner.State.GetPreConsensusJustification(),
+		Version:                    ver,
+		DataSSZ:                    byts,
 	}
 
 	if err := r.BaseRunner.decide(r, input); err != nil {

ssv/attester.go

@@ -28,15 +28,13 @@ func NewAttesterRunnner(
 	network Network,
 	signer types.KeyManager,
 	valCheck qbft.ProposedValueCheckF,
-	highestDecidedSlot phase0.Slot,
 ) Runner {
 	return &AttesterRunner{
 		BaseRunner: &BaseRunner{
-			BeaconRoleType:     types.BNRoleAttester,
-			BeaconNetwork:      beaconNetwork,
-			Share:              share,
-			QBFTController:     qbftController,
-			highestDecidedSlot: highestDecidedSlot,
+			BeaconRoleType: types.BNRoleAttester,
+			BeaconNetwork:  beaconNetwork,
+			Share:          share,
+			QBFTController: qbftController,
 		},
 
 		beacon:   beacon,

ssv/partial_sig_container.go

@@ -1,39 +1,25 @@
 package ssv
 
 import (
-	"encoding/hex"
+	"bytes"
 	"github.com/bloxapp/ssv-spec/types"
 	"github.com/pkg/errors"
+	"sort"
 )
 
-type PartialSigContainer struct {
-	Signatures map[string]map[types.OperatorID][]byte
-	// Quorum is the number of min signatures needed for quorum
-	Quorum uint64
-}
+type PartialSignatureContainer map[types.OperatorID]*types.SignedPartialSignatureMessage
 
-func NewPartialSigContainer(quorum uint64) *PartialSigContainer {
-	return &PartialSigContainer{
-		Quorum:     quorum,
-		Signatures: make(map[string]map[types.OperatorID][]byte),
-	}
+func NewPartialSignatureContainer() PartialSignatureContainer {
+	return make(PartialSignatureContainer)
 }
 
-func (ps *PartialSigContainer) AddSignature(sigMsg *types.PartialSignatureMessage) {
-	if ps.Signatures[rootHex(sigMsg.SigningRoot)] == nil {
-		ps.Signatures[rootHex(sigMsg.SigningRoot)] = make(map[types.OperatorID][]byte)
-	}
-	m := ps.Signatures[rootHex(sigMsg.SigningRoot)]
+// ReconstructSignature return reconstructed signature for a root
+func (ps PartialSignatureContainer) ReconstructSignature(root [32]byte, validatorPubKey []byte) ([]byte, error) {
+	// collect signatures
+	sigs := ps.SignaturesForRoot(root)
 
-	if m[sigMsg.Signer] == nil {
-		m[sigMsg.Signer] = make([]byte, 96)
-		copy(m[sigMsg.Signer], sigMsg.PartialSignature)
-	}
-}
-
-func (ps *PartialSigContainer) ReconstructSignature(root [32]byte, validatorPubKey []byte) ([]byte, error) {
-	// Reconstruct signatures
-	signature, err := types.ReconstructSignatures(ps.Signatures[rootHex(root)])
+	// reconstruct
+	signature, err := types.ReconstructSignatures(sigs)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to reconstruct signatures")
 	}
@@ -43,10 +29,44 @@ func (ps *PartialSigContainer) ReconstructSignature(root [32]byte, validatorPubK
 	return signature.Serialize(), nil
 }
 
-func (ps *PartialSigContainer) HasQuorum(root [32]byte) bool {
-	return uint64(len(ps.Signatures[rootHex(root)])) >= ps.Quorum
+// SignaturesForRoot returns a map of signer and signature for a specific root
+func (ps PartialSignatureContainer) SignaturesForRoot(root [32]byte) map[types.OperatorID][]byte {
+	sigs := make(map[types.OperatorID][]byte, 0)
+	for operatorID, sigMsg := range ps {
+		for _, msg := range sigMsg.Message.Messages {
+			if bytes.Equal(msg.SigningRoot[:], root[:]) {
+				sigs[operatorID] = msg.PartialSignature
+			}
+		}
+	}
+	return sigs
+}
+
+// Roots returns roots for the partial sigs
+func (ps PartialSignatureContainer) Roots() [][32]byte {
+	ret := make([][32]byte, 0)
+
+	if len(ps) <= 0 {
+		return ret
+	}
+
+	for _, sigMsg := range ps {
+		for _, msg := range sigMsg.Message.Messages {
+			ret = append(ret, msg.SigningRoot)
+		}
+		break // only need to iterate first msg
+	}
+	return ret
 }
 
-func rootHex(r [32]byte) string {
-	return hex.EncodeToString(r[:])
+// AllSorted returns ordered by signer array of signed messages
+func (ps PartialSignatureContainer) AllSorted() []*types.SignedPartialSignatureMessage {
+	ret := make([]*types.SignedPartialSignatureMessage, len(ps))
+	for _, m := range ps {
+		ret = append(ret, m)
+	}
+	sort.Slice(ret, func(i, j int) bool {
+		return ret[i].Signer < ret[j].Signer
+	})
+	return ret
 }

ssv/pre_consensus_justification.go

@@ -1,35 +1,23 @@
 package ssv
 
 import (
-	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/bloxapp/ssv-spec/qbft"
 	"github.com/bloxapp/ssv-spec/types"
 	"github.com/pkg/errors"
 )
 
-// correctQBFTState returns true if QBFT controller state requires pre-consensus justification
-func (b *BaseRunner) correctQBFTState(msg *qbft.SignedMessage) bool {
-	inst := b.QBFTController.InstanceForHeight(b.QBFTController.Height)
-	decidedInstance := inst != nil && inst.State != nil && inst.State.Decided
-
-	// firstHeightNotDecided is true if height == 0 (special case) and did not start yet
-	firstHeightNotDecided := inst == nil && b.QBFTController.Height == msg.Message.Height && msg.Message.Height == qbft.FirstHeight
-
-	// notFirstHeightDecided returns true if height != 0, height decided and the message is for next height
-	notFirstHeightDecided := decidedInstance && msg.Message.Height > qbft.FirstHeight && b.QBFTController.Height+1 == msg.Message.Height
-
-	return firstHeightNotDecided || notFirstHeightDecided
-}
-
-// shouldProcessingJustificationsForHeight returns true if pre-consensus justification should be processed, false otherwise
-func (b *BaseRunner) shouldProcessingJustificationsForHeight(msg *qbft.SignedMessage) bool {
-	correctMsgTYpe := msg.Message.MsgType == qbft.ProposalMsgType || msg.Message.MsgType == qbft.RoundChangeMsgType
-	correctBeaconRole := b.BeaconRoleType == types.BNRoleProposer || b.BeaconRoleType == types.BNRoleAggregator || b.BeaconRoleType == types.BNRoleSyncCommitteeContribution
-	return b.correctQBFTState(msg) && correctMsgTYpe && correctBeaconRole
+// shouldProcessJustifications returns true if pre-consensus justification should be processed, false otherwise
+func (b *BaseRunner) shouldProcessJustifications(msg *qbft.SignedMessage) bool {
+	correctMsgType := msg.Message.MsgType == qbft.ProposalMsgType || msg.Message.MsgType == qbft.RoundChangeMsgType
+	correctBeaconRole := b.BeaconRoleType == types.BNRoleProposer || b.BeaconRoleType == types.BNRoleAggregator ||
+		b.BeaconRoleType == types.BNRoleSyncCommitteeContribution
+	correctQBFTHeight := b.QBFTController.Height < msg.Message.Height ||
+		(b.QBFTController.Height == msg.Message.Height && b.QBFTController.Height == qbft.FirstHeight)
+	return correctMsgType && correctBeaconRole && correctQBFTHeight
 }
 
 // validatePreConsensusJustifications returns an error if pre-consensus justification is invalid, nil otherwise
-func (b *BaseRunner) validatePreConsensusJustifications(data *types.ConsensusData, highestDecidedDutySlot phase0.Slot) error {
+func (b *BaseRunner) validatePreConsensusJustifications(data *types.ConsensusData) error {
 	//test invalid consensus data
 	if err := data.Validate(); err != nil {
 		return err
@@ -39,8 +27,8 @@ func (b *BaseRunner) validatePreConsensusJustifications(data *types.ConsensusDat
 		return errors.New("wrong beacon role")
 	}
 
-	if data.Duty.Slot <= highestDecidedDutySlot {
-		return errors.New("duty.slot <= highest decided slot")
+	if qbft.Height(data.Duty.Slot) <= b.QBFTController.Height && b.QBFTController.Height != qbft.FirstHeight {
+		return errors.New("duty.slot <= highest known slot")
 	}
 
 	// validate justification quorum
@@ -110,8 +98,8 @@ func (b *BaseRunner) validatePreConsensusJustifications(data *types.ConsensusDat
 5) add pre-consensus sigs to container
 6) decided on duty
 */
-func (b *BaseRunner) processPreConsensusJustification(runner Runner, highestDecidedDutySlot phase0.Slot, msg *qbft.SignedMessage) error {
-	if !b.shouldProcessingJustificationsForHeight(msg) {
+func (b *BaseRunner) processPreConsensusJustification(runner Runner, msg *qbft.SignedMessage) error {
+	if !b.shouldProcessJustifications(msg) {
 		return nil
 	}
 
@@ -120,7 +108,7 @@ func (b *BaseRunner) processPreConsensusJustification(runner Runner, highestDeci
 		return errors.Wrap(err, "could not decoded ConsensusData")
 	}
 
-	if err := b.validatePreConsensusJustifications(cd, highestDecidedDutySlot); err != nil {
+	if err := b.validatePreConsensusJustifications(cd); err != nil {
 		return err
 	}
 

ssv/proposer.go

@@ -32,15 +32,13 @@ func NewProposerRunner(
 	network Network,
 	signer types.KeyManager,
 	valCheck qbft.ProposedValueCheckF,
-	highestDecidedSlot phase0.Slot,
 ) Runner {
 	return &ProposerRunner{
 		BaseRunner: &BaseRunner{
-			BeaconRoleType:     types.BNRoleProposer,
-			BeaconNetwork:      beaconNetwork,
-			Share:              share,
-			QBFTController:     qbftController,
-			highestDecidedSlot: highestDecidedSlot,
+			BeaconRoleType: types.BNRoleProposer,
+			BeaconNetwork:  beaconNetwork,
+			Share:          share,
+			QBFTController: qbftController,
 		},
 
 		beacon:   beacon,
@@ -60,13 +58,13 @@ func (r *ProposerRunner) HasRunningDuty() bool {
 }
 
 func (r *ProposerRunner) ProcessPreConsensus(signedMsg *types.SignedPartialSignatureMessage) error {
-	quorum, roots, err := r.BaseRunner.basePreConsensusMsgProcessing(r, signedMsg)
+	shouldProcess, roots, err := r.BaseRunner.basePreConsensusMsgProcessing(r, signedMsg)
 	if err != nil {
 		return errors.Wrap(err, "failed processing randao message")
 	}
 
-	// quorum returns true only once (first time quorum achieved)
-	if !quorum {
+	// shouldProcess returns true only once (first time shouldProcess achieved)
+	if !shouldProcess {
 		return nil
 	}
 
@@ -102,9 +100,10 @@ func (r *ProposerRunner) ProcessPreConsensus(signedMsg *types.SignedPartialSigna
 	}
 
 	input := &types.ConsensusData{
-		Duty:    *duty,
-		Version: ver,
-		DataSSZ: byts,
+		Duty:                       *duty,
+		PreConsensusJustifications: r.BaseRunner.State.GetPreConsensusJustification(),
+		Version:                    ver,
+		DataSSZ:                    byts,
 	}
 
 	if err := r.BaseRunner.decide(r, input); err != nil {