evidence: migrate reactor to proto (#4949)

## Description

migration of evidence reactor to proto

Closes: #XXX

CHANGELOG_PENDING.md

@@ -41,6 +41,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
   - [store] \#4778 Transition store module to protobuf encoding
     - `BlockStoreStateJSON` is now `BlockStoreState` and is encoded as binary in the database
   - [rpc] \#4968 JSON encoding is now handled by `libs/json`, not Amino
+  - [evidence] \#4949 `evidence` reactor migration to Protobuf encoding
 
 - Apps
 

evidence/codec.go

@@ -1,21 +0,0 @@
-package evidence
-
-import (
-	amino "github.com/tendermint/go-amino"
-
-	cryptoamino "github.com/tendermint/tendermint/crypto/encoding/amino"
-	"github.com/tendermint/tendermint/types"
-)
-
-var cdc = amino.NewCodec()
-
-func init() {
-	RegisterMessages(cdc)
-	cryptoamino.RegisterAmino(cdc)
-	types.RegisterEvidences(cdc)
-}
-
-// For testing purposes only
-func RegisterMockEvidences() {
-	types.RegisterMockEvidences(cdc)
-}

evidence/pool.go

@@ -5,10 +5,13 @@ import (
 	"sync"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
+	gogotypes "github.com/gogo/protobuf/types"
 	dbm "github.com/tendermint/tm-db"
 
 	clist "github.com/tendermint/tendermint/libs/clist"
 	"github.com/tendermint/tendermint/libs/log"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
@@ -131,7 +134,14 @@ func (evpool *Pool) Update(block *types.Block, state sm.State) {
 // that may be needed in the future to verify votes
 func (evpool *Pool) AddPOLC(polc types.ProofOfLockChange) error {
 	key := keyPOLC(polc)
-	polcBytes := cdc.MustMarshalBinaryBare(polc)
+	pbplc, err := polc.ToProto()
+	if err != nil {
+		return err
+	}
+	polcBytes, err := proto.Marshal(pbplc)
+	if err != nil {
+		return fmt.Errorf("addPOLC: unable to marshal ProofOfLockChange: %w", err)
+	}
 	return evpool.evidenceStore.Set(key, polcBytes)
 }
 
@@ -214,7 +224,13 @@ func (evpool *Pool) MarkEvidenceAsCommitted(height int64, lastBlockTime time.Tim
 	for _, ev := range evidence {
 		// As the evidence is stored in the block store we only need to record the height that it was saved at.
 		key := keyCommitted(ev)
-		evBytes := cdc.MustMarshalBinaryBare(height)
+
+		h := gogotypes.Int64Value{Value: height}
+		evBytes, err := proto.Marshal(&h)
+		if err != nil {
+			panic(err)
+		}
+
 		if err := evpool.evidenceStore.Set(key, evBytes); err != nil {
 			evpool.logger.Error("Unable to add committed evidence", "err", err)
 			// if we can't move evidence to committed then don't remove the evidence from pending
@@ -276,18 +292,28 @@ func (evpool *Pool) IsPending(evidence types.Evidence) bool {
 }
 
 // RetrievePOLC attempts to find a polc at the given height and round, if not there it returns an error
-func (evpool *Pool) RetrievePOLC(height int64, round int32) (types.ProofOfLockChange, error) {
-	var polc types.ProofOfLockChange
+func (evpool *Pool) RetrievePOLC(height int64, round int32) (polc types.ProofOfLockChange, err error) {
+	var pbpolc tmproto.ProofOfLockChange
 	key := keyPOLCFromHeightAndRound(height, round)
 	polcBytes, err := evpool.evidenceStore.Get(key)
 	if err != nil {
 		return polc, err
 	}
+
 	if polcBytes == nil {
 		return polc, fmt.Errorf("unable to find polc at height %d and round %d", height, round)
 	}
-	err = cdc.UnmarshalBinaryBare(polcBytes, &polc)
-	return polc, err
+
+	err = proto.Unmarshal(polcBytes, &pbpolc)
+	if err != nil {
+		return polc, err
+	}
+	plc, err := types.ProofOfLockChangeFromProto(&pbpolc)
+	if err != nil {
+		return polc, err
+	}
+
+	return *plc, err
 }
 
 // EvidenceFront goes to the first evidence in the clist
@@ -338,8 +364,18 @@ func (evpool *Pool) State() sm.State {
 }
 
 func (evpool *Pool) addPendingEvidence(evidence types.Evidence) error {
-	evBytes := cdc.MustMarshalBinaryBare(evidence)
+	evi, err := types.EvidenceToProto(evidence)
+	if err != nil {
+		return err
+	}
+
+	evBytes, err := proto.Marshal(evi)
+	if err != nil {
+		return fmt.Errorf("unable to marshal evidence: %w", err)
+	}
+
 	key := keyPending(evidence)
+
 	return evpool.evidenceStore.Set(key, evBytes)
 }
 
@@ -370,13 +406,23 @@ func (evpool *Pool) listEvidence(prefixKey byte, maxNum int64) ([]types.Evidence
 		}
 		count++
 
-		var ev types.Evidence
-		err := cdc.UnmarshalBinaryBare(val, &ev)
+		var (
+			ev   types.Evidence
+			evpb tmproto.Evidence
+		)
+		err := proto.Unmarshal(val, &evpb)
 		if err != nil {
 			return nil, err
 		}
+
+		ev, err = types.EvidenceFromProto(&evpb)
+		if err != nil {
+			return nil, err
+		}
+
 		evidence = append(evidence, ev)
 	}
+
 	return evidence, nil
 }
 
@@ -390,16 +436,26 @@ func (evpool *Pool) removeExpiredPendingEvidence() {
 	blockEvidenceMap := make(map[string]struct{})
 	for ; iter.Valid(); iter.Next() {
 		evBytes := iter.Value()
-		var ev types.Evidence
-		err := cdc.UnmarshalBinaryBare(evBytes, &ev)
+		var (
+			ev   types.Evidence
+			evpb tmproto.Evidence
+		)
+		err := proto.Unmarshal(evBytes, &evpb)
 		if err != nil {
-			evpool.logger.Error("Unable to unmarshal POLC", "err", err)
+			evpool.logger.Error("Unable to unmarshal Evidence", "err", err)
+			continue
+		}
+
+		ev, err = types.EvidenceFromProto(&evpb)
+		if err != nil {
+			evpool.logger.Error("Error in transition evidence from protobuf", "err", err)
 			continue
 		}
 		if !evpool.IsExpired(ev.Height()-1, ev.Time()) {
 			if len(blockEvidenceMap) != 0 {
 				evpool.removeEvidenceFromList(blockEvidenceMap)
 			}
+
 			return
 		}
 		evpool.removePendingEvidence(ev)
@@ -430,12 +486,19 @@ func (evpool *Pool) pruneExpiredPOLC() {
 	defer iter.Close()
 	for ; iter.Valid(); iter.Next() {
 		proofBytes := iter.Value()
-		var proof types.ProofOfLockChange
-		err := cdc.UnmarshalBinaryBare(proofBytes, &proof)
+		var (
+			pbproof tmproto.ProofOfLockChange
+		)
+		err := proto.Unmarshal(proofBytes, &pbproof)
 		if err != nil {
 			evpool.logger.Error("Unable to unmarshal POLC", "err", err)
 			continue
 		}
+		proof, err := types.ProofOfLockChangeFromProto(&pbproof)
+		if err != nil {
+			evpool.logger.Error("Unable to transition POLC from protobuf", "err", err)
+			continue
+		}
 		if !evpool.IsExpired(proof.Height()-1, proof.Time()) {
 			return
 		}

evidence/pool_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -21,7 +22,6 @@ import (
 )
 
 func TestMain(m *testing.M) {
-	RegisterMockEvidences()
 
 	code := m.Run()
 	os.Exit(code)
@@ -269,12 +269,20 @@ func TestRecoverPendingEvidence(t *testing.T) {
 
 	// load good evidence
 	goodKey := keyPending(goodEvidence)
-	goodEvidenceBytes := cdc.MustMarshalBinaryBare(goodEvidence)
+	evi, err := types.EvidenceToProto(goodEvidence)
+	require.NoError(t, err)
+	goodEvidenceBytes, err := proto.Marshal(evi)
+	require.NoError(t, err)
 	_ = evidenceDB.Set(goodKey, goodEvidenceBytes)
 
 	// load expired evidence
 	expiredKey := keyPending(expiredEvidence)
-	expiredEvidenceBytes := cdc.MustMarshalBinaryBare(expiredEvidence)
+	eevi, err := types.EvidenceToProto(expiredEvidence)
+	require.NoError(t, err)
+
+	expiredEvidenceBytes, err := proto.Marshal(eevi)
+	require.NoError(t, err)
+
 	_ = evidenceDB.Set(expiredKey, expiredEvidenceBytes)
 	pool, err := NewPool(stateDB, evidenceDB, blockStore)
 	require.NoError(t, err)

evidence/reactor.go

@@ -2,14 +2,14 @@ package evidence
 
 import (
 	"fmt"
-	"reflect"
 	"time"
 
-	amino "github.com/tendermint/go-amino"
-
+	"github.com/gogo/protobuf/proto"
 	clist "github.com/tendermint/tendermint/libs/clist"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
+	ep "github.com/tendermint/tendermint/proto/evidence"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -64,39 +64,26 @@ func (evR *Reactor) AddPeer(peer p2p.Peer) {
 // Receive implements Reactor.
 // It adds any received evidence to the evpool.
 func (evR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	msg, err := decodeMsg(msgBytes)
+	evis, err := decodeMsg(msgBytes)
 	if err != nil {
-		evR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
-		evR.Switch.StopPeerForError(src, err)
-		return
-	}
-
-	if err = msg.ValidateBasic(); err != nil {
-		evR.Logger.Error("Peer sent us invalid msg", "peer", src, "msg", msg, "err", err)
+		evR.Logger.Error("Error decoding message", "src", src, "chId", chID, "err", err, "bytes", msgBytes)
 		evR.Switch.StopPeerForError(src, err)
 		return
 	}
 
-	evR.Logger.Debug("Receive", "src", src, "chId", chID, "msg", msg)
-
-	switch msg := msg.(type) {
-	case *ListMessage:
-		for _, ev := range msg.Evidence {
-			err := evR.evpool.AddEvidence(ev)
-			switch err.(type) {
-			case ErrInvalidEvidence:
-				evR.Logger.Error("Evidence is not valid", "evidence", msg.Evidence, "err", err)
-				// punish peer
-				evR.Switch.StopPeerForError(src, err)
-				return
-			case nil:
-			default:
-				evR.Logger.Error("Evidence has not been added", "evidence", msg.Evidence, "err", err)
-				return
-			}
+	for _, ev := range evis {
+		err := evR.evpool.AddEvidence(ev)
+		switch err.(type) {
+		case ErrInvalidEvidence:
+			evR.Logger.Error("Evidence is not valid", "evidence", evis, "err", err)
+			// punish peer
+			evR.Switch.StopPeerForError(src, err)
+			return
+		case nil:
+		default:
+			evR.Logger.Error("Evidence has not been added", "evidence", evis, "err", err)
+			return
 		}
-	default:
-		evR.Logger.Error(fmt.Sprintf("Unknown message type %v", reflect.TypeOf(msg)))
 	}
 }
 
@@ -131,9 +118,14 @@ func (evR *Reactor) broadcastEvidenceRoutine(peer p2p.Peer) {
 		}
 
 		ev := next.Value.(types.Evidence)
-		msg, retry := evR.checkSendEvidenceMessage(peer, ev)
-		if msg != nil {
-			success := peer.Send(EvidenceChannel, cdc.MustMarshalBinaryBare(msg))
+		evis, retry := evR.checkSendEvidenceMessage(peer, ev)
+		if len(evis) > 0 {
+			msgBytes, err := encodeMsg(evis)
+			if err != nil {
+				panic(err)
+			}
+
+			success := peer.Send(EvidenceChannel, msgBytes)
 			retry = !success
 		}
 
@@ -164,7 +156,7 @@ func (evR *Reactor) broadcastEvidenceRoutine(peer p2p.Peer) {
 func (evR Reactor) checkSendEvidenceMessage(
 	peer p2p.Peer,
 	ev types.Evidence,
-) (msg Message, retry bool) {
+) (evis []types.Evidence, retry bool) {
 
 	// make sure the peer is up to date
 	evHeight := ev.Height()
@@ -212,8 +204,7 @@ func (evR Reactor) checkSendEvidenceMessage(
 	}
 
 	// send evidence
-	msg = &ListMessage{[]types.Evidence{ev}}
-	return msg, false
+	return []types.Evidence{ev}, false
 }
 
 // PeerState describes the state of a peer.
@@ -221,43 +212,45 @@ type PeerState interface {
 	GetHeight() int64
 }
 
-//-----------------------------------------------------------------------------
-// Messages
-
-// Message is a message sent or received by the Reactor.
-type Message interface {
-	ValidateBasic() error
-}
+// encodemsg takes a array of evidence
+// returns the byte encoding of the List Message
+func encodeMsg(evis []types.Evidence) ([]byte, error) {
+	evi := make([]*tmproto.Evidence, len(evis))
+	for i := 0; i < len(evis); i++ {
+		ev, err := types.EvidenceToProto(evis[i])
+		if err != nil {
+			return nil, err
+		}
+		evi[i] = ev
+	}
 
-func RegisterMessages(cdc *amino.Codec) {
-	cdc.RegisterInterface((*Message)(nil), nil)
-	cdc.RegisterConcrete(&ListMessage{},
-		"tendermint/evidence/ListMessage", nil)
-}
+	epl := ep.List{
+		Evidence: evi,
+	}
 
-func decodeMsg(bz []byte) (msg Message, err error) {
-	err = cdc.UnmarshalBinaryBare(bz, &msg)
-	return
+	return proto.Marshal(&epl)
 }
 
-//-------------------------------------
-
-// ListMessage contains a list of evidence.
-type ListMessage struct {
-	Evidence []types.Evidence
-}
+// decodemsg takes an array of bytes
+// returns an array of evidence
+func decodeMsg(bz []byte) (evis []types.Evidence, err error) {
+	lm := ep.List{}
+	proto.Unmarshal(bz, &lm)
+
+	evis = make([]types.Evidence, len(lm.Evidence))
+	for i := 0; i < len(lm.Evidence); i++ {
+		ev, err := types.EvidenceFromProto(lm.Evidence[i])
+		if err != nil {
+			return nil, err
+		}
+		evis[i] = ev
+	}
 
-// ValidateBasic performs basic validation.
-func (m *ListMessage) ValidateBasic() error {
-	for i, ev := range m.Evidence {
+	for i, ev := range evis {
 		if err := ev.ValidateBasic(); err != nil {
-			return fmt.Errorf("invalid evidence (#%d): %v", i, err)
+			return nil, fmt.Errorf("invalid evidence (#%d): %v", i, err)
 		}
 	}
-	return nil
-}
 
-// String returns a string representation of the ListMessage.
-func (m *ListMessage) String() string {
-	return fmt.Sprintf("[ListMessage %v]", m.Evidence)
+	return evis, nil
 }

evidence/reactor_test.go

@@ -205,31 +205,3 @@ func TestReactorSelectiveBroadcast(t *testing.T) {
 	peers := reactors[1].Switch.Peers().List()
 	assert.Equal(t, 1, len(peers))
 }
-func TestListMessageValidationBasic(t *testing.T) {
-
-	testCases := []struct {
-		testName          string
-		malleateEvListMsg func(*ListMessage)
-		expectErr         bool
-	}{
-		{"Good ListMessage", func(evList *ListMessage) {}, false},
-		{"Invalid ListMessage", func(evList *ListMessage) {
-			evList.Evidence = append(evList.Evidence,
-				&types.DuplicateVoteEvidence{})
-		}, true},
-	}
-	for _, tc := range testCases {
-		tc := tc
-		t.Run(tc.testName, func(t *testing.T) {
-			evListMsg := &ListMessage{}
-			n := 3
-			valAddr := []byte("myval")
-			evListMsg.Evidence = make([]types.Evidence, n)
-			for i := 0; i < n; i++ {
-				evListMsg.Evidence[i] = types.NewMockEvidence(int64(i+1), time.Now(), valAddr)
-			}
-			tc.malleateEvListMsg(evListMsg)
-			assert.Equal(t, tc.expectErr, evListMsg.ValidateBasic() != nil, "Validate Basic had an unexpected result")
-		})
-	}
-}

node/node_test.go

@@ -252,7 +252,6 @@ func TestCreateProposalBlock(t *testing.T) {
 
 	// Make EvidencePool
 	types.RegisterMockEvidencesGlobal() // XXX!
-	evidence.RegisterMockEvidences()
 	evidenceDB := dbm.NewMemDB()
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 	evidencePool, err := evidence.NewPool(stateDB, evidenceDB, blockStore)

proto/evidence/msgs.pb.go

@@ -25,7 +25,7 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type List struct {
-	Evidence []types.Evidence `protobuf:"bytes,1,rep,name=evidence,proto3" json:"evidence"`
+	Evidence []*types.Evidence `protobuf:"bytes,1,rep,name=evidence,proto3" json:"evidence,omitempty"`
 }
 
 func (m *List) Reset()         { *m = List{} }
@@ -61,7 +61,7 @@ func (m *List) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_List proto.InternalMessageInfo
 
-func (m *List) GetEvidence() []types.Evidence {
+func (m *List) GetEvidence() []*types.Evidence {
 	if m != nil {
 		return m.Evidence
 	}
@@ -136,23 +136,24 @@ func init() {
 func init() { proto.RegisterFile("proto/evidence/msgs.proto", fileDescriptor_df8322769b0bd7d6) }
 
 var fileDescriptor_df8322769b0bd7d6 = []byte{
-	// 253 bytes of a gzipped FileDescriptorProto
+	// 258 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x4f, 0x2d, 0xcb, 0x4c, 0x49, 0xcd, 0x4b, 0x4e, 0xd5, 0xcf, 0x2d, 0x4e, 0x2f, 0xd6,
 	0x03, 0x8b, 0x09, 0x49, 0x96, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44,
 	0xf4, 0x60, 0xaa, 0xa4, 0xd4, 0x4a, 0x32, 0x32, 0x8b, 0x52, 0xe2, 0x0b, 0x12, 0x8b, 0x4a, 0x2a,
 	0xf5, 0x21, 0x26, 0xa4, 0xe7, 0xa7, 0xe7, 0x23, 0x58, 0x10, 0x0d, 0x52, 0x52, 0x10, 0x91, 0x92,
-	0xca, 0x82, 0xd4, 0x62, 0xb8, 0x1d, 0x10, 0x39, 0x25, 0x2f, 0x2e, 0x16, 0x9f, 0xcc, 0xe2, 0x12,
-	0x21, 0x27, 0x2e, 0x0e, 0x98, 0x8c, 0x04, 0xa3, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x82, 0x1e, 0x86,
-	0xcd, 0x60, 0x13, 0xf4, 0x5c, 0xa1, 0xea, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0xeb,
-	0x53, 0x6a, 0x61, 0xe4, 0x62, 0xf1, 0xcc, 0x4b, 0xcb, 0x17, 0x92, 0xe1, 0xe2, 0x4c, 0xce, 0xcf,
-	0xcd, 0xcd, 0x2c, 0x29, 0x49, 0x4d, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x08, 0x42, 0x08, 0x08,
-	0x49, 0x71, 0x71, 0x14, 0x14, 0x65, 0xe6, 0x17, 0x65, 0x96, 0x54, 0x4a, 0x30, 0x29, 0x30, 0x6a,
-	0x30, 0x07, 0xc1, 0xf9, 0x28, 0xce, 0x60, 0x56, 0x60, 0x24, 0xc7, 0x19, 0x4e, 0x9e, 0x27, 0x1e,
-	0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17,
-	0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4,
-	0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x30, 0x15, 0x99, 0x89, 0x1a, 0x0f, 0x49, 0x6c, 0x60, 0xbe, 0x31,
-	0x20, 0x00, 0x00, 0xff, 0xff, 0xf7, 0xf9, 0xc5, 0xd0, 0xa0, 0x01, 0x00, 0x00,
+	0xca, 0x82, 0xd4, 0x62, 0xb8, 0x1d, 0x10, 0x39, 0x25, 0x17, 0x2e, 0x16, 0x9f, 0xcc, 0xe2, 0x12,
+	0x21, 0x1b, 0x2e, 0x0e, 0x98, 0x8c, 0x04, 0xa3, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x82, 0x1e, 0x86,
+	0xcd, 0x60, 0x13, 0xf4, 0x5c, 0xa1, 0xea, 0x82, 0xe0, 0x3a, 0x94, 0x5a, 0x18, 0xb9, 0x58, 0x3c,
+	0xf3, 0xd2, 0xf2, 0x85, 0x64, 0xb8, 0x38, 0x93, 0xf3, 0x73, 0x73, 0x33, 0x4b, 0x4a, 0x52, 0x53,
+	0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x82, 0x10, 0x02, 0x42, 0x52, 0x5c, 0x1c, 0x05, 0x45, 0x99,
+	0xf9, 0x45, 0x99, 0x25, 0x95, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x70, 0xbe, 0x90, 0x13,
+	0x92, 0x03, 0x98, 0x15, 0x18, 0x89, 0x71, 0x80, 0x13, 0xcb, 0x89, 0x7b, 0xf2, 0x0c, 0x08, 0x67,
+	0x38, 0x79, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13,
+	0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x7e, 0x7a, 0x66,
+	0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0xc2, 0x54, 0x64, 0x26, 0x6a, 0x0c, 0x24,
+	0xb1, 0x81, 0xf9, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x79, 0x46, 0xba, 0xe0, 0x9a, 0x01,
+	0x00, 0x00,
 }
 
 func (m *List) Marshal() (dAtA []byte, err error) {
@@ -347,7 +348,7 @@ func (m *List) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Evidence = append(m.Evidence, types.Evidence{})
+			m.Evidence = append(m.Evidence, &types.Evidence{})
 			if err := m.Evidence[len(m.Evidence)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}

proto/evidence/msgs.proto

@@ -7,7 +7,7 @@ import "third_party/proto/gogoproto/gogo.proto";
 import "proto/types/evidence.proto";
 
 message List {
-  repeated tendermint.proto.types.Evidence evidence = 1 [(gogoproto.nullable) = false];
+  repeated tendermint.proto.types.Evidence evidence = 1;
 }
 
 message Info {

proto/types/evidence.pb.go

@@ -566,8 +566,8 @@ func (m *EvidenceData) GetHash() []byte {
 }
 
 type ProofOfLockChange struct {
-	Votes  []Vote         `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes"`
-	PubKey keys.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"`
+	Votes  []*Vote         `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes,omitempty"`
+	PubKey *keys.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
 }
 
 func (m *ProofOfLockChange) Reset()         { *m = ProofOfLockChange{} }
@@ -603,18 +603,18 @@ func (m *ProofOfLockChange) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ProofOfLockChange proto.InternalMessageInfo
 
-func (m *ProofOfLockChange) GetVotes() []Vote {
+func (m *ProofOfLockChange) GetVotes() []*Vote {
 	if m != nil {
 		return m.Votes
 	}
 	return nil
 }
 
-func (m *ProofOfLockChange) GetPubKey() keys.PublicKey {
+func (m *ProofOfLockChange) GetPubKey() *keys.PublicKey {
 	if m != nil {
 		return m.PubKey
 	}
-	return keys.PublicKey{}
+	return nil
 }
 
 func init() {
@@ -632,57 +632,57 @@ func init() {
 func init() { proto.RegisterFile("proto/types/evidence.proto", fileDescriptor_86495eef24aeacc0) }
 
 var fileDescriptor_86495eef24aeacc0 = []byte{
-	// 789 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xcf, 0x4f, 0xe3, 0x46,
-	0x14, 0xb6, 0xc9, 0x8f, 0xc2, 0x23, 0xf4, 0x87, 0x05, 0x25, 0xb2, 0x20, 0x20, 0xab, 0x2a, 0xb4,
-	0x6a, 0x1d, 0x08, 0x55, 0xd5, 0x2b, 0x81, 0xa2, 0x54, 0x50, 0x15, 0xb9, 0x15, 0x87, 0x1e, 0x6a,
-	0x8d, 0xed, 0x89, 0x3d, 0x8a, 0xed, 0xb1, 0xec, 0x71, 0xa4, 0x1c, 0xab, 0xf6, 0xd0, 0x23, 0x97,
-	0xfe, 0x19, 0x7b, 0xdd, 0xbf, 0x81, 0x23, 0xda, 0xd3, 0x9e, 0x76, 0x57, 0xf0, 0x8f, 0xac, 0x3c,
-	0x1e, 0xdb, 0x41, 0xe0, 0x88, 0xdb, 0x6a, 0x2f, 0xd1, 0xe4, 0xcd, 0xfb, 0xde, 0xf7, 0x8d, 0xdf,
-	0x9b, 0x6f, 0x40, 0x8d, 0x62, 0xca, 0x68, 0x9f, 0xcd, 0x22, 0x9c, 0xf4, 0xf1, 0x94, 0x38, 0x38,
-	0xb4, 0xb1, 0xce, 0x83, 0xca, 0x97, 0x0c, 0x87, 0x0e, 0x8e, 0x03, 0x12, 0xb2, 0x3c, 0xa2, 0xf3,
-	0x34, 0xf5, 0x6b, 0xe6, 0x91, 0xd8, 0x31, 0x23, 0x14, 0xb3, 0x59, 0x3f, 0xc7, 0xbb, 0xd4, 0xa5,
-	0xd5, 0x2a, 0xcf, 0x56, 0x37, 0xe7, 0x6b, 0xf3, 0x5f, 0xb1, 0xb1, 0xe3, 0x52, 0xea, 0xfa, 0x38,
-	0xc7, 0x5a, 0xe9, 0xb8, 0xcf, 0x48, 0x80, 0x13, 0x86, 0x82, 0x48, 0x24, 0x6c, 0xe7, 0x48, 0x3b,
-	0x9e, 0x45, 0x8c, 0xf6, 0x27, 0x78, 0xf6, 0x00, 0xaf, 0xfd, 0x2d, 0xc3, 0xc6, 0x69, 0x1a, 0xf9,
-	0xc4, 0x46, 0x0c, 0x5f, 0x51, 0x86, 0x7f, 0x16, 0xc2, 0x95, 0x23, 0x68, 0x4f, 0x29, 0xc3, 0x26,
-	0xea, 0xca, 0xbb, 0xf2, 0xfe, 0xea, 0x60, 0x4b, 0x7f, 0xfa, 0x0c, 0x7a, 0x86, 0x32, 0x5a, 0x59,
-	0xee, 0x71, 0x09, 0xb2, 0xba, 0x4b, 0xcf, 0x05, 0x0d, 0xb5, 0x7f, 0x65, 0xe8, 0x5e, 0x52, 0x86,
-	0x43, 0x46, 0x90, 0x7f, 0x1c, 0x84, 0x38, 0x21, 0xe8, 0x03, 0xc8, 0x78, 0x21, 0x43, 0xe7, 0x57,
-	0x6a, 0x4f, 0x4a, 0xea, 0x3d, 0xf8, 0xac, 0x68, 0xa3, 0xe9, 0x61, 0xe2, 0x7a, 0x8c, 0x6b, 0x68,
-	0x18, 0x9f, 0x16, 0xe1, 0x11, 0x8f, 0x2a, 0xbf, 0xc0, 0x5a, 0x99, 0x98, 0x7d, 0x7f, 0xc1, 0xaa,
-	0xea, 0x79, 0x73, 0xf4, 0xa2, 0x39, 0xfa, 0x1f, 0x45, 0x73, 0x86, 0xcb, 0x37, 0x6f, 0x76, 0xa4,
-	0xeb, 0xb7, 0x3b, 0xb2, 0xd1, 0x29, 0xa0, 0xd9, 0xa6, 0xf2, 0x0d, 0x7c, 0x5e, 0x96, 0x42, 0x8e,
-	0x13, 0xe3, 0x24, 0xe9, 0x36, 0x76, 0xe5, 0xfd, 0x8e, 0x51, 0x6a, 0x39, 0xce, 0xc3, 0xda, 0x2b,
-	0x19, 0x94, 0x4c, 0xaf, 0x81, 0x42, 0x87, 0x06, 0x1f, 0x89, 0x6a, 0x65, 0x1b, 0x20, 0x46, 0xa1,
-	0x63, 0x5a, 0x33, 0x86, 0x93, 0x6e, 0x93, 0x27, 0xad, 0x64, 0x91, 0x61, 0x16, 0xd0, 0xfe, 0x93,
-	0x41, 0x3d, 0xa1, 0xe1, 0xd8, 0x27, 0x36, 0x23, 0xa1, 0x3b, 0xc2, 0xc8, 0xc1, 0x71, 0x52, 0x1e,
-	0xee, 0x07, 0x58, 0xf2, 0x0e, 0xc5, 0x24, 0x7c, 0x55, 0xd7, 0xd4, 0xdf, 0x89, 0x1b, 0x62, 0x27,
-	0x87, 0x1a, 0x4b, 0xde, 0x21, 0x47, 0x0d, 0xc4, 0xf1, 0x9e, 0x8b, 0x1a, 0x68, 0x2f, 0x65, 0xe8,
-	0x5e, 0xa4, 0x21, 0x62, 0xc4, 0xbe, 0x42, 0x3e, 0x71, 0x10, 0xa3, 0x71, 0x29, 0xe4, 0x47, 0x68,
-	0x7b, 0x3c, 0x55, 0x88, 0xe9, 0xd5, 0x95, 0x15, 0x05, 0x45, 0xb6, 0x72, 0x00, 0xcd, 0x6c, 0xda,
-	0x9e, 0x35, 0x97, 0x3c, 0x53, 0x39, 0x80, 0x75, 0x12, 0x4e, 0x33, 0x01, 0x66, 0x5e, 0xc3, 0x1c,
-	0x13, 0xec, 0x3b, 0xfc, 0xfb, 0xae, 0x18, 0x8a, 0xd8, 0xcb, 0x69, 0xce, 0xb2, 0x1d, 0xed, 0x9f,
-	0x16, 0x2c, 0x97, 0x42, 0x5d, 0xd8, 0x74, 0x8a, 0xfb, 0x6d, 0xf2, 0x4b, 0x51, 0x74, 0x44, 0x28,
-	0xff, 0xbe, 0x4e, 0xc3, 0x93, 0xb6, 0x30, 0x92, 0x8c, 0x0d, 0xe7, 0x49, 0xbf, 0x98, 0xc2, 0x96,
-	0x5d, 0x35, 0x4e, 0x68, 0x4d, 0x2a, 0xb6, 0xfc, 0xc4, 0x83, 0x3a, 0xb6, 0xfa, 0xa6, 0x8f, 0x24,
-	0x43, 0xb5, 0xeb, 0x47, 0x22, 0x02, 0xd5, 0xcf, 0xbb, 0x64, 0x4e, 0x8b, 0x36, 0x55, 0xac, 0x0d,
-	0xce, 0x7a, 0x50, 0xc7, 0x5a, 0xd7, 0xdf, 0x91, 0x64, 0x74, 0xfd, 0xba, 0xde, 0x47, 0xa0, 0x46,
-	0x85, 0x5d, 0x99, 0x28, 0xf7, 0xab, 0x8a, 0xb1, 0xb9, 0x98, 0xb1, 0xce, 0xe8, 0x32, 0xc6, 0xa8,
-	0xce, 0x04, 0xcf, 0x61, 0x2d, 0xa0, 0xf6, 0xa4, 0x22, 0x69, 0x2d, 0x9e, 0xe5, 0x79, 0x1b, 0x1b,
-	0x49, 0x46, 0x27, 0x98, 0xb7, 0xb5, 0xbf, 0x60, 0x9d, 0x17, 0x8b, 0xb9, 0x6f, 0x54, 0x35, 0xdb,
-	0xbc, 0xe6, 0xb7, 0x8b, 0x6a, 0x3e, 0xb4, 0x9a, 0x91, 0x64, 0x28, 0xc1, 0xa3, 0xe8, 0xb0, 0x05,
-	0x8d, 0x24, 0x0d, 0xb4, 0x31, 0x74, 0x8a, 0xd0, 0x29, 0x62, 0x48, 0x19, 0xc2, 0xf2, 0xdc, 0xe4,
-	0x35, 0xf6, 0x57, 0x07, 0xbb, 0x75, 0x54, 0x65, 0xa9, 0x66, 0xe6, 0x37, 0x46, 0x89, 0x53, 0x14,
-	0x68, 0x7a, 0x28, 0xf1, 0xf8, 0x2c, 0x75, 0x0c, 0xbe, 0xd6, 0xfe, 0x97, 0xe1, 0x8b, 0xcb, 0x98,
-	0xd2, 0xf1, 0x6f, 0xe3, 0x0b, 0x6a, 0x4f, 0x4e, 0x3c, 0x14, 0xba, 0x58, 0xf9, 0x09, 0xb8, 0xab,
-	0x27, 0x82, 0x6a, 0xe1, 0x45, 0x13, 0x34, 0x39, 0x40, 0x39, 0x83, 0x4f, 0xa2, 0xd4, 0x32, 0x27,
-	0x78, 0x26, 0x46, 0x76, 0xef, 0x31, 0x36, 0x7f, 0x4d, 0xf5, 0xec, 0x35, 0xd5, 0x2f, 0x53, 0xcb,
-	0x27, 0xf6, 0x39, 0x9e, 0x89, 0x32, 0xed, 0x28, 0xb5, 0xb2, 0x7f, 0x67, 0x37, 0x77, 0x3d, 0xf9,
-	0xf6, 0xae, 0x27, 0xbf, 0xbb, 0xeb, 0xc9, 0xd7, 0xf7, 0x3d, 0xe9, 0xf6, 0xbe, 0x27, 0xbd, 0xbe,
-	0xef, 0x49, 0x7f, 0x7e, 0xe7, 0x12, 0xe6, 0xa5, 0x96, 0x6e, 0xd3, 0xa0, 0x5f, 0x95, 0x9e, 0x5f,
-	0xce, 0xbd, 0xf6, 0x56, 0x9b, 0xff, 0x39, 0x7a, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xca, 0x62, 0x59,
-	0xfb, 0x5f, 0x08, 0x00, 0x00,
+	// 786 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xcf, 0x4f, 0xdc, 0x46,
+	0x14, 0xb6, 0xd9, 0x1f, 0x85, 0xc7, 0xd2, 0x1f, 0x16, 0x94, 0x95, 0x05, 0x0b, 0xb2, 0xaa, 0x42,
+	0xab, 0xd6, 0x0b, 0x4b, 0xd5, 0x73, 0x59, 0x28, 0xda, 0x0a, 0xaa, 0x22, 0x37, 0xe2, 0x90, 0x43,
+	0xac, 0xb1, 0x3d, 0x6b, 0x8f, 0xd6, 0xf6, 0x58, 0xf6, 0x78, 0x25, 0x1f, 0xa3, 0xe4, 0x90, 0xdc,
+	0xf8, 0x47, 0x72, 0xcd, 0xdf, 0xc0, 0x11, 0xe5, 0x94, 0x53, 0x12, 0xc1, 0x3f, 0x12, 0x79, 0xfc,
+	0x6b, 0x11, 0x18, 0xed, 0x2d, 0xca, 0x65, 0x35, 0xfb, 0xe6, 0x7d, 0xef, 0xfb, 0xc6, 0xef, 0xcd,
+	0x37, 0x20, 0x07, 0x21, 0x65, 0xb4, 0xcf, 0x92, 0x00, 0x47, 0x7d, 0x3c, 0x25, 0x16, 0xf6, 0x4d,
+	0xac, 0xf2, 0xa0, 0xf4, 0x23, 0xc3, 0xbe, 0x85, 0x43, 0x8f, 0xf8, 0x2c, 0x8b, 0xa8, 0x3c, 0x4d,
+	0xfe, 0x99, 0x39, 0x24, 0xb4, 0xf4, 0x00, 0x85, 0x2c, 0xe9, 0x67, 0x78, 0x9b, 0xda, 0xb4, 0x5a,
+	0x65, 0xd9, 0xf2, 0xfa, 0x6c, 0x6d, 0xfe, 0x9b, 0x6f, 0x6c, 0xd9, 0x94, 0xda, 0x2e, 0xce, 0xb0,
+	0x46, 0x3c, 0xee, 0x33, 0xe2, 0xe1, 0x88, 0x21, 0x2f, 0xc8, 0x13, 0x36, 0x33, 0xa4, 0x19, 0x26,
+	0x01, 0xa3, 0xfd, 0x09, 0x4e, 0xee, 0xe0, 0x95, 0xe7, 0x22, 0xac, 0x1d, 0xc7, 0x81, 0x4b, 0x4c,
+	0xc4, 0xf0, 0x05, 0x65, 0xf8, 0xef, 0x5c, 0xb8, 0x74, 0x00, 0xed, 0x29, 0x65, 0x58, 0x47, 0x5d,
+	0x71, 0x5b, 0xdc, 0x5d, 0x1e, 0x6c, 0xa8, 0x0f, 0x9f, 0x41, 0x4d, 0x51, 0x5a, 0x2b, 0xcd, 0x3d,
+	0x2c, 0x41, 0x46, 0x77, 0x61, 0x5e, 0xd0, 0x50, 0x79, 0x29, 0x42, 0xf7, 0x9c, 0x32, 0xec, 0x33,
+	0x82, 0xdc, 0x43, 0xcf, 0xc7, 0x11, 0x41, 0x5f, 0x40, 0xc6, 0x1b, 0x11, 0x3a, 0xff, 0x52, 0x73,
+	0x52, 0x52, 0xef, 0xc0, 0x77, 0x45, 0x1b, 0x75, 0x07, 0x13, 0xdb, 0x61, 0x5c, 0x43, 0x43, 0xfb,
+	0xb6, 0x08, 0x8f, 0x78, 0x54, 0xfa, 0x07, 0x56, 0xca, 0xc4, 0xf4, 0xfb, 0xe7, 0xac, 0xb2, 0x9a,
+	0x35, 0x47, 0x2d, 0x9a, 0xa3, 0x3e, 0x29, 0x9a, 0x33, 0x5c, 0xbc, 0xfa, 0xb0, 0x25, 0x5c, 0x7e,
+	0xdc, 0x12, 0xb5, 0x4e, 0x01, 0x4d, 0x37, 0xa5, 0x5f, 0xe0, 0xfb, 0xb2, 0x14, 0xb2, 0xac, 0x10,
+	0x47, 0x51, 0xb7, 0xb1, 0x2d, 0xee, 0x76, 0xb4, 0x52, 0xcb, 0x61, 0x16, 0x56, 0xde, 0x89, 0x20,
+	0xa5, 0x7a, 0x35, 0xe4, 0x5b, 0xd4, 0xfb, 0x4a, 0x54, 0x4b, 0x9b, 0x00, 0x21, 0xf2, 0x2d, 0xdd,
+	0x48, 0x18, 0x8e, 0xba, 0x4d, 0x9e, 0xb4, 0x94, 0x46, 0x86, 0x69, 0x40, 0x79, 0x25, 0x82, 0x7c,
+	0x44, 0xfd, 0xb1, 0x4b, 0x4c, 0x46, 0x7c, 0x7b, 0x84, 0x91, 0x85, 0xc3, 0xa8, 0x3c, 0xdc, 0x1f,
+	0xb0, 0xe0, 0xec, 0xe7, 0x93, 0xf0, 0x53, 0x5d, 0x53, 0xff, 0x27, 0xb6, 0x8f, 0xad, 0x0c, 0xaa,
+	0x2d, 0x38, 0xfb, 0x1c, 0x35, 0xc8, 0x8f, 0x37, 0x2f, 0x6a, 0xa0, 0xbc, 0x15, 0xa1, 0x7b, 0x16,
+	0xfb, 0x88, 0x11, 0xf3, 0x02, 0xb9, 0xc4, 0x42, 0x8c, 0x86, 0xa5, 0x90, 0x3f, 0xa1, 0xed, 0xf0,
+	0xd4, 0x5c, 0x4c, 0xaf, 0xae, 0x6c, 0x5e, 0x30, 0xcf, 0x96, 0xf6, 0xa0, 0x99, 0x4e, 0xdb, 0x5c,
+	0x73, 0xc9, 0x33, 0xa5, 0x3d, 0x58, 0x25, 0xfe, 0x34, 0x15, 0xa0, 0x67, 0x35, 0xf4, 0x31, 0xc1,
+	0xae, 0xc5, 0xbf, 0xef, 0x92, 0x26, 0xe5, 0x7b, 0x19, 0xcd, 0x49, 0xba, 0xa3, 0xbc, 0x68, 0xc1,
+	0x62, 0x29, 0xd4, 0x86, 0x75, 0xab, 0xb8, 0xdf, 0x3a, 0xbf, 0x14, 0x45, 0x47, 0x72, 0xe5, 0xbf,
+	0xd7, 0x69, 0x78, 0xd0, 0x16, 0x46, 0x82, 0xb6, 0x66, 0x3d, 0xe8, 0x17, 0x53, 0xd8, 0x30, 0xab,
+	0xc6, 0xe5, 0x5a, 0xa3, 0x8a, 0x2d, 0x3b, 0xf1, 0xa0, 0x8e, 0xad, 0xbe, 0xe9, 0x23, 0x41, 0x93,
+	0xcd, 0xfa, 0x91, 0x08, 0x40, 0x76, 0xb3, 0x2e, 0xe9, 0xd3, 0xa2, 0x4d, 0x15, 0x6b, 0x83, 0xb3,
+	0xee, 0xd5, 0xb1, 0xd6, 0xf5, 0x77, 0x24, 0x68, 0x5d, 0xb7, 0xae, 0xf7, 0x01, 0xc8, 0x41, 0x61,
+	0x57, 0x3a, 0xca, 0xfc, 0xaa, 0x62, 0x6c, 0x3e, 0xce, 0x58, 0x67, 0x74, 0x29, 0x63, 0x50, 0x67,
+	0x82, 0xa7, 0xb0, 0xe2, 0x51, 0x73, 0x52, 0x91, 0xb4, 0x1e, 0x9f, 0xe5, 0x59, 0x1b, 0x1b, 0x09,
+	0x5a, 0xc7, 0x9b, 0xb5, 0xb5, 0x67, 0xb0, 0xca, 0x8b, 0x85, 0xdc, 0x37, 0xaa, 0x9a, 0x6d, 0x5e,
+	0xf3, 0xd7, 0xc7, 0x6a, 0xde, 0xb5, 0x9a, 0x91, 0xa0, 0x49, 0xde, 0xbd, 0xe8, 0xb0, 0x05, 0x8d,
+	0x28, 0xf6, 0x94, 0x31, 0x74, 0x8a, 0xd0, 0x31, 0x62, 0x48, 0x1a, 0xc2, 0xe2, 0xcc, 0xe4, 0x35,
+	0x76, 0x97, 0x07, 0xdb, 0x75, 0x54, 0x65, 0xa9, 0x66, 0xea, 0x37, 0x5a, 0x89, 0x93, 0x24, 0x68,
+	0x3a, 0x28, 0x72, 0xf8, 0x2c, 0x75, 0x34, 0xbe, 0x56, 0x5e, 0x8b, 0xf0, 0xc3, 0x79, 0x48, 0xe9,
+	0xf8, 0xbf, 0xf1, 0x19, 0x35, 0x27, 0x47, 0x0e, 0xf2, 0x6d, 0x2c, 0x0d, 0x80, 0xbb, 0x7a, 0x94,
+	0x53, 0xcd, 0xf1, 0x00, 0x44, 0xd2, 0x5f, 0xf0, 0x4d, 0x10, 0x1b, 0xfa, 0x04, 0x27, 0xf9, 0xb0,
+	0xee, 0xdc, 0x47, 0x65, 0xef, 0xa8, 0x9a, 0xbe, 0xa3, 0xea, 0x79, 0x6c, 0xb8, 0xc4, 0x3c, 0xc5,
+	0x89, 0xd6, 0x0e, 0x62, 0xe3, 0x14, 0x27, 0xc3, 0x93, 0xab, 0x9b, 0x9e, 0x78, 0x7d, 0xd3, 0x13,
+	0x3f, 0xdd, 0xf4, 0xc4, 0xcb, 0xdb, 0x9e, 0x70, 0x7d, 0xdb, 0x13, 0xde, 0xdf, 0xf6, 0x84, 0xa7,
+	0xbf, 0xd9, 0x84, 0x39, 0xb1, 0xa1, 0x9a, 0xd4, 0xeb, 0x57, 0x45, 0x67, 0x97, 0x33, 0x2f, 0xbc,
+	0xd1, 0xe6, 0x7f, 0x0e, 0x3e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x6a, 0x4c, 0xe5, 0x0b, 0x53, 0x08,
+	0x00, 0x00,
 }
 
 func (m *DuplicateVoteEvidence) Marshal() (dAtA []byte, err error) {
@@ -1195,16 +1195,18 @@ func (m *ProofOfLockChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.PubKey != nil {
+		{
+			size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintEvidence(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintEvidence(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x12
 	}
-	i--
-	dAtA[i] = 0x12
 	if len(m.Votes) > 0 {
 		for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -1460,8 +1462,10 @@ func (m *ProofOfLockChange) Size() (n int) {
 			n += 1 + l + sovEvidence(uint64(l))
 		}
 	}
-	l = m.PubKey.Size()
-	n += 1 + l + sovEvidence(uint64(l))
+	if m.PubKey != nil {
+		l = m.PubKey.Size()
+		n += 1 + l + sovEvidence(uint64(l))
+	}
 	return n
 }
 
@@ -2757,7 +2761,7 @@ func (m *ProofOfLockChange) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Votes = append(m.Votes, Vote{})
+			m.Votes = append(m.Votes, &Vote{})
 			if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2791,6 +2795,9 @@ func (m *ProofOfLockChange) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.PubKey == nil {
+				m.PubKey = &keys.PublicKey{}
+			}
 			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}

proto/types/evidence.proto

@@ -65,6 +65,6 @@ message EvidenceData {
 }
 
 message ProofOfLockChange {
-  repeated Vote                          votes   = 1 [(gogoproto.nullable) = false];
-  tendermint.proto.crypto.keys.PublicKey pub_key = 2 [(gogoproto.nullable) = false];
+  repeated Vote                          votes   = 1;
+  tendermint.proto.crypto.keys.PublicKey pub_key = 2;
 }

types/evidence.go

@@ -10,6 +10,7 @@ import (
 	amino "github.com/tendermint/go-amino"
 
 	"github.com/tendermint/tendermint/crypto"
+	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/merkle"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	tmjson "github.com/tendermint/tendermint/libs/json"
@@ -1257,6 +1258,59 @@ func (e ProofOfLockChange) String() string {
 		e.Votes[0].Round)
 }
 
+func (e *ProofOfLockChange) ToProto() (*tmproto.ProofOfLockChange, error) {
+	if e == nil {
+		return nil, errors.New("nil proof of lock change")
+	}
+	plc := new(tmproto.ProofOfLockChange)
+	vpb := make([]*tmproto.Vote, len(e.Votes))
+
+	for i, v := range e.Votes {
+		pb := v.ToProto()
+		if pb != nil {
+			vpb[i] = pb
+		}
+	}
+
+	pk, err := cryptoenc.PubKeyToProto(e.PubKey)
+	if err != nil {
+		return nil, err
+	}
+	plc.PubKey = &pk
+	plc.Votes = vpb
+
+	return plc, nil
+}
+
+func ProofOfLockChangeFromProto(pb *tmproto.ProofOfLockChange) (*ProofOfLockChange, error) {
+	if pb == nil {
+		return nil, errors.New("nil proof of lock change")
+	}
+
+	plc := new(ProofOfLockChange)
+	vpb := make([]Vote, len(pb.Votes))
+	for i, v := range pb.Votes {
+		vi, err := VoteFromProto(v)
+		if err != nil {
+			return nil, err
+		}
+		vpb[i] = *vi
+	}
+
+	if pb.PubKey == nil {
+		return nil, errors.New("proofOfLockChange: nil PubKey")
+	}
+	pk, err := cryptoenc.PubKeyFromProto(*pb.PubKey)
+	if err != nil {
+		return nil, err
+	}
+
+	plc.PubKey = pk
+	plc.Votes = vpb
+
+	return plc, nil
+}
+
 //-----------------------------------------------------------------
 
 // UNSTABLE
@@ -1297,7 +1351,8 @@ func NewMockEvidence(height int64, eTime time.Time, address []byte) MockEvidence
 	return MockEvidence{
 		EvidenceHeight:  height,
 		EvidenceTime:    eTime,
-		EvidenceAddress: address}
+		EvidenceAddress: address,
+	}
 }
 
 func (e MockEvidence) Height() int64   { return e.EvidenceHeight }

types/evidence_test.go

@@ -573,3 +573,42 @@ func TestEvidenceProto(t *testing.T) {
 		})
 	}
 }
+
+func TestProofOfLockChangeProtoBuf(t *testing.T) {
+	// -------- Votes --------
+	val := NewMockPV()
+	val2 := NewMockPV()
+	val3 := NewMockPV()
+	blockID := makeBlockID(tmhash.Sum([]byte("blockhash")), math.MaxInt32, tmhash.Sum([]byte("partshash")))
+	const chainID = "mychain"
+	v := makeVote(t, val, chainID, math.MaxInt32, math.MaxInt64, 1, 0x01, blockID, defaultVoteTime)
+	v2 := makeVote(t, val2, chainID, math.MaxInt32, math.MaxInt64, 1, 0x01, blockID, defaultVoteTime)
+
+	testCases := []struct {
+		msg     string
+		polc    ProofOfLockChange
+		expErr  bool
+		expErr2 bool
+	}{
+		{"failure, empty key", ProofOfLockChange{Votes: []Vote{*v, *v2}}, true, true},
+		{"failure empty ProofOfLockChange", ProofOfLockChange{}, true, true},
+		{"success", ProofOfLockChange{Votes: []Vote{*v, *v2}, PubKey: val3.PrivKey.PubKey()}, false, false},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		pbpolc, err := tc.polc.ToProto()
+		if tc.expErr {
+			require.Error(t, err)
+		} else {
+			require.NoError(t, err)
+		}
+
+		c, err := ProofOfLockChangeFromProto(pbpolc)
+		if !tc.expErr2 {
+			require.NoError(t, err, tc.msg)
+			require.Equal(t, &tc.polc, c, tc.msg)
+		} else {
+			require.Error(t, err, tc.msg)
+		}
+	}
+}