test: protobuf vectors for reactors (#5221)

## Description Add test vectors for all reactors - [x] state-sync - [x] privval - [x] mempool - [x] p2p - [x] evidence - [ ] light? this PR is primarily oriented at testvectors for things going over the wire. should we expand the testvectors into types as well? Closes: #XXX
2026-01-03 03:35:19 +00:00 · 2020-08-11 16:00:11 +02:00
parent bfcf45a461
commit 40bd416d59
15 changed files with 403 additions and 138 deletions
--- a/blockchain/msgs_test.go
+++ b/blockchain/msgs_test.go
@@ -1,6 +1,7 @@
 package blockchain

 import (
+	"encoding/hex"
 	"math"
 	"testing"

@@ -77,8 +78,8 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
 	}
 }

+// nolint:lll // ignore line length in tests
 func TestBlockchainMessageVectors(t *testing.T) {
-
 	block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil)

 	bpb, err := block.ToProto()
@@ -87,43 +88,29 @@ func TestBlockchainMessageVectors(t *testing.T) {
 	testCases := []struct {
 		testName string
 		bmsg     proto.Message
-		expBytes []byte
+		expBytes string
 	}{
 		{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
-			BlockRequest: &bcproto.BlockRequest{Height: 1}}}, []byte{0xa, 0x2, 0x8, 0x1}},
+			BlockRequest: &bcproto.BlockRequest{Height: 1}}}, "0a020801"},
 		{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
 			BlockRequest: &bcproto.BlockRequest{Height: math.MaxInt64}}},
-			[]byte{0xa, 0xa, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
+			"0a0a08ffffffffffffffff7f"},
 		{"BlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_BlockResponse{
-			BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, []byte{0x1a, 0xb3, 0x1, 0xa,
-			0xb0, 0x1, 0xa, 0x59, 0xa, 0x0, 0x18, 0x3, 0x22, 0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3,
-			0x98, 0xfe, 0xff, 0xff, 0xff, 0x1, 0x2a, 0x2, 0x12, 0x0, 0x3a, 0x20, 0xc4, 0xda,
-			0x88, 0xe8, 0x76, 0x6, 0x2a, 0xa1, 0x54, 0x34, 0x0, 0xd5, 0xd, 0xe, 0xaa, 0xd, 0xac,
-			0x88, 0x9, 0x60, 0x57, 0x94, 0x9c, 0xfb, 0x7b, 0xca, 0x7f, 0x3a, 0x48, 0xc0, 0x4b,
-			0xf9, 0x6a, 0x20, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
-			0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4,
-			0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0x12, 0x2f, 0xa, 0xb, 0x48, 0x65, 0x6c,
-			0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x12, 0x20, 0xc4, 0xda, 0x88, 0xe8,
-			0x76, 0x6, 0x2a, 0xa1, 0x54, 0x34, 0x0, 0xd5, 0xd, 0xe, 0xaa, 0xd, 0xac, 0x88, 0x9,
-			0x60, 0x57, 0x94, 0x9c, 0xfb, 0x7b, 0xca, 0x7f, 0x3a, 0x48, 0xc0, 0x4b, 0xf9, 0x1a,
-			0x22, 0x12, 0x20, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
-			0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4,
-			0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55}},
+			BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, "1ab3010ab0010a590a001803220b088092b8c398feffffff012a0212003a20c4da88e876062aa1543400d50d0eaa0dac88096057949cfb7bca7f3a48c04bf96a20e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855122f0a0b48656c6c6f20576f726c641220c4da88e876062aa1543400d50d0eaa0dac88096057949cfb7bca7f3a48c04bf91a221220e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
 		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
-			NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, []byte{0x12, 0x2, 0x8, 0x1}},
+			NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, "12020801"},
 		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
 			NoBlockResponse: &bcproto.NoBlockResponse{Height: math.MaxInt64}}},
-			[]byte{0x12, 0xa, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
+			"120a08ffffffffffffffff7f"},
 		{"StatusRequestMessage", &bcproto.Message{Sum: &bcproto.Message_StatusRequest{
 			StatusRequest: &bcproto.StatusRequest{}}},
-			[]byte{0x22, 0x0}},
+			"2200"},
 		{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
 			StatusResponse: &bcproto.StatusResponse{Height: 1, Base: 2}}},
-			[]byte{0x2a, 0x4, 0x8, 0x1, 0x10, 0x2}},
+			"2a0408011002"},
 		{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
 			StatusResponse: &bcproto.StatusResponse{Height: math.MaxInt64, Base: math.MaxInt64}}},
-			[]byte{0x2a, 0x14, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x10,
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
+			"2a1408ffffffffffffffff7f10ffffffffffffffff7f"},
 	}

 	for _, tc := range testCases {
@@ -131,7 +118,7 @@ func TestBlockchainMessageVectors(t *testing.T) {
 		t.Run(tc.testName, func(t *testing.T) {
 			bz, _ := proto.Marshal(tc.bmsg)

-			require.Equal(t, tc.expBytes, bz)
+			require.Equal(t, tc.expBytes, hex.EncodeToString(bz))
 		})
 	}
 }
--- a/consensus/msgs_test.go
+++ b/consensus/msgs_test.go
@@ -1,6 +1,7 @@
 package consensus

 import (
+	"encoding/hex"
 	"math"
 	"testing"
 	"time"
@@ -313,6 +314,7 @@ func TestWALMsgProto(t *testing.T) {
 	}
 }

+// nolint:lll //ignore line length for tests
 func TestConsMsgsVectors(t *testing.T) {
 	date := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC)
 	psh := types.PartSetHeader{
@@ -367,7 +369,7 @@ func TestConsMsgsVectors(t *testing.T) {
 	testCases := []struct {
 		testName string
 		cMsg     proto.Message
-		expBytes []byte
+		expBytes string
 	}{
 		{"NewRoundStep", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{
 			Height:                1,
@@ -375,74 +377,42 @@ func TestConsMsgsVectors(t *testing.T) {
 			Step:                  1,
 			SecondsSinceStartTime: 1,
 			LastCommitRound:       1,
-		}}}, []byte{0xa, 0xa, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1, 0x28, 0x1}},
+		}}}, "0a0a08011001180120012801"},
 		{"NewRoundStep Max", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{
 			Height:                math.MaxInt64,
 			Round:                 math.MaxInt32,
 			Step:                  math.MaxUint32,
 			SecondsSinceStartTime: math.MaxInt64,
 			LastCommitRound:       math.MaxInt32,
-		}}}, []byte{0xa, 0x26, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x10, 0xff,
-			0xff, 0xff, 0xff, 0x7, 0x18, 0xff, 0xff, 0xff, 0xff, 0xf, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff,
-			0xff, 0xff, 0xff, 0x7f, 0x28, 0xff, 0xff, 0xff, 0xff, 0x7}},
-
+		}}}, "0a2608ffffffffffffffff7f10ffffffff0718ffffffff0f20ffffffffffffffff7f28ffffffff07"},
 		{"NewValidBlock", &tmcons.Message{Sum: &tmcons.Message_NewValidBlock{
 			NewValidBlock: &tmcons.NewValidBlock{
 				Height: 1, Round: 1, BlockPartSetHeader: pbPsh, BlockParts: pbBits, IsCommit: false}}},
-			[]byte{0x12, 0x31, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d,
-				0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d,
-				0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x22, 0x5, 0x8, 0x1, 0x12, 0x1, 0x0}},
+			"1231080110011a24080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d22050801120100"},
 		{"Proposal", &tmcons.Message{Sum: &tmcons.Message_Proposal{Proposal: &tmcons.Proposal{Proposal: *pbProposal}}},
-			[]byte{0x1a, 0x72, 0xa, 0x70, 0x8, 0x20, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1, 0x2a, 0x48, 0xa, 0x20, 0x61,
-				0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69,
-				0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8,
-				0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
-				0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65,
-				0x2d, 0x32, 0x6, 0x8, 0xc0, 0xb8, 0x9f, 0xdc, 0x5, 0x3a, 0x14, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
-				0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e}},
+			"1a720a7008201001180120012a480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d320608c0b89fdc053a146164645f6d6f72655f6578636c616d6174696f6e"},
 		{"ProposalPol", &tmcons.Message{Sum: &tmcons.Message_ProposalPol{
 			ProposalPol: &tmcons.ProposalPOL{Height: 1, ProposalPolRound: 1}}},
-			[]byte{0x22, 0x6, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x0}},
+			"2206080110011a00"},
 		{"BlockPart", &tmcons.Message{Sum: &tmcons.Message_BlockPart{
 			BlockPart: &tmcons.BlockPart{Height: 1, Round: 1, Part: *pbParts}}},
-			[]byte{0x2a, 0x36, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x30, 0x8, 0x1, 0x12, 0x4,
-				0x74, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x20, 0x61,
-				0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
-				0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63,
-				0x6f, 0x64, 0x65, 0x2d}},
+			"2a36080110011a3008011204746573741a26080110011a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d"},
 		{"Vote", &tmcons.Message{Sum: &tmcons.Message_Vote{
 			Vote: &tmcons.Vote{Vote: vpb}}},
-			[]byte{0x32, 0x70, 0xa, 0x6e, 0x8, 0x2, 0x10, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64,
-				0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69,
-				0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12,
-				0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78,
-				0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f,
-				0x63, 0x6f, 0x64, 0x65, 0x2d, 0x2a, 0x6, 0x8, 0xc0, 0xb8, 0x9f, 0xdc, 0x5, 0x32, 0x14, 0x61, 0x64,
-				0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f,
-				0x6e, 0x38, 0x1}},
+			"32700a6e0802100122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d2a0608c0b89fdc0532146164645f6d6f72655f6578636c616d6174696f6e3801"},
 		{"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{
 			HasVote: &tmcons.HasVote{Height: 1, Round: 1, Type: tmproto.PrevoteType, Index: 1}}},
-			[]byte{0x3a, 0x8, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1}},
+			"3a080801100118012001"},
 		{"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{
 			HasVote: &tmcons.HasVote{Height: math.MaxInt64, Round: math.MaxInt32,
 				Type: tmproto.PrevoteType, Index: math.MaxInt32}}},
-			[]byte{0x3a, 0x18, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0x7f, 0x10, 0xff, 0xff, 0xff, 0xff, 0x7, 0x18, 0x1, 0x20, 0xff, 0xff, 0xff, 0xff, 0x7}},
+			"3a1808ffffffffffffffff7f10ffffffff07180120ffffffff07"},
 		{"VoteSetMaj23", &tmcons.Message{Sum: &tmcons.Message_VoteSetMaj23{
 			VoteSetMaj23: &tmcons.VoteSetMaj23{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi}}},
-			[]byte{0x42, 0x50, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64, 0x5f,
-				0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-				0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8, 0x1,
-				0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
-				0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64,
-				0x65, 0x2d}},
+			"425008011001180122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d"},
 		{"VoteSetBits", &tmcons.Message{Sum: &tmcons.Message_VoteSetBits{
 			VoteSetBits: &tmcons.VoteSetBits{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi, Votes: *pbBits}}},
-			[]byte{0x4a, 0x57, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
-				0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73,
-				0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
-				0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73,
-				0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x2a, 0x5, 0x8, 0x1, 0x12, 0x1, 0x0}},
+			"4a5708011001180122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d2a050801120100"},
 	}

 	for _, tc := range testCases {
@@ -451,7 +421,7 @@ func TestConsMsgsVectors(t *testing.T) {
 			bz, err := proto.Marshal(tc.cMsg)
 			require.NoError(t, err)

-			require.Equal(t, tc.expBytes, bz)
+			require.Equal(t, tc.expBytes, hex.EncodeToString(bz))
 		})
 	}
 }
--- a/evidence/reactor_test.go
+++ b/evidence/reactor_test.go
@@ -1,6 +1,7 @@
 package evidence

 import (
+	"encoding/hex"
 	"fmt"
 	"sync"
 	"testing"
@@ -14,9 +15,14 @@ import (
 	dbm "github.com/tendermint/tm-db"

 	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/evidence/mocks"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
+	ep "github.com/tendermint/tendermint/proto/tendermint/evidence"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/proto/tendermint/version"
 	"github.com/tendermint/tendermint/types"
 )

@@ -208,3 +214,87 @@ func TestReactorSelectiveBroadcast(t *testing.T) {
 	peers := reactors[1].Switch.Peers().List()
 	assert.Equal(t, 1, len(peers))
 }
+
+func exampleVote(t byte) *types.Vote {
+	var stamp, err = time.Parse(types.TimeFormat, "2017-12-25T03:00:01.234Z")
+	if err != nil {
+		panic(err)
+	}
+
+	return &types.Vote{
+		Type:      tmproto.SignedMsgType(t),
+		Height:    3,
+		Round:     2,
+		Timestamp: stamp,
+		BlockID: types.BlockID{
+			Hash: tmhash.Sum([]byte("blockID_hash")),
+			PartSetHeader: types.PartSetHeader{
+				Total: 1000000,
+				Hash:  tmhash.Sum([]byte("blockID_part_set_header_hash")),
+			},
+		},
+		ValidatorAddress: crypto.AddressHash([]byte("validator_address")),
+		ValidatorIndex:   56789,
+	}
+}
+
+func exampleHeader() *types.Header {
+	blockID := types.BlockID{Hash: []byte{0}, PartSetHeader: types.PartSetHeader{Total: 123, Hash: []byte{0}}}
+
+	h := &types.Header{
+		Version:            version.Consensus{Block: 1, App: 2},
+		ChainID:            "chainId",
+		Height:             3,
+		Time:               time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC),
+		LastBlockID:        blockID,
+		LastCommitHash:     tmhash.Sum([]byte("last_commit_hash")),
+		DataHash:           tmhash.Sum([]byte("data_hash")),
+		ValidatorsHash:     tmhash.Sum([]byte("validators_hash")),
+		NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
+		ConsensusHash:      tmhash.Sum([]byte("consensus_hash")),
+		AppHash:            tmhash.Sum([]byte("app_hash")),
+		LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
+		EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
+		ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
+	}
+
+	return h
+}
+
+// nolint:lll //ignore line length for tests
+func TestEvidenceVectors(t *testing.T) {
+
+	dupl := types.NewDuplicateVoteEvidence(exampleVote(1), exampleVote(2), time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC))
+	lve := types.NewLunaticValidatorEvidence(exampleHeader(), exampleVote(1), "Datahash", time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC))
+
+	testCases := []struct {
+		testName     string
+		evidenceList []types.Evidence
+		expBytes     string
+	}{
+		{"DuplicateVoteEvidence", []types.Evidence{dupl}, "0a81020afe010a79080210031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031279080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031a0608f49a8ded05"},
+		{"LunaticValidatorEvidence", []types.Evidence{lve}, "0ade031adb030acb020a04080110021207636861696e49641803220608f49a8ded052a0a0a01001205087b1201003220e7aad01a1af897b05bcf78c7563b5d1adc2939d543dac949a5c8712156d19bf83a206d6e28b8b98b5327042ea50a57dd46e6cc851c72e528bdeaa6efdeeefe66a0b84220db5d0767f57d844ba68132eaf74f6b8b83df6c03810a6a4378c2a6b2caf93e8d4a201eef9748a3c48ff996033757d73200886e7b2b4e9d9df07b19a34a44bae3e2c85220e5e566c41ed57e3ff8cc10f184178788b8faa602b07cf1f425217bd8179f1f245a2041cafae31cc70f5801fa1016a2dd54a9bcb8201b5b389919fe9976762532c5166220092e058630247ed6009863a12eee117d26cd9d08b5adcaab37f2ab35db475a376a2073865db08f49d58428905d389ab4ca4b96e45a3206c7a69d43a5dc7372e60714721427834082c131975497cdebfbdce6c8e5196a13541279080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031a084461746168617368220608f49a8ded05"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		evi := make([]*tmproto.Evidence, len(tc.evidenceList))
+		for i := 0; i < len(tc.evidenceList); i++ {
+			ev, err := types.EvidenceToProto(tc.evidenceList[i])
+			require.NoError(t, err, tc.testName)
+			evi[i] = ev
+		}
+
+		epl := ep.List{
+			Evidence: evi,
+		}
+
+		bz, err := epl.Marshal()
+		require.NoError(t, err, tc.testName)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+
+	}
+
+}
--- a/mempool/reactor_test.go
+++ b/mempool/reactor_test.go
@@ -1,6 +1,7 @@
 package mempool

 import (
+	"encoding/hex"
 	"errors"
 	"net"
 	"sync"
@@ -10,12 +11,14 @@ import (
 	"github.com/fortytw2/leaktest"
 	"github.com/go-kit/kit/log/term"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"

 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/p2p/mock"
+	memproto "github.com/tendermint/tendermint/proto/tendermint/mempool"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
@@ -246,3 +249,30 @@ func ensureNoTxs(t *testing.T, reactor *Reactor, timeout time.Duration) {
 	time.Sleep(timeout) // wait for the txs in all mempools
 	assert.Zero(t, reactor.mempool.Size())
 }
+
+func TestMempoolVectors(t *testing.T) {
+
+	testCases := []struct {
+		testName string
+		tx       []byte
+		expBytes string
+	}{
+		{"tx 1", []byte{123}, "0a030a017b"},
+		{"tx 2", []byte("proto encoding in mempool"), "0a1b0a1970726f746f20656e636f64696e6720696e206d656d706f6f6c"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		msg := memproto.Message{
+			Sum: &memproto.Message_Tx{
+				Tx: &memproto.Tx{Tx: tc.tx},
+			},
+		}
+		bz, err := msg.Marshal()
+		require.NoError(t, err, tc.testName)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+	}
+
+}
--- a/p2p/conn/connection_test.go
+++ b/p2p/conn/connection_test.go
@@ -1,11 +1,13 @@
 package conn

 import (
+	"encoding/hex"
 	"net"
 	"testing"
 	"time"

 	"github.com/fortytw2/leaktest"
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

@@ -561,3 +563,27 @@ func TestMConnectionTrySend(t *testing.T) {
 	assert.False(t, mconn.TrySend(0x01, msg))
 	assert.Equal(t, "TrySend", <-resultCh)
 }
+
+// nolint:lll //ignore line length for tests
+func TestConnVectors(t *testing.T) {
+
+	testCases := []struct {
+		testName string
+		msg      proto.Message
+		expBytes string
+	}{
+		{"PacketPing", &tmp2p.PacketPing{}, "0a00"},
+		{"PacketPong", &tmp2p.PacketPong{}, "1200"},
+		{"PacketMsg", &tmp2p.PacketMsg{ChannelID: 1, EOF: false, Data: []byte("data transmitted over the wire")}, "1a2208011a1e64617461207472616e736d6974746564206f766572207468652077697265"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		pm := mustWrapPacket(tc.msg)
+		bz, err := pm.Marshal()
+		require.NoError(t, err, tc.testName)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+	}
+}
--- a/p2p/pex/pex_reactor.go
+++ b/p2p/pex/pex_reactor.go
@@ -779,7 +779,7 @@ func mustEncode(pb proto.Message) []byte {
 		panic(fmt.Sprintf("Unknown message type %T", pb))
 	}

-	bz, err := proto.Marshal(&msg)
+	bz, err := msg.Marshal()
 	if err != nil {
 		panic(fmt.Errorf("unable to marshal %T: %w", pb, err))
 	}
@@ -788,10 +788,12 @@ func mustEncode(pb proto.Message) []byte {

 func decodeMsg(bz []byte) (proto.Message, error) {
 	pb := &tmp2p.Message{}
-	err := proto.Unmarshal(bz, pb)
+
+	err := pb.Unmarshal(bz)
 	if err != nil {
 		return nil, err
 	}
+
 	switch msg := pb.Sum.(type) {
 	case *tmp2p.Message_PexRequest:
 		return msg.PexRequest, nil
--- a/p2p/pex/pex_reactor_test.go
+++ b/p2p/pex/pex_reactor_test.go
@@ -1,6 +1,7 @@
 package pex

 import (
+	"encoding/hex"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -8,6 +9,7 @@ import (
 	"testing"
 	"time"

+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

@@ -673,3 +675,29 @@ func createSwitchAndAddReactors(reactors ...p2p.Reactor) *p2p.Switch {
 	}
 	return sw
 }
+
+func TestPexVectors(t *testing.T) {
+
+	addr := tmp2p.NetAddress{
+		ID:   "1",
+		IP:   "127.0.0.1",
+		Port: 9090,
+	}
+
+	testCases := []struct {
+		testName string
+		msg      proto.Message
+		expBytes string
+	}{
+		{"PexRequest", &tmp2p.PexRequest{}, "0a00"},
+		{"PexAddrs", &tmp2p.PexAddrs{Addrs: []tmp2p.NetAddress{addr}}, "12130a110a013112093132372e302e302e31188247"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		bz := mustEncode(tc.msg)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+	}
+}
--- a/privval/messages.go
+++ b/privval/messages.go
--- a/privval/msgs_test.go
+++ b/privval/msgs_test.go
@@ -0,0 +1,103 @@
+package privval
+
+import (
+	"encoding/hex"
+	"testing"
+	"time"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/stretchr/testify/require"
+
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
+	"github.com/tendermint/tendermint/crypto/tmhash"
+	privproto "github.com/tendermint/tendermint/proto/tendermint/privval"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/types"
+)
+
+var stamp = time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC)
+
+func exampleVote() *types.Vote {
+	return &types.Vote{
+		Type:      tmproto.SignedMsgType(1),
+		Height:    3,
+		Round:     2,
+		Timestamp: stamp,
+		BlockID: types.BlockID{
+			Hash: tmhash.Sum([]byte("blockID_hash")),
+			PartSetHeader: types.PartSetHeader{
+				Total: 1000000,
+				Hash:  tmhash.Sum([]byte("blockID_part_set_header_hash")),
+			},
+		},
+		ValidatorAddress: crypto.AddressHash([]byte("validator_address")),
+		ValidatorIndex:   56789,
+	}
+}
+
+func exampleProposal() *types.Proposal {
+
+	return &types.Proposal{
+		Type:      tmproto.SignedMsgType(1),
+		Height:    3,
+		Round:     2,
+		Timestamp: stamp,
+		POLRound:  2,
+		Signature: []byte("it's a signature"),
+		BlockID: types.BlockID{
+			Hash: tmhash.Sum([]byte("blockID_hash")),
+			PartSetHeader: types.PartSetHeader{
+				Total: 1000000,
+				Hash:  tmhash.Sum([]byte("blockID_part_set_header_hash")),
+			},
+		},
+	}
+}
+
+// nolint:lll // ignore line length for tests
+func TestPrivvalVectors(t *testing.T) {
+	pk := ed25519.GenPrivKeyFromSecret([]byte("it's a secret")).PubKey()
+	ppk, err := cryptoenc.PubKeyToProto(pk)
+	require.NoError(t, err)
+
+	// Generate a simple vote
+	vote := exampleVote()
+	votepb := vote.ToProto()
+
+	// Generate a simple proposal
+	proposal := exampleProposal()
+	proposalpb := proposal.ToProto()
+
+	// Create a Reuseable remote error
+	remoteError := &privproto.RemoteSignerError{Code: 1, Description: "it's a error"}
+
+	testCases := []struct {
+		testName string
+		msg      proto.Message
+		expBytes string
+	}{
+		{"ping request", &privproto.PingRequest{}, ""},
+		{"ping response", &privproto.PingResponse{}, ""},
+		{"pubKey request", &privproto.PubKeyRequest{}, "0a00"},
+		{"pubKey response", &privproto.PubKeyResponse{PubKey: &ppk, Error: nil}, "12240a220a20556a436f1218d30942efe798420f51dc9b6a311b929c578257457d05c5fcf230"},
+		{"pubKey response with error", &privproto.PubKeyResponse{PubKey: nil, Error: remoteError}, "121212100801120c697427732061206572726f72"},
+		{"Vote Request", &privproto.SignVoteRequest{Vote: votepb}, "1a760a74080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0608f49a8ded0532146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb03"},
+		{"Vote Response", &privproto.SignedVoteResponse{Vote: votepb, Error: nil}, "22760a74080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0608f49a8ded0532146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb03"},
+		{"Vote Response with error", &privproto.SignedVoteResponse{Vote: nil, Error: remoteError}, "221212100801120c697427732061206572726f72"},
+		{"Proposal Request", &privproto.SignProposalRequest{Proposal: proposalpb}, "2a700a6e08011003180220022a4a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a320608f49a8ded053a10697427732061207369676e6174757265"},
+		{"Proposal Response", &privproto.SignedProposalResponse{Proposal: proposalpb, Error: nil}, "32700a6e08011003180220022a4a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a320608f49a8ded053a10697427732061207369676e6174757265"},
+		{"Proposal Response with error", &privproto.SignedProposalResponse{Proposal: nil, Error: remoteError}, "321212100801120c697427732061206572726f72"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		pm := mustWrapMsg(tc.msg)
+		bz, err := pm.Marshal()
+		require.NoError(t, err, tc.testName)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+	}
+}
--- a/privval/signer_client.go
+++ b/privval/signer_client.go
@@ -111,7 +111,7 @@ func (sc *SignerClient) SignVote(chainID string, vote *tmproto.Vote) error {

 // SignProposal requests a remote signer to sign a proposal
 func (sc *SignerClient) SignProposal(chainID string, proposal *tmproto.Proposal) error {
-	response, err := sc.endpoint.SendRequest(mustWrapMsg(&privvalproto.SignProposalRequest{Proposal: *proposal}))
+	response, err := sc.endpoint.SendRequest(mustWrapMsg(&privvalproto.SignProposalRequest{Proposal: proposal}))
 	if err != nil {
 		return err
 	}
--- a/privval/signer_requestHandler.go
+++ b/privval/signer_requestHandler.go
@@ -49,12 +49,12 @@ func DefaultValidationRequestHandler(
 	case *privvalproto.Message_SignProposalRequest:
 		proposal := r.SignProposalRequest.Proposal

-		err = privVal.SignProposal(chainID, &proposal)
+		err = privVal.SignProposal(chainID, proposal)
 		if err != nil {
 			res = mustWrapMsg(&privvalproto.SignedProposalResponse{
 				Proposal: nil, Error: &privvalproto.RemoteSignerError{Code: 0, Description: err.Error()}})
 		} else {
-			res = mustWrapMsg(&privvalproto.SignedProposalResponse{Proposal: &proposal, Error: nil})
+			res = mustWrapMsg(&privvalproto.SignedProposalResponse{Proposal: proposal, Error: nil})
 		}
 	case *privvalproto.Message_PingRequest:
 		err, res = nil, mustWrapMsg(&privvalproto.PingResponse{})
--- a/proto/tendermint/privval/types.pb.go
+++ b/proto/tendermint/privval/types.pb.go
@@ -304,7 +304,7 @@ func (m *SignedVoteResponse) GetError() *RemoteSignerError {

 // SignProposalRequest is a request to sign a proposal
 type SignProposalRequest struct {
-	Proposal types.Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal"`
+	Proposal *types.Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
 }

 func (m *SignProposalRequest) Reset()         { *m = SignProposalRequest{} }
@@ -340,11 +340,11 @@ func (m *SignProposalRequest) XXX_DiscardUnknown() {

 var xxx_messageInfo_SignProposalRequest proto.InternalMessageInfo

-func (m *SignProposalRequest) GetProposal() types.Proposal {
+func (m *SignProposalRequest) GetProposal() *types.Proposal {
 	if m != nil {
 		return m.Proposal
 	}
-	return types.Proposal{}
+	return nil
 }

 // SignedProposalResponse is response containing a signed proposal or an error
@@ -654,53 +654,52 @@ func init() {
 func init() { proto.RegisterFile("tendermint/privval/types.proto", fileDescriptor_cb4e437a5328cf9c) }

 var fileDescriptor_cb4e437a5328cf9c = []byte{
-	// 721 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x4e, 0xdb, 0x4a,
-	0x14, 0xc6, 0x6d, 0x48, 0x02, 0xf7, 0x84, 0xfc, 0x61, 0xe0, 0x72, 0x73, 0x23, 0xae, 0xc9, 0x75,
-	0xd5, 0x16, 0xb1, 0x48, 0x24, 0xaa, 0x56, 0xaa, 0xda, 0x2e, 0x0a, 0x58, 0x4d, 0x84, 0x70, 0xd2,
-	0x49, 0x28, 0x15, 0x52, 0x15, 0x91, 0x64, 0xea, 0x5a, 0x10, 0xcf, 0xd4, 0xe3, 0x20, 0x65, 0xd1,
-	0x5d, 0xb7, 0x95, 0xfa, 0x18, 0x5d, 0xf7, 0x29, 0x58, 0xb2, 0xec, 0xaa, 0xaa, 0xe0, 0x45, 0x2a,
-	0x8f, 0x27, 0xb6, 0xc9, 0x9f, 0x4a, 0x88, 0x9d, 0xe7, 0x7c, 0x33, 0xbf, 0xf3, 0x1d, 0xcf, 0x27,
-	0x0d, 0x68, 0x1e, 0x71, 0x7a, 0xc4, 0xed, 0xdb, 0x8e, 0x57, 0x61, 0xae, 0x7d, 0x7e, 0x7e, 0x72,
-	0x56, 0xf1, 0x86, 0x8c, 0xf0, 0x32, 0x73, 0xa9, 0x47, 0x11, 0x8a, 0xf4, 0xb2, 0xd4, 0x8b, 0xab,
-	0x16, 0xb5, 0xa8, 0x90, 0x2b, 0xfe, 0x57, 0xb0, 0xb3, 0xb8, 0x1e, 0x23, 0x75, 0xdd, 0x21, 0xf3,
-	0x68, 0xe5, 0x94, 0x0c, 0xf9, 0x14, 0x55, 0xf0, 0xe3, 0x5d, 0xf4, 0x1a, 0x2c, 0x63, 0xd2, 0xa7,
-	0x1e, 0x69, 0xda, 0x96, 0x43, 0x5c, 0xc3, 0x75, 0xa9, 0x8b, 0x10, 0x24, 0xba, 0xb4, 0x47, 0x0a,
-	0x6a, 0x49, 0xdd, 0x4c, 0x62, 0xf1, 0x8d, 0x4a, 0x90, 0xee, 0x11, 0xde, 0x75, 0x6d, 0xe6, 0xd9,
-	0xd4, 0x29, 0xcc, 0x95, 0xd4, 0xcd, 0xbf, 0x70, 0xbc, 0xa4, 0xe7, 0x20, 0xd3, 0x18, 0x74, 0xf6,
-	0xc9, 0x10, 0x93, 0x8f, 0x03, 0xc2, 0x3d, 0xfd, 0xb3, 0x0a, 0xd9, 0x51, 0x85, 0x33, 0xea, 0x70,
-	0x82, 0x1e, 0xc3, 0x02, 0x1b, 0x74, 0xda, 0xa7, 0x64, 0x28, 0xe0, 0xe9, 0xed, 0xf5, 0x72, 0x6c,
-	0xcc, 0xc0, 0x7c, 0xb9, 0x31, 0xe8, 0x9c, 0xd9, 0x5d, 0xff, 0x58, 0x8a, 0x89, 0xe3, 0xe8, 0x19,
-	0x24, 0x89, 0xef, 0x4c, 0xb4, 0x4d, 0x6f, 0xdf, 0x2f, 0x4f, 0xfe, 0x9b, 0xf2, 0xc4, 0x18, 0x38,
-	0x38, 0xa3, 0xbf, 0x80, 0x9c, 0x5f, 0x7d, 0x43, 0x3d, 0x22, 0x9d, 0xa1, 0x2d, 0x48, 0x9c, 0x53,
-	0x8f, 0x48, 0x0f, 0x6b, 0x71, 0x5c, 0xf0, 0x73, 0xc4, 0x66, 0xb1, 0x47, 0xff, 0x04, 0x48, 0x40,
-	0x7b, 0x01, 0x40, 0x0e, 0x72, 0x0b, 0xc2, 0xdd, 0xdc, 0x37, 0x61, 0xc5, 0xaf, 0x36, 0x5c, 0xca,
-	0x28, 0x3f, 0x39, 0x1b, 0x4d, 0xf0, 0x1c, 0x16, 0x99, 0x2c, 0x49, 0x0f, 0xc5, 0x49, 0x0f, 0xa3,
-	0x43, 0x3b, 0x89, 0x8b, 0x9f, 0x1b, 0x0a, 0x0e, 0x4f, 0xe8, 0x5f, 0x54, 0x58, 0x0b, 0x86, 0x8a,
-	0xb8, 0x72, 0xb0, 0x27, 0xb7, 0x01, 0x47, 0xc8, 0xbb, 0x0d, 0x99, 0x81, 0x74, 0xc3, 0x76, 0xac,
-	0x51, 0x70, 0xb2, 0xb0, 0x14, 0x2c, 0x03, 0x4f, 0xfa, 0xf7, 0x24, 0x2c, 0x1c, 0x10, 0xce, 0x4f,
-	0x2c, 0x82, 0xf6, 0x21, 0x27, 0x13, 0xd4, 0x76, 0x83, 0xed, 0xd2, 0xe6, 0xff, 0xd3, 0x3a, 0xde,
-	0x08, 0x64, 0x55, 0xc1, 0x19, 0x16, 0x2f, 0x20, 0x13, 0xf2, 0x11, 0x2c, 0x68, 0x26, 0xfd, 0xeb,
-	0x7f, 0xa2, 0x05, 0x3b, 0xab, 0x0a, 0xce, 0xb2, 0x9b, 0xf1, 0x7e, 0x0d, 0xcb, 0xdc, 0xb6, 0x9c,
-	0xb6, 0x7f, 0xed, 0xa1, 0xbd, 0x79, 0x01, 0xbc, 0x37, 0x0d, 0x38, 0x96, 0xcb, 0xaa, 0x82, 0x73,
-	0x7c, 0x2c, 0xaa, 0xc7, 0xb0, 0xca, 0xc5, 0x4d, 0x8d, 0xa0, 0xd2, 0x66, 0x42, 0x50, 0x1f, 0xcc,
-	0xa2, 0xde, 0x8c, 0x6b, 0x55, 0xc1, 0x88, 0x4f, 0x86, 0xf8, 0x1d, 0xfc, 0x2d, 0xec, 0x8e, 0x2e,
-	0x31, 0xb4, 0x9c, 0x14, 0xf0, 0x87, 0xb3, 0xe0, 0x63, 0x61, 0xac, 0x2a, 0x78, 0x85, 0x4f, 0xc9,
-	0xe8, 0x7b, 0x28, 0x48, 0xeb, 0xb1, 0x06, 0xd2, 0x7e, 0x4a, 0x74, 0xd8, 0x9a, 0x6d, 0x7f, 0x3c,
-	0x98, 0x55, 0x05, 0xaf, 0xf1, 0xe9, 0x91, 0xdd, 0x83, 0x25, 0x66, 0x3b, 0x56, 0xe8, 0x7e, 0x41,
-	0xb0, 0x37, 0xa6, 0xde, 0x60, 0x94, 0xb2, 0xaa, 0x82, 0xd3, 0x2c, 0x5a, 0xa2, 0x57, 0x90, 0x91,
-	0x14, 0x69, 0x71, 0x51, 0x60, 0x4a, 0xb3, 0x31, 0xa1, 0xb1, 0x25, 0x16, 0x5b, 0xef, 0x24, 0x61,
-	0x9e, 0x0f, 0xfa, 0x5b, 0xdf, 0x54, 0x48, 0x89, 0x90, 0x73, 0x84, 0x20, 0x6b, 0x60, 0x5c, 0xc7,
-	0xcd, 0xf6, 0xa1, 0xb9, 0x6f, 0xd6, 0x8f, 0xcc, 0xbc, 0x82, 0x34, 0x28, 0x86, 0x35, 0xe3, 0x6d,
-	0xc3, 0xd8, 0x6d, 0x19, 0x7b, 0x6d, 0x6c, 0x34, 0x1b, 0x75, 0xb3, 0x69, 0xe4, 0x55, 0x54, 0x80,
-	0x55, 0xa9, 0x9b, 0xf5, 0xf6, 0x6e, 0xdd, 0x34, 0x8d, 0xdd, 0x56, 0xad, 0x6e, 0xe6, 0xe7, 0xd0,
-	0x7f, 0xf0, 0xaf, 0x54, 0xa2, 0x72, 0xbb, 0x55, 0x3b, 0x30, 0xea, 0x87, 0xad, 0xfc, 0x3c, 0xfa,
-	0x07, 0x56, 0xa4, 0x8c, 0x8d, 0x97, 0x7b, 0xa1, 0x90, 0x88, 0x11, 0x8f, 0x70, 0xad, 0x65, 0x84,
-	0x4a, 0x72, 0xa7, 0x79, 0x71, 0xa5, 0xa9, 0x97, 0x57, 0x9a, 0xfa, 0xeb, 0x4a, 0x53, 0xbf, 0x5e,
-	0x6b, 0xca, 0xe5, 0xb5, 0xa6, 0xfc, 0xb8, 0xd6, 0x94, 0xe3, 0xa7, 0x96, 0xed, 0x7d, 0x18, 0x74,
-	0xca, 0x5d, 0xda, 0xaf, 0xc4, 0xdf, 0x91, 0xf8, 0xd3, 0xe5, 0xbf, 0x46, 0x93, 0x6f, 0x59, 0x27,
-	0x25, 0x94, 0x47, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x98, 0xd1, 0x49, 0xc8, 0xe8, 0x06, 0x00,
-	0x00,
+	// 711 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x6e, 0xd3, 0x4a,
+	0x14, 0xc6, 0xed, 0x36, 0x49, 0x7b, 0x4f, 0x9a, 0x3f, 0x9d, 0xf6, 0xf6, 0xe6, 0x46, 0xbd, 0xbe,
+	0xc1, 0x08, 0xa8, 0xba, 0x48, 0xa4, 0x22, 0x90, 0x10, 0x62, 0x41, 0x5b, 0x8b, 0x44, 0x55, 0xed,
+	0x30, 0x49, 0x29, 0xaa, 0x84, 0xac, 0x26, 0x19, 0x8c, 0xd5, 0xc6, 0x33, 0x78, 0x9c, 0x4a, 0x59,
+	0xb0, 0x63, 0x8b, 0xc4, 0x63, 0xb0, 0xe6, 0x29, 0x58, 0x76, 0xc9, 0x12, 0xb5, 0x2f, 0x82, 0x3c,
+	0x9e, 0x38, 0x6e, 0xfe, 0x20, 0x41, 0x77, 0x9e, 0xf3, 0xcd, 0xfc, 0xce, 0x77, 0x3c, 0x9f, 0x34,
+	0xa0, 0x05, 0xc4, 0xeb, 0x11, 0xbf, 0xef, 0x7a, 0x41, 0x8d, 0xf9, 0xee, 0xc5, 0xc5, 0xe9, 0x79,
+	0x2d, 0x18, 0x32, 0xc2, 0xab, 0xcc, 0xa7, 0x01, 0x45, 0x68, 0xac, 0x57, 0xa5, 0x5e, 0x5e, 0x77,
+	0xa8, 0x43, 0x85, 0x5c, 0x0b, 0xbf, 0xa2, 0x9d, 0xe5, 0xcd, 0x04, 0xa9, 0xeb, 0x0f, 0x59, 0x40,
+	0x6b, 0x67, 0x64, 0xc8, 0x67, 0xa8, 0x82, 0x9f, 0xec, 0xa2, 0x37, 0x60, 0x15, 0x93, 0x3e, 0x0d,
+	0x48, 0xcb, 0x75, 0x3c, 0xe2, 0x1b, 0xbe, 0x4f, 0x7d, 0x84, 0x20, 0xd5, 0xa5, 0x3d, 0x52, 0x52,
+	0x2b, 0xea, 0x56, 0x1a, 0x8b, 0x6f, 0x54, 0x81, 0x6c, 0x8f, 0xf0, 0xae, 0xef, 0xb2, 0xc0, 0xa5,
+	0x5e, 0x69, 0xa1, 0xa2, 0x6e, 0xfd, 0x85, 0x93, 0x25, 0xbd, 0x00, 0xb9, 0xe6, 0xa0, 0x73, 0x40,
+	0x86, 0x98, 0xbc, 0x1f, 0x10, 0x1e, 0xe8, 0x1f, 0x55, 0xc8, 0x8f, 0x2a, 0x9c, 0x51, 0x8f, 0x13,
+	0xf4, 0x08, 0x96, 0xd8, 0xa0, 0x63, 0x9f, 0x91, 0xa1, 0x80, 0x67, 0x77, 0x36, 0xab, 0x89, 0x31,
+	0x23, 0xf3, 0xd5, 0xe6, 0xa0, 0x73, 0xee, 0x76, 0xc3, 0x63, 0x19, 0x26, 0x8e, 0xa3, 0xa7, 0x90,
+	0x26, 0xa1, 0x33, 0xd1, 0x36, 0xbb, 0x73, 0xaf, 0x3a, 0xfd, 0x6f, 0xaa, 0x53, 0x63, 0xe0, 0xe8,
+	0x8c, 0xfe, 0x0c, 0x0a, 0x61, 0xf5, 0x15, 0x0d, 0x88, 0x74, 0x86, 0xb6, 0x21, 0x75, 0x41, 0x03,
+	0x22, 0x3d, 0x6c, 0x24, 0x71, 0xd1, 0xcf, 0x11, 0x9b, 0xc5, 0x1e, 0xfd, 0x03, 0x20, 0x01, 0xed,
+	0x45, 0x00, 0x39, 0xc8, 0x6f, 0x10, 0x6e, 0xe7, 0xfe, 0x10, 0xd6, 0xc2, 0x6a, 0xd3, 0xa7, 0x8c,
+	0xf2, 0xd3, 0xf3, 0xd1, 0x04, 0x8f, 0x61, 0x99, 0xc9, 0x92, 0xf4, 0x50, 0x9e, 0xf6, 0x10, 0x1f,
+	0x8a, 0xf7, 0xea, 0x9f, 0x54, 0xd8, 0x88, 0xc6, 0x19, 0x13, 0xe5, 0x48, 0x7f, 0x88, 0xbc, 0xdd,
+	0x78, 0x39, 0xc8, 0x36, 0x5d, 0xcf, 0x19, 0x45, 0x26, 0x0f, 0x2b, 0xd1, 0x32, 0xf2, 0xa4, 0x7f,
+	0x4d, 0xc3, 0xd2, 0x21, 0xe1, 0xfc, 0xd4, 0x21, 0xe8, 0x00, 0x0a, 0x32, 0x3b, 0xb6, 0x1f, 0x6d,
+	0x97, 0x36, 0xef, 0xcc, 0xea, 0x78, 0x23, 0x8a, 0x75, 0x05, 0xe7, 0x58, 0xb2, 0x80, 0x4c, 0x28,
+	0x8e, 0x61, 0x51, 0x33, 0xe9, 0x5f, 0xff, 0x15, 0x2d, 0xda, 0x59, 0x57, 0x70, 0x9e, 0xdd, 0x0c,
+	0xf6, 0x4b, 0x58, 0xe5, 0xae, 0xe3, 0xd9, 0xe1, 0x85, 0xc7, 0xf6, 0x16, 0x05, 0xf0, 0xee, 0x2c,
+	0xe0, 0x44, 0x22, 0xeb, 0x0a, 0x2e, 0xf0, 0x89, 0x90, 0x9e, 0xc0, 0x3a, 0x17, 0x37, 0x35, 0x82,
+	0x4a, 0x9b, 0x29, 0x41, 0xbd, 0x3f, 0x8f, 0x7a, 0x33, 0xa8, 0x75, 0x05, 0x23, 0x3e, 0x1d, 0xdf,
+	0x37, 0xf0, 0xb7, 0xb0, 0x3b, 0xba, 0xc4, 0xd8, 0x72, 0x5a, 0xc0, 0x1f, 0xcc, 0x83, 0x4f, 0xc4,
+	0xb0, 0xae, 0xe0, 0x35, 0x3e, 0x23, 0x9d, 0x6f, 0xa1, 0x24, 0xad, 0x27, 0x1a, 0x48, 0xfb, 0x19,
+	0xd1, 0x61, 0x7b, 0xbe, 0xfd, 0xc9, 0x60, 0xd6, 0x15, 0xbc, 0xc1, 0x67, 0x47, 0x76, 0x1f, 0x56,
+	0x98, 0xeb, 0x39, 0xb1, 0xfb, 0x25, 0xc1, 0xfe, 0x7f, 0xe6, 0x0d, 0x8e, 0x53, 0x56, 0x57, 0x70,
+	0x96, 0x8d, 0x97, 0xe8, 0x05, 0xe4, 0x24, 0x45, 0x5a, 0x5c, 0x16, 0x98, 0xca, 0x7c, 0x4c, 0x6c,
+	0x6c, 0x85, 0x25, 0xd6, 0xbb, 0x69, 0x58, 0xe4, 0x83, 0xfe, 0xf6, 0x17, 0x15, 0x32, 0x22, 0xe4,
+	0x1c, 0x21, 0xc8, 0x1b, 0x18, 0x5b, 0xb8, 0x65, 0x1f, 0x99, 0x07, 0xa6, 0x75, 0x6c, 0x16, 0x15,
+	0xa4, 0x41, 0x39, 0xae, 0x19, 0xaf, 0x9b, 0xc6, 0x5e, 0xdb, 0xd8, 0xb7, 0xb1, 0xd1, 0x6a, 0x5a,
+	0x66, 0xcb, 0x28, 0xaa, 0xa8, 0x04, 0xeb, 0x52, 0x37, 0x2d, 0x7b, 0xcf, 0x32, 0x4d, 0x63, 0xaf,
+	0xdd, 0xb0, 0xcc, 0xe2, 0x02, 0xfa, 0x0f, 0xfe, 0x95, 0xca, 0xb8, 0x6c, 0xb7, 0x1b, 0x87, 0x86,
+	0x75, 0xd4, 0x2e, 0x2e, 0xa2, 0x7f, 0x60, 0x4d, 0xca, 0xd8, 0x78, 0xbe, 0x1f, 0x0b, 0xa9, 0x04,
+	0xf1, 0x18, 0x37, 0xda, 0x46, 0xac, 0xa4, 0x77, 0x5b, 0xdf, 0xae, 0x34, 0xf5, 0xf2, 0x4a, 0x53,
+	0x7f, 0x5c, 0x69, 0xea, 0xe7, 0x6b, 0x4d, 0xb9, 0xbc, 0xd6, 0x94, 0xef, 0xd7, 0x9a, 0x72, 0xf2,
+	0xc4, 0x71, 0x83, 0x77, 0x83, 0x4e, 0xb5, 0x4b, 0xfb, 0xb5, 0xe4, 0x0b, 0x92, 0x7c, 0xb4, 0xc2,
+	0x77, 0x68, 0xfa, 0x15, 0xeb, 0x64, 0x84, 0xf2, 0xf0, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbe,
+	0xc8, 0xae, 0x83, 0xe2, 0x06, 0x00, 0x00,
 }

 func (m *RemoteSignerError) Marshal() (dAtA []byte, err error) {
@@ -910,16 +909,18 @@ func (m *SignProposalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.Proposal != nil {
+		{
+			size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintTypes(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
 	}
-	i--
-	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }

@@ -1305,8 +1306,10 @@ func (m *SignProposalRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = m.Proposal.Size()
-	n += 1 + l + sovTypes(uint64(l))
+	if m.Proposal != nil {
+		l = m.Proposal.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
 	return n
 }

@@ -2014,6 +2017,9 @@ func (m *SignProposalRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.Proposal == nil {
+				m.Proposal = &types.Proposal{}
+			}
 			if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
--- a/proto/tendermint/privval/types.proto
+++ b/proto/tendermint/privval/types.proto
@@ -43,7 +43,7 @@ message SignedVoteResponse {

 // SignProposalRequest is a request to sign a proposal
 message SignProposalRequest {
-  tendermint.types.Proposal proposal = 1 [(gogoproto.nullable) = false];
+  tendermint.types.Proposal proposal = 1;
 }

 // SignedProposalResponse is response containing a signed proposal or an error
@@ -70,4 +70,3 @@ message Message {
    PingResponse           ping_response            = 8;
  }
 }
-
--- a/statesync/messages.go
+++ b/statesync/messages.go
@@ -31,7 +31,7 @@ func mustEncodeMsg(pb proto.Message) []byte {
 	default:
 		panic(fmt.Errorf("unknown message type %T", pb))
 	}
-	bz, err := proto.Marshal(&msg)
+	bz, err := msg.Marshal()
 	if err != nil {
 		panic(fmt.Errorf("unable to marshal %T: %w", pb, err))
 	}
--- a/statesync/messages_test.go
+++ b/statesync/messages_test.go
@@ -1,6 +1,7 @@
 package statesync

 import (
+	"encoding/hex"
 	"testing"

 	"github.com/gogo/protobuf/proto"
@@ -81,3 +82,26 @@ func TestValidateMsg(t *testing.T) {
 		})
 	}
 }
+
+//nolint:lll // ignore line length
+func TestStateSyncVectors(t *testing.T) {
+
+	testCases := []struct {
+		testName string
+		msg      proto.Message
+		expBytes string
+	}{
+		{"SnapshotsRequest", &ssproto.SnapshotsRequest{}, "0a00"},
+		{"SnapshotsResponse", &ssproto.SnapshotsResponse{Height: 1, Format: 2, Chunks: 3, Hash: []byte("chuck hash"), Metadata: []byte("snapshot metadata")}, "1225080110021803220a636875636b20686173682a11736e617073686f74206d65746164617461"},
+		{"ChunkRequest", &ssproto.ChunkRequest{Height: 1, Format: 2, Index: 3}, "1a06080110021803"},
+		{"ChunkResponse", &ssproto.ChunkResponse{Height: 1, Format: 2, Index: 3, Chunk: []byte("it's a chunk")}, "2214080110021803220c697427732061206368756e6b"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+
+		bz := mustEncodeMsg(tc.msg)
+
+		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
+	}
+}