diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go
index c207b24e1..83f6df21d 100644
--- a/abci/types/types.pb.go
+++ b/abci/types/types.pb.go
@@ -8,11 +8,11 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	keys "github.com/tendermint/tendermint/proto/crypto/keys"
 	merkle "github.com/tendermint/tendermint/proto/crypto/merkle"
-	types "github.com/tendermint/tendermint/proto/types"
+	types1 "github.com/tendermint/tendermint/proto/types"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -720,7 +720,7 @@ func (m *RequestQuery) GetProve() bool {
 
 type RequestBeginBlock struct {
 	Hash                []byte         `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	Header              types.Header   `protobuf:"bytes,2,opt,name=header,proto3" json:"header"`
+	Header              types1.Header  `protobuf:"bytes,2,opt,name=header,proto3" json:"header"`
 	LastCommitInfo      LastCommitInfo `protobuf:"bytes,3,opt,name=last_commit_info,json=lastCommitInfo,proto3" json:"last_commit_info"`
 	ByzantineValidators []Evidence     `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators,proto3" json:"byzantine_validators"`
 }
@@ -765,11 +765,11 @@ func (m *RequestBeginBlock) GetHash() []byte {
 	return nil
 }
 
-func (m *RequestBeginBlock) GetHeader() types.Header {
+func (m *RequestBeginBlock) GetHeader() types1.Header {
 	if m != nil {
 		return m.Header
 	}
-	return types.Header{}
+	return types1.Header{}
 }
 
 func (m *RequestBeginBlock) GetLastCommitInfo() LastCommitInfo {
@@ -2417,9 +2417,9 @@ func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string {
 // ConsensusParams contains all consensus-relevant parameters
 // that can be adjusted by the abci app
 type ConsensusParams struct {
-	Block     *BlockParams           `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
-	Evidence  *types.EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
-	Validator *types.ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
+	Block     *BlockParams            `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
+	Evidence  *types1.EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
+	Validator *types1.ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
 }
 
 func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
@@ -2462,14 +2462,14 @@ func (m *ConsensusParams) GetBlock() *BlockParams {
 	return nil
 }
 
-func (m *ConsensusParams) GetEvidence() *types.EvidenceParams {
+func (m *ConsensusParams) GetEvidence() *types1.EvidenceParams {
 	if m != nil {
 		return m.Evidence
 	}
 	return nil
 }
 
-func (m *ConsensusParams) GetValidator() *types.ValidatorParams {
+func (m *ConsensusParams) GetValidator() *types1.ValidatorParams {
 	if m != nil {
 		return m.Validator
 	}
@@ -13148,7 +13148,7 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Evidence == nil {
-				m.Evidence = &types.EvidenceParams{}
+				m.Evidence = &types1.EvidenceParams{}
 			}
 			if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -13184,7 +13184,7 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Validator == nil {
-				m.Validator = &types.ValidatorParams{}
+				m.Validator = &types1.ValidatorParams{}
 			}
 			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
diff --git a/consensus/state_test.go b/consensus/state_test.go
index d053fc005..0bc07e152 100644
--- a/consensus/state_test.go
+++ b/consensus/state_test.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/tendermint/tendermint/abci/example/counter"
 	cstypes "github.com/tendermint/tendermint/consensus/types"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/log"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
@@ -1802,7 +1803,9 @@ func TestStateOutputVoteStats(t *testing.T) {
 	// create dummy peer
 	peer := p2pmock.NewPeer(nil)
 
-	vote := signVote(vss[1], tmproto.PrecommitType, []byte("test"), types.PartSetHeader{})
+	randBytes := tmrand.Bytes(tmhash.Size)
+
+	vote := signVote(vss[1], tmproto.PrecommitType, randBytes, types.PartSetHeader{})
 
 	voteMessage := &VoteMessage{vote}
 	cs.handleMsg(msgInfo{voteMessage, peer.ID()})
@@ -1816,7 +1819,7 @@ func TestStateOutputVoteStats(t *testing.T) {
 
 	// sending the vote for the bigger height
 	incrementHeight(vss[1])
-	vote = signVote(vss[1], tmproto.PrecommitType, []byte("test"), types.PartSetHeader{})
+	vote = signVote(vss[1], tmproto.PrecommitType, randBytes, types.PartSetHeader{})
 
 	cs.handleMsg(msgInfo{&VoteMessage{vote}, peer.ID()})
 
diff --git a/consensus/types/height_vote_set_test.go b/consensus/types/height_vote_set_test.go
index 4abcac9df..774badda4 100644
--- a/consensus/types/height_vote_set_test.go
+++ b/consensus/types/height_vote_set_test.go
@@ -6,6 +6,8 @@ import (
 	"testing"
 
 	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto/tmhash"
+	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -60,6 +62,8 @@ func makeVoteHR(t *testing.T, height int64, valIndex, round int32, privVals []ty
 		panic(err)
 	}
 
+	randBytes := tmrand.Bytes(tmhash.Size)
+
 	vote := &types.Vote{
 		ValidatorAddress: pubKey.Address(),
 		ValidatorIndex:   valIndex,
@@ -67,7 +71,7 @@ func makeVoteHR(t *testing.T, height int64, valIndex, round int32, privVals []ty
 		Round:            round,
 		Timestamp:        tmtime.Now(),
 		Type:             tmproto.PrecommitType,
-		BlockID:          types.BlockID{Hash: []byte("fakehash"), PartsHeader: types.PartSetHeader{}},
+		BlockID:          types.BlockID{Hash: randBytes, PartsHeader: types.PartSetHeader{}},
 	}
 	chainID := config.ChainID()
 
diff --git a/privval/file.go b/privval/file.go
index d870ccbbf..e07e724ac 100644
--- a/privval/file.go
+++ b/privval/file.go
@@ -14,6 +14,7 @@ import (
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 	tmos "github.com/tendermint/tendermint/libs/os"
+	"github.com/tendermint/tendermint/libs/protoio"
 	"github.com/tendermint/tendermint/libs/tempfile"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
@@ -397,15 +398,14 @@ func (pv *FilePV) saveSigned(height int64, round int32, step int8,
 // returns true if the only difference in the votes is their timestamp.
 func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) {
 	var lastVote, newVote tmproto.CanonicalVote
-	if err := proto.Unmarshal(lastSignBytes, &lastVote); err != nil {
+	if err := protoio.UnmarshalDelimited(lastSignBytes, &lastVote); err != nil {
 		panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into vote: %v", err))
 	}
-	if err := proto.Unmarshal(newSignBytes, &newVote); err != nil {
+	if err := protoio.UnmarshalDelimited(newSignBytes, &newVote); err != nil {
 		panic(fmt.Sprintf("signBytes cannot be unmarshalled into vote: %v", err))
 	}
 
 	lastTime := lastVote.Timestamp
-
 	// set the times to the same value and check equality
 	now := tmtime.Now()
 	lastVote.Timestamp = now
@@ -418,10 +418,10 @@ func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.T
 // returns true if the only difference in the proposals is their timestamp
 func checkProposalsOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) {
 	var lastProposal, newProposal tmproto.CanonicalProposal
-	if err := proto.Unmarshal(lastSignBytes, &lastProposal); err != nil {
+	if err := protoio.UnmarshalDelimited(lastSignBytes, &lastProposal); err != nil {
 		panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into proposal: %v", err))
 	}
-	if err := proto.Unmarshal(newSignBytes, &newProposal); err != nil {
+	if err := protoio.UnmarshalDelimited(newSignBytes, &newProposal); err != nil {
 		panic(fmt.Sprintf("signBytes cannot be unmarshalled into proposal: %v", err))
 	}
 
diff --git a/privval/file_test.go b/privval/file_test.go
index cb6f5819f..23f215411 100644
--- a/privval/file_test.go
+++ b/privval/file_test.go
@@ -12,7 +12,9 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 	tmjson "github.com/tendermint/tendermint/libs/json"
+	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -53,7 +55,8 @@ func TestResetValidator(t *testing.T) {
 	// test vote
 	height, round := int64(10), int32(1)
 	voteType := tmproto.PrevoteType
-	blockID := types.BlockID{Hash: []byte{1, 2, 3}, PartsHeader: types.PartSetHeader{}}
+	randBytes := tmrand.Bytes(tmhash.Size)
+	blockID := types.BlockID{Hash: randBytes, PartsHeader: types.PartSetHeader{}}
 	vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
 	err = privVal.SignVote("mychainid", vote.ToProto())
 	assert.NoError(t, err, "expected no error signing vote")
@@ -163,8 +166,13 @@ func TestSignVote(t *testing.T) {
 
 	privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
 
-	block1 := types.BlockID{Hash: []byte{1, 2, 3}, PartsHeader: types.PartSetHeader{}}
-	block2 := types.BlockID{Hash: []byte{3, 2, 1}, PartsHeader: types.PartSetHeader{}}
+	randbytes := tmrand.Bytes(tmhash.Size)
+	randbytes2 := tmrand.Bytes(tmhash.Size)
+
+	block1 := types.BlockID{Hash: randbytes,
+		PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
+	block2 := types.BlockID{Hash: randbytes2,
+		PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
 
 	height, round := int64(10), int32(1)
 	voteType := tmproto.PrevoteType
@@ -211,8 +219,13 @@ func TestSignProposal(t *testing.T) {
 
 	privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
 
-	block1 := types.BlockID{Hash: []byte{1, 2, 3}, PartsHeader: types.PartSetHeader{Total: 5, Hash: []byte{1, 2, 3}}}
-	block2 := types.BlockID{Hash: []byte{3, 2, 1}, PartsHeader: types.PartSetHeader{Total: 10, Hash: []byte{3, 2, 1}}}
+	randbytes := tmrand.Bytes(tmhash.Size)
+	randbytes2 := tmrand.Bytes(tmhash.Size)
+
+	block1 := types.BlockID{Hash: randbytes,
+		PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
+	block2 := types.BlockID{Hash: randbytes2,
+		PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
 	height, round := int64(10), int32(1)
 
 	// sign a proposal for first time
@@ -253,8 +266,8 @@ func TestDifferByTimestamp(t *testing.T) {
 	require.Nil(t, err)
 
 	privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
-
-	block1 := types.BlockID{Hash: []byte{1, 2, 3}, PartsHeader: types.PartSetHeader{Total: 5, Hash: []byte{1, 2, 3}}}
+	randbytes := tmrand.Bytes(tmhash.Size)
+	block1 := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
 	height, round := int64(10), int32(1)
 	chainID := "mychainid"
 
@@ -284,7 +297,7 @@ func TestDifferByTimestamp(t *testing.T) {
 	// test vote
 	{
 		voteType := tmproto.PrevoteType
-		blockID := types.BlockID{Hash: []byte{1, 2, 3}, PartsHeader: types.PartSetHeader{}}
+		blockID := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{}}
 		vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
 		v := vote.ToProto()
 		err := privVal.SignVote("mychainid", v)
diff --git a/proto/consensus/walmsgs.pb.go b/proto/consensus/walmsgs.pb.go
index f2e1a0cbc..c722662ea 100644
--- a/proto/consensus/walmsgs.pb.go
+++ b/proto/consensus/walmsgs.pb.go
@@ -7,9 +7,9 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	_ "github.com/golang/protobuf/ptypes/duration"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	types "github.com/tendermint/tendermint/proto/types"
 	io "io"
 	math "math"
diff --git a/proto/state/types.pb.go b/proto/state/types.pb.go
index 312844142..4f563f8a3 100644
--- a/proto/state/types.pb.go
+++ b/proto/state/types.pb.go
@@ -7,8 +7,8 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	types "github.com/tendermint/tendermint/abci/types"
 	types1 "github.com/tendermint/tendermint/proto/types"
 	version "github.com/tendermint/tendermint/proto/version"
diff --git a/proto/types/canonical.pb.go b/proto/types/canonical.pb.go
index 6cf57e159..56eb1399b 100644
--- a/proto/types/canonical.pb.go
+++ b/proto/types/canonical.pb.go
@@ -4,11 +4,12 @@
 package types
 
 import (
+	encoding_binary "encoding/binary"
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -80,8 +81,8 @@ func (m *CanonicalBlockID) GetPartsHeader() CanonicalPartSetHeader {
 }
 
 type CanonicalPartSetHeader struct {
-	Hash  []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	Total uint32 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
+	Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
+	Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
 }
 
 func (m *CanonicalPartSetHeader) Reset()         { *m = CanonicalPartSetHeader{} }
@@ -117,13 +118,6 @@ func (m *CanonicalPartSetHeader) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_CanonicalPartSetHeader proto.InternalMessageInfo
 
-func (m *CanonicalPartSetHeader) GetHash() []byte {
-	if m != nil {
-		return m.Hash
-	}
-	return nil
-}
-
 func (m *CanonicalPartSetHeader) GetTotal() uint32 {
 	if m != nil {
 		return m.Total
@@ -131,14 +125,21 @@ func (m *CanonicalPartSetHeader) GetTotal() uint32 {
 	return 0
 }
 
+func (m *CanonicalPartSetHeader) GetHash() []byte {
+	if m != nil {
+		return m.Hash
+	}
+	return nil
+}
+
 type CanonicalProposal struct {
-	Type      SignedMsgType    `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
-	Height    int64            `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty" binary:" fixed64 "`
-	Round     int64            `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty" binary:" fixed64 "`
-	POLRound  int64            `protobuf:"varint,4,opt,name=pol_round,json=polRound,proto3" json:"pol_round,omitempty"`
-	BlockID   CanonicalBlockID `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	Timestamp time.Time        `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
-	ChainID   string           `protobuf:"bytes,7,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	Type      SignedMsgType     `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
+	Height    int64             `protobuf:"fixed64,2,opt,name=height,proto3" json:"height,omitempty"`
+	Round     int64             `protobuf:"fixed64,3,opt,name=round,proto3" json:"round,omitempty"`
+	POLRound  int64             `protobuf:"varint,4,opt,name=pol_round,json=polRound,proto3" json:"pol_round,omitempty"`
+	BlockID   *CanonicalBlockID `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id,omitempty"`
+	Timestamp time.Time         `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	ChainID   string            `protobuf:"bytes,7,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
 }
 
 func (m *CanonicalProposal) Reset()         { *m = CanonicalProposal{} }
@@ -202,11 +203,11 @@ func (m *CanonicalProposal) GetPOLRound() int64 {
 	return 0
 }
 
-func (m *CanonicalProposal) GetBlockID() CanonicalBlockID {
+func (m *CanonicalProposal) GetBlockID() *CanonicalBlockID {
 	if m != nil {
 		return m.BlockID
 	}
-	return CanonicalBlockID{}
+	return nil
 }
 
 func (m *CanonicalProposal) GetTimestamp() time.Time {
@@ -224,12 +225,12 @@ func (m *CanonicalProposal) GetChainID() string {
 }
 
 type CanonicalVote struct {
-	Type      SignedMsgType    `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
-	Height    int64            `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty" binary:" fixed64 "`
-	Round     int64            `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty" binary:" fixed64 "`
-	BlockID   CanonicalBlockID `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	Timestamp time.Time        `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
-	ChainID   string           `protobuf:"bytes,7,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	Type      SignedMsgType     `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
+	Height    int64             `protobuf:"fixed64,2,opt,name=height,proto3" json:"height,omitempty"`
+	Round     int64             `protobuf:"fixed64,3,opt,name=round,proto3" json:"round,omitempty"`
+	BlockID   *CanonicalBlockID `protobuf:"bytes,4,opt,name=block_id,json=blockId,proto3" json:"block_id,omitempty"`
+	Timestamp time.Time         `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	ChainID   string            `protobuf:"bytes,6,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
 }
 
 func (m *CanonicalVote) Reset()         { *m = CanonicalVote{} }
@@ -286,11 +287,11 @@ func (m *CanonicalVote) GetRound() int64 {
 	return 0
 }
 
-func (m *CanonicalVote) GetBlockID() CanonicalBlockID {
+func (m *CanonicalVote) GetBlockID() *CanonicalBlockID {
 	if m != nil {
 		return m.BlockID
 	}
-	return CanonicalBlockID{}
+	return nil
 }
 
 func (m *CanonicalVote) GetTimestamp() time.Time {
@@ -317,39 +318,38 @@ func init() {
 func init() { proto.RegisterFile("proto/types/canonical.proto", fileDescriptor_3f9b1d584b46f180) }
 
 var fileDescriptor_3f9b1d584b46f180 = []byte{
-	// 506 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x54, 0x4d, 0x8b, 0xd3, 0x40,
-	0x18, 0x6e, 0xb6, 0x5f, 0xe9, 0xb4, 0xeb, 0xc7, 0x20, 0x35, 0x54, 0x48, 0x42, 0xc0, 0xa5, 0xc2,
-	0x32, 0x81, 0x55, 0x04, 0x3d, 0x66, 0x45, 0x2c, 0x28, 0x2e, 0xd9, 0xa2, 0xe0, 0xa5, 0x4c, 0x92,
-	0xd9, 0x64, 0x30, 0xcd, 0x84, 0x64, 0x0a, 0xf6, 0xe4, 0x5f, 0xd8, 0xab, 0xff, 0x68, 0x8f, 0x3d,
-	0x7a, 0xaa, 0x92, 0xde, 0x3c, 0xfa, 0x0b, 0x64, 0x66, 0xfa, 0x75, 0xa8, 0x7a, 0xd5, 0x4b, 0x79,
-	0xe7, 0x99, 0xe7, 0x79, 0xde, 0xa7, 0xef, 0xbc, 0x04, 0x3c, 0xc8, 0x0b, 0xc6, 0x99, 0xcb, 0xe7,
-	0x39, 0x29, 0xdd, 0x10, 0x67, 0x2c, 0xa3, 0x21, 0x4e, 0x91, 0x44, 0x61, 0x9f, 0x93, 0x2c, 0x22,
-	0xc5, 0x94, 0x66, 0x5c, 0x21, 0x48, 0xf2, 0x06, 0x27, 0x3c, 0xa1, 0x45, 0x34, 0xc9, 0x71, 0xc1,
-	0xe7, 0xae, 0x32, 0x88, 0x59, 0xcc, 0x76, 0x95, 0x62, 0x0f, 0xee, 0xef, 0x9b, 0xcb, 0xdf, 0xf5,
-	0x85, 0x15, 0x33, 0x16, 0xa7, 0x44, 0x69, 0x83, 0xd9, 0x95, 0xcb, 0xe9, 0x94, 0x94, 0x1c, 0x4f,
-	0x73, 0x45, 0x70, 0x3e, 0x83, 0x3b, 0xe7, 0x9b, 0x30, 0x5e, 0xca, 0xc2, 0x8f, 0xa3, 0x17, 0x10,
-	0x82, 0x46, 0x82, 0xcb, 0xc4, 0xd0, 0x6c, 0x6d, 0xd8, 0xf3, 0x65, 0x0d, 0xdf, 0x83, 0x9e, 0x48,
-	0x51, 0x4e, 0x12, 0x82, 0x23, 0x52, 0x18, 0x47, 0xb6, 0x36, 0xec, 0x9e, 0x21, 0x74, 0x38, 0x38,
-	0xda, 0x7a, 0x5e, 0xe0, 0x82, 0x5f, 0x12, 0xfe, 0x4a, 0xaa, 0xbc, 0xc6, 0xcd, 0xd2, 0xaa, 0xf9,
-	0x5d, 0xe9, 0xa4, 0x20, 0xc7, 0x03, 0xfd, 0xc3, 0xe4, 0x83, 0x31, 0xee, 0x81, 0x26, 0x67, 0x1c,
-	0xa7, 0xb2, 0xff, 0xb1, 0xaf, 0x0e, 0xce, 0x97, 0x3a, 0xb8, 0xbb, 0x33, 0x29, 0x58, 0xce, 0x4a,
-	0x9c, 0xc2, 0x67, 0xa0, 0x21, 0xc2, 0x48, 0xfd, 0xad, 0xb3, 0x87, 0xbf, 0x8b, 0x7a, 0x49, 0xe3,
-	0x8c, 0x44, 0x6f, 0xca, 0x78, 0x3c, 0xcf, 0x89, 0x2f, 0x25, 0x10, 0x81, 0x56, 0x42, 0x68, 0x9c,
-	0x70, 0xd9, 0xa7, 0xee, 0xf5, 0x7f, 0x2e, 0x2d, 0x18, 0xd0, 0x0c, 0x17, 0xf3, 0xe7, 0x8e, 0x7d,
-	0x45, 0x3f, 0x91, 0xe8, 0xe9, 0x13, 0xdb, 0xf1, 0xd7, 0x2c, 0x78, 0x0a, 0x9a, 0x05, 0x9b, 0x65,
-	0x91, 0x51, 0xff, 0x23, 0x5d, 0x91, 0xe0, 0x23, 0xd0, 0xc9, 0x59, 0x3a, 0x51, 0x8a, 0x86, 0x54,
-	0xf4, 0xaa, 0xa5, 0xa5, 0x5f, 0xbc, 0x7d, 0xed, 0x0b, 0xcc, 0xd7, 0x73, 0x96, 0xca, 0x0a, 0x8e,
-	0x81, 0x1e, 0x88, 0x57, 0x99, 0xd0, 0xc8, 0x68, 0xca, 0x91, 0x0f, 0xff, 0x3a, 0xf2, 0xf5, 0x33,
-	0x7a, 0xb7, 0xc5, 0xb0, 0xab, 0xa5, 0xd5, 0x5e, 0x03, 0x7e, 0x5b, 0x5a, 0x8d, 0x22, 0xe8, 0x81,
-	0xce, 0x76, 0x0f, 0x8c, 0x96, 0xb4, 0x1d, 0x20, 0xb5, 0x29, 0x68, 0xb3, 0x29, 0x68, 0xbc, 0x61,
-	0x78, 0xba, 0x30, 0xba, 0xfe, 0x66, 0x69, 0xfe, 0x4e, 0x06, 0x4f, 0x80, 0x1e, 0x26, 0x98, 0x66,
-	0x22, 0x59, 0xdb, 0xd6, 0x86, 0x1d, 0xaf, 0x2b, 0x7a, 0x9d, 0x0b, 0x4c, 0xf4, 0x92, 0x97, 0xa3,
-	0xc8, 0xf9, 0x71, 0x04, 0x8e, 0xb7, 0xd1, 0xde, 0x31, 0x4e, 0xfe, 0xdd, 0x77, 0xf9, 0xef, 0x87,
-	0xed, 0xbd, 0xbc, 0xa9, 0x4c, 0x6d, 0x51, 0x99, 0xda, 0xf7, 0xca, 0xd4, 0xae, 0x57, 0x66, 0x6d,
-	0xb1, 0x32, 0x6b, 0x5f, 0x57, 0x66, 0xed, 0xc3, 0x69, 0x4c, 0x79, 0x32, 0x0b, 0x50, 0xc8, 0xa6,
-	0xee, 0xee, 0x3f, 0xed, 0x97, 0x7b, 0x9f, 0x90, 0xa0, 0x25, 0x0f, 0x8f, 0x7f, 0x05, 0x00, 0x00,
-	0xff, 0xff, 0x79, 0xf8, 0x2b, 0x08, 0xb5, 0x04, 0x00, 0x00,
+	// 493 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0x41, 0x8b, 0xd3, 0x40,
+	0x14, 0x6e, 0xba, 0x69, 0x9b, 0x4e, 0xbb, 0xb2, 0x0e, 0x52, 0x43, 0x85, 0xa4, 0x14, 0x5c, 0x22,
+	0xc8, 0x04, 0xd6, 0x93, 0xd7, 0xac, 0x88, 0x05, 0xc5, 0x32, 0xbb, 0x28, 0x78, 0x29, 0xd3, 0x64,
+	0x4c, 0x06, 0xd3, 0x4c, 0x48, 0xa6, 0x87, 0x9e, 0xfc, 0x0b, 0xfb, 0x6b, 0xfc, 0x0d, 0x7b, 0xdc,
+	0xa3, 0xa7, 0x2a, 0x29, 0xfe, 0x0f, 0x99, 0x99, 0xb6, 0xe9, 0x61, 0x8b, 0x07, 0xc5, 0x4b, 0x78,
+	0xef, 0x7b, 0xef, 0x7d, 0xef, 0xcb, 0xf7, 0x18, 0xf0, 0x24, 0x2f, 0xb8, 0xe0, 0xbe, 0x58, 0xe5,
+	0xb4, 0xf4, 0x43, 0x92, 0xf1, 0x8c, 0x85, 0x24, 0x45, 0x0a, 0x85, 0x03, 0x41, 0xb3, 0x88, 0x16,
+	0x0b, 0x96, 0x09, 0x8d, 0x20, 0xd5, 0x37, 0x3c, 0x17, 0x09, 0x2b, 0xa2, 0x59, 0x4e, 0x0a, 0xb1,
+	0xf2, 0x35, 0x41, 0xcc, 0x63, 0x5e, 0x47, 0xba, 0x7b, 0xf8, 0xf8, 0x90, 0x5c, 0x7d, 0xb7, 0x05,
+	0x37, 0xe6, 0x3c, 0x4e, 0xa9, 0x9e, 0x9d, 0x2f, 0x3f, 0xfb, 0x82, 0x2d, 0x68, 0x29, 0xc8, 0x22,
+	0xd7, 0x0d, 0xe3, 0xaf, 0xe0, 0xec, 0x72, 0x27, 0x26, 0x48, 0x79, 0xf8, 0x65, 0xf2, 0x0a, 0x42,
+	0x60, 0x26, 0xa4, 0x4c, 0x6c, 0x63, 0x64, 0x78, 0x7d, 0xac, 0x62, 0xf8, 0x11, 0xf4, 0xa5, 0x8a,
+	0x72, 0x96, 0x50, 0x12, 0xd1, 0xc2, 0x6e, 0x8e, 0x0c, 0xaf, 0x77, 0x81, 0xd0, 0xfd, 0xc2, 0xd1,
+	0x9e, 0x73, 0x4a, 0x0a, 0x71, 0x45, 0xc5, 0x1b, 0x35, 0x15, 0x98, 0xb7, 0x6b, 0xb7, 0x81, 0x7b,
+	0x8a, 0x49, 0x43, 0xe3, 0x00, 0x0c, 0xee, 0x6f, 0x86, 0x8f, 0x40, 0x4b, 0x70, 0x41, 0x52, 0xa5,
+	0xe3, 0x14, 0xeb, 0x64, 0x2f, 0xae, 0x59, 0x8b, 0x1b, 0xff, 0x6a, 0x82, 0x87, 0x35, 0x49, 0xc1,
+	0x73, 0x5e, 0x92, 0x14, 0xbe, 0x04, 0xa6, 0x14, 0xa3, 0xc6, 0x1f, 0x5c, 0x3c, 0x3d, 0x26, 0xf5,
+	0x8a, 0xc5, 0x19, 0x8d, 0xde, 0x95, 0xf1, 0xf5, 0x2a, 0xa7, 0x58, 0x8d, 0xc0, 0x01, 0x68, 0x27,
+	0x94, 0xc5, 0x89, 0x50, 0x6b, 0xce, 0xf0, 0x36, 0x93, 0x92, 0x0a, 0xbe, 0xcc, 0x22, 0xfb, 0x44,
+	0xc1, 0x3a, 0x81, 0xcf, 0x40, 0x37, 0xe7, 0xe9, 0x4c, 0x57, 0xcc, 0x91, 0xe1, 0x9d, 0x04, 0xfd,
+	0x6a, 0xed, 0x5a, 0xd3, 0xf7, 0x6f, 0xb1, 0xc4, 0xb0, 0x95, 0xf3, 0x54, 0x45, 0x70, 0x0a, 0xac,
+	0xb9, 0x74, 0x79, 0xc6, 0x22, 0xbb, 0xa5, 0x2c, 0xf4, 0xfe, 0x68, 0xe1, 0xf6, 0x2c, 0x41, 0xaf,
+	0x5a, 0xbb, 0x9d, 0x6d, 0x82, 0x3b, 0x8a, 0x66, 0x12, 0xc1, 0x00, 0x74, 0xf7, 0x37, 0xb5, 0xdb,
+	0x8a, 0x72, 0x88, 0xf4, 0xd5, 0xd1, 0xee, 0xea, 0xe8, 0x7a, 0xd7, 0x11, 0x58, 0xf2, 0x02, 0x37,
+	0x3f, 0x5c, 0x03, 0xd7, 0x63, 0xf0, 0x1c, 0x58, 0x61, 0x42, 0x58, 0x26, 0x55, 0x75, 0x46, 0x86,
+	0xd7, 0xd5, 0xbb, 0x2e, 0x25, 0x26, 0x77, 0xa9, 0xe2, 0x24, 0x1a, 0x7f, 0x6b, 0x82, 0xd3, 0xbd,
+	0xac, 0x0f, 0x5c, 0xd0, 0xff, 0xe7, 0xf1, 0xa1, 0x71, 0xe6, 0xbf, 0x37, 0xae, 0xf5, 0xf7, 0xc6,
+	0xb5, 0x8f, 0x1b, 0x17, 0xbc, 0xbe, 0xad, 0x1c, 0xe3, 0xae, 0x72, 0x8c, 0x9f, 0x95, 0x63, 0xdc,
+	0x6c, 0x9c, 0xc6, 0xdd, 0xc6, 0x69, 0x7c, 0xdf, 0x38, 0x8d, 0x4f, 0xcf, 0x63, 0x26, 0x92, 0xe5,
+	0x1c, 0x85, 0x7c, 0xe1, 0xd7, 0xff, 0x73, 0x18, 0x1e, 0x3c, 0xed, 0x79, 0x5b, 0x25, 0x2f, 0x7e,
+	0x07, 0x00, 0x00, 0xff, 0xff, 0xfa, 0xd1, 0x62, 0xe9, 0x4d, 0x04, 0x00, 0x00,
 }
 
 func (m *CanonicalBlockID) Marshal() (dAtA []byte, err error) {
@@ -412,17 +412,17 @@ func (m *CanonicalPartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
-	if m.Total != 0 {
-		i = encodeVarintCanonical(dAtA, i, uint64(m.Total))
-		i--
-		dAtA[i] = 0x10
-	}
 	if len(m.Hash) > 0 {
 		i -= len(m.Hash)
 		copy(dAtA[i:], m.Hash)
 		i = encodeVarintCanonical(dAtA, i, uint64(len(m.Hash)))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
+	}
+	if m.Total != 0 {
+		i = encodeVarintCanonical(dAtA, i, uint64(m.Total))
+		i--
+		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
@@ -462,30 +462,34 @@ func (m *CanonicalProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i = encodeVarintCanonical(dAtA, i, uint64(n2))
 	i--
 	dAtA[i] = 0x32
-	{
-		size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
+	if m.BlockID != nil {
+		{
+			size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintCanonical(dAtA, i, uint64(size))
 		}
-		i -= size
-		i = encodeVarintCanonical(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x2a
 	}
-	i--
-	dAtA[i] = 0x2a
 	if m.POLRound != 0 {
 		i = encodeVarintCanonical(dAtA, i, uint64(m.POLRound))
 		i--
 		dAtA[i] = 0x20
 	}
 	if m.Round != 0 {
-		i = encodeVarintCanonical(dAtA, i, uint64(m.Round))
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Round))
 		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0x19
 	}
 	if m.Height != 0 {
-		i = encodeVarintCanonical(dAtA, i, uint64(m.Height))
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Height))
 		i--
-		dAtA[i] = 0x10
+		dAtA[i] = 0x11
 	}
 	if m.Type != 0 {
 		i = encodeVarintCanonical(dAtA, i, uint64(m.Type))
@@ -520,7 +524,7 @@ func (m *CanonicalVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		copy(dAtA[i:], m.ChainID)
 		i = encodeVarintCanonical(dAtA, i, uint64(len(m.ChainID)))
 		i--
-		dAtA[i] = 0x3a
+		dAtA[i] = 0x32
 	}
 	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err4 != nil {
@@ -529,26 +533,30 @@ func (m *CanonicalVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i -= n4
 	i = encodeVarintCanonical(dAtA, i, uint64(n4))
 	i--
-	dAtA[i] = 0x32
-	{
-		size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintCanonical(dAtA, i, uint64(size))
-	}
-	i--
 	dAtA[i] = 0x2a
-	if m.Round != 0 {
-		i = encodeVarintCanonical(dAtA, i, uint64(m.Round))
+	if m.BlockID != nil {
+		{
+			size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintCanonical(dAtA, i, uint64(size))
+		}
 		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0x22
+	}
+	if m.Round != 0 {
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Round))
+		i--
+		dAtA[i] = 0x19
 	}
 	if m.Height != 0 {
-		i = encodeVarintCanonical(dAtA, i, uint64(m.Height))
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Height))
 		i--
-		dAtA[i] = 0x10
+		dAtA[i] = 0x11
 	}
 	if m.Type != 0 {
 		i = encodeVarintCanonical(dAtA, i, uint64(m.Type))
@@ -590,13 +598,13 @@ func (m *CanonicalPartSetHeader) Size() (n int) {
 	}
 	var l int
 	_ = l
+	if m.Total != 0 {
+		n += 1 + sovCanonical(uint64(m.Total))
+	}
 	l = len(m.Hash)
 	if l > 0 {
 		n += 1 + l + sovCanonical(uint64(l))
 	}
-	if m.Total != 0 {
-		n += 1 + sovCanonical(uint64(m.Total))
-	}
 	return n
 }
 
@@ -610,16 +618,18 @@ func (m *CanonicalProposal) Size() (n int) {
 		n += 1 + sovCanonical(uint64(m.Type))
 	}
 	if m.Height != 0 {
-		n += 1 + sovCanonical(uint64(m.Height))
+		n += 9
 	}
 	if m.Round != 0 {
-		n += 1 + sovCanonical(uint64(m.Round))
+		n += 9
 	}
 	if m.POLRound != 0 {
 		n += 1 + sovCanonical(uint64(m.POLRound))
 	}
-	l = m.BlockID.Size()
-	n += 1 + l + sovCanonical(uint64(l))
+	if m.BlockID != nil {
+		l = m.BlockID.Size()
+		n += 1 + l + sovCanonical(uint64(l))
+	}
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovCanonical(uint64(l))
 	l = len(m.ChainID)
@@ -639,13 +649,15 @@ func (m *CanonicalVote) Size() (n int) {
 		n += 1 + sovCanonical(uint64(m.Type))
 	}
 	if m.Height != 0 {
-		n += 1 + sovCanonical(uint64(m.Height))
+		n += 9
 	}
 	if m.Round != 0 {
-		n += 1 + sovCanonical(uint64(m.Round))
+		n += 9
+	}
+	if m.BlockID != nil {
+		l = m.BlockID.Size()
+		n += 1 + l + sovCanonical(uint64(l))
 	}
-	l = m.BlockID.Size()
-	n += 1 + l + sovCanonical(uint64(l))
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovCanonical(uint64(l))
 	l = len(m.ChainID)
@@ -811,6 +823,25 @@ func (m *CanonicalPartSetHeader) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
+			}
+			m.Total = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowCanonical
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Total |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
 			}
@@ -844,25 +875,6 @@ func (m *CanonicalPartSetHeader) Unmarshal(dAtA []byte) error {
 				m.Hash = []byte{}
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
-			}
-			m.Total = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCanonical
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Total |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipCanonical(dAtA[iNdEx:])
@@ -936,43 +948,25 @@ func (m *CanonicalProposal) Unmarshal(dAtA []byte) error {
 				}
 			}
 		case 2:
-			if wireType != 0 {
+			if wireType != 1 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
 			}
 			m.Height = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCanonical
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Height |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
 			}
+			m.Height = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
 		case 3:
-			if wireType != 0 {
+			if wireType != 1 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
 			}
 			m.Round = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCanonical
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Round |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
 			}
+			m.Round = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
 		case 4:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field POLRound", wireType)
@@ -1021,6 +1015,9 @@ func (m *CanonicalProposal) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.BlockID == nil {
+				m.BlockID = &CanonicalBlockID{}
+			}
 			if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1163,44 +1160,26 @@ func (m *CanonicalVote) Unmarshal(dAtA []byte) error {
 				}
 			}
 		case 2:
-			if wireType != 0 {
+			if wireType != 1 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
 			}
 			m.Height = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCanonical
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Height |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
 			}
+			m.Height = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
 		case 3:
-			if wireType != 0 {
+			if wireType != 1 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
 			}
 			m.Round = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCanonical
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Round |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
 			}
-		case 5:
+			m.Round = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType)
 			}
@@ -1229,11 +1208,14 @@ func (m *CanonicalVote) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.BlockID == nil {
+				m.BlockID = &CanonicalBlockID{}
+			}
 			if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
 			}
@@ -1266,7 +1248,7 @@ func (m *CanonicalVote) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
 			}
diff --git a/proto/types/canonical.proto b/proto/types/canonical.proto
index ae85bdec2..028b92e7b 100644
--- a/proto/types/canonical.proto
+++ b/proto/types/canonical.proto
@@ -13,25 +13,25 @@ message CanonicalBlockID {
 }
 
 message CanonicalPartSetHeader {
-  bytes  hash  = 1;
-  uint32 total = 2;
+  uint32 total = 1;
+  bytes  hash  = 2;
 }
 
 message CanonicalProposal {
   SignedMsgType             type      = 1;  // type alias for byte
-  int64                     height    = 2 [(gogoproto.moretags) = "binary:\" fixed64 \""];
-  int64                     round     = 3 [(gogoproto.moretags) = "binary:\" fixed64 \""];
+  sfixed64                  height    = 2;  // canonicalization requires fixed size encoding here
+  sfixed64                  round     = 3;  // canonicalization requires fixed size encoding here
   int64                     pol_round = 4 [(gogoproto.customname) = "POLRound"];
-  CanonicalBlockID          block_id  = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"];
+  CanonicalBlockID          block_id  = 5 [(gogoproto.customname) = "BlockID"];
   google.protobuf.Timestamp timestamp = 6 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
   string                    chain_id  = 7 [(gogoproto.customname) = "ChainID"];
 }
 
 message CanonicalVote {
   SignedMsgType             type      = 1;  // type alias for byte
-  int64                     height    = 2 [(gogoproto.moretags) = "binary:\" fixed64 \""];
-  int64                     round     = 3 [(gogoproto.moretags) = "binary:\" fixed64 \""];
-  CanonicalBlockID          block_id  = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"];
-  google.protobuf.Timestamp timestamp = 6 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-  string                    chain_id  = 7 [(gogoproto.customname) = "ChainID"];
+  sfixed64                  height    = 2;  // canonicalization requires fixed size encoding here
+  sfixed64                  round     = 3;  // canonicalization requires fixed size encoding here
+  CanonicalBlockID          block_id  = 4 [(gogoproto.customname) = "BlockID"];
+  google.protobuf.Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  string                    chain_id  = 6 [(gogoproto.customname) = "ChainID"];
 }
diff --git a/proto/types/evidence.pb.go b/proto/types/evidence.pb.go
index cd5ca0c4b..30c7955d4 100644
--- a/proto/types/evidence.pb.go
+++ b/proto/types/evidence.pb.go
@@ -7,8 +7,8 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	keys "github.com/tendermint/tendermint/proto/crypto/keys"
 	io "io"
 	math "math"
diff --git a/proto/types/types.pb.go b/proto/types/types.pb.go
index 77fc97a2d..33bb2348b 100644
--- a/proto/types/types.pb.go
+++ b/proto/types/types.pb.go
@@ -7,8 +7,8 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/timestamp"
 	merkle "github.com/tendermint/tendermint/proto/crypto/merkle"
 	bits "github.com/tendermint/tendermint/proto/libs/bits"
 	version "github.com/tendermint/tendermint/proto/version"
@@ -67,23 +67,25 @@ type SignedMsgType int32
 
 const (
 	SIGNED_MSG_TYPE_UNKNOWN SignedMsgType = 0
-	PrevoteType             SignedMsgType = 1
-	PrecommitType           SignedMsgType = 2
-	ProposalType            SignedMsgType = 3
+	// Votes
+	PrevoteType   SignedMsgType = 1
+	PrecommitType SignedMsgType = 2
+	// Proposals
+	ProposalType SignedMsgType = 32
 )
 
 var SignedMsgType_name = map[int32]string{
-	0: "SIGNED_MSG_TYPE_UNKNOWN",
-	1: "PREVOTE_TYPE",
-	2: "PRECOMMIT_TYPE",
-	3: "PROPOSAL_TYPE",
+	0:  "SIGNED_MSG_TYPE_UNKNOWN",
+	1:  "PREVOTE_TYPE",
+	2:  "PRECOMMIT_TYPE",
+	32: "PROPOSAL_TYPE",
 }
 
 var SignedMsgType_value = map[string]int32{
 	"SIGNED_MSG_TYPE_UNKNOWN": 0,
 	"PREVOTE_TYPE":            1,
 	"PRECOMMIT_TYPE":          2,
-	"PROPOSAL_TYPE":           3,
+	"PROPOSAL_TYPE":           32,
 }
 
 func (x SignedMsgType) String() string {
diff --git a/proto/types/types.proto b/proto/types/types.proto
index 1323ca2dd..d3dcfc68a 100644
--- a/proto/types/types.proto
+++ b/proto/types/types.proto
@@ -26,9 +26,12 @@ enum SignedMsgType {
   option (gogoproto.goproto_enum_prefix)   = false;
 
   SIGNED_MSG_TYPE_UNKNOWN = 0;
+  // Votes
   PREVOTE_TYPE            = 1 [(gogoproto.enumvalue_customname) = "PrevoteType"];
   PRECOMMIT_TYPE          = 2 [(gogoproto.enumvalue_customname) = "PrecommitType"];
-  PROPOSAL_TYPE           = 3 [(gogoproto.enumvalue_customname) = "ProposalType"];
+
+  // Proposals
+  PROPOSAL_TYPE           = 32 [(gogoproto.enumvalue_customname) = "ProposalType"];
 }
 
 // PartsetHeader
diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh
index cd2873955..21f85c375 100755
--- a/scripts/protocgen.sh
+++ b/scripts/protocgen.sh
@@ -6,6 +6,6 @@ proto_dirs=$(find . -path ./third_party -prune -o -name '*.proto' -print0 | xarg
 for dir in $proto_dirs; do
   protoc \
   -I. \
-  --gogofaster_out=Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative:. \
+  --gogofaster_out=Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative:. \
   $(find "${dir}" -maxdepth 1 -name '*.proto')
 done
diff --git a/types/block.go b/types/block.go
index 9af3ee614..aac66dd01 100644
--- a/types/block.go
+++ b/types/block.go
@@ -1306,6 +1306,7 @@ func BlockIDFromProto(bID *tmproto.BlockID) (*BlockID, error) {
 	if bID == nil {
 		return nil, errors.New("nil BlockID")
 	}
+
 	blockID := new(BlockID)
 	ph, err := PartSetHeaderFromProto(&bID.PartsHeader)
 	if err != nil {
diff --git a/types/canonical.go b/types/canonical.go
index a8d552f1b..efd4e300d 100644
--- a/types/canonical.go
+++ b/types/canonical.go
@@ -15,25 +15,33 @@ const TimeFormat = time.RFC3339Nano
 //-----------------------------------
 // Canonicalize the structs
 
-func CanonicalizeBlockID(blockID tmproto.BlockID) tmproto.CanonicalBlockID {
-	return tmproto.CanonicalBlockID{
-		Hash:        blockID.Hash,
-		PartsHeader: CanonicalizePartSetHeader(blockID.PartsHeader),
+func CanonicalizeBlockID(bid tmproto.BlockID) *tmproto.CanonicalBlockID {
+	rbid, err := BlockIDFromProto(&bid)
+	if err != nil {
+		panic(err)
 	}
+	var cbid *tmproto.CanonicalBlockID
+	if rbid == nil || rbid.IsZero() {
+		cbid = nil
+	} else {
+		cbid = &tmproto.CanonicalBlockID{
+			Hash:        bid.Hash,
+			PartsHeader: CanonicalizePartSetHeader(bid.PartsHeader),
+		}
+	}
+
+	return cbid
 }
 
 func CanonicalizePartSetHeader(psh tmproto.PartSetHeader) tmproto.CanonicalPartSetHeader {
-	return tmproto.CanonicalPartSetHeader{
-		Hash:  psh.Hash,
-		Total: psh.Total,
-	}
+	return tmproto.CanonicalPartSetHeader(psh)
 }
 
 func CanonicalizeProposal(chainID string, proposal *tmproto.Proposal) tmproto.CanonicalProposal {
 	return tmproto.CanonicalProposal{
 		Type:      tmproto.ProposalType,
-		Height:    proposal.Height,
-		Round:     int64(proposal.Round), // cast int->int64 to make amino encode it fixed64 (does not work for int)
+		Height:    proposal.Height,       // encoded as sfixed64
+		Round:     int64(proposal.Round), // encoded as sfixed64
 		POLRound:  int64(proposal.PolRound),
 		BlockID:   CanonicalizeBlockID(proposal.BlockID),
 		Timestamp: proposal.Timestamp,
@@ -44,8 +52,8 @@ func CanonicalizeProposal(chainID string, proposal *tmproto.Proposal) tmproto.Ca
 func CanonicalizeVote(chainID string, vote *tmproto.Vote) tmproto.CanonicalVote {
 	return tmproto.CanonicalVote{
 		Type:      vote.Type,
-		Height:    vote.Height,
-		Round:     int64(vote.Round), // cast int->int64 to make amino encode it fixed64 (does not work for int)
+		Height:    vote.Height,       // encoded as sfixed64
+		Round:     int64(vote.Round), // encoded as sfixed64
 		BlockID:   CanonicalizeBlockID(vote.BlockID),
 		Timestamp: vote.Timestamp,
 		ChainID:   chainID,
diff --git a/types/canonical_test.go b/types/canonical_test.go
new file mode 100644
index 000000000..3b17e2d76
--- /dev/null
+++ b/types/canonical_test.go
@@ -0,0 +1,39 @@
+package types
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/tendermint/tendermint/crypto/tmhash"
+	tmrand "github.com/tendermint/tendermint/libs/rand"
+	tmproto "github.com/tendermint/tendermint/proto/types"
+)
+
+func TestCanonicalizeBlockID(t *testing.T) {
+	randhash := tmrand.Bytes(tmhash.Size)
+	block1 := tmproto.BlockID{Hash: randhash,
+		PartsHeader: tmproto.PartSetHeader{Total: 5, Hash: randhash}}
+	block2 := tmproto.BlockID{Hash: randhash,
+		PartsHeader: tmproto.PartSetHeader{Total: 10, Hash: randhash}}
+	cblock1 := tmproto.CanonicalBlockID{Hash: randhash,
+		PartsHeader: tmproto.CanonicalPartSetHeader{Total: 5, Hash: randhash}}
+	cblock2 := tmproto.CanonicalBlockID{Hash: randhash,
+		PartsHeader: tmproto.CanonicalPartSetHeader{Total: 10, Hash: randhash}}
+
+	tests := []struct {
+		name string
+		args tmproto.BlockID
+		want *tmproto.CanonicalBlockID
+	}{
+		{"first", block1, &cblock1},
+		{"second", block2, &cblock2},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			if got := CanonicalizeBlockID(tt.args); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("CanonicalizeBlockID() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/types/proposal.go b/types/proposal.go
index f4b6a8f8f..36769f714 100644
--- a/types/proposal.go
+++ b/types/proposal.go
@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
-
-	"github.com/tendermint/tendermint/libs/bytes"
+	tmbytes "github.com/tendermint/tendermint/libs/bytes"
+	"github.com/tendermint/tendermint/libs/protoio"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
 )
@@ -87,17 +86,18 @@ func (p *Proposal) String() string {
 		p.Round,
 		p.BlockID,
 		p.POLRound,
-		bytes.Fingerprint(p.Signature),
+		tmbytes.Fingerprint(p.Signature),
 		CanonicalTime(p.Timestamp))
 }
 
 // ProposalSignBytes returns the Proposal bytes for signing
 func ProposalSignBytes(chainID string, p *tmproto.Proposal) []byte {
 	pb := CanonicalizeProposal(chainID, p)
-	bz, err := proto.Marshal(&pb)
+	bz, err := protoio.MarshalDelimited(&pb)
 	if err != nil {
 		panic(err)
 	}
+
 	return bz
 }
 
diff --git a/types/proposal_test.go b/types/proposal_test.go
index ba611e9c6..f3bdb750f 100644
--- a/types/proposal_test.go
+++ b/types/proposal_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/tendermint/tendermint/crypto/tmhash"
+	"github.com/tendermint/tendermint/libs/protoio"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 )
@@ -25,9 +26,10 @@ func init() {
 		panic(err)
 	}
 	testProposal = &Proposal{
-		Height:    12345,
-		Round:     23456,
-		BlockID:   BlockID{[]byte{1, 2, 3}, PartSetHeader{111, []byte("blockparts")}},
+		Height: 12345,
+		Round:  23456,
+		BlockID: BlockID{Hash: []byte("--June_15_2020_amino_was_removed"),
+			PartsHeader: PartSetHeader{Total: 111, Hash: []byte("--June_15_2020_amino_was_removed")}},
 		POLRound:  -1,
 		Timestamp: stamp,
 	}
@@ -38,14 +40,15 @@ func TestProposalSignable(t *testing.T) {
 	chainID := "test_chain_id"
 	signBytes := ProposalSignBytes(chainID, pbp)
 	pb := CanonicalizeProposal(chainID, pbp)
-	expected, err := proto.Marshal(&pb)
+
+	expected, err := protoio.MarshalDelimited(&pb)
 	require.NoError(t, err)
 	require.Equal(t, expected, signBytes, "Got unexpected sign bytes for Proposal")
 }
 
 func TestProposalString(t *testing.T) {
 	str := testProposal.String()
-	expected := `Proposal{12345/23456 (010203:111:626C6F636B70, -1) 000000000000 @ 2018-02-11T07:09:22.765Z}`
+	expected := `Proposal{12345/23456 (2D2D4A756E655F31355F323032305F616D696E6F5F7761735F72656D6F766564:111:2D2D4A756E65, -1) 000000000000 @ 2018-02-11T07:09:22.765Z}` //nolint:lll // ignore line length for tests
 	if str != expected {
 		t.Errorf("got unexpected string for Proposal. Expected:\n%v\nGot:\n%v", expected, str)
 	}
diff --git a/types/vote.go b/types/vote.go
index 3bab2d707..1f473510f 100644
--- a/types/vote.go
+++ b/types/vote.go
@@ -6,10 +6,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
-
 	"github.com/tendermint/tendermint/crypto"
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
+	"github.com/tendermint/tendermint/libs/protoio"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 )
 
@@ -87,10 +86,11 @@ func (vote *Vote) CommitSig() CommitSig {
 // If any error arises this will panic
 func VoteSignBytes(chainID string, vote *tmproto.Vote) []byte {
 	pb := CanonicalizeVote(chainID, vote)
-	bz, err := proto.Marshal(&pb)
+	bz, err := protoio.MarshalDelimited(&pb)
 	if err != nil {
 		panic(err)
 	}
+
 	return bz
 }
 
diff --git a/types/vote_test.go b/types/vote_test.go
index 48e4b9dd4..902fdaa09 100644
--- a/types/vote_test.go
+++ b/types/vote_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/tmhash"
+	"github.com/tendermint/tendermint/libs/protoio"
 	tmproto "github.com/tendermint/tendermint/proto/types"
 )
 
@@ -51,8 +52,7 @@ func TestVoteSignable(t *testing.T) {
 	v := vote.ToProto()
 	signBytes := VoteSignBytes("test_chain_id", v)
 	pb := CanonicalizeVote("test_chain_id", v)
-
-	expected, err := proto.Marshal(&pb)
+	expected, err := protoio.MarshalDelimited(&pb)
 	require.NoError(t, err)
 
 	require.Equal(t, expected, signBytes, "Got unexpected sign bytes for Vote.")
@@ -68,38 +68,72 @@ func TestVoteSignBytesTestVectors(t *testing.T) {
 		0: {
 			"", &Vote{},
 			// NOTE: Height and Round are skipped here. This case needs to be considered while parsing.
-			[]byte{0x2a, 0x2, 0x12, 0x0, 0x32, 0xb, 0x8, 0x80, 0x92, 0xb8,
-				0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
+			[]byte{0xd, 0x2a, 0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
 		},
 		// with proper (fixed size) height and round (PreCommit):
 		1: {
 			"", &Vote{Height: 1, Round: 1, Type: tmproto.PrecommitType},
-			[]byte{0x8, 0x2, 0x10, 0x1, 0x18, 0x1, 0x2a, 0x2, 0x12, 0x0, 0x32,
+			[]byte{
+				0x21,                                   // length
+				0x8,                                    // (field_number << 3) | wire_type
+				0x2,                                    // PrecommitType
+				0x11,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // height
+				0x19,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // round
+				0x2a, // (field_number << 3) | wire_type
+				// remaining fields (timestamp):
 				0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
 		},
 		// with proper (fixed size) height and round (PreVote):
 		2: {
 			"", &Vote{Height: 1, Round: 1, Type: tmproto.PrevoteType},
-			[]byte{0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x2a, 0x2, 0x12, 0x0,
-				0x32, 0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
+			[]byte{
+				0x21,                                   // length
+				0x8,                                    // (field_number << 3) | wire_type
+				0x1,                                    // PrevoteType
+				0x11,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // height
+				0x19,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // round
+				0x2a, // (field_number << 3) | wire_type
+				// remaining fields (timestamp):
+				0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
 		},
 		3: {
 			"", &Vote{Height: 1, Round: 1},
-			[]byte{0x10, 0x1, 0x18, 0x1, 0x2a, 0x2, 0x12, 0x0, 0x32, 0xb,
-				0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
+			[]byte{
+				0x1f,                                   // length
+				0x11,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // height
+				0x19,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // round
+				// remaining fields (timestamp):
+				0x2a,
+				0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1},
 		},
 		// containing non-empty chain_id:
 		4: {
 			"test_chain_id", &Vote{Height: 1, Round: 1},
-			[]byte{0x10, 0x1, 0x18, 0x1, 0x2a, 0x2, 0x12, 0x0, 0x32, 0xb, 0x8,
-				0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1, 0x3a, 0xd,
-				0x74, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64},
+			[]byte{
+				0x2e,                                   // length
+				0x11,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // height
+				0x19,                                   // (field_number << 3) | wire_type
+				0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // round
+				// remaining fields:
+				0x2a,                                                                // (field_number << 3) | wire_type
+				0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3, 0x98, 0xfe, 0xff, 0xff, 0xff, 0x1, // timestamp
+				// (field_number << 3) | wire_type
+				0x32,
+				0xd, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64}, // chainID
 		},
 	}
 	for i, tc := range tests {
 		v := tc.vote.ToProto()
 		got := VoteSignBytes(tc.chainID, v)
-		require.Equal(t, tc.want, got, "test case #%v: got unexpected sign bytes for Vote.", i)
+		assert.Equal(t, len(tc.want), len(got), "test case #%v: got unexpected sign bytes length for Vote.", i)
+		assert.Equal(t, tc.want, got, "test case #%v: got unexpected sign bytes for Vote.", i)
 	}
 }