chore: 06-solomachine adding CheckForMisbehaviour and UpdateStateOnMisbehaviour

modules/light-clients/06-solomachine/types/misbehaviour.go

@@ -22,6 +22,12 @@ func (misbehaviour Misbehaviour) Type() string {
 	return exported.TypeClientMisbehaviour
 }
 
+// TODO: Remove GetHeight() when new interface type ClientMessage is introduced
+// GetHeight implements the exported.Header interface
+func (misbehaviour Misbehaviour) GetHeight() exported.Height {
+	return nil
+}
+
 // ValidateBasic implements Misbehaviour interface.
 func (misbehaviour Misbehaviour) ValidateBasic() error {
 	if err := host.ClientIdentifierValidator(misbehaviour.ClientId); err != nil {

modules/light-clients/06-solomachine/types/update.go

@@ -17,74 +17,116 @@ import (
 // - the currently registered public key did not provide the update signature
 func (cs ClientState) CheckHeaderAndUpdateState(
 	ctx sdk.Context, cdc codec.BinaryCodec, clientStore sdk.KVStore,
-	header exported.Header,
+	msg exported.Header, // TODO: Update to exported.ClientMessage
 ) (exported.ClientState, exported.ConsensusState, error) {
-	smHeader, ok := header.(*Header)
-	if !ok {
-		return nil, nil, sdkerrors.Wrapf(
-			clienttypes.ErrInvalidHeader, "header type %T, expected  %T", header, &Header{},
-		)
+	if err := cs.VerifyClientMessage(cdc, msg); err != nil {
+		return nil, nil, err
 	}
 
-	if err := checkHeader(cdc, &cs, smHeader); err != nil {
-		return nil, nil, err
+	foundMisbehaviour := cs.CheckForMisbehaviour(ctx, cdc, clientStore, msg)
+	if foundMisbehaviour {
+		return cs.UpdateStateOnMisbehaviour(ctx, cdc, clientStore)
 	}
 
-	clientState, consensusState := update(&cs, smHeader)
-	return clientState, consensusState, nil
+	return cs.UpdateState(ctx, cdc, clientStore, msg)
 }
 
-// checkHeader checks if the Solo Machine update signature is valid.
-func checkHeader(cdc codec.BinaryCodec, clientState *ClientState, header *Header) error {
-	// assert update sequence is current sequence
-	if header.Sequence != clientState.Sequence {
-		return sdkerrors.Wrapf(
-			clienttypes.ErrInvalidHeader,
-			"header sequence does not match the client state sequence (%d != %d)", header.Sequence, clientState.Sequence,
-		)
-	}
+// VerifyClientMessage checks if the Solo Machine update signature(s) is valid.
+func (cs ClientState) VerifyClientMessage(cdc codec.BinaryCodec, clientMsg exported.Header) error {
+	switch msg := clientMsg.(type) {
+	case *Header:
+		// assert update sequence is current sequence
+		if msg.Sequence != cs.Sequence {
+			return sdkerrors.Wrapf(
+				clienttypes.ErrInvalidHeader,
+				"header sequence does not match the client state sequence (%d != %d)", msg.Sequence, cs.Sequence,
+			)
+		}
 
-	// assert update timestamp is not less than current consensus state timestamp
-	if header.Timestamp < clientState.ConsensusState.Timestamp {
-		return sdkerrors.Wrapf(
-			clienttypes.ErrInvalidHeader,
-			"header timestamp is less than to the consensus state timestamp (%d < %d)", header.Timestamp, clientState.ConsensusState.Timestamp,
-		)
-	}
+		// assert update timestamp is not less than current consensus state timestamp
+		if msg.Timestamp < cs.ConsensusState.Timestamp {
+			return sdkerrors.Wrapf(
+				clienttypes.ErrInvalidHeader,
+				"header timestamp is less than to the consensus state timestamp (%d < %d)", msg.Timestamp, cs.ConsensusState.Timestamp,
+			)
+		}
 
-	// assert currently registered public key signed over the new public key with correct sequence
-	data, err := HeaderSignBytes(cdc, header)
-	if err != nil {
-		return err
-	}
+		// assert currently registered public key signed over the new public key with correct sequence
+		data, err := HeaderSignBytes(cdc, msg)
+		if err != nil {
+			return err
+		}
 
-	sigData, err := UnmarshalSignatureData(cdc, header.Signature)
-	if err != nil {
-		return err
-	}
+		sigData, err := UnmarshalSignatureData(cdc, msg.Signature)
+		if err != nil {
+			return err
+		}
+
+		publicKey, err := cs.ConsensusState.GetPubKey()
+		if err != nil {
+			return err
+		}
+
+		if err := VerifySignature(publicKey, data, sigData); err != nil {
+			return sdkerrors.Wrap(ErrInvalidHeader, err.Error())
+		}
+	case *Misbehaviour:
+		// NOTE: a check that the misbehaviour message data are not equal is done by
+		// misbehaviour.ValidateBasic which is called by the 02-client keeper.
+		// verify first signature
+		if err := verifySignatureAndData(cdc, cs, msg, msg.SignatureOne); err != nil {
+			return sdkerrors.Wrap(err, "failed to verify signature one")
+		}
 
-	publicKey, err := clientState.ConsensusState.GetPubKey()
-	if err != nil {
-		return err
+		// verify second signature
+		if err := verifySignatureAndData(cdc, cs, msg, msg.SignatureTwo); err != nil {
+			return sdkerrors.Wrap(err, "failed to verify signature two")
+		}
+
+	default:
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expected type %T, got type %T", Header{}, msg)
 	}
+	return nil
+}
 
-	if err := VerifySignature(publicKey, data, sigData); err != nil {
-		return sdkerrors.Wrap(ErrInvalidHeader, err.Error())
+// CheckForMisbehaviour returns true for type Misbehaviour (passed VerifyClientMessage check), otherwise returns false
+func (cs ClientState) CheckForMisbehaviour(
+	_ sdk.Context, _ codec.BinaryCodec, _ sdk.KVStore,
+	msg exported.Header, // TODO: Update to exported.ClientMessage
+) bool {
+	var foundMisbehaviour bool
+	switch msg.(type) {
+	case *Header:
+		foundMisbehaviour = false
+	case *Misbehaviour:
+		foundMisbehaviour = true
 	}
 
-	return nil
+	return foundMisbehaviour
 }
 
-// update the consensus state to the new public key and an incremented sequence
-func update(clientState *ClientState, header *Header) (*ClientState, *ConsensusState) {
+// UpdateStateOnMisbehaviour updates state upon misbehaviour. This method should only be called on misbehaviour
+// as it does not perform any misbehaviour checks.
+func (cs ClientState) UpdateStateOnMisbehaviour(
+	_ sdk.Context, _ codec.BinaryCodec, _ sdk.KVStore, // prematurely include args for self storage of consensus state
+) (*ClientState, exported.ConsensusState, error) {
+	cs.IsFrozen = true
+	return &cs, cs.ConsensusState, nil
+}
+
+// UpdateState updates the consensus state to the new public key and an incremented sequence.
+func (cs ClientState) UpdateState(
+	ctx sdk.Context, cdc codec.BinaryCodec, clientStore sdk.KVStore,
+	header exported.Header,
+) (exported.ClientState, exported.ConsensusState, error) {
+	smHeader := header.(*Header)
 	consensusState := &ConsensusState{
-		PublicKey:   header.NewPublicKey,
-		Diversifier: header.NewDiversifier,
-		Timestamp:   header.Timestamp,
+		PublicKey:   smHeader.NewPublicKey,
+		Diversifier: smHeader.NewDiversifier,
+		Timestamp:   smHeader.Timestamp,
 	}
 
-	// increment sequence number
-	clientState.Sequence++
-	clientState.ConsensusState = consensusState
-	return clientState, consensusState
+	cs.Sequence++
+	cs.ConsensusState = consensusState
+	return &cs, consensusState, nil
 }