types: rename partsheader to partsetheader (#5029)

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

CHANGELOG_PENDING.md

@@ -52,6 +52,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
   - [types] \#4852 Vote & Proposal `SignBytes` is now func `VoteSignBytes` & `ProposalSignBytes`
   - [privval] \#4985 `privval` reactor migration to Protobuf encoding
   - [evidence] \#4949 `evidence` reactor migration to Protobuf encoding
+  - [types] \#5029 Rename all values from `PartsHeader` to `PartSetHeader` to have consistency
 
 - Apps
 

abci/types/types.pb.go

@@ -2767,110 +2767,6 @@ func (m *TxResult) GetResult() ResponseDeliverTx {
 	return ResponseDeliverTx{}
 }
 
-type BlockID struct {
-	Hash        []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
-}
-
-func (m *BlockID) Reset()         { *m = BlockID{} }
-func (m *BlockID) String() string { return proto.CompactTextString(m) }
-func (*BlockID) ProtoMessage()    {}
-func (*BlockID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{39}
-}
-func (m *BlockID) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *BlockID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_BlockID.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *BlockID) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockID.Merge(m, src)
-}
-func (m *BlockID) XXX_Size() int {
-	return m.Size()
-}
-func (m *BlockID) XXX_DiscardUnknown() {
-	xxx_messageInfo_BlockID.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BlockID proto.InternalMessageInfo
-
-func (m *BlockID) GetHash() []byte {
-	if m != nil {
-		return m.Hash
-	}
-	return nil
-}
-
-func (m *BlockID) GetPartsHeader() PartSetHeader {
-	if m != nil {
-		return m.PartsHeader
-	}
-	return PartSetHeader{}
-}
-
-type PartSetHeader struct {
-	Total int32  `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
-	Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
-}
-
-func (m *PartSetHeader) Reset()         { *m = PartSetHeader{} }
-func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
-func (*PartSetHeader) ProtoMessage()    {}
-func (*PartSetHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{40}
-}
-func (m *PartSetHeader) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *PartSetHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_PartSetHeader.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *PartSetHeader) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PartSetHeader.Merge(m, src)
-}
-func (m *PartSetHeader) XXX_Size() int {
-	return m.Size()
-}
-func (m *PartSetHeader) XXX_DiscardUnknown() {
-	xxx_messageInfo_PartSetHeader.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PartSetHeader proto.InternalMessageInfo
-
-func (m *PartSetHeader) GetTotal() int32 {
-	if m != nil {
-		return m.Total
-	}
-	return 0
-}
-
-func (m *PartSetHeader) GetHash() []byte {
-	if m != nil {
-		return m.Hash
-	}
-	return nil
-}
-
 // Validator
 type Validator struct {
 	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
@@ -2882,7 +2778,7 @@ func (m *Validator) Reset()         { *m = Validator{} }
 func (m *Validator) String() string { return proto.CompactTextString(m) }
 func (*Validator) ProtoMessage()    {}
 func (*Validator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{41}
+	return fileDescriptor_5056eb770c93415b, []int{39}
 }
 func (m *Validator) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2935,7 +2831,7 @@ func (m *ValidatorUpdate) Reset()         { *m = ValidatorUpdate{} }
 func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) }
 func (*ValidatorUpdate) ProtoMessage()    {}
 func (*ValidatorUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{42}
+	return fileDescriptor_5056eb770c93415b, []int{40}
 }
 func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2988,7 +2884,7 @@ func (m *VoteInfo) Reset()         { *m = VoteInfo{} }
 func (m *VoteInfo) String() string { return proto.CompactTextString(m) }
 func (*VoteInfo) ProtoMessage()    {}
 func (*VoteInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{43}
+	return fileDescriptor_5056eb770c93415b, []int{41}
 }
 func (m *VoteInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3043,7 +2939,7 @@ func (m *Evidence) Reset()         { *m = Evidence{} }
 func (m *Evidence) String() string { return proto.CompactTextString(m) }
 func (*Evidence) ProtoMessage()    {}
 func (*Evidence) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{44}
+	return fileDescriptor_5056eb770c93415b, []int{42}
 }
 func (m *Evidence) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3119,7 +3015,7 @@ func (m *Snapshot) Reset()         { *m = Snapshot{} }
 func (m *Snapshot) String() string { return proto.CompactTextString(m) }
 func (*Snapshot) ProtoMessage()    {}
 func (*Snapshot) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5056eb770c93415b, []int{45}
+	return fileDescriptor_5056eb770c93415b, []int{43}
 }
 func (m *Snapshot) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3226,8 +3122,6 @@ func init() {
 	proto.RegisterType((*EventAttribute)(nil), "tendermint.abci.types.EventAttribute")
 	proto.RegisterType((*Event)(nil), "tendermint.abci.types.Event")
 	proto.RegisterType((*TxResult)(nil), "tendermint.abci.types.TxResult")
-	proto.RegisterType((*BlockID)(nil), "tendermint.abci.types.BlockID")
-	proto.RegisterType((*PartSetHeader)(nil), "tendermint.abci.types.PartSetHeader")
 	proto.RegisterType((*Validator)(nil), "tendermint.abci.types.Validator")
 	proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.types.ValidatorUpdate")
 	proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.types.VoteInfo")
@@ -3238,176 +3132,173 @@ func init() {
 func init() { proto.RegisterFile("proto/abci/types.proto", fileDescriptor_5056eb770c93415b) }
 
 var fileDescriptor_5056eb770c93415b = []byte{
-	// 2704 bytes of a gzipped FileDescriptorProto
+	// 2650 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x73, 0x1b, 0xc7,
-	0x11, 0xc6, 0x02, 0x20, 0x1e, 0x0d, 0x02, 0x04, 0x47, 0xb2, 0x0c, 0x23, 0x36, 0xa9, 0xac, 0x2c,
-	0x59, 0x7e, 0x04, 0xb4, 0xe9, 0x2a, 0x97, 0x1d, 0x39, 0x71, 0x08, 0x8a, 0x0a, 0x18, 0xc9, 0x22,
-	0xbd, 0x24, 0x15, 0x3b, 0xa9, 0xf2, 0x66, 0xb0, 0x3b, 0x04, 0xd6, 0x04, 0x76, 0xd7, 0xbb, 0x03,
-	0x9a, 0x48, 0xe5, 0x90, 0xca, 0x25, 0x95, 0x9b, 0xf2, 0x03, 0xf2, 0x1f, 0x72, 0x48, 0x95, 0xf3,
+	0x11, 0xc6, 0x02, 0x20, 0x1e, 0x4d, 0x02, 0x04, 0x47, 0xb2, 0x0c, 0x23, 0x36, 0xa9, 0xac, 0x2c,
+	0x59, 0x7e, 0x04, 0xb4, 0xe9, 0x2a, 0x97, 0x1d, 0x29, 0x71, 0x08, 0x8a, 0x0a, 0x18, 0xc9, 0x22,
+	0xb5, 0x24, 0x15, 0x39, 0xa9, 0xf2, 0x66, 0xb0, 0x3b, 0x04, 0xd6, 0x04, 0x76, 0xd7, 0xbb, 0x03,
+	0x8a, 0x48, 0xe5, 0x90, 0xca, 0x25, 0x95, 0x9b, 0xf2, 0x03, 0xf2, 0x1f, 0x72, 0x48, 0x95, 0xf3,
 	0x07, 0x52, 0xe5, 0xca, 0xc9, 0xc7, 0x9c, 0x9c, 0x94, 0x94, 0x53, 0xf2, 0x1f, 0x52, 0xa9, 0x79,
 	0xec, 0x0b, 0xc4, 0x63, 0xe1, 0xe8, 0x96, 0xdb, 0x4c, 0x6f, 0x77, 0xcf, 0x4c, 0xcf, 0x4c, 0xf7,
-	0xd7, 0x3d, 0x0b, 0xd7, 0x5c, 0xcf, 0xa1, 0xce, 0x16, 0xee, 0x1a, 0xd6, 0x16, 0x1d, 0xbb, 0xc4,
-	0x6f, 0x71, 0x02, 0x7a, 0x8e, 0x12, 0xdb, 0x24, 0xde, 0xd0, 0xb2, 0x69, 0x8b, 0x7d, 0x6c, 0xf1,
-	0x8f, 0xcd, 0x4d, 0xc1, 0x6e, 0x78, 0x63, 0x97, 0x3a, 0x5b, 0x43, 0xe2, 0x9d, 0x0d, 0x48, 0x5c,
-	0xae, 0xf9, 0xbc, 0x60, 0xe0, 0xa4, 0xc4, 0x87, 0x97, 0x12, 0x92, 0x67, 0x64, 0x9c, 0xfc, 0xdc,
-	0x88, 0xcb, 0xb9, 0xd8, 0xc3, 0xc3, 0xe0, 0xcb, 0x66, 0xcf, 0x71, 0x7a, 0x03, 0xb2, 0xc5, 0x7b,
-	0xdd, 0xd1, 0xe9, 0x16, 0xb5, 0x86, 0xc4, 0xa7, 0x78, 0xe8, 0x4a, 0x86, 0x5b, 0xb4, 0x6f, 0x79,
-	0xa6, 0xee, 0x62, 0x8f, 0x8e, 0x05, 0xd7, 0x56, 0xcf, 0xe9, 0x39, 0x51, 0x4b, 0xf0, 0xa9, 0xff,
-	0x2e, 0x41, 0x51, 0x23, 0x9f, 0x8f, 0x88, 0x4f, 0xd1, 0xbb, 0x90, 0x27, 0x46, 0xdf, 0x69, 0x64,
-	0xaf, 0x2b, 0xb7, 0x2b, 0xdb, 0x6a, 0x6b, 0xea, 0x6a, 0x5b, 0x92, 0x7b, 0xcf, 0xe8, 0x3b, 0x9d,
-	0x8c, 0xc6, 0x25, 0xd0, 0x1d, 0x58, 0x39, 0x1d, 0x8c, 0xfc, 0x7e, 0x23, 0xc7, 0x45, 0x6f, 0xcc,
-	0x17, 0xbd, 0xc7, 0x58, 0x3b, 0x19, 0x4d, 0xc8, 0xb0, 0x61, 0x2d, 0xfb, 0xd4, 0x69, 0xe4, 0xd3,
-	0x0c, 0xbb, 0x6f, 0x9f, 0xf2, 0x61, 0x99, 0x04, 0xea, 0x00, 0xf8, 0x84, 0xea, 0x8e, 0x4b, 0x2d,
-	0xc7, 0x6e, 0xac, 0x70, 0xf9, 0x57, 0xe6, 0xcb, 0x1f, 0x11, 0x7a, 0xc0, 0xd9, 0x3b, 0x19, 0xad,
-	0xec, 0x07, 0x1d, 0xa6, 0xc9, 0xb2, 0x2d, 0xaa, 0x1b, 0x7d, 0x6c, 0xd9, 0x8d, 0x42, 0x1a, 0x4d,
-	0xfb, 0xb6, 0x45, 0x77, 0x19, 0x3b, 0xd3, 0x64, 0x05, 0x1d, 0x66, 0x8a, 0xcf, 0x47, 0xc4, 0x1b,
-	0x37, 0x8a, 0x69, 0x4c, 0xf1, 0x11, 0x63, 0x65, 0xa6, 0xe0, 0x32, 0xe8, 0x3e, 0x54, 0xba, 0xa4,
-	0x67, 0xd9, 0x7a, 0x77, 0xe0, 0x18, 0x67, 0x8d, 0x12, 0x57, 0x71, 0x7b, 0xbe, 0x8a, 0x36, 0x13,
-	0x68, 0x33, 0xfe, 0x4e, 0x46, 0x83, 0x6e, 0xd8, 0x43, 0x6d, 0x28, 0x19, 0x7d, 0x62, 0x9c, 0xe9,
-	0xf4, 0xa2, 0x51, 0xe6, 0x9a, 0x6e, 0xce, 0xd7, 0xb4, 0xcb, 0xb8, 0x8f, 0x2f, 0x3a, 0x19, 0xad,
-	0x68, 0x88, 0x26, 0xb3, 0x8b, 0x49, 0x06, 0xd6, 0x39, 0xf1, 0x98, 0x96, 0x2b, 0x69, 0xec, 0x72,
-	0x57, 0xf0, 0x73, 0x3d, 0x65, 0x33, 0xe8, 0xa0, 0x3d, 0x28, 0x13, 0xdb, 0x94, 0x0b, 0xab, 0x70,
-	0x45, 0xb7, 0x16, 0x9c, 0x30, 0xdb, 0x0c, 0x96, 0x55, 0x22, 0xb2, 0x8d, 0x7e, 0x08, 0x05, 0xc3,
-	0x19, 0x0e, 0x2d, 0xda, 0x58, 0xe5, 0x3a, 0x5e, 0x5e, 0xb0, 0x24, 0xce, 0xdb, 0xc9, 0x68, 0x52,
-	0x0a, 0x1d, 0x43, 0x6d, 0x60, 0xf9, 0x54, 0xf7, 0x6d, 0xec, 0xfa, 0x7d, 0x87, 0xfa, 0x8d, 0x2a,
-	0xd7, 0xf3, 0xfa, 0x7c, 0x3d, 0x0f, 0x2c, 0x9f, 0x1e, 0x05, 0x22, 0x9d, 0x8c, 0x56, 0x1d, 0xc4,
-	0x09, 0x4c, 0xab, 0x73, 0x7a, 0x4a, 0xbc, 0x50, 0x6d, 0xa3, 0x96, 0x46, 0xeb, 0x01, 0x93, 0x09,
-	0xb4, 0x30, 0xad, 0x4e, 0x9c, 0x80, 0x30, 0x5c, 0x19, 0x38, 0xd8, 0x0c, 0x95, 0xea, 0x46, 0x7f,
-	0x64, 0x9f, 0x35, 0xd6, 0xb8, 0xea, 0xad, 0x05, 0x13, 0x76, 0xb0, 0x19, 0x28, 0xda, 0x65, 0x62,
-	0x9d, 0x8c, 0xb6, 0x3e, 0x98, 0x24, 0x22, 0x13, 0xae, 0x62, 0xd7, 0x1d, 0x8c, 0x27, 0xc7, 0xa8,
-	0xf3, 0x31, 0xde, 0x9c, 0x3f, 0xc6, 0x0e, 0x93, 0x9c, 0x1c, 0x04, 0xe1, 0x4b, 0xd4, 0x76, 0x11,
-	0x56, 0xce, 0xf1, 0x60, 0x44, 0xd4, 0x57, 0xa0, 0x12, 0x73, 0x1f, 0xa8, 0x01, 0xc5, 0x21, 0xf1,
-	0x7d, 0xdc, 0x23, 0x0d, 0xe5, 0xba, 0x72, 0xbb, 0xac, 0x05, 0x5d, 0xb5, 0x06, 0xab, 0x71, 0x67,
-	0xa1, 0x0e, 0x43, 0x41, 0xe6, 0x00, 0x98, 0xe0, 0x39, 0xf1, 0x7c, 0x76, 0xeb, 0xa5, 0xa0, 0xec,
-	0xa2, 0x1b, 0x50, 0xe5, 0x47, 0x4c, 0x0f, 0xbe, 0x33, 0x67, 0x96, 0xd7, 0x56, 0x39, 0xf1, 0x91,
-	0x64, 0xda, 0x84, 0x8a, 0xbb, 0xed, 0x86, 0x2c, 0x39, 0xce, 0x02, 0xee, 0xb6, 0x2b, 0x19, 0xd4,
-	0xef, 0x43, 0x7d, 0xd2, 0x5f, 0xa0, 0x3a, 0xe4, 0xce, 0xc8, 0x58, 0x8e, 0xc7, 0x9a, 0xe8, 0xaa,
-	0x5c, 0x16, 0x1f, 0xa3, 0xac, 0xc9, 0x35, 0xfe, 0x31, 0x1b, 0x0a, 0x87, 0x2e, 0x82, 0xf9, 0x38,
-	0xe6, 0xa1, 0xb9, 0x74, 0x65, 0xbb, 0xd9, 0x12, 0xee, 0xbb, 0x15, 0xb8, 0xef, 0xd6, 0x71, 0xe0,
-	0xbe, 0xdb, 0xa5, 0xaf, 0xbe, 0xd9, 0xcc, 0x3c, 0xfe, 0xfb, 0xa6, 0xa2, 0x71, 0x09, 0xf4, 0x02,
-	0xbb, 0xc5, 0xd8, 0xb2, 0x75, 0xcb, 0x94, 0xe3, 0x14, 0x79, 0x7f, 0xdf, 0x44, 0x1f, 0x41, 0xdd,
-	0x70, 0x6c, 0x9f, 0xd8, 0xfe, 0xc8, 0xd7, 0x45, 0x78, 0x90, 0x0e, 0x78, 0xd6, 0xcd, 0xda, 0x0d,
-	0xd8, 0x0f, 0x39, 0xb7, 0xb6, 0x66, 0x24, 0x09, 0xe8, 0x01, 0xc0, 0x39, 0x1e, 0x58, 0x26, 0xa6,
-	0x8e, 0xe7, 0x37, 0xf2, 0xd7, 0x73, 0x73, 0x94, 0x3d, 0x0a, 0x18, 0x4f, 0x5c, 0x13, 0x53, 0xd2,
-	0xce, 0xb3, 0x99, 0x6b, 0x31, 0x79, 0x74, 0x0b, 0xd6, 0xb0, 0xeb, 0xea, 0x3e, 0xc5, 0x94, 0xe8,
-	0xdd, 0x31, 0x25, 0x3e, 0x77, 0xd2, 0xab, 0x5a, 0x15, 0xbb, 0xee, 0x11, 0xa3, 0xb6, 0x19, 0x51,
-	0x35, 0xc3, 0xdd, 0xe6, 0xfe, 0x10, 0x21, 0xc8, 0x9b, 0x98, 0x62, 0x6e, 0xad, 0x55, 0x8d, 0xb7,
-	0x19, 0xcd, 0xc5, 0xb4, 0x2f, 0x6d, 0xc0, 0xdb, 0xe8, 0x1a, 0x14, 0xfa, 0xc4, 0xea, 0xf5, 0x29,
-	0x5f, 0x76, 0x4e, 0x93, 0x3d, 0xb6, 0x31, 0xae, 0xe7, 0x9c, 0x13, 0x1e, 0x52, 0x4a, 0x9a, 0xe8,
-	0xa8, 0x8f, 0xb3, 0xb0, 0x7e, 0xc9, 0x67, 0x32, 0xbd, 0x7d, 0xec, 0xf7, 0x83, 0xb1, 0x58, 0x1b,
-	0xbd, 0xc3, 0xf4, 0x62, 0x93, 0x78, 0x32, 0x14, 0x36, 0xe2, 0x16, 0x10, 0x8b, 0xef, 0xf0, 0xef,
-	0x72, 0xcd, 0x92, 0x1b, 0x9d, 0x40, 0x7d, 0x80, 0x7d, 0xaa, 0x0b, 0x5f, 0xa3, 0xf3, 0xa8, 0x96,
-	0x9b, 0xeb, 0x79, 0x1f, 0xe0, 0xc0, 0x47, 0xb1, 0x73, 0x2d, 0xd5, 0xd5, 0x06, 0x09, 0x2a, 0xfa,
-	0x18, 0xae, 0x76, 0xc7, 0xbf, 0xc4, 0x36, 0xb5, 0x6c, 0xa2, 0x5f, 0xda, 0x9e, 0xcd, 0x19, 0xaa,
-	0xf7, 0xce, 0x2d, 0x93, 0xd8, 0x46, 0xb0, 0x2f, 0x57, 0x42, 0x15, 0xe1, 0xbe, 0xf9, 0xea, 0xc7,
-	0x50, 0x4b, 0xfa, 0x7e, 0x54, 0x83, 0x2c, 0xbd, 0x90, 0xc6, 0xc8, 0xd2, 0x0b, 0xf4, 0x0e, 0xe4,
-	0x99, 0x3a, 0x6e, 0x88, 0xda, 0xcc, 0xe0, 0x2c, 0xa5, 0x8f, 0xc7, 0x2e, 0xd1, 0x38, 0xbf, 0xaa,
-	0x86, 0x97, 0x20, 0x8c, 0x07, 0x93, 0xba, 0xd5, 0x57, 0x61, 0x6d, 0xc2, 0xd5, 0xc7, 0x76, 0x54,
-	0x89, 0xef, 0xa8, 0xba, 0x06, 0xd5, 0x84, 0x47, 0x57, 0xaf, 0xc1, 0xd5, 0x69, 0xae, 0x59, 0xb5,
-	0x43, 0x7a, 0xc2, 0xb9, 0xa2, 0x3b, 0x50, 0x0a, 0x7d, 0xb3, 0xb8, 0x84, 0xb3, 0xec, 0x16, 0x88,
-	0x68, 0xa1, 0x00, 0xbb, 0x83, 0xec, 0x1c, 0xf3, 0x73, 0x92, 0xe5, 0xd3, 0x2f, 0x62, 0xd7, 0xed,
-	0x60, 0xbf, 0xaf, 0xfe, 0x02, 0x1a, 0xb3, 0x3c, 0xee, 0xc4, 0x62, 0xf2, 0xe1, 0xf1, 0xbc, 0x06,
-	0x85, 0x53, 0xc7, 0x1b, 0x62, 0xca, 0x95, 0x55, 0x35, 0xd9, 0x63, 0xc7, 0x56, 0x78, 0xdf, 0x1c,
-	0x27, 0x8b, 0x8e, 0xaa, 0xc3, 0x0b, 0x33, 0xfd, 0x2d, 0x13, 0xb1, 0x6c, 0x93, 0x08, 0xab, 0x56,
-	0x35, 0xd1, 0x89, 0x14, 0x89, 0xc9, 0x8a, 0x0e, 0x1b, 0xd6, 0xe7, 0x2b, 0xe6, 0xfa, 0xcb, 0x9a,
-	0xec, 0xa9, 0x7f, 0x29, 0x43, 0x49, 0x23, 0xbe, 0xcb, 0x5c, 0x01, 0xea, 0x40, 0x99, 0x5c, 0x18,
-	0x44, 0x20, 0x2a, 0x65, 0x01, 0xfe, 0x10, 0x32, 0x7b, 0x01, 0x3f, 0x0b, 0xf8, 0xa1, 0x30, 0x7a,
-	0x2f, 0x81, 0x26, 0x6f, 0x2c, 0x52, 0x12, 0x87, 0x93, 0xef, 0x27, 0xe1, 0xe4, 0xcb, 0x0b, 0x64,
-	0x27, 0xf0, 0xe4, 0x7b, 0x09, 0x3c, 0xb9, 0x68, 0xe0, 0x04, 0xa0, 0xdc, 0x9f, 0x02, 0x28, 0x17,
-	0x2d, 0x7f, 0x06, 0xa2, 0xdc, 0x9f, 0x82, 0x28, 0x6f, 0x2f, 0x9c, 0xcb, 0x54, 0x48, 0xf9, 0x7e,
-	0x12, 0x52, 0x2e, 0x32, 0xc7, 0x04, 0xa6, 0x7c, 0x30, 0x0d, 0x53, 0xbe, 0xba, 0x40, 0xc7, 0x4c,
-	0x50, 0xb9, 0x7b, 0x09, 0x54, 0xde, 0x5a, 0xa0, 0x6a, 0x0a, 0xaa, 0xdc, 0x4f, 0xa0, 0x4a, 0x48,
-	0x65, 0x9b, 0x19, 0xb0, 0xf2, 0xde, 0x65, 0x58, 0xf9, 0xca, 0xa2, 0xa3, 0x36, 0x0d, 0x57, 0x7e,
-	0x30, 0x81, 0x2b, 0x6f, 0x2e, 0x5a, 0xd5, 0x24, 0xb0, 0x3c, 0x99, 0x01, 0x2c, 0xdf, 0x58, 0xa0,
-	0x68, 0x01, 0xb2, 0x3c, 0x99, 0x81, 0x2c, 0x17, 0xa9, 0x5d, 0x00, 0x2d, 0xbb, 0xf3, 0xa0, 0xe5,
-	0x9b, 0x8b, 0xa6, 0x9c, 0x0e, 0x5b, 0x92, 0xb9, 0xd8, 0xf2, 0xad, 0x05, 0x83, 0x2c, 0x0f, 0x2e,
-	0x5f, 0x65, 0xe1, 0x7d, 0xc2, 0x25, 0x31, 0x57, 0x48, 0x3c, 0xcf, 0xf1, 0x24, 0x6e, 0x13, 0x1d,
-	0xf5, 0x36, 0x03, 0x1c, 0x91, 0xe3, 0x99, 0x03, 0x44, 0x79, 0xe0, 0x89, 0xb9, 0x19, 0xf5, 0xcf,
+	0xd7, 0x3d, 0x0b, 0x57, 0x5c, 0xcf, 0xa1, 0xce, 0x26, 0xee, 0x18, 0xd6, 0x26, 0x1d, 0xb9, 0xc4,
+	0x6f, 0x72, 0x02, 0x7a, 0x89, 0x12, 0xdb, 0x24, 0xde, 0xc0, 0xb2, 0x69, 0x93, 0x7d, 0x6c, 0xf2,
+	0x8f, 0x8d, 0x0d, 0xc1, 0x6e, 0x78, 0x23, 0x97, 0x3a, 0x9b, 0x03, 0xe2, 0x9d, 0xf6, 0x49, 0x5c,
+	0xae, 0xf1, 0xb2, 0x60, 0xe0, 0xa4, 0xc4, 0x87, 0xd7, 0x12, 0x92, 0xa7, 0x64, 0x94, 0xfc, 0x5c,
+	0x8f, 0xcb, 0xb9, 0xd8, 0xc3, 0x83, 0xe0, 0xcb, 0x46, 0xd7, 0x71, 0xba, 0x7d, 0xb2, 0xc9, 0x7b,
+	0x9d, 0xe1, 0xc9, 0x26, 0xb5, 0x06, 0xc4, 0xa7, 0x78, 0xe0, 0x4a, 0x86, 0x1b, 0xb4, 0x67, 0x79,
+	0xa6, 0xee, 0x62, 0x8f, 0x8e, 0x04, 0xd7, 0x66, 0xd7, 0xe9, 0x3a, 0x51, 0x4b, 0xf0, 0xa9, 0xff,
+	0x2e, 0x41, 0x51, 0x23, 0x5f, 0x0c, 0x89, 0x4f, 0xd1, 0x87, 0x90, 0x27, 0x46, 0xcf, 0xa9, 0x67,
+	0xaf, 0x2a, 0x37, 0x97, 0xb7, 0xd4, 0xe6, 0xc4, 0xd5, 0x36, 0x25, 0xf7, 0xae, 0xd1, 0x73, 0xda,
+	0x19, 0x8d, 0x4b, 0xa0, 0x5b, 0xb0, 0x74, 0xd2, 0x1f, 0xfa, 0xbd, 0x7a, 0x8e, 0x8b, 0x5e, 0x9b,
+	0x2d, 0x7a, 0x97, 0xb1, 0xb6, 0x33, 0x9a, 0x90, 0x61, 0xc3, 0x5a, 0xf6, 0x89, 0x53, 0xcf, 0xa7,
+	0x19, 0x76, 0xcf, 0x3e, 0xe1, 0xc3, 0x32, 0x09, 0xd4, 0x06, 0xf0, 0x09, 0xd5, 0x1d, 0x97, 0x5a,
+	0x8e, 0x5d, 0x5f, 0xe2, 0xf2, 0x6f, 0xcc, 0x96, 0x3f, 0x24, 0x74, 0x9f, 0xb3, 0xb7, 0x33, 0x5a,
+	0xd9, 0x0f, 0x3a, 0x4c, 0x93, 0x65, 0x5b, 0x54, 0x37, 0x7a, 0xd8, 0xb2, 0xeb, 0x85, 0x34, 0x9a,
+	0xf6, 0x6c, 0x8b, 0xee, 0x30, 0x76, 0xa6, 0xc9, 0x0a, 0x3a, 0xcc, 0x14, 0x5f, 0x0c, 0x89, 0x37,
+	0xaa, 0x17, 0xd3, 0x98, 0xe2, 0x21, 0x63, 0x65, 0xa6, 0xe0, 0x32, 0xe8, 0x1e, 0x2c, 0x77, 0x48,
+	0xd7, 0xb2, 0xf5, 0x4e, 0xdf, 0x31, 0x4e, 0xeb, 0x25, 0xae, 0xe2, 0xe6, 0x6c, 0x15, 0x2d, 0x26,
+	0xd0, 0x62, 0xfc, 0xed, 0x8c, 0x06, 0x9d, 0xb0, 0x87, 0x5a, 0x50, 0x32, 0x7a, 0xc4, 0x38, 0xd5,
+	0xe9, 0x79, 0xbd, 0xcc, 0x35, 0x5d, 0x9f, 0xad, 0x69, 0x87, 0x71, 0x1f, 0x9d, 0xb7, 0x33, 0x5a,
+	0xd1, 0x10, 0x4d, 0x66, 0x17, 0x93, 0xf4, 0xad, 0x33, 0xe2, 0x31, 0x2d, 0x97, 0xd2, 0xd8, 0xe5,
+	0x8e, 0xe0, 0xe7, 0x7a, 0xca, 0x66, 0xd0, 0x41, 0xbb, 0x50, 0x26, 0xb6, 0x29, 0x17, 0xb6, 0xcc,
+	0x15, 0xdd, 0x98, 0x73, 0xc2, 0x6c, 0x33, 0x58, 0x56, 0x89, 0xc8, 0x36, 0xfa, 0x21, 0x14, 0x0c,
+	0x67, 0x30, 0xb0, 0x68, 0x7d, 0x85, 0xeb, 0x78, 0x7d, 0xce, 0x92, 0x38, 0x6f, 0x3b, 0xa3, 0x49,
+	0x29, 0x74, 0x04, 0xd5, 0xbe, 0xe5, 0x53, 0xdd, 0xb7, 0xb1, 0xeb, 0xf7, 0x1c, 0xea, 0xd7, 0x2b,
+	0x5c, 0xcf, 0xdb, 0xb3, 0xf5, 0xdc, 0xb7, 0x7c, 0x7a, 0x18, 0x88, 0xb4, 0x33, 0x5a, 0xa5, 0x1f,
+	0x27, 0x30, 0xad, 0xce, 0xc9, 0x09, 0xf1, 0x42, 0xb5, 0xf5, 0x6a, 0x1a, 0xad, 0xfb, 0x4c, 0x26,
+	0xd0, 0xc2, 0xb4, 0x3a, 0x71, 0x02, 0xc2, 0x70, 0xa9, 0xef, 0x60, 0x33, 0x54, 0xaa, 0x1b, 0xbd,
+	0xa1, 0x7d, 0x5a, 0x5f, 0xe5, 0xaa, 0x37, 0xe7, 0x4c, 0xd8, 0xc1, 0x66, 0xa0, 0x68, 0x87, 0x89,
+	0xb5, 0x33, 0xda, 0x5a, 0x7f, 0x9c, 0x88, 0x4c, 0xb8, 0x8c, 0x5d, 0xb7, 0x3f, 0x1a, 0x1f, 0xa3,
+	0xc6, 0xc7, 0x78, 0x77, 0xf6, 0x18, 0xdb, 0x4c, 0x72, 0x7c, 0x10, 0x84, 0x2f, 0x50, 0x5b, 0x45,
+	0x58, 0x3a, 0xc3, 0xfd, 0x21, 0x51, 0xdf, 0x80, 0xe5, 0x98, 0xfb, 0x40, 0x75, 0x28, 0x0e, 0x88,
+	0xef, 0xe3, 0x2e, 0xa9, 0x2b, 0x57, 0x95, 0x9b, 0x65, 0x2d, 0xe8, 0xaa, 0x55, 0x58, 0x89, 0x3b,
+	0x0b, 0x75, 0x10, 0x0a, 0x32, 0x07, 0xc0, 0x04, 0xcf, 0x88, 0xe7, 0xb3, 0x5b, 0x2f, 0x05, 0x65,
+	0x17, 0x5d, 0x83, 0x0a, 0x3f, 0x62, 0x7a, 0xf0, 0x9d, 0x39, 0xb3, 0xbc, 0xb6, 0xc2, 0x89, 0x8f,
+	0x24, 0xd3, 0x06, 0x2c, 0xbb, 0x5b, 0x6e, 0xc8, 0x92, 0xe3, 0x2c, 0xe0, 0x6e, 0xb9, 0x92, 0x41,
+	0xfd, 0x3e, 0xd4, 0xc6, 0xfd, 0x05, 0xaa, 0x41, 0xee, 0x94, 0x8c, 0xe4, 0x78, 0xac, 0x89, 0x2e,
+	0xcb, 0x65, 0xf1, 0x31, 0xca, 0x9a, 0x5c, 0xe3, 0x1f, 0xb3, 0xa1, 0x70, 0xe8, 0x22, 0x98, 0x8f,
+	0x63, 0x1e, 0x9a, 0x4b, 0x2f, 0x6f, 0x35, 0x9a, 0xc2, 0x7d, 0x37, 0x03, 0xf7, 0xdd, 0x3c, 0x0a,
+	0xdc, 0x77, 0xab, 0xf4, 0xd5, 0x37, 0x1b, 0x99, 0xa7, 0x7f, 0xdf, 0x50, 0x34, 0x2e, 0x81, 0x5e,
+	0x61, 0xb7, 0x18, 0x5b, 0xb6, 0x6e, 0x99, 0x72, 0x9c, 0x22, 0xef, 0xef, 0x99, 0xe8, 0x21, 0xd4,
+	0x0c, 0xc7, 0xf6, 0x89, 0xed, 0x0f, 0x7d, 0x5d, 0x84, 0x07, 0xe9, 0x80, 0xa7, 0xdd, 0xac, 0x9d,
+	0x80, 0xfd, 0x80, 0x73, 0x6b, 0xab, 0x46, 0x92, 0x80, 0xee, 0x03, 0x9c, 0xe1, 0xbe, 0x65, 0x62,
+	0xea, 0x78, 0x7e, 0x3d, 0x7f, 0x35, 0x37, 0x43, 0xd9, 0xa3, 0x80, 0xf1, 0xd8, 0x35, 0x31, 0x25,
+	0xad, 0x3c, 0x9b, 0xb9, 0x16, 0x93, 0x47, 0x37, 0x60, 0x15, 0xbb, 0xae, 0xee, 0x53, 0x4c, 0x89,
+	0xde, 0x19, 0x51, 0xe2, 0x73, 0x27, 0xbd, 0xa2, 0x55, 0xb0, 0xeb, 0x1e, 0x32, 0x6a, 0x8b, 0x11,
+	0x55, 0x33, 0xdc, 0x6d, 0xee, 0x0f, 0x11, 0x82, 0xbc, 0x89, 0x29, 0xe6, 0xd6, 0x5a, 0xd1, 0x78,
+	0x9b, 0xd1, 0x5c, 0x4c, 0x7b, 0xd2, 0x06, 0xbc, 0x8d, 0xae, 0x40, 0xa1, 0x47, 0xac, 0x6e, 0x8f,
+	0xf2, 0x65, 0xe7, 0x34, 0xd9, 0x63, 0x1b, 0xe3, 0x7a, 0xce, 0x19, 0xe1, 0x21, 0xa5, 0xa4, 0x89,
+	0x8e, 0xfa, 0x34, 0x0b, 0x6b, 0x17, 0x7c, 0x26, 0xd3, 0xdb, 0xc3, 0x7e, 0x2f, 0x18, 0x8b, 0xb5,
+	0xd1, 0x07, 0x4c, 0x2f, 0x36, 0x89, 0x27, 0x43, 0x61, 0x3d, 0x6e, 0x01, 0xb1, 0xf8, 0x36, 0xff,
+	0x2e, 0xd7, 0x2c, 0xb9, 0xd1, 0x31, 0xd4, 0xfa, 0xd8, 0xa7, 0xba, 0xf0, 0x35, 0x3a, 0x8f, 0x6a,
+	0xb9, 0x99, 0x9e, 0xf7, 0x3e, 0x0e, 0x7c, 0x14, 0x3b, 0xd7, 0x52, 0x5d, 0xb5, 0x9f, 0xa0, 0xa2,
+	0xc7, 0x70, 0xb9, 0x33, 0xfa, 0x25, 0xb6, 0xa9, 0x65, 0x13, 0xfd, 0xc2, 0xf6, 0x6c, 0x4c, 0x51,
+	0xbd, 0x7b, 0x66, 0x99, 0xc4, 0x36, 0x82, 0x7d, 0xb9, 0x14, 0xaa, 0x08, 0xf7, 0xcd, 0x57, 0x1f,
+	0x43, 0x35, 0xe9, 0xfb, 0x51, 0x15, 0xb2, 0xf4, 0x5c, 0x1a, 0x23, 0x4b, 0xcf, 0xd1, 0x07, 0x90,
+	0x67, 0xea, 0xb8, 0x21, 0xaa, 0x53, 0x83, 0xb3, 0x94, 0x3e, 0x1a, 0xb9, 0x44, 0xe3, 0xfc, 0xaa,
+	0x1a, 0x5e, 0x82, 0x30, 0x1e, 0x8c, 0xeb, 0x56, 0xdf, 0x84, 0xd5, 0x31, 0x57, 0x1f, 0xdb, 0x51,
+	0x25, 0xbe, 0xa3, 0xea, 0x2a, 0x54, 0x12, 0x1e, 0x5d, 0xbd, 0x02, 0x97, 0x27, 0xb9, 0x66, 0xd5,
+	0x0e, 0xe9, 0x09, 0xe7, 0x8a, 0x6e, 0x41, 0x29, 0xf4, 0xcd, 0xe2, 0x12, 0x4e, 0xb3, 0x5b, 0x20,
+	0xa2, 0x85, 0x02, 0xec, 0x0e, 0xb2, 0x73, 0xcc, 0xcf, 0x49, 0x96, 0x4f, 0xbf, 0x88, 0x5d, 0xb7,
+	0x8d, 0xfd, 0x9e, 0xfa, 0x0b, 0xa8, 0x4f, 0xf3, 0xb8, 0x63, 0x8b, 0xc9, 0x87, 0xc7, 0xf3, 0x0a,
+	0x14, 0x4e, 0x1c, 0x6f, 0x80, 0x29, 0x57, 0x56, 0xd1, 0x64, 0x8f, 0x1d, 0x5b, 0xe1, 0x7d, 0x73,
+	0x9c, 0x2c, 0x3a, 0xaa, 0x0e, 0xaf, 0x4c, 0xf5, 0xb7, 0x4c, 0xc4, 0xb2, 0x4d, 0x22, 0xac, 0x5a,
+	0xd1, 0x44, 0x27, 0x52, 0x24, 0x26, 0x2b, 0x3a, 0x6c, 0x58, 0x9f, 0xaf, 0x98, 0xeb, 0x2f, 0x6b,
+	0xb2, 0xa7, 0xfe, 0xa5, 0x0c, 0x25, 0x8d, 0xf8, 0x2e, 0x73, 0x05, 0xa8, 0x0d, 0x65, 0x72, 0x6e,
+	0x10, 0x81, 0xa8, 0x94, 0x39, 0xf8, 0x43, 0xc8, 0xec, 0x06, 0xfc, 0x2c, 0xe0, 0x87, 0xc2, 0xe8,
+	0xa3, 0x04, 0x9a, 0xbc, 0x36, 0x4f, 0x49, 0x1c, 0x4e, 0xde, 0x4e, 0xc2, 0xc9, 0xd7, 0xe7, 0xc8,
+	0x8e, 0xe1, 0xc9, 0x8f, 0x12, 0x78, 0x72, 0xde, 0xc0, 0x09, 0x40, 0xb9, 0x37, 0x01, 0x50, 0xce,
+	0x5b, 0xfe, 0x14, 0x44, 0xb9, 0x37, 0x01, 0x51, 0xde, 0x9c, 0x3b, 0x97, 0x89, 0x90, 0xf2, 0x76,
+	0x12, 0x52, 0xce, 0x33, 0xc7, 0x18, 0xa6, 0xbc, 0x3f, 0x09, 0x53, 0xbe, 0x39, 0x47, 0xc7, 0x54,
+	0x50, 0xb9, 0x73, 0x01, 0x54, 0xde, 0x98, 0xa3, 0x6a, 0x02, 0xaa, 0xdc, 0x4b, 0xa0, 0x4a, 0x48,
+	0x65, 0x9b, 0x29, 0xb0, 0xf2, 0xee, 0x45, 0x58, 0xf9, 0xc6, 0xbc, 0xa3, 0x36, 0x09, 0x57, 0x7e,
+	0x3c, 0x86, 0x2b, 0xaf, 0xcf, 0x5b, 0xd5, 0x38, 0xb0, 0x3c, 0x9e, 0x02, 0x2c, 0xdf, 0x99, 0xa3,
+	0x68, 0x0e, 0xb2, 0x3c, 0x9e, 0x82, 0x2c, 0xe7, 0xa9, 0x9d, 0x03, 0x2d, 0x3b, 0xb3, 0xa0, 0xe5,
+	0xbb, 0xf3, 0xa6, 0x9c, 0x0e, 0x5b, 0x92, 0x99, 0xd8, 0xf2, 0xbd, 0x39, 0x83, 0x2c, 0x0e, 0x2e,
+	0xdf, 0x64, 0xe1, 0x7d, 0xcc, 0x25, 0x31, 0x57, 0x48, 0x3c, 0xcf, 0xf1, 0x24, 0x6e, 0x13, 0x1d,
+	0xf5, 0x26, 0x03, 0x1c, 0x91, 0xe3, 0x99, 0x01, 0x44, 0x79, 0xe0, 0x89, 0xb9, 0x19, 0xf5, 0xcf,
 	0x4a, 0x24, 0xcb, 0xa3, 0x73, 0x1c, 0xac, 0x94, 0x25, 0x58, 0x89, 0xe1, 0xd3, 0x6c, 0x12, 0x9f,
-	0x6e, 0x42, 0x85, 0x85, 0x92, 0x09, 0xe8, 0x89, 0xdd, 0x00, 0x7a, 0xa2, 0xd7, 0x60, 0x9d, 0x63,
-	0x08, 0x81, 0x62, 0x65, 0xfc, 0xc8, 0xf3, 0x60, 0xb8, 0xc6, 0x3e, 0x88, 0xa3, 0x2b, 0x02, 0xc9,
-	0xf7, 0xe0, 0x4a, 0x8c, 0x37, 0x0c, 0x51, 0x02, 0x63, 0xd5, 0x43, 0xee, 0x1d, 0x19, 0xab, 0x3e,
-	0x8c, 0x0c, 0x14, 0xc1, 0x5a, 0x04, 0x79, 0xc3, 0x31, 0x89, 0x0c, 0x20, 0xbc, 0xcd, 0xa0, 0xee,
-	0xc0, 0xe9, 0xc9, 0x30, 0xc1, 0x9a, 0x8c, 0x2b, 0xf4, 0xa9, 0x65, 0xe1, 0x2c, 0xd5, 0x3f, 0x29,
-	0x91, 0xbe, 0x08, 0xe9, 0x4e, 0x03, 0xa5, 0xca, 0xb3, 0x04, 0xa5, 0xd9, 0xff, 0x0d, 0x94, 0xaa,
-	0xff, 0x51, 0xa2, 0x2d, 0x0d, 0xe1, 0xe6, 0xb7, 0x33, 0x41, 0x14, 0x7e, 0x57, 0xf8, 0x06, 0xc9,
-	0xf0, 0x2b, 0x33, 0x85, 0x02, 0xdf, 0x86, 0x64, 0xa6, 0x50, 0x14, 0x01, 0x99, 0x77, 0xd0, 0x07,
-	0x50, 0x76, 0x3d, 0xc7, 0x39, 0xd5, 0x1d, 0xd7, 0x97, 0x7e, 0x39, 0x01, 0xb0, 0x44, 0x59, 0xa8,
-	0x25, 0x0a, 0x4a, 0xad, 0x43, 0xc6, 0x7a, 0xe0, 0xfa, 0x5a, 0xc9, 0x95, 0xad, 0x18, 0xc0, 0x28,
-	0x27, 0xf0, 0xef, 0x8b, 0x50, 0x66, 0x8b, 0xf0, 0x5d, 0x6c, 0x10, 0xee, 0x5e, 0xcb, 0x5a, 0x44,
-	0x50, 0x4d, 0x40, 0x97, 0xdd, 0x3c, 0x7a, 0x08, 0x05, 0x72, 0x4e, 0x6c, 0xca, 0x76, 0x8b, 0x19,
-	0xf8, 0xc5, 0x99, 0xb0, 0x92, 0xd8, 0xb4, 0xdd, 0x60, 0x66, 0xfd, 0xd7, 0x37, 0x9b, 0x75, 0x21,
-	0xf3, 0x86, 0x33, 0xb4, 0x28, 0x19, 0xba, 0x74, 0xac, 0x49, 0x2d, 0xea, 0x6f, 0xb3, 0x0c, 0xdd,
-	0x25, 0x42, 0xc0, 0x54, 0x43, 0x07, 0xd7, 0x27, 0x1b, 0xc3, 0xfa, 0xe9, 0x8c, 0xff, 0x12, 0x40,
-	0x0f, 0xfb, 0xfa, 0x17, 0xd8, 0xa6, 0xc4, 0x94, 0x3b, 0x50, 0xee, 0x61, 0xff, 0xa7, 0x9c, 0xc0,
-	0x40, 0x1b, 0xfb, 0x3c, 0xf2, 0x89, 0xc9, 0xb7, 0x22, 0xa7, 0x15, 0x7b, 0xd8, 0x3f, 0xf1, 0x89,
-	0x19, 0x5b, 0x6b, 0xf1, 0x59, 0xac, 0x35, 0x69, 0xef, 0xd2, 0xa4, 0xbd, 0x7f, 0x97, 0x8d, 0xee,
-	0x49, 0x04, 0x86, 0xff, 0x3f, 0x6d, 0xf1, 0x07, 0x9e, 0x1c, 0x27, 0xe3, 0x30, 0xfa, 0x04, 0xd6,
-	0xc3, 0xfb, 0xa9, 0x8f, 0xf8, 0xbd, 0x0d, 0x4e, 0xe1, 0x72, 0xd7, 0xbc, 0x7e, 0x9e, 0x24, 0xfb,
-	0xe8, 0x53, 0x78, 0x7e, 0xc2, 0x1b, 0x85, 0x03, 0x64, 0x97, 0x72, 0x4a, 0xcf, 0x25, 0x9d, 0x52,
-	0xa0, 0x3f, 0xb2, 0x5e, 0xee, 0x99, 0xdc, 0x9a, 0x7d, 0x96, 0x90, 0xc5, 0x11, 0xc6, 0xd4, 0x33,
-	0x71, 0x03, 0xaa, 0x1e, 0xa1, 0xd8, 0xb2, 0xf5, 0x44, 0xfa, 0xbb, 0x2a, 0x88, 0x22, 0x38, 0xa8,
-	0x8f, 0xe0, 0xb9, 0xa9, 0x18, 0x03, 0xfd, 0x00, 0xca, 0x11, 0x48, 0x51, 0xe6, 0xe6, 0x90, 0x61,
-	0x2e, 0x14, 0x49, 0xa8, 0x5f, 0x2a, 0x91, 0xe2, 0x64, 0x8e, 0x75, 0x1f, 0x0a, 0x1e, 0xf1, 0x47,
-	0x03, 0x91, 0xef, 0xd4, 0xb6, 0xdf, 0x5e, 0x06, 0xa3, 0x30, 0xea, 0x68, 0x40, 0x35, 0xa9, 0x42,
-	0xfd, 0x08, 0x0a, 0x82, 0x82, 0x00, 0x0a, 0x3b, 0xbb, 0xbb, 0x7b, 0x87, 0xc7, 0xf5, 0x0c, 0x2a,
-	0xc3, 0xca, 0x4e, 0xfb, 0x40, 0x3b, 0xae, 0x2b, 0x8c, 0xac, 0xed, 0xfd, 0x64, 0x6f, 0xf7, 0xb8,
-	0x9e, 0x45, 0xeb, 0x50, 0x15, 0x6d, 0xfd, 0xde, 0x81, 0xf6, 0xe1, 0xce, 0x71, 0x3d, 0x17, 0x23,
-	0x1d, 0xed, 0x3d, 0xbc, 0xbb, 0xa7, 0xd5, 0xf3, 0xea, 0x5b, 0x2c, 0x93, 0x9a, 0x01, 0x61, 0xa2,
-	0x9c, 0x49, 0x89, 0xe5, 0x4c, 0xea, 0xef, 0xb3, 0xd0, 0x9c, 0x8d, 0x48, 0xd0, 0xe1, 0xc4, 0x8a,
-	0xdf, 0x5d, 0x1a, 0xd4, 0x4c, 0x2c, 0x1b, 0xdd, 0x84, 0x9a, 0x47, 0x4e, 0x09, 0x35, 0xfa, 0x02,
-	0x2d, 0x89, 0x78, 0x57, 0xd5, 0xaa, 0x92, 0xca, 0x85, 0x7c, 0xc1, 0xf6, 0x19, 0x31, 0xa8, 0x2e,
-	0x92, 0x38, 0x71, 0xfe, 0xca, 0x8c, 0x8d, 0x51, 0x8f, 0x04, 0x51, 0x3d, 0x5a, 0x64, 0xc4, 0x32,
-	0xac, 0x68, 0x7b, 0xc7, 0xda, 0x27, 0xf5, 0x2c, 0x42, 0x50, 0xe3, 0x4d, 0xfd, 0xe8, 0xe1, 0xce,
-	0xe1, 0x51, 0xe7, 0x80, 0x19, 0xf1, 0x0a, 0xac, 0x05, 0x46, 0x0c, 0x88, 0x79, 0xf5, 0xaf, 0x0a,
-	0xac, 0x4d, 0x5c, 0x0f, 0xf4, 0x2e, 0xac, 0x08, 0x08, 0xae, 0xcc, 0x2d, 0xe2, 0xf3, 0xfb, 0x2e,
-	0x6f, 0x94, 0x10, 0x40, 0xef, 0x43, 0x89, 0xc8, 0x4a, 0x85, 0xbc, 0x92, 0xd7, 0x2f, 0x57, 0x5b,
-	0x82, 0x5a, 0x86, 0x14, 0x0d, 0x25, 0x58, 0x08, 0x0d, 0xef, 0xbc, 0xcc, 0x16, 0xbf, 0x7b, 0x59,
-	0x3c, 0xf4, 0x16, 0x52, 0x3e, 0x92, 0x51, 0x77, 0xa1, 0x12, 0x9b, 0x14, 0xfa, 0x0e, 0x94, 0x87,
-	0xf8, 0x42, 0xd6, 0xaa, 0x44, 0x09, 0xa2, 0x34, 0xc4, 0x17, 0xbc, 0x4c, 0x85, 0x9e, 0x87, 0x22,
-	0xfb, 0xd8, 0xc3, 0xc2, 0x79, 0xe4, 0xb4, 0xc2, 0x10, 0x5f, 0xfc, 0x18, 0xfb, 0xaa, 0x01, 0xb5,
-	0x64, 0x21, 0x87, 0x9d, 0x26, 0xcf, 0x19, 0xd9, 0x26, 0xd7, 0xb1, 0xa2, 0x89, 0x0e, 0xba, 0x03,
-	0x2b, 0xe7, 0x8e, 0xf0, 0x3d, 0xf3, 0x6e, 0xdd, 0x23, 0x87, 0x92, 0x58, 0x39, 0x48, 0xc8, 0xa8,
-	0x0f, 0xa1, 0xc6, 0xbd, 0xc8, 0x0e, 0xa5, 0x9e, 0xd5, 0x1d, 0x51, 0x12, 0xaf, 0x48, 0xae, 0x4e,
-	0xa9, 0x48, 0x86, 0x38, 0x23, 0x44, 0x29, 0x39, 0x51, 0x0e, 0xe3, 0x1d, 0xf5, 0xd7, 0x0a, 0xac,
-	0x70, 0x85, 0xcc, 0xc5, 0xf0, 0x1a, 0x8f, 0x44, 0xb0, 0xac, 0x8d, 0x0c, 0x00, 0x1c, 0x0c, 0x14,
-	0xcc, 0xf7, 0xe6, 0x3c, 0xe7, 0x16, 0x4e, 0xab, 0xfd, 0xa2, 0xf4, 0x72, 0x57, 0x23, 0x05, 0x31,
-	0x4f, 0x17, 0x53, 0xab, 0x3e, 0x56, 0xa0, 0x74, 0x7c, 0x21, 0x4f, 0xe8, 0x8c, 0xd2, 0x0f, 0x9b,
-	0xfd, 0x3e, 0x9f, 0xbd, 0x28, 0x96, 0x88, 0x8e, 0xac, 0x25, 0xe5, 0xc2, 0x3a, 0xd5, 0xbd, 0xf0,
-	0x26, 0xe6, 0x97, 0x4b, 0x27, 0x83, 0x12, 0x9e, 0x74, 0x3b, 0x03, 0x28, 0xf2, 0xf3, 0xb0, 0x7f,
-	0x77, 0x6a, 0x65, 0xf0, 0x43, 0x58, 0x75, 0xb1, 0x47, 0x7d, 0x3d, 0x51, 0x1f, 0x9c, 0x95, 0x91,
-	0x1f, 0x62, 0x8f, 0x1e, 0x11, 0x9a, 0xa8, 0x15, 0x56, 0xb8, 0xbc, 0x20, 0xa9, 0xef, 0x41, 0x35,
-	0xc1, 0xc3, 0x16, 0x4b, 0x1d, 0x8a, 0x07, 0xc1, 0xb9, 0xe1, 0x9d, 0x70, 0x26, 0xd9, 0x68, 0x26,
-	0xea, 0x1d, 0x28, 0x87, 0xc7, 0x9a, 0xe5, 0x1b, 0xd8, 0x34, 0x3d, 0xe2, 0xfb, 0x72, 0xb6, 0x41,
-	0x97, 0x97, 0x42, 0x9d, 0x2f, 0x64, 0xcd, 0x27, 0xa7, 0x89, 0x8e, 0x6a, 0xc1, 0xda, 0x44, 0x04,
-	0x45, 0x3f, 0x82, 0xa2, 0x3b, 0xea, 0xea, 0xc1, 0x81, 0x9a, 0xb8, 0x47, 0x12, 0x8a, 0x9e, 0x91,
-	0xb1, 0xdf, 0x3a, 0x1c, 0x75, 0x07, 0x96, 0x71, 0x9f, 0x8c, 0x03, 0xd3, 0xb9, 0xa3, 0xee, 0x7d,
-	0x71, 0xf8, 0xc4, 0x50, 0xd9, 0xf8, 0x50, 0xbf, 0x82, 0x52, 0x70, 0x9e, 0xd1, 0xdd, 0xf8, 0x6d,
-	0x55, 0x2e, 0x5f, 0xf6, 0x69, 0x01, 0x5e, 0x0e, 0x12, 0x09, 0xb2, 0x0c, 0xc9, 0xb7, 0x7a, 0x36,
-	0x31, 0xf5, 0x28, 0xf9, 0xe1, 0x63, 0x96, 0xb4, 0x35, 0xf1, 0xe1, 0x41, 0x90, 0xf9, 0xa8, 0xff,
-	0x54, 0xa0, 0x14, 0x38, 0x8f, 0xa9, 0xe7, 0x3c, 0x31, 0xa5, 0xec, 0xb7, 0x9d, 0xd2, 0xac, 0x42,
-	0x74, 0x50, 0xf6, 0xcf, 0x2f, 0x5d, 0xf6, 0x7f, 0x03, 0x10, 0xdf, 0x7b, 0xfd, 0xdc, 0xa1, 0x96,
-	0xdd, 0xd3, 0x85, 0x65, 0x05, 0xb0, 0xab, 0xf3, 0x2f, 0x8f, 0xf8, 0x87, 0x43, 0x6e, 0xe4, 0xdf,
-	0x28, 0x50, 0x0a, 0xc3, 0xf0, 0xb2, 0x65, 0xc7, 0x6b, 0x50, 0x90, 0xa1, 0x46, 0xd4, 0x1d, 0x65,
-	0x2f, 0x3c, 0x75, 0xf9, 0xd8, 0xf9, 0x6f, 0x42, 0x69, 0x48, 0x28, 0xe6, 0x88, 0x44, 0xa4, 0x99,
-	0x61, 0xff, 0xb5, 0x1b, 0x50, 0x89, 0xd5, 0x81, 0x51, 0x11, 0x72, 0x0f, 0xc9, 0x17, 0xf5, 0x0c,
-	0xaa, 0x40, 0x51, 0x23, 0xbc, 0xf4, 0x53, 0x57, 0xb6, 0xbf, 0xac, 0xc0, 0xda, 0x4e, 0x7b, 0x77,
-	0x9f, 0x45, 0x42, 0xcb, 0xc0, 0x3c, 0x05, 0x3d, 0x80, 0x3c, 0xcf, 0xc2, 0x53, 0xbc, 0x38, 0x37,
-	0xd3, 0xd4, 0x11, 0x91, 0x06, 0x2b, 0x3c, 0x59, 0x47, 0x69, 0x1e, 0xa2, 0x9b, 0xa9, 0xca, 0x8b,
-	0x6c, 0x92, 0xfc, 0x0c, 0xa7, 0x78, 0x9f, 0x6e, 0xa6, 0xa9, 0x39, 0xa2, 0x4f, 0xa1, 0x1c, 0x65,
-	0xe1, 0x69, 0x5f, 0xad, 0x9b, 0xa9, 0xab, 0x91, 0x4c, 0x7f, 0x94, 0x6d, 0xa4, 0x7d, 0xb3, 0x6d,
-	0xa6, 0xf6, 0x9b, 0xe8, 0x63, 0x28, 0x06, 0x79, 0x5d, 0xba, 0x77, 0xe5, 0x66, 0xca, 0x4a, 0x21,
-	0xdb, 0x3e, 0x91, 0x98, 0xa7, 0x79, 0x3c, 0x6f, 0xa6, 0x2a, 0x87, 0xa2, 0x13, 0x28, 0x48, 0x40,
-	0x9d, 0xea, 0xc5, 0xb8, 0x99, 0xae, 0xfe, 0xc7, 0x8c, 0x1c, 0x95, 0x3e, 0xd2, 0xfe, 0x30, 0xd0,
-	0x4c, 0x5d, 0x07, 0x46, 0x18, 0x20, 0x96, 0xa3, 0xa7, 0xfe, 0x13, 0xa0, 0x99, 0xbe, 0xbe, 0x8b,
-	0x7e, 0x0e, 0xa5, 0x30, 0x13, 0x4b, 0xf9, 0x22, 0xdf, 0x4c, 0x5b, 0x62, 0x45, 0x9f, 0x41, 0x35,
-	0x99, 0x7c, 0x2c, 0xf3, 0xce, 0xde, 0x5c, 0xaa, 0x76, 0xca, 0xc6, 0x4a, 0xe6, 0x23, 0xcb, 0xbc,
-	0xbe, 0x37, 0x97, 0x2a, 0xa8, 0xa2, 0x73, 0x58, 0xbf, 0x9c, 0x42, 0x2c, 0xfb, 0x24, 0xdf, 0x5c,
-	0xba, 0xd0, 0x8a, 0xc6, 0x80, 0xa6, 0xa4, 0x21, 0x4b, 0xbf, 0xd3, 0x37, 0x97, 0xaf, 0xbe, 0xb6,
-	0xf7, 0xbe, 0x7a, 0xb2, 0xa1, 0x7c, 0xfd, 0x64, 0x43, 0xf9, 0xc7, 0x93, 0x0d, 0xe5, 0xf1, 0xd3,
-	0x8d, 0xcc, 0xd7, 0x4f, 0x37, 0x32, 0x7f, 0x7b, 0xba, 0x91, 0xf9, 0xd9, 0xeb, 0x3d, 0x8b, 0xf6,
-	0x47, 0xdd, 0x96, 0xe1, 0x0c, 0xb7, 0x22, 0xb5, 0xf1, 0x66, 0xf4, 0x27, 0x55, 0xb7, 0xc0, 0x83,
-	0xdf, 0xdb, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x52, 0xf1, 0x66, 0x15, 0x64, 0x25, 0x00, 0x00,
+	0x6e, 0xc0, 0x32, 0x0b, 0x25, 0x63, 0xd0, 0x13, 0xbb, 0x01, 0xf4, 0x44, 0x6f, 0xc1, 0x1a, 0xc7,
+	0x10, 0x02, 0xc5, 0xca, 0xf8, 0x91, 0xe7, 0xc1, 0x70, 0x95, 0x7d, 0x10, 0x47, 0x57, 0x04, 0x92,
+	0xef, 0xc1, 0xa5, 0x18, 0x6f, 0x18, 0xa2, 0x04, 0xc6, 0xaa, 0x85, 0xdc, 0xdb, 0x32, 0x56, 0x7d,
+	0x12, 0x19, 0x28, 0x82, 0xb5, 0x08, 0xf2, 0x86, 0x63, 0x12, 0x19, 0x40, 0x78, 0x9b, 0x41, 0xdd,
+	0xbe, 0xd3, 0x95, 0x61, 0x82, 0x35, 0x19, 0x57, 0xe8, 0x53, 0xcb, 0xc2, 0x59, 0xaa, 0x7f, 0x52,
+	0x22, 0x7d, 0x11, 0xd2, 0x9d, 0x04, 0x4a, 0x95, 0x17, 0x09, 0x4a, 0xb3, 0xff, 0x1b, 0x28, 0x55,
+	0xff, 0xa3, 0x44, 0x5b, 0x1a, 0xc2, 0xcd, 0x6f, 0x67, 0x82, 0x28, 0xfc, 0x2e, 0xf1, 0x0d, 0x92,
+	0xe1, 0x57, 0x66, 0x0a, 0x05, 0xbe, 0x0d, 0xc9, 0x4c, 0xa1, 0x28, 0x02, 0x32, 0xef, 0xa0, 0x8f,
+	0xa1, 0xec, 0x7a, 0x8e, 0x73, 0xa2, 0x3b, 0xae, 0x2f, 0xfd, 0x72, 0x02, 0x60, 0x89, 0xb2, 0x50,
+	0x53, 0x14, 0x94, 0x9a, 0x07, 0x8c, 0x75, 0xdf, 0xf5, 0xb5, 0x92, 0x2b, 0x5b, 0x31, 0x80, 0x51,
+	0x4e, 0xe0, 0xdf, 0x57, 0xa1, 0xcc, 0x16, 0xe1, 0xbb, 0xd8, 0x20, 0xdc, 0xbd, 0x96, 0xb5, 0x88,
+	0xa0, 0x9a, 0x80, 0x2e, 0xba, 0x79, 0xf4, 0x00, 0x0a, 0xe4, 0x8c, 0xd8, 0x94, 0xed, 0x16, 0x33,
+	0xf0, 0xab, 0x53, 0x61, 0x25, 0xb1, 0x69, 0xab, 0xce, 0xcc, 0xfa, 0xaf, 0x6f, 0x36, 0x6a, 0x42,
+	0xe6, 0x1d, 0x67, 0x60, 0x51, 0x32, 0x70, 0xe9, 0x48, 0x93, 0x5a, 0xd4, 0xdf, 0x66, 0x19, 0xba,
+	0x4b, 0x84, 0x80, 0x89, 0x86, 0x0e, 0xae, 0x4f, 0x36, 0x86, 0xf5, 0xd3, 0x19, 0xff, 0x35, 0x80,
+	0x2e, 0xf6, 0xf5, 0x27, 0xd8, 0xa6, 0xc4, 0x94, 0x3b, 0x50, 0xee, 0x62, 0xff, 0xa7, 0x9c, 0xc0,
+	0x40, 0x1b, 0xfb, 0x3c, 0xf4, 0x89, 0xc9, 0xb7, 0x22, 0xa7, 0x15, 0xbb, 0xd8, 0x3f, 0xf6, 0x89,
+	0x19, 0x5b, 0x6b, 0xf1, 0x45, 0xac, 0x35, 0x69, 0xef, 0xd2, 0xb8, 0xbd, 0x7f, 0x97, 0x8d, 0xee,
+	0x49, 0x04, 0x86, 0xff, 0x3f, 0x6d, 0xf1, 0x07, 0x9e, 0x1c, 0x27, 0xe3, 0x30, 0xfa, 0x14, 0xd6,
+	0xc2, 0xfb, 0xa9, 0x0f, 0xf9, 0xbd, 0x0d, 0x4e, 0xe1, 0x62, 0xd7, 0xbc, 0x76, 0x96, 0x24, 0xfb,
+	0xe8, 0x33, 0x78, 0x79, 0xcc, 0x1b, 0x85, 0x03, 0x64, 0x17, 0x72, 0x4a, 0x2f, 0x25, 0x9d, 0x52,
+	0xa0, 0x3f, 0xb2, 0x5e, 0xee, 0x85, 0xdc, 0x9a, 0x3d, 0x96, 0x90, 0xc5, 0x11, 0xc6, 0xc4, 0x33,
+	0x71, 0x0d, 0x2a, 0x1e, 0xa1, 0xd8, 0xb2, 0xf5, 0x44, 0xfa, 0xbb, 0x22, 0x88, 0x22, 0x38, 0xa8,
+	0x8f, 0xe0, 0xa5, 0x89, 0x18, 0x03, 0xfd, 0x00, 0xca, 0x11, 0x48, 0x51, 0x66, 0xe6, 0x90, 0x61,
+	0x2e, 0x14, 0x49, 0xa8, 0x5f, 0x2a, 0x91, 0xe2, 0x64, 0x8e, 0x75, 0x0f, 0x0a, 0x1e, 0xf1, 0x87,
+	0x7d, 0x91, 0xef, 0x54, 0xb7, 0xde, 0x5f, 0x04, 0xa3, 0x30, 0xea, 0xb0, 0x4f, 0x35, 0xa9, 0x42,
+	0x7d, 0x08, 0x05, 0x41, 0x41, 0x00, 0x85, 0xed, 0x9d, 0x9d, 0xdd, 0x83, 0xa3, 0x5a, 0x06, 0x95,
+	0x61, 0x69, 0xbb, 0xb5, 0xaf, 0x1d, 0xd5, 0x14, 0x46, 0xd6, 0x76, 0x7f, 0xb2, 0xbb, 0x73, 0x54,
+	0xcb, 0xa2, 0x35, 0xa8, 0x88, 0xb6, 0x7e, 0x77, 0x5f, 0xfb, 0x64, 0xfb, 0xa8, 0x96, 0x8b, 0x91,
+	0x0e, 0x77, 0x1f, 0xdc, 0xd9, 0xd5, 0x6a, 0x79, 0xf5, 0x3d, 0x96, 0x49, 0x4d, 0x81, 0x30, 0x51,
+	0xce, 0xa4, 0xc4, 0x72, 0x26, 0xf5, 0xf7, 0x59, 0x68, 0x4c, 0x47, 0x24, 0xe8, 0x60, 0x6c, 0xc5,
+	0x1f, 0x2e, 0x0c, 0x6a, 0xc6, 0x96, 0x8d, 0xae, 0x43, 0xd5, 0x23, 0x27, 0x84, 0x1a, 0x3d, 0x81,
+	0x96, 0x44, 0xbc, 0xab, 0x68, 0x15, 0x49, 0xe5, 0x42, 0xbe, 0x60, 0xfb, 0x9c, 0x18, 0x54, 0x17,
+	0x49, 0x9c, 0x38, 0x7f, 0x65, 0xc6, 0xc6, 0xa8, 0x87, 0x82, 0xa8, 0x1e, 0xce, 0x33, 0x62, 0x19,
+	0x96, 0xb4, 0xdd, 0x23, 0xed, 0xd3, 0x5a, 0x16, 0x21, 0xa8, 0xf2, 0xa6, 0x7e, 0xf8, 0x60, 0xfb,
+	0xe0, 0xb0, 0xbd, 0xcf, 0x8c, 0x78, 0x09, 0x56, 0x03, 0x23, 0x06, 0xc4, 0xbc, 0xfa, 0x57, 0x05,
+	0x56, 0xc7, 0xae, 0x07, 0xfa, 0x10, 0x96, 0x04, 0x04, 0x57, 0x66, 0x16, 0xf1, 0xf9, 0x7d, 0x97,
+	0x37, 0x4a, 0x08, 0xa0, 0xdb, 0x50, 0x22, 0xb2, 0x52, 0x21, 0xaf, 0xe4, 0xd5, 0x8b, 0xd5, 0x96,
+	0xa0, 0x96, 0x21, 0x45, 0x43, 0x09, 0x16, 0x42, 0xc3, 0x3b, 0x2f, 0xb3, 0xc5, 0xef, 0x5e, 0x14,
+	0x0f, 0xbd, 0x85, 0x94, 0x8f, 0x64, 0xd4, 0x1d, 0x58, 0x8e, 0x4d, 0x0a, 0x7d, 0x07, 0xca, 0x03,
+	0x7c, 0x2e, 0x6b, 0x55, 0xa2, 0x04, 0x51, 0x1a, 0xe0, 0x73, 0x5e, 0xa6, 0x42, 0x2f, 0x43, 0x91,
+	0x7d, 0xec, 0x62, 0xe1, 0x3c, 0x72, 0x5a, 0x61, 0x80, 0xcf, 0x7f, 0x8c, 0x7d, 0xd5, 0x80, 0x6a,
+	0xb2, 0x90, 0xc3, 0x4e, 0x93, 0xe7, 0x0c, 0x6d, 0x93, 0xeb, 0x58, 0xd2, 0x44, 0x07, 0xdd, 0x82,
+	0xa5, 0x33, 0x47, 0xf8, 0x9e, 0x59, 0xb7, 0xee, 0x91, 0x43, 0x49, 0xac, 0x1c, 0x24, 0x64, 0xd4,
+	0x07, 0x50, 0xe5, 0x5e, 0x64, 0x9b, 0x52, 0xcf, 0xea, 0x0c, 0x29, 0x89, 0x57, 0x24, 0x57, 0x26,
+	0x54, 0x24, 0x43, 0x9c, 0x11, 0xa2, 0x94, 0x9c, 0x28, 0x87, 0xf1, 0x8e, 0xfa, 0x6b, 0x05, 0x96,
+	0xb8, 0x42, 0xe6, 0x62, 0x78, 0x8d, 0x47, 0x22, 0x58, 0xd6, 0x46, 0x06, 0x00, 0x0e, 0x06, 0x0a,
+	0xe6, 0x7b, 0x7d, 0x96, 0x73, 0x0b, 0xa7, 0xd5, 0x7a, 0x55, 0x7a, 0xb9, 0xcb, 0x91, 0x82, 0x98,
+	0xa7, 0x8b, 0xa9, 0x55, 0x9f, 0x2a, 0x50, 0x3a, 0x3a, 0x97, 0x27, 0x74, 0x4a, 0xe9, 0x87, 0xcd,
+	0x7e, 0x8f, 0xcf, 0x5e, 0x14, 0x4b, 0x44, 0x47, 0xd6, 0x92, 0x72, 0x61, 0x9d, 0xea, 0x6e, 0x78,
+	0x13, 0xf3, 0x8b, 0xa5, 0x93, 0x41, 0x09, 0x4f, 0xba, 0x9d, 0x5b, 0x50, 0x0e, 0x4f, 0x0b, 0x83,
+	0xf1, 0xd8, 0x34, 0x3d, 0xe2, 0xfb, 0xd2, 0xc8, 0x41, 0x97, 0x57, 0x18, 0x9d, 0x27, 0xb2, 0x94,
+	0x92, 0xd3, 0x44, 0x47, 0xb5, 0x60, 0x75, 0x2c, 0x30, 0xa1, 0x1f, 0x41, 0xd1, 0x1d, 0x76, 0xf4,
+	0x60, 0x9f, 0xc6, 0x8e, 0xa7, 0x44, 0x78, 0xa7, 0x64, 0xe4, 0x37, 0x0f, 0x86, 0x9d, 0xbe, 0x65,
+	0xdc, 0x23, 0xa3, 0x60, 0x46, 0xee, 0xb0, 0x73, 0x4f, 0xec, 0xa9, 0x18, 0x2a, 0x1b, 0x1f, 0xea,
+	0x57, 0x50, 0x0a, 0x8e, 0x09, 0xba, 0x13, 0xbf, 0x04, 0xca, 0xc5, 0x3b, 0x34, 0x29, 0x6e, 0xca,
+	0x41, 0x22, 0x41, 0x96, 0x78, 0xf8, 0x56, 0xd7, 0x26, 0xa6, 0x1e, 0xe5, 0x14, 0x7c, 0xcc, 0x92,
+	0xb6, 0x2a, 0x3e, 0xdc, 0x0f, 0x12, 0x0a, 0xf5, 0x9f, 0x0a, 0x94, 0x82, 0x3b, 0x39, 0xf1, 0xf8,
+	0x24, 0xa6, 0x94, 0xfd, 0xb6, 0x53, 0x9a, 0x56, 0xdf, 0x0d, 0xaa, 0xe9, 0xf9, 0x85, 0xab, 0xe9,
+	0xef, 0x00, 0xa2, 0x0e, 0xc5, 0x7d, 0xfd, 0xcc, 0xa1, 0x96, 0xdd, 0xd5, 0x85, 0x65, 0x05, 0x5e,
+	0xaa, 0xf1, 0x2f, 0x8f, 0xf8, 0x87, 0x03, 0x6e, 0xe4, 0xdf, 0x28, 0x50, 0x0a, 0xa3, 0xdb, 0xa2,
+	0xd5, 0xbc, 0x2b, 0x50, 0x90, 0x1e, 0x5c, 0x94, 0xf3, 0x64, 0x2f, 0x2c, 0x38, 0xe7, 0x63, 0x05,
+	0xe7, 0x06, 0x94, 0x06, 0x84, 0x62, 0x1e, 0xe8, 0x45, 0xf6, 0x16, 0xf6, 0xdf, 0xba, 0x06, 0xcb,
+	0xb1, 0xf2, 0x2a, 0x2a, 0x42, 0xee, 0x01, 0x79, 0x52, 0xcb, 0xa0, 0x65, 0x28, 0x6a, 0x84, 0x57,
+	0x54, 0x6a, 0xca, 0xd6, 0x97, 0xcb, 0xb0, 0xba, 0xdd, 0xda, 0xd9, 0x63, 0x01, 0xc6, 0x32, 0x30,
+	0xcf, 0xec, 0xf6, 0x21, 0xcf, 0x93, 0xdb, 0x14, 0x0f, 0xb9, 0x8d, 0x34, 0xe5, 0x39, 0xa4, 0xc1,
+	0x12, 0xcf, 0x81, 0x51, 0x9a, 0xf7, 0xdd, 0x46, 0xaa, 0xaa, 0x1d, 0x9b, 0x24, 0x3f, 0xc3, 0x29,
+	0x9e, 0x7d, 0x1b, 0x69, 0x4a, 0x79, 0xe8, 0x33, 0x28, 0x47, 0xc9, 0x6d, 0xda, 0xc7, 0xe0, 0x46,
+	0xea, 0x22, 0x1f, 0xd3, 0x1f, 0x81, 0xf8, 0xb4, 0x4f, 0xa1, 0x8d, 0xd4, 0xee, 0x08, 0x3d, 0x86,
+	0x62, 0x90, 0x2e, 0xa5, 0x7b, 0xae, 0x6d, 0xa4, 0x2c, 0xc0, 0xb1, 0xed, 0x13, 0xf9, 0x6e, 0x9a,
+	0x37, 0xe9, 0x46, 0xaa, 0x2a, 0x23, 0x3a, 0x86, 0x82, 0xc4, 0xa9, 0xa9, 0x1e, 0x62, 0x1b, 0xe9,
+	0xca, 0x6a, 0xcc, 0xc8, 0x51, 0x45, 0x21, 0xed, 0x3b, 0x7c, 0x23, 0x75, 0x79, 0x15, 0x61, 0x80,
+	0x58, 0xea, 0x9b, 0xfa, 0x81, 0xbd, 0x91, 0xbe, 0x6c, 0x8a, 0x7e, 0x0e, 0xa5, 0x30, 0xc1, 0x49,
+	0xf9, 0xd0, 0xdd, 0x48, 0x5b, 0xb9, 0x44, 0x9f, 0x43, 0x25, 0x89, 0xe9, 0x17, 0x79, 0xbe, 0x6e,
+	0x2c, 0x54, 0x92, 0x64, 0x63, 0x25, 0x61, 0xfe, 0x22, 0x8f, 0xda, 0x8d, 0x85, 0xea, 0x94, 0xe8,
+	0x0c, 0xd6, 0x2e, 0x22, 0xf3, 0x45, 0x5f, 0xba, 0x1b, 0x0b, 0xd7, 0x2f, 0xd1, 0x08, 0xd0, 0x04,
+	0x74, 0xbf, 0xf0, 0xf3, 0x77, 0x63, 0xf1, 0xa2, 0x66, 0x6b, 0xf7, 0xab, 0x67, 0xeb, 0xca, 0xd7,
+	0xcf, 0xd6, 0x95, 0x7f, 0x3c, 0x5b, 0x57, 0x9e, 0x3e, 0x5f, 0xcf, 0x7c, 0xfd, 0x7c, 0x3d, 0xf3,
+	0xb7, 0xe7, 0xeb, 0x99, 0x9f, 0xbd, 0xdd, 0xb5, 0x68, 0x6f, 0xd8, 0x69, 0x1a, 0xce, 0x60, 0x33,
+	0x52, 0x1b, 0x6f, 0x46, 0x3f, 0x28, 0x75, 0x0a, 0x3c, 0xf8, 0xbd, 0xff, 0xdf, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0x41, 0x23, 0x27, 0x2d, 0xbb, 0x24, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -6326,81 +6217,6 @@ func (m *TxResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *BlockID) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *BlockID) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintTypes(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	if len(m.Hash) > 0 {
-		i -= len(m.Hash)
-		copy(dAtA[i:], m.Hash)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *PartSetHeader) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Hash) > 0 {
-		i -= len(m.Hash)
-		copy(dAtA[i:], m.Hash)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.Total != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Total))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *Validator) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -6542,12 +6358,12 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x28
 	}
-	n49, err49 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
-	if err49 != nil {
-		return 0, err49
+	n48, err48 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
+	if err48 != nil {
+		return 0, err48
 	}
-	i -= n49
-	i = encodeVarintTypes(dAtA, i, uint64(n49))
+	i -= n48
+	i = encodeVarintTypes(dAtA, i, uint64(n48))
 	i--
 	dAtA[i] = 0x22
 	if m.Height != 0 {
@@ -7739,37 +7555,6 @@ func (m *TxResult) Size() (n int) {
 	return n
 }
 
-func (m *BlockID) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Hash)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = m.PartsHeader.Size()
-	n += 1 + l + sovTypes(uint64(l))
-	return n
-}
-
-func (m *PartSetHeader) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Total != 0 {
-		n += 1 + sovTypes(uint64(m.Total))
-	}
-	l = len(m.Hash)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	return n
-}
-
 func (m *Validator) Size() (n int) {
 	if m == nil {
 		return 0
@@ -13828,232 +13613,6 @@ func (m *TxResult) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BlockID) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: BlockID: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BlockID: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
-			if m.Hash == nil {
-				m.Hash = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *PartSetHeader) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: PartSetHeader: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PartSetHeader: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		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 ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Total |= int32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
-			if m.Hash == nil {
-				m.Hash = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *Validator) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

blockchain/v0/reactor.go

@@ -350,8 +350,8 @@ FOR_LOOP:
 			}
 
 			firstParts := first.MakePartSet(types.BlockPartSizeBytes)
-			firstPartsHeader := firstParts.Header()
-			firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
+			firstPartSetHeader := firstParts.Header()
+			firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 			// Finally, verify the first block using the second's commit
 			// NOTE: we can probably make this more efficient, but note that calling
 			// first.Hash() doesn't verify the tx contents, so MakePartSet() is

blockchain/v0/reactor_test.go

@@ -110,7 +110,7 @@ func newBlockchainReactor(
 		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
 		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
+		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		if err != nil {

blockchain/v1/reactor.go

@@ -454,8 +454,8 @@ func (bcR *BlockchainReactor) processBlock() error {
 	chainID := bcR.initialState.ChainID
 
 	firstParts := first.MakePartSet(types.BlockPartSizeBytes)
-	firstPartsHeader := firstParts.Header()
-	firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
+	firstPartSetHeader := firstParts.Header()
+	firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 	// Finally, verify the first block using the second's commit
 	// NOTE: we can probably make this more efficient, but note that calling
 	// first.Hash() doesn't verify the tx contents, so MakePartSet() is

blockchain/v1/reactor_test.go

@@ -132,7 +132,7 @@ func newBlockchainReactor(
 		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
 		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
+		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		if err != nil {

blockchain/v2/processor.go

@@ -148,8 +148,8 @@ func (state *pcState) handle(event Event) (Event, error) {
 		first, second := firstItem.block, secondItem.block
 
 		firstParts := first.MakePartSet(types.BlockPartSizeBytes)
-		firstPartsHeader := firstParts.Header()
-		firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
+		firstPartSetHeader := firstParts.Header()
+		firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 
 		err = state.context.verifyCommit(tmState.ChainID, firstID, first.Height, second.LastCommit)
 		if err != nil {

blockchain/v2/reactor_test.go

@@ -530,7 +530,7 @@ func newReactorStore(
 		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
 		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
+		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		if err != nil {

consensus/byzantine_test.go

@@ -179,7 +179,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 
 	// Create a new proposal block from state/txs from the mempool.
 	block1, blockParts1 := cs.createProposalBlock()
-	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartsHeader: blockParts1.Header()}
+	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
 	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
 	p1 := proposal1.ToProto()
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p1); err != nil {
@@ -190,7 +190,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 
 	// Create a new proposal block from state/txs from the mempool.
 	block2, blockParts2 := cs.createProposalBlock()
-	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartsHeader: blockParts2.Header()}
+	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
 	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
 	p2 := proposal2.ToProto()
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p2); err != nil {

consensus/common_test.go

@@ -103,7 +103,7 @@ func (vs *validatorStub) signVote(
 		Round:            vs.Round,
 		Timestamp:        tmtime.Now(),
 		Type:             voteType,
-		BlockID:          types.BlockID{Hash: hash, PartsHeader: header},
+		BlockID:          types.BlockID{Hash: hash, PartSetHeader: header},
 	}
 	v := vote.ToProto()
 	err = vs.PrivValidator.SignVote(config.ChainID(), v)
@@ -200,7 +200,7 @@ func decideProposal(
 	}
 
 	// Make proposal
-	polRound, propBlockID := validRound, types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}
+	polRound, propBlockID := validRound, types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
 	proposal = types.NewProposal(height, round, polRound, propBlockID)
 	p := proposal.ToProto()
 	if err := vs.SignProposal(chainID, p); err != nil {

consensus/msgs.go

@@ -36,16 +36,16 @@ func MsgToProto(msg Message) (*tmcons.Message, error) {
 			},
 		}
 	case *NewValidBlockMessage:
-		pbPartsHeader := msg.BlockPartsHeader.ToProto()
+		pbPartSetHeader := msg.BlockPartSetHeader.ToProto()
 		pbBits := msg.BlockParts.ToProto()
 		pb = tmcons.Message{
 			Sum: &tmcons.Message_NewValidBlock{
 				NewValidBlock: &tmcons.NewValidBlock{
-					Height:           msg.Height,
-					Round:            msg.Round,
-					BlockPartsHeader: pbPartsHeader,
-					BlockParts:       pbBits,
-					IsCommit:         msg.IsCommit,
+					Height:             msg.Height,
+					Round:              msg.Round,
+					BlockPartSetHeader: pbPartSetHeader,
+					BlockParts:         pbBits,
+					IsCommit:           msg.IsCommit,
 				},
 			},
 		}
@@ -165,7 +165,7 @@ func MsgFromProto(msg *tmcons.Message) (Message, error) {
 			LastCommitRound:       msg.NewRoundStep.LastCommitRound,
 		}
 	case *tmcons.Message_NewValidBlock:
-		pbPartsHeader, err := types.PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartsHeader)
+		pbPartSetHeader, err := types.PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartSetHeader)
 		if err != nil {
 			return nil, fmt.Errorf("parts to proto error: %w", err)
 		}
@@ -174,11 +174,11 @@ func MsgFromProto(msg *tmcons.Message) (Message, error) {
 		pbBits.FromProto(msg.NewValidBlock.BlockParts)
 
 		pb = &NewValidBlockMessage{
-			Height:           msg.NewValidBlock.Height,
-			Round:            msg.NewValidBlock.Round,
-			BlockPartsHeader: *pbPartsHeader,
-			BlockParts:       pbBits,
-			IsCommit:         msg.NewValidBlock.IsCommit,
+			Height:             msg.NewValidBlock.Height,
+			Round:              msg.NewValidBlock.Round,
+			BlockPartSetHeader: *pbPartSetHeader,
+			BlockParts:         pbBits,
+			IsCommit:           msg.NewValidBlock.IsCommit,
 		}
 	case *tmcons.Message_Proposal:
 		pbP, err := types.ProposalFromProto(&msg.Proposal.Proposal)

consensus/msgs_test.go

@@ -23,8 +23,8 @@ func TestMsgToProto(t *testing.T) {
 	}
 	pbPsh := psh.ToProto()
 	bi := types.BlockID{
-		Hash:        tmrand.Bytes(32),
-		PartsHeader: psh,
+		Hash:          tmrand.Bytes(32),
+		PartSetHeader: psh,
 	}
 	pbBi := bi.ToProto()
 	bits := bits.NewBitArray(1)
@@ -90,19 +90,19 @@ func TestMsgToProto(t *testing.T) {
 		}, false},
 
 		{"successful NewValidBlockMessage", &NewValidBlockMessage{
-			Height:           1,
-			Round:            1,
-			BlockPartsHeader: psh,
-			BlockParts:       bits,
-			IsCommit:         false,
+			Height:             1,
+			Round:              1,
+			BlockPartSetHeader: psh,
+			BlockParts:         bits,
+			IsCommit:           false,
 		}, &tmcons.Message{
 			Sum: &tmcons.Message_NewValidBlock{
 				NewValidBlock: &tmcons.NewValidBlock{
-					Height:           1,
-					Round:            1,
-					BlockPartsHeader: pbPsh,
-					BlockParts:       pbBits,
-					IsCommit:         false,
+					Height:             1,
+					Round:              1,
+					BlockPartSetHeader: pbPsh,
+					BlockParts:         pbBits,
+					IsCommit:           false,
 				},
 			},
 		}, false},

consensus/reactor.go

@@ -415,11 +415,11 @@ func (conR *Reactor) broadcastNewRoundStepMessage(rs *cstypes.RoundState) {
 
 func (conR *Reactor) broadcastNewValidBlockMessage(rs *cstypes.RoundState) {
 	csMsg := &NewValidBlockMessage{
-		Height:           rs.Height,
-		Round:            rs.Round,
-		BlockPartsHeader: rs.ProposalBlockParts.Header(),
-		BlockParts:       rs.ProposalBlockParts.BitArray(),
-		IsCommit:         rs.Step == cstypes.RoundStepCommit,
+		Height:             rs.Height,
+		Round:              rs.Round,
+		BlockPartSetHeader: rs.ProposalBlockParts.Header(),
+		BlockParts:         rs.ProposalBlockParts.BitArray(),
+		IsCommit:           rs.Step == cstypes.RoundStepCommit,
 	}
 	conR.Switch.Broadcast(StateChannel, MustEncode(csMsg))
 }
@@ -484,7 +484,7 @@ OUTER_LOOP:
 		prs := ps.GetRoundState()
 
 		// Send proposal Block parts?
-		if rs.ProposalBlockParts.HasHeader(prs.ProposalBlockPartsHeader) {
+		if rs.ProposalBlockParts.HasHeader(prs.ProposalBlockPartSetHeader) {
 			if index, ok := rs.ProposalBlockParts.BitArray().Sub(prs.ProposalBlockParts.Copy()).PickRandom(); ok {
 				part := rs.ProposalBlockParts.GetPart(index)
 				msg := &BlockPartMessage{
@@ -512,7 +512,7 @@ OUTER_LOOP:
 						"blockstoreBase", conR.conS.blockStore.Base(), "blockstoreHeight", conR.conS.blockStore.Height())
 					time.Sleep(conR.conS.config.PeerGossipSleepDuration)
 				} else {
-					ps.InitProposalBlockParts(blockMeta.BlockID.PartsHeader)
+					ps.InitProposalBlockParts(blockMeta.BlockID.PartSetHeader)
 				}
 				// continue the loop since prs is a copy and not effected by this initialization
 				continue OUTER_LOOP
@@ -577,9 +577,9 @@ func (conR *Reactor) gossipDataForCatchup(logger log.Logger, rs *cstypes.RoundSt
 				"blockstoreBase", conR.conS.blockStore.Base(), "blockstoreHeight", conR.conS.blockStore.Height())
 			time.Sleep(conR.conS.config.PeerGossipSleepDuration)
 			return
-		} else if !blockMeta.BlockID.PartsHeader.Equals(prs.ProposalBlockPartsHeader) {
-			logger.Info("Peer ProposalBlockPartsHeader mismatch, sleeping",
-				"blockPartsHeader", blockMeta.BlockID.PartsHeader, "peerBlockPartsHeader", prs.ProposalBlockPartsHeader)
+		} else if !blockMeta.BlockID.PartSetHeader.Equals(prs.ProposalBlockPartSetHeader) {
+			logger.Info("Peer ProposalBlockPartSetHeader mismatch, sleeping",
+				"blockPartSetHeader", blockMeta.BlockID.PartSetHeader, "peerBlockPartSetHeader", prs.ProposalBlockPartSetHeader)
 			time.Sleep(conR.conS.config.PeerGossipSleepDuration)
 			return
 		}
@@ -587,7 +587,7 @@ func (conR *Reactor) gossipDataForCatchup(logger log.Logger, rs *cstypes.RoundSt
 		part := conR.conS.blockStore.LoadBlockPart(prs.Height, index)
 		if part == nil {
 			logger.Error("Could not load part", "index", index,
-				"blockPartsHeader", blockMeta.BlockID.PartsHeader, "peerBlockPartsHeader", prs.ProposalBlockPartsHeader)
+				"blockPartSetHeader", blockMeta.BlockID.PartSetHeader, "peerBlockPartSetHeader", prs.ProposalBlockPartSetHeader)
 			time.Sleep(conR.conS.config.PeerGossipSleepDuration)
 			return
 		}
@@ -996,14 +996,14 @@ func (ps *PeerState) SetHasProposal(proposal *types.Proposal) {
 		return
 	}
 
-	ps.PRS.ProposalBlockPartsHeader = proposal.BlockID.PartsHeader
-	ps.PRS.ProposalBlockParts = bits.NewBitArray(int(proposal.BlockID.PartsHeader.Total))
+	ps.PRS.ProposalBlockPartSetHeader = proposal.BlockID.PartSetHeader
+	ps.PRS.ProposalBlockParts = bits.NewBitArray(int(proposal.BlockID.PartSetHeader.Total))
 	ps.PRS.ProposalPOLRound = proposal.POLRound
 	ps.PRS.ProposalPOL = nil // Nil until ProposalPOLMessage received.
 }
 
 // InitProposalBlockParts initializes the peer's proposal block parts header and bit array.
-func (ps *PeerState) InitProposalBlockParts(partsHeader types.PartSetHeader) {
+func (ps *PeerState) InitProposalBlockParts(partSetHeader types.PartSetHeader) {
 	ps.mtx.Lock()
 	defer ps.mtx.Unlock()
 
@@ -1011,8 +1011,8 @@ func (ps *PeerState) InitProposalBlockParts(partsHeader types.PartSetHeader) {
 		return
 	}
 
-	ps.PRS.ProposalBlockPartsHeader = partsHeader
-	ps.PRS.ProposalBlockParts = bits.NewBitArray(int(partsHeader.Total))
+	ps.PRS.ProposalBlockPartSetHeader = partSetHeader
+	ps.PRS.ProposalBlockParts = bits.NewBitArray(int(partSetHeader.Total))
 }
 
 // SetHasProposalBlockPart sets the given block part index as known for the peer.
@@ -1262,7 +1262,7 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) {
 	ps.PRS.StartTime = startTime
 	if psHeight != msg.Height || psRound != msg.Round {
 		ps.PRS.Proposal = false
-		ps.PRS.ProposalBlockPartsHeader = types.PartSetHeader{}
+		ps.PRS.ProposalBlockPartSetHeader = types.PartSetHeader{}
 		ps.PRS.ProposalBlockParts = nil
 		ps.PRS.ProposalPOLRound = -1
 		ps.PRS.ProposalPOL = nil
@@ -1305,7 +1305,7 @@ func (ps *PeerState) ApplyNewValidBlockMessage(msg *NewValidBlockMessage) {
 		return
 	}
 
-	ps.PRS.ProposalBlockPartsHeader = msg.BlockPartsHeader
+	ps.PRS.ProposalBlockPartSetHeader = msg.BlockPartSetHeader
 	ps.PRS.ProposalBlockParts = msg.BlockParts
 }
 
@@ -1453,11 +1453,11 @@ func (m *NewRoundStepMessage) String() string {
 //i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
 // In case the block is also committed, then IsCommit flag is set to true.
 type NewValidBlockMessage struct {
-	Height           int64
-	Round            int32
-	BlockPartsHeader types.PartSetHeader
-	BlockParts       *bits.BitArray
-	IsCommit         bool
+	Height             int64
+	Round              int32
+	BlockPartSetHeader types.PartSetHeader
+	BlockParts         *bits.BitArray
+	IsCommit           bool
 }
 
 // ValidateBasic performs basic validation.
@@ -1468,16 +1468,16 @@ func (m *NewValidBlockMessage) ValidateBasic() error {
 	if m.Round < 0 {
 		return errors.New("negative Round")
 	}
-	if err := m.BlockPartsHeader.ValidateBasic(); err != nil {
-		return fmt.Errorf("wrong BlockPartsHeader: %v", err)
+	if err := m.BlockPartSetHeader.ValidateBasic(); err != nil {
+		return fmt.Errorf("wrong BlockPartSetHeader: %v", err)
 	}
 	if m.BlockParts.Size() == 0 {
 		return errors.New("empty blockParts")
 	}
-	if m.BlockParts.Size() != int(m.BlockPartsHeader.Total) {
-		return fmt.Errorf("blockParts bit array size %d not equal to BlockPartsHeader.Total %d",
+	if m.BlockParts.Size() != int(m.BlockPartSetHeader.Total) {
+		return fmt.Errorf("blockParts bit array size %d not equal to BlockPartSetHeader.Total %d",
 			m.BlockParts.Size(),
-			m.BlockPartsHeader.Total)
+			m.BlockPartSetHeader.Total)
 	}
 	if m.BlockParts.Size() > int(types.MaxBlockPartsCount) {
 		return fmt.Errorf("blockParts bit array is too big: %d, max: %d", m.BlockParts.Size(), types.MaxBlockPartsCount)
@@ -1488,7 +1488,7 @@ func (m *NewValidBlockMessage) ValidateBasic() error {
 // String returns a string representation.
 func (m *NewValidBlockMessage) String() string {
 	return fmt.Sprintf("[ValidBlockMessage H:%v R:%v BP:%v BA:%v IsCommit:%v]",
-		m.Height, m.Round, m.BlockPartsHeader, m.BlockParts, m.IsCommit)
+		m.Height, m.Round, m.BlockPartSetHeader, m.BlockParts, m.IsCommit)
 }
 
 //-------------------------------------

consensus/reactor_test.go

@@ -737,16 +737,19 @@ func TestNewValidBlockMessageValidateBasic(t *testing.T) {
 		{func(msg *NewValidBlockMessage) { msg.Height = -1 }, "negative Height"},
 		{func(msg *NewValidBlockMessage) { msg.Round = -1 }, "negative Round"},
 		{
-			func(msg *NewValidBlockMessage) { msg.BlockPartsHeader.Total = 2 },
-			"blockParts bit array size 1 not equal to BlockPartsHeader.Total 2",
+			func(msg *NewValidBlockMessage) { msg.BlockPartSetHeader.Total = 2 },
+			"blockParts bit array size 1 not equal to BlockPartSetHeader.Total 2",
 		},
 		{
-			func(msg *NewValidBlockMessage) { msg.BlockPartsHeader.Total = 0; msg.BlockParts = bits.NewBitArray(0) },
+			func(msg *NewValidBlockMessage) {
+				msg.BlockPartSetHeader.Total = 0
+				msg.BlockParts = bits.NewBitArray(0)
+			},
 			"empty blockParts",
 		},
 		{
 			func(msg *NewValidBlockMessage) { msg.BlockParts = bits.NewBitArray(int(types.MaxBlockPartsCount) + 1) },
-			"blockParts bit array size 1602 not equal to BlockPartsHeader.Total 1",
+			"blockParts bit array size 1602 not equal to BlockPartSetHeader.Total 1",
 		},
 	}
 
@@ -756,7 +759,7 @@ func TestNewValidBlockMessageValidateBasic(t *testing.T) {
 			msg := &NewValidBlockMessage{
 				Height: 1,
 				Round:  0,
-				BlockPartsHeader: types.PartSetHeader{
+				BlockPartSetHeader: types.PartSetHeader{
 					Total: 1,
 				},
 				BlockParts: bits.NewBitArray(1),
@@ -881,7 +884,7 @@ func TestVoteSetMaj23MessageValidateBasic(t *testing.T) {
 	validBlockID := types.BlockID{}
 	invalidBlockID := types.BlockID{
 		Hash: bytes.HexBytes{},
-		PartsHeader: types.PartSetHeader{
+		PartSetHeader: types.PartSetHeader{
 			Total: 1,
 			Hash:  []byte{0},
 		},
@@ -928,12 +931,12 @@ func TestVoteSetBitsMessageValidateBasic(t *testing.T) {
 		{func(msg *VoteSetBitsMessage) {
 			msg.BlockID = types.BlockID{
 				Hash: bytes.HexBytes{},
-				PartsHeader: types.PartSetHeader{
+				PartSetHeader: types.PartSetHeader{
 					Total: 1,
 					Hash:  []byte{0},
 				},
 			}
-		}, "wrong BlockID: wrong PartsHeader: wrong Hash:"},
+		}, "wrong BlockID: wrong PartSetHeader: wrong Hash:"},
 		{func(msg *VoteSetBitsMessage) { msg.Votes = bits.NewBitArray(types.MaxVotesCount + 1) },
 			"votes bit array is too big: 10001, max: 10000"},
 	}

consensus/replay.go

@@ -70,7 +70,7 @@ func (cs *State) readReplayMessage(msg *TimedWALMessage, newStepSub types.Subscr
 		case *ProposalMessage:
 			p := msg.Proposal
 			cs.Logger.Info("Replay: Proposal", "height", p.Height, "round", p.Round, "header",
-				p.BlockID.PartsHeader, "pol", p.POLRound, "peer", peerID)
+				p.BlockID.PartSetHeader, "pol", p.POLRound, "peer", peerID)
 		case *BlockPartMessage:
 			cs.Logger.Info("Replay: BlockPart", "height", msg.Height, "round", msg.Round, "peer", peerID)
 		case *VoteMessage:

consensus/replay_test.go

@@ -359,7 +359,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ := css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
 	propBlockParts := propBlock.MakePartSet(partSize)
-	blockID := types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
+	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 
 	proposal := types.NewProposal(vss[1].Height, round, -1, blockID)
 	p := proposal.ToProto()
@@ -391,7 +391,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
+	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 
 	proposal = types.NewProposal(vss[2].Height, round, -1, blockID)
 	p = proposal.ToProto()
@@ -430,7 +430,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
+	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss := make([]*validatorStub, nVals+1)
 	copy(newVss, vss[:nVals+1])
 	sort.Sort(ValidatorStubsByPower(newVss))
@@ -509,7 +509,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
+	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss = make([]*validatorStub, nVals+3)
 	copy(newVss, vss[:nVals+3])
 	sort.Sort(ValidatorStubsByPower(newVss))
@@ -767,7 +767,7 @@ func applyBlock(stateDB dbm.DB, st sm.State, blk *types.Block, proxyApp proxy.Ap
 	testPartSize := types.BlockPartSizeBytes
 	blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
 
-	blkID := types.BlockID{Hash: blk.Hash(), PartsHeader: blk.MakePartSet(testPartSize).Header()}
+	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()}
 	newState, _, err := blockExec.ApplyBlock(st, blkID, blk)
 	if err != nil {
 		panic(err)
@@ -1102,7 +1102,7 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {
 	case msgInfo:
 		switch msg := m.Msg.(type) {
 		case *ProposalMessage:
-			return &msg.Proposal.BlockID.PartsHeader
+			return &msg.Proposal.BlockID.PartSetHeader
 		case *BlockPartMessage:
 			return msg.Part
 		case *VoteMessage:
@@ -1154,7 +1154,7 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
 func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	block := bs.chain[height-1]
 	return &types.BlockMeta{
-		BlockID: types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
+		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
 		Header:  block.Header,
 	}
 }

consensus/state.go

@@ -1030,7 +1030,7 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 	cs.wal.FlushAndSync()
 
 	// Make proposal
-	propBlockID := types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}
+	propBlockID := types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
 	proposal := types.NewProposal(height, round, cs.ValidRound, propBlockID)
 	p := proposal.ToProto()
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p); err == nil {
@@ -1268,7 +1268,7 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 		logger.Info("enterPrecommit: +2/3 prevoted locked block. Relocking")
 		cs.LockedRound = round
 		cs.eventBus.PublishEventRelock(cs.RoundStateEvent())
-		cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartsHeader)
+		cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartSetHeader)
 		return
 	}
 
@@ -1283,7 +1283,7 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 		cs.LockedBlock = cs.ProposalBlock
 		cs.LockedBlockParts = cs.ProposalBlockParts
 		cs.eventBus.PublishEventLock(cs.RoundStateEvent())
-		cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartsHeader)
+		cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartSetHeader)
 		return
 	}
 
@@ -1294,9 +1294,9 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 	cs.LockedRound = -1
 	cs.LockedBlock = nil
 	cs.LockedBlockParts = nil
-	if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
+	if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
 		cs.ProposalBlock = nil
-		cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
+		cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
 	}
 	cs.eventBus.PublishEventUnlock(cs.RoundStateEvent())
 	cs.signAddVote(tmproto.PrecommitType, nil, types.PartSetHeader{})
@@ -1396,7 +1396,7 @@ func (cs *State) enterCommit(height int64, commitRound int32) {
 
 	// If we don't have the block being committed, set up to get it.
 	if !cs.ProposalBlock.HashesTo(blockID.Hash) {
-		if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
+		if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
 			logger.Info(
 				"Commit is for a block we don't know about. Set ProposalBlock=nil",
 				"proposal",
@@ -1406,7 +1406,7 @@ func (cs *State) enterCommit(height int64, commitRound int32) {
 			// We're getting the wrong block.
 			// Set up ProposalBlockParts and keep waiting.
 			cs.ProposalBlock = nil
-			cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
+			cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
 			cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
 			cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
 		}
@@ -1463,7 +1463,7 @@ func (cs *State) finalizeCommit(height int64) {
 	if !ok {
 		panic("Cannot finalizeCommit, commit does not have two thirds majority")
 	}
-	if !blockParts.HasHeader(blockID.PartsHeader) {
+	if !blockParts.HasHeader(blockID.PartSetHeader) {
 		panic("Expected ProposalBlockParts header to be commit header")
 	}
 	if !block.HashesTo(blockID.Hash) {
@@ -1526,7 +1526,7 @@ func (cs *State) finalizeCommit(height int64) {
 	var retainHeight int64
 	stateCopy, retainHeight, err = cs.blockExec.ApplyBlock(
 		stateCopy,
-		types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()},
+		types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()},
 		block)
 	if err != nil {
 		cs.Logger.Error("Error on ApplyBlock. Did the application crash? Please restart tendermint", "err", err)
@@ -1697,7 +1697,7 @@ func (cs *State) defaultSetProposal(proposal *types.Proposal) error {
 	// This happens if we're already in cstypes.RoundStepCommit or if there is a valid block in the current round.
 	// TODO: We can check if Proposal is for a different block as this is a sign of misbehavior!
 	if cs.ProposalBlockParts == nil {
-		cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockID.PartsHeader)
+		cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockID.PartSetHeader)
 	}
 	cs.Logger.Info("Received proposal", "proposal", proposal)
 	return nil
@@ -1930,8 +1930,8 @@ func (cs *State) addVote(
 					// We're getting the wrong block.
 					cs.ProposalBlock = nil
 				}
-				if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
-					cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
+				if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
+					cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
 				}
 				cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
 				cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
@@ -2010,7 +2010,7 @@ func (cs *State) signVote(
 		Round:            cs.Round,
 		Timestamp:        cs.voteTime(),
 		Type:             msgType,
-		BlockID:          types.BlockID{Hash: hash, PartsHeader: header},
+		BlockID:          types.BlockID{Hash: hash, PartSetHeader: header},
 	}
 	v := vote.ToProto()
 	err = cs.privValidator.SignVote(cs.state.ChainID, v)

consensus/state_test.go

@@ -204,7 +204,7 @@ func TestStateBadProposal(t *testing.T) {
 	stateHash[0] = (stateHash[0] + 1) % 255
 	propBlock.AppHash = stateHash
 	propBlockParts := propBlock.MakePartSet(partSize)
-	blockID := types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
+	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	proposal := types.NewProposal(vs2.Height, round, -1, blockID)
 	p := proposal.ToProto()
 	if err := vs2.SignProposal(config.ChainID(), p); err != nil {
@@ -311,10 +311,10 @@ func TestStateFullRound2(t *testing.T) {
 
 	// we should be stuck in limbo waiting for more prevotes
 	rs := cs1.GetRoundState()
-	propBlockHash, propPartsHeader := rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header()
+	propBlockHash, propPartSetHeader := rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header()
 
 	// prevote arrives from vs2:
-	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propPartsHeader, vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propPartSetHeader, vs2)
 	ensurePrevote(voteCh, height, round) // prevote
 
 	ensurePrecommit(voteCh, height, round) //precommit
@@ -324,7 +324,7 @@ func TestStateFullRound2(t *testing.T) {
 	// we should be stuck in limbo waiting for more precommits
 
 	// precommit arrives from vs2:
-	signAddVotes(cs1, tmproto.PrecommitType, propBlockHash, propPartsHeader, vs2)
+	signAddVotes(cs1, tmproto.PrecommitType, propBlockHash, propPartSetHeader, vs2)
 	ensurePrecommit(voteCh, height, round)
 
 	// wait to finish commit, propose in next height
@@ -994,7 +994,7 @@ func TestStateLockPOLSafety2(t *testing.T) {
 	_, propBlock0 := decideProposal(cs1, vss[0], height, round)
 	propBlockHash0 := propBlock0.Hash()
 	propBlockParts0 := propBlock0.MakePartSet(partSize)
-	propBlockID0 := types.BlockID{Hash: propBlockHash0, PartsHeader: propBlockParts0.Header()}
+	propBlockID0 := types.BlockID{Hash: propBlockHash0, PartSetHeader: propBlockParts0.Header()}
 
 	// the others sign a polka but we don't see it
 	prevotes := signVotes(tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4)

consensus/types/height_vote_set_test.go

@@ -71,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: randBytes, PartsHeader: types.PartSetHeader{}},
+		BlockID:          types.BlockID{Hash: randBytes, PartSetHeader: types.PartSetHeader{}},
 	}
 	chainID := config.ChainID()
 

consensus/types/peer_round_state.go

@@ -21,10 +21,11 @@ type PeerRoundState struct {
 	StartTime time.Time `json:"start_time"`
 
 	// True if peer has proposal for this round
-	Proposal                 bool                `json:"proposal"`
-	ProposalBlockPartsHeader types.PartSetHeader `json:"proposal_block_parts_header"` //
-	ProposalBlockParts       *bits.BitArray      `json:"proposal_block_parts"`        //
-	ProposalPOLRound         int32               `json:"proposal_pol_round"`          // Proposal's POL round. -1 if none.
+	Proposal                   bool                `json:"proposal"`
+	ProposalBlockPartSetHeader types.PartSetHeader `json:"proposal_block_part_set_header"`
+	ProposalBlockParts         *bits.BitArray      `json:"proposal_block_parts"`
+	// Proposal's POL round. -1 if none.
+	ProposalPOLRound int32 `json:"proposal_pol_round"`
 
 	// nil until ProposalPOLMessage received.
 	ProposalPOL     *bits.BitArray `json:"proposal_pol"`
@@ -57,7 +58,7 @@ func (prs PeerRoundState) StringIndented(indent string) string {
 %s  Catchup    %v (round %v)
 %s}`,
 		indent, prs.Height, prs.Round, prs.Step, prs.StartTime,
-		indent, prs.ProposalBlockPartsHeader, prs.ProposalBlockParts,
+		indent, prs.ProposalBlockPartSetHeader, prs.ProposalBlockParts,
 		indent, prs.ProposalPOL, prs.ProposalPOLRound,
 		indent, prs.Prevotes,
 		indent, prs.Precommits,

consensus/types/round_state.go

@@ -149,8 +149,8 @@ func (rs *RoundState) CompleteProposalEvent() types.EventDataCompleteProposal {
 	// We must construct BlockID from ProposalBlock and ProposalBlockParts
 	// cs.Proposal is not guaranteed to be set when this function is called
 	blockID := types.BlockID{
-		Hash:        rs.ProposalBlock.Hash(),
-		PartsHeader: rs.ProposalBlockParts.Header(),
+		Hash:          rs.ProposalBlock.Hash(),
+		PartSetHeader: rs.ProposalBlockParts.Header(),
 	}
 
 	return types.EventDataCompleteProposal{

evidence/pool_test.go

@@ -303,14 +303,14 @@ func TestPotentialAmnesiaEvidence(t *testing.T) {
 		//evidenceTime    = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
 		firstBlockID = types.BlockID{
 			Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
-			PartsHeader: types.PartSetHeader{
+			PartSetHeader: types.PartSetHeader{
 				Total: 1,
 				Hash:  []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
 			},
 		}
 		secondBlockID = types.BlockID{
 			Hash: []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
-			PartsHeader: types.PartSetHeader{
+			PartSetHeader: types.PartSetHeader{
 				Total: 1,
 				Hash:  []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
 			},

light/helpers_test.go

@@ -81,8 +81,8 @@ func (pkz privKeys) signHeader(header *types.Header, first, last int) *types.Com
 	vset := pkz.ToValidators(1, 1)
 
 	blockID := types.BlockID{
-		Hash:        header.Hash(),
-		PartsHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
+		Hash:          header.Hash(),
+		PartSetHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
 	}
 
 	// Fill in the votes we want.

privval/file_test.go

@@ -56,7 +56,7 @@ func TestResetValidator(t *testing.T) {
 	height, round := int64(10), int32(1)
 	voteType := tmproto.PrevoteType
 	randBytes := tmrand.Bytes(tmhash.Size)
-	blockID := types.BlockID{Hash: randBytes, PartsHeader: types.PartSetHeader{}}
+	blockID := types.BlockID{Hash: randBytes, PartSetHeader: 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")
@@ -170,9 +170,9 @@ func TestSignVote(t *testing.T) {
 	randbytes2 := tmrand.Bytes(tmhash.Size)
 
 	block1 := types.BlockID{Hash: randbytes,
-		PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
+		PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
 	block2 := types.BlockID{Hash: randbytes2,
-		PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
+		PartSetHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
 
 	height, round := int64(10), int32(1)
 	voteType := tmproto.PrevoteType
@@ -223,9 +223,9 @@ func TestSignProposal(t *testing.T) {
 	randbytes2 := tmrand.Bytes(tmhash.Size)
 
 	block1 := types.BlockID{Hash: randbytes,
-		PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
+		PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
 	block2 := types.BlockID{Hash: randbytes2,
-		PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
+		PartSetHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
 	height, round := int64(10), int32(1)
 
 	// sign a proposal for first time
@@ -267,7 +267,7 @@ func TestDifferByTimestamp(t *testing.T) {
 
 	privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
 	randbytes := tmrand.Bytes(tmhash.Size)
-	block1 := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
+	block1 := types.BlockID{Hash: randbytes, PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
 	height, round := int64(10), int32(1)
 	chainID := "mychainid"
 
@@ -297,7 +297,7 @@ func TestDifferByTimestamp(t *testing.T) {
 	// test vote
 	{
 		voteType := tmproto.PrevoteType
-		blockID := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{}}
+		blockID := types.BlockID{Hash: randbytes, PartSetHeader: types.PartSetHeader{}}
 		vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
 		v := vote.ToProto()
 		err := privVal.SignVote("mychainid", v)

privval/signer_client_test.go

@@ -104,7 +104,7 @@ func TestSignerProposal(t *testing.T) {
 			Height:    1,
 			Round:     2,
 			POLRound:  2,
-			BlockID:   types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp: ts,
 		}
 		want := &types.Proposal{
@@ -112,7 +112,7 @@ func TestSignerProposal(t *testing.T) {
 			Height:    1,
 			Round:     2,
 			POLRound:  2,
-			BlockID:   types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp: ts,
 		}
 
@@ -135,7 +135,7 @@ func TestSignerVote(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -145,7 +145,7 @@ func TestSignerVote(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -170,7 +170,7 @@ func TestSignerVoteResetDeadline(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -180,7 +180,7 @@ func TestSignerVoteResetDeadline(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -215,7 +215,7 @@ func TestSignerVoteKeepAlive(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -225,7 +225,7 @@ func TestSignerVoteKeepAlive(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,
@@ -266,7 +266,7 @@ func TestSignerSignProposalErrors(t *testing.T) {
 			Height:    1,
 			Round:     2,
 			POLRound:  2,
-			BlockID:   types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp: ts,
 			Signature: []byte("signature"),
 		}
@@ -291,7 +291,7 @@ func TestSignerSignVoteErrors(t *testing.T) {
 			Type:             tmproto.PrecommitType,
 			Height:           1,
 			Round:            2,
-			BlockID:          types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
+			BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
 			Timestamp:        ts,
 			ValidatorAddress: valAddr,
 			ValidatorIndex:   1,

proto/abci/types.proto

@@ -323,16 +323,6 @@ message TxResult {
 //----------------------------------------
 // Blockchain Types
 
-message BlockID {
-  bytes         hash         = 1;
-  PartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
-}
-
-message PartSetHeader {
-  int32 total = 1;
-  bytes hash  = 2;
-}
-
 // Validator
 message Validator {
   bytes address = 1;

proto/consensus/msgs.pb.go

@@ -107,11 +107,11 @@ func (m *NewRoundStep) GetLastCommitRound() int32 {
 //i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
 // In case the block is also committed, then IsCommit flag is set to true.
 type NewValidBlock struct {
-	Height           int64               `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
-	Round            int32               `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
-	BlockPartsHeader types.PartSetHeader `protobuf:"bytes,3,opt,name=block_parts_header,json=blockPartsHeader,proto3" json:"block_parts_header"`
-	BlockParts       *bits.BitArray      `protobuf:"bytes,4,opt,name=block_parts,json=blockParts,proto3" json:"block_parts,omitempty"`
-	IsCommit         bool                `protobuf:"varint,5,opt,name=is_commit,json=isCommit,proto3" json:"is_commit,omitempty"`
+	Height             int64               `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Round              int32               `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	BlockPartSetHeader types.PartSetHeader `protobuf:"bytes,3,opt,name=block_part_set_header,json=blockPartSetHeader,proto3" json:"block_part_set_header"`
+	BlockParts         *bits.BitArray      `protobuf:"bytes,4,opt,name=block_parts,json=blockParts,proto3" json:"block_parts,omitempty"`
+	IsCommit           bool                `protobuf:"varint,5,opt,name=is_commit,json=isCommit,proto3" json:"is_commit,omitempty"`
 }
 
 func (m *NewValidBlock) Reset()         { *m = NewValidBlock{} }
@@ -161,9 +161,9 @@ func (m *NewValidBlock) GetRound() int32 {
 	return 0
 }
 
-func (m *NewValidBlock) GetBlockPartsHeader() types.PartSetHeader {
+func (m *NewValidBlock) GetBlockPartSetHeader() types.PartSetHeader {
 	if m != nil {
-		return m.BlockPartsHeader
+		return m.BlockPartSetHeader
 	}
 	return types.PartSetHeader{}
 }
@@ -801,61 +801,61 @@ func init() {
 func init() { proto.RegisterFile("proto/consensus/msgs.proto", fileDescriptor_9de64017f8b3fc88) }
 
 var fileDescriptor_9de64017f8b3fc88 = []byte{
-	// 858 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x8f, 0xdb, 0x44,
-	0x18, 0xb6, 0x59, 0x67, 0x93, 0x7d, 0xbd, 0x1f, 0x65, 0x54, 0x4a, 0x48, 0x45, 0xb2, 0x18, 0x09,
-	0xad, 0x10, 0x72, 0xaa, 0xec, 0x01, 0xa9, 0x42, 0x02, 0xcc, 0x47, 0xdd, 0x55, 0xd3, 0x46, 0x4e,
-	0xd5, 0x03, 0x17, 0xcb, 0x89, 0x47, 0xce, 0xd0, 0xd8, 0x63, 0x79, 0x26, 0x59, 0x72, 0xe5, 0x17,
-	0xf0, 0x03, 0xf8, 0x1b, 0x48, 0xfc, 0x84, 0x1e, 0x7b, 0xe4, 0x54, 0xa1, 0xec, 0x1f, 0x40, 0x42,
-	0xe2, 0x8c, 0xe6, 0x23, 0xb1, 0xb7, 0xf5, 0x2e, 0xec, 0x05, 0x89, 0xcb, 0xca, 0x33, 0xef, 0xfb,
-	0x3c, 0xf3, 0x7e, 0x3e, 0x1b, 0xe8, 0xe4, 0x05, 0xe5, 0xb4, 0x3f, 0xa5, 0x19, 0xc3, 0x19, 0x5b,
-	0xb0, 0x7e, 0xca, 0x12, 0xe6, 0xca, 0x4b, 0x74, 0x9b, 0xe3, 0x2c, 0xc6, 0x45, 0x4a, 0x32, 0xee,
-	0x6e, 0x1d, 0x3a, 0x1f, 0xf1, 0x19, 0x29, 0xe2, 0x30, 0x8f, 0x0a, 0xbe, 0xea, 0x2b, 0x74, 0x42,
-	0x13, 0x5a, 0x7e, 0x29, 0x74, 0xe7, 0x5d, 0x75, 0xc3, 0x57, 0x39, 0x66, 0xea, 0xaf, 0x36, 0xdc,
-	0x55, 0x86, 0x39, 0x99, 0xb0, 0xfe, 0x84, 0xf0, 0x4b, 0x46, 0xe7, 0x17, 0x13, 0xf6, 0x1f, 0xe3,
-	0xf3, 0x80, 0x2e, 0xb2, 0x78, 0xcc, 0x71, 0x8e, 0xee, 0xc0, 0xee, 0x0c, 0x93, 0x64, 0xc6, 0xdb,
-	0xe6, 0xb1, 0x79, 0xb2, 0x13, 0xe8, 0x13, 0xba, 0x0d, 0x8d, 0x42, 0x38, 0xb5, 0xdf, 0x3a, 0x36,
-	0x4f, 0x1a, 0x81, 0x3a, 0x20, 0x04, 0x16, 0xe3, 0x38, 0x6f, 0xef, 0x1c, 0x9b, 0x27, 0x07, 0x81,
-	0xfc, 0x46, 0x9f, 0x42, 0x9b, 0xe1, 0x29, 0xcd, 0x62, 0x16, 0x32, 0x92, 0x4d, 0x71, 0xc8, 0x78,
-	0x54, 0xf0, 0x90, 0x93, 0x14, 0xb7, 0x2d, 0xc9, 0xf9, 0x8e, 0xb6, 0x8f, 0x85, 0x79, 0x2c, 0xac,
-	0x4f, 0x49, 0x8a, 0xd1, 0xc7, 0xf0, 0xf6, 0x3c, 0x62, 0x3c, 0x9c, 0xd2, 0x34, 0x25, 0x3c, 0x54,
-	0xcf, 0x35, 0xe4, 0x73, 0x47, 0xc2, 0xf0, 0x95, 0xbc, 0x97, 0xa1, 0x3a, 0x7f, 0x98, 0x70, 0xf0,
-	0x18, 0x9f, 0x3f, 0x8b, 0xe6, 0x24, 0xf6, 0xe6, 0x74, 0xfa, 0xfc, 0x86, 0x81, 0x8f, 0x01, 0x4d,
-	0x04, 0x4c, 0xd6, 0x95, 0x85, 0x33, 0x1c, 0xc5, 0xb8, 0x90, 0x69, 0xd8, 0x83, 0x9e, 0x5b, 0x69,
-	0x84, 0x2a, 0xd6, 0x28, 0x2a, 0xf8, 0x18, 0x73, 0x5f, 0xba, 0x79, 0xd6, 0x8b, 0x57, 0x3d, 0x23,
-	0xb8, 0x25, 0x09, 0x84, 0x85, 0xa9, 0x7b, 0xf4, 0x39, 0xd8, 0x15, 0x52, 0x99, 0xac, 0x3d, 0xe8,
-	0x56, 0xd9, 0x44, 0x13, 0x5c, 0xd1, 0x04, 0xd7, 0x23, 0xfc, 0xcb, 0xa2, 0x88, 0x56, 0x01, 0x94,
-	0x34, 0xe8, 0x2e, 0xec, 0x11, 0xa6, 0xf3, 0x97, 0x99, 0xb7, 0x82, 0x16, 0x61, 0x2a, 0x6f, 0xc7,
-	0x87, 0xd6, 0xa8, 0xa0, 0x39, 0x65, 0xd1, 0x1c, 0x7d, 0x06, 0xad, 0x5c, 0x7f, 0xcb, 0x74, 0xed,
-	0x41, 0xa7, 0x26, 0x68, 0xed, 0xa1, 0xe3, 0xdd, 0x22, 0x9c, 0x9f, 0x4d, 0xb0, 0x37, 0xc6, 0xd1,
-	0x93, 0x47, 0x57, 0x96, 0xee, 0x13, 0x40, 0x1b, 0x4c, 0x98, 0xd3, 0x79, 0x58, 0xad, 0xe3, 0xad,
-	0x8d, 0x65, 0x44, 0xe7, 0xb2, 0x25, 0xe8, 0x01, 0xec, 0x57, 0xbd, 0x75, 0x31, 0xff, 0x21, 0x7d,
-	0x1d, 0x9b, 0x5d, 0x61, 0x73, 0x9e, 0xc3, 0x9e, 0xb7, 0xa9, 0xc9, 0x0d, 0xdb, 0x7a, 0x0f, 0x2c,
-	0x51, 0x7b, 0xfd, 0xf6, 0x9d, 0xfa, 0x46, 0xea, 0x37, 0xa5, 0xa7, 0x33, 0x00, 0xeb, 0x19, 0xe5,
-	0x62, 0xf8, 0xac, 0x25, 0xe5, 0x58, 0x57, 0xb3, 0x06, 0x29, 0xbc, 0x02, 0xe9, 0xe3, 0xfc, 0x68,
-	0x42, 0xd3, 0x8f, 0x98, 0xc4, 0xdd, 0x2c, 0xbe, 0x53, 0xb0, 0x04, 0x9b, 0x8c, 0xef, 0xb0, 0x6e,
-	0xd0, 0xc6, 0x24, 0xc9, 0x70, 0x3c, 0x64, 0xc9, 0xd3, 0x55, 0x8e, 0x03, 0xe9, 0x2c, 0xa8, 0x48,
-	0x16, 0xe3, 0x1f, 0xe4, 0x40, 0x35, 0x02, 0x75, 0x70, 0x7e, 0x35, 0x61, 0x5f, 0x44, 0x30, 0xc6,
-	0x7c, 0x18, 0x7d, 0x3f, 0x38, 0xfd, 0x2f, 0x22, 0xf9, 0x06, 0x5a, 0x6a, 0xc0, 0x49, 0xac, 0xa7,
-	0xfb, 0xbd, 0x37, 0x81, 0xb2, 0x77, 0x0f, 0xbf, 0xf6, 0x8e, 0x44, 0x95, 0xd7, 0xaf, 0x7a, 0x4d,
-	0x7d, 0x11, 0x34, 0x25, 0xf6, 0x61, 0xec, 0xfc, 0x69, 0x82, 0xad, 0x43, 0xf7, 0x08, 0x67, 0xff,
-	0x9f, 0xc8, 0xd1, 0x7d, 0x68, 0x88, 0x09, 0x60, 0x72, 0x39, 0xff, 0xed, 0x70, 0x2b, 0x88, 0xf3,
-	0x97, 0x05, 0xcd, 0x21, 0x66, 0x2c, 0x4a, 0x30, 0x3a, 0x83, 0xc3, 0x0c, 0x9f, 0xab, 0x85, 0x0a,
-	0xa5, 0x82, 0xaa, 0xb9, 0x73, 0xdc, 0xba, 0xff, 0x01, 0x6e, 0x55, 0xa1, 0x7d, 0x23, 0xd8, 0xcf,
-	0xaa, 0x8a, 0x3d, 0x84, 0x23, 0xc1, 0xb5, 0x14, 0x52, 0x18, 0xca, 0x40, 0x65, 0xbd, 0xec, 0xc1,
-	0x87, 0x57, 0x92, 0x95, 0xb2, 0xe9, 0x1b, 0xc1, 0x41, 0x76, 0x49, 0x47, 0xab, 0xd2, 0x52, 0xb3,
-	0xc2, 0x25, 0xcf, 0x46, 0x41, 0xfc, 0x8a, 0xb4, 0xa0, 0x6f, 0x5f, 0x13, 0x01, 0x55, 0xeb, 0x0f,
-	0xae, 0x67, 0x18, 0x3d, 0x79, 0xe4, 0x5f, 0xd6, 0x00, 0xf4, 0x05, 0x40, 0x29, 0xa5, 0xba, 0xda,
-	0xbd, 0x7a, 0x96, 0xad, 0x56, 0xf8, 0x46, 0xb0, 0xb7, 0x15, 0x53, 0x21, 0x05, 0x72, 0xa1, 0x77,
-	0xdf, 0x94, 0xc7, 0x12, 0x2b, 0xa6, 0xd0, 0x37, 0xd4, 0x5a, 0xa3, 0xfb, 0xd0, 0x9a, 0x45, 0x2c,
-	0x94, 0xa8, 0xa6, 0x44, 0xbd, 0x5f, 0x8f, 0xd2, 0xbb, 0xef, 0x1b, 0x41, 0x73, 0xa6, 0x65, 0xe0,
-	0x0c, 0x0e, 0x05, 0x2e, 0x64, 0x98, 0x87, 0xa9, 0x58, 0xc7, 0x76, 0xeb, 0xba, 0x86, 0x56, 0x17,
-	0x57, 0x34, 0x74, 0x59, 0x5d, 0xe4, 0x07, 0x70, 0xb0, 0xe5, 0x12, 0xf3, 0xd4, 0xde, 0xbb, 0xae,
-	0x88, 0x95, 0x45, 0x12, 0x45, 0x5c, 0x96, 0x47, 0xaf, 0x01, 0x3b, 0x6c, 0x91, 0x7a, 0x67, 0x2f,
-	0xd6, 0x5d, 0xf3, 0xe5, 0xba, 0x6b, 0xfe, 0xbe, 0xee, 0x9a, 0x3f, 0x5d, 0x74, 0x8d, 0x97, 0x17,
-	0x5d, 0xe3, 0xb7, 0x8b, 0xae, 0xf1, 0xdd, 0xbd, 0x84, 0xf0, 0xd9, 0x62, 0xe2, 0x4e, 0x69, 0xda,
-	0x2f, 0xc9, 0xab, 0x9f, 0xaf, 0xfd, 0x5c, 0x99, 0xec, 0xca, 0x8b, 0xd3, 0xbf, 0x03, 0x00, 0x00,
-	0xff, 0xff, 0x6c, 0xa7, 0x03, 0xea, 0xc8, 0x08, 0x00, 0x00,
+	// 860 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xdd, 0x8e, 0xdb, 0x44,
+	0x14, 0xb6, 0x59, 0x67, 0x93, 0x3d, 0xde, 0x1f, 0x18, 0xb5, 0x25, 0x6c, 0x45, 0xb2, 0x18, 0x09,
+	0xad, 0x10, 0x72, 0xaa, 0xec, 0x05, 0x52, 0x85, 0x04, 0x98, 0x9f, 0xba, 0xab, 0xa6, 0x8d, 0x9c,
+	0xaa, 0x42, 0xdc, 0x58, 0x4e, 0x3c, 0x72, 0x86, 0xc6, 0x1e, 0xcb, 0x33, 0xc9, 0x92, 0x5b, 0x9e,
+	0x80, 0x07, 0xe0, 0x35, 0x90, 0x78, 0x84, 0x5e, 0xf6, 0x92, 0xab, 0x0a, 0x65, 0x1f, 0x01, 0xc1,
+	0x35, 0x9a, 0x9f, 0xc4, 0x4e, 0xeb, 0x2e, 0xec, 0x0d, 0x52, 0x6f, 0xa2, 0x99, 0x39, 0xe7, 0x7c,
+	0x73, 0xe6, 0x3b, 0xe7, 0x7c, 0x0e, 0x1c, 0xe7, 0x05, 0xe5, 0xb4, 0x37, 0xa1, 0x19, 0xc3, 0x19,
+	0x9b, 0xb3, 0x5e, 0xca, 0x12, 0xe6, 0xca, 0x43, 0x74, 0x83, 0xe3, 0x2c, 0xc6, 0x45, 0x4a, 0x32,
+	0xee, 0x6e, 0x1c, 0x8e, 0x3f, 0xe2, 0x53, 0x52, 0xc4, 0x61, 0x1e, 0x15, 0x7c, 0xd9, 0x53, 0xd1,
+	0x09, 0x4d, 0x68, 0xb9, 0x52, 0xd1, 0xc7, 0xef, 0xaa, 0x13, 0xbe, 0xcc, 0x31, 0x53, 0xbf, 0xda,
+	0x70, 0x5b, 0x19, 0x66, 0x64, 0xcc, 0x7a, 0x63, 0xc2, 0xb7, 0x8c, 0xce, 0xaf, 0x26, 0xec, 0x3f,
+	0xc4, 0x17, 0x01, 0x9d, 0x67, 0xf1, 0x88, 0xe3, 0x1c, 0xdd, 0x82, 0xdd, 0x29, 0x26, 0xc9, 0x94,
+	0xb7, 0xcd, 0x13, 0xf3, 0x74, 0x27, 0xd0, 0x3b, 0x74, 0x03, 0x1a, 0x85, 0x70, 0x6a, 0xbf, 0x75,
+	0x62, 0x9e, 0x36, 0x02, 0xb5, 0x41, 0x08, 0x2c, 0xc6, 0x71, 0xde, 0xde, 0x39, 0x31, 0x4f, 0x0f,
+	0x02, 0xb9, 0x46, 0x9f, 0x42, 0x9b, 0xe1, 0x09, 0xcd, 0x62, 0x16, 0x32, 0x92, 0x4d, 0x70, 0xc8,
+	0x78, 0x54, 0xf0, 0x90, 0x93, 0x14, 0xb7, 0x2d, 0x89, 0x79, 0x53, 0xdb, 0x47, 0xc2, 0x3c, 0x12,
+	0xd6, 0xc7, 0x24, 0xc5, 0xe8, 0x63, 0x78, 0x67, 0x16, 0x31, 0x1e, 0x4e, 0x68, 0x9a, 0x12, 0x1e,
+	0xaa, 0xeb, 0x1a, 0xf2, 0xba, 0x23, 0x61, 0xf8, 0x4a, 0x9e, 0xcb, 0x54, 0x9d, 0xbf, 0x4c, 0x38,
+	0x78, 0x88, 0x2f, 0x9e, 0x44, 0x33, 0x12, 0x7b, 0x33, 0x3a, 0x79, 0x7a, 0xcd, 0xc4, 0xbf, 0x83,
+	0x9b, 0x63, 0x11, 0x26, 0x79, 0x0d, 0x19, 0xe6, 0xe1, 0x14, 0x47, 0x31, 0x2e, 0xe4, 0x4b, 0xec,
+	0x7e, 0xd7, 0xad, 0xd4, 0x42, 0xf1, 0x35, 0x8c, 0x0a, 0x3e, 0xc2, 0xdc, 0x97, 0x6e, 0x9e, 0xf5,
+	0xec, 0x45, 0xd7, 0x08, 0x90, 0xc4, 0xd8, 0xb2, 0xa0, 0xcf, 0xc1, 0x2e, 0x91, 0x99, 0x7c, 0xb1,
+	0xdd, 0xef, 0x54, 0xf1, 0x44, 0x25, 0x5c, 0x51, 0x09, 0xd7, 0x23, 0xfc, 0xcb, 0xa2, 0x88, 0x96,
+	0x01, 0x6c, 0x80, 0x18, 0xba, 0x0d, 0x7b, 0x84, 0x69, 0x12, 0xe4, 0xf3, 0x5b, 0x41, 0x8b, 0x30,
+	0xf5, 0x78, 0xc7, 0x87, 0xd6, 0xb0, 0xa0, 0x39, 0x65, 0xd1, 0x0c, 0x7d, 0x06, 0xad, 0x5c, 0xaf,
+	0xe5, 0x9b, 0xed, 0xfe, 0x71, 0x4d, 0xda, 0xda, 0x43, 0x67, 0xbc, 0x89, 0x70, 0x7e, 0x31, 0xc1,
+	0x5e, 0x1b, 0x87, 0x8f, 0x1e, 0xbc, 0x96, 0xbf, 0x4f, 0x00, 0xad, 0x63, 0xc2, 0x9c, 0xce, 0xc2,
+	0x2a, 0x99, 0x6f, 0xaf, 0x2d, 0x43, 0x3a, 0x93, 0x75, 0x41, 0xf7, 0x60, 0xbf, 0xea, 0xad, 0xe9,
+	0xfc, 0x97, 0xe7, 0xeb, 0xdc, 0xec, 0x0a, 0x9a, 0xf3, 0x14, 0xf6, 0xbc, 0x35, 0x27, 0xd7, 0xac,
+	0xed, 0x1d, 0xb0, 0x04, 0xf7, 0xfa, 0xee, 0x5b, 0xf5, 0xa5, 0xd4, 0x77, 0x4a, 0x4f, 0xa7, 0x0f,
+	0xd6, 0x13, 0xca, 0x45, 0x07, 0x5a, 0x0b, 0xca, 0xb1, 0x66, 0xb3, 0x26, 0x52, 0x78, 0x05, 0xd2,
+	0xc7, 0xf9, 0xc9, 0x84, 0xa6, 0x1f, 0x31, 0x19, 0x77, 0xbd, 0xfc, 0xce, 0xc0, 0x12, 0x68, 0x32,
+	0xbf, 0xc3, 0xba, 0x56, 0x1b, 0x91, 0x24, 0xc3, 0xf1, 0x80, 0x25, 0x8f, 0x97, 0x39, 0x0e, 0xa4,
+	0xb3, 0x80, 0x22, 0x59, 0x8c, 0x7f, 0x94, 0x0d, 0xd5, 0x08, 0xd4, 0xc6, 0xf9, 0xcd, 0x84, 0x7d,
+	0x91, 0xc1, 0x08, 0xf3, 0x41, 0xf4, 0x43, 0xff, 0xec, 0xff, 0xc8, 0xe4, 0x1b, 0x68, 0xa9, 0x06,
+	0x27, 0xb1, 0xee, 0xee, 0xf7, 0x5e, 0x0d, 0x94, 0xb5, 0xbb, 0xff, 0xb5, 0x77, 0x24, 0x58, 0x5e,
+	0xbd, 0xe8, 0x36, 0xf5, 0x41, 0xd0, 0x94, 0xb1, 0xf7, 0x63, 0xe7, 0x4f, 0x13, 0x6c, 0x9d, 0xba,
+	0x47, 0x38, 0x7b, 0x73, 0x32, 0x47, 0x77, 0xa1, 0x21, 0x3a, 0x80, 0xc9, 0xe1, 0xfc, 0xaf, 0xcd,
+	0xad, 0x42, 0x9c, 0xbf, 0x2d, 0x68, 0x0e, 0x30, 0x63, 0x51, 0x82, 0xd1, 0x39, 0x1c, 0x66, 0xf8,
+	0x42, 0x0d, 0x54, 0x28, 0x65, 0x54, 0xf5, 0x9d, 0xe3, 0xd6, 0x7d, 0x08, 0xdc, 0xaa, 0x4c, 0xfb,
+	0x46, 0xb0, 0x9f, 0x55, 0x65, 0x7b, 0x00, 0x47, 0x02, 0x6b, 0x21, 0xf4, 0x30, 0x94, 0x89, 0x4a,
+	0xbe, 0xec, 0xfe, 0x87, 0xaf, 0x05, 0x2b, 0xb5, 0xd3, 0x37, 0x82, 0x83, 0x6c, 0x4b, 0x4c, 0xab,
+	0xd2, 0x52, 0x33, 0xc2, 0x25, 0xce, 0x5a, 0x41, 0xfc, 0x8a, 0xb4, 0xa0, 0x6f, 0x5f, 0x12, 0x01,
+	0xc5, 0xf5, 0x07, 0x57, 0x23, 0x0c, 0x1f, 0x3d, 0xf0, 0xb7, 0x35, 0x00, 0x7d, 0x01, 0x50, 0x4a,
+	0xa9, 0x66, 0xbb, 0x5b, 0x8f, 0xb2, 0xd1, 0x0a, 0xdf, 0x08, 0xf6, 0x36, 0x62, 0x2a, 0xa4, 0x40,
+	0x0e, 0xf4, 0xee, 0xab, 0xf2, 0x58, 0xc6, 0x8a, 0x2e, 0xf4, 0x0d, 0x35, 0xd6, 0xe8, 0x2e, 0xb4,
+	0xa6, 0x11, 0x0b, 0x65, 0x54, 0x53, 0x46, 0xbd, 0x5f, 0x1f, 0xa5, 0x67, 0xdf, 0x37, 0x82, 0xe6,
+	0x54, 0xcb, 0xc0, 0x39, 0x1c, 0x8a, 0x38, 0xf9, 0x39, 0x49, 0xc5, 0x38, 0xb6, 0x5b, 0x57, 0x15,
+	0xb4, 0x3a, 0xb8, 0xa2, 0xa0, 0x8b, 0xea, 0x20, 0xdf, 0x83, 0x83, 0x0d, 0x96, 0xe8, 0xa7, 0xf6,
+	0xde, 0x55, 0x24, 0x56, 0x06, 0x49, 0x90, 0xb8, 0x28, 0xb7, 0x5e, 0x03, 0x76, 0xd8, 0x3c, 0xf5,
+	0xce, 0x9f, 0xad, 0x3a, 0xe6, 0xf3, 0x55, 0xc7, 0xfc, 0x63, 0xd5, 0x31, 0x7f, 0xbe, 0xec, 0x18,
+	0xcf, 0x2f, 0x3b, 0xc6, 0xef, 0x97, 0x1d, 0xe3, 0xfb, 0x3b, 0x09, 0xe1, 0xd3, 0xf9, 0xd8, 0x9d,
+	0xd0, 0xb4, 0x57, 0x82, 0x57, 0x97, 0x2f, 0xfd, 0x67, 0x19, 0xef, 0xca, 0x83, 0xb3, 0x7f, 0x02,
+	0x00, 0x00, 0xff, 0xff, 0xc8, 0x89, 0x05, 0x9a, 0xcd, 0x08, 0x00, 0x00,
 }
 
 func (m *NewRoundStep) Marshal() (dAtA []byte, err error) {
@@ -949,7 +949,7 @@ func (m *NewValidBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		dAtA[i] = 0x22
 	}
 	{
-		size, err := m.BlockPartsHeader.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.BlockPartSetHeader.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -1542,7 +1542,7 @@ func (m *NewValidBlock) Size() (n int) {
 	if m.Round != 0 {
 		n += 1 + sovMsgs(uint64(m.Round))
 	}
-	l = m.BlockPartsHeader.Size()
+	l = m.BlockPartSetHeader.Size()
 	n += 1 + l + sovMsgs(uint64(l))
 	if m.BlockParts != nil {
 		l = m.BlockParts.Size()
@@ -2019,7 +2019,7 @@ func (m *NewValidBlock) Unmarshal(dAtA []byte) error {
 			}
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockPartsHeader", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockPartSetHeader", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -2046,7 +2046,7 @@ func (m *NewValidBlock) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.BlockPartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.BlockPartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex

proto/consensus/msgs.proto

@@ -21,11 +21,11 @@ message NewRoundStep {
 //i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
 // In case the block is also committed, then IsCommit flag is set to true.
 message NewValidBlock {
-  int64                          height             = 1;
-  int32                          round              = 2;
-  tendermint.types.PartSetHeader block_parts_header = 3 [(gogoproto.nullable) = false];
-  tendermint.libs.bits.BitArray  block_parts        = 4;
-  bool                           is_commit          = 5;
+  int64                          height                = 1;
+  int32                          round                 = 2;
+  tendermint.types.PartSetHeader block_part_set_header = 3 [(gogoproto.nullable) = false];
+  tendermint.libs.bits.BitArray  block_parts           = 4;
+  bool                           is_commit             = 5;
 }
 
 // ProposalMessage is sent when a new block is proposed.

proto/types/canonical.pb.go

@@ -29,8 +29,8 @@ var _ = time.Kitchen
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type CanonicalBlockID struct {
-	Hash        []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	PartsHeader CanonicalPartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
+	Hash          []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	PartSetHeader CanonicalPartSetHeader `protobuf:"bytes,2,opt,name=part_set_header,json=partSetHeader,proto3" json:"part_set_header"`
 }
 
 func (m *CanonicalBlockID) Reset()         { *m = CanonicalBlockID{} }
@@ -73,9 +73,9 @@ func (m *CanonicalBlockID) GetHash() []byte {
 	return nil
 }
 
-func (m *CanonicalBlockID) GetPartsHeader() CanonicalPartSetHeader {
+func (m *CanonicalBlockID) GetPartSetHeader() CanonicalPartSetHeader {
 	if m != nil {
-		return m.PartsHeader
+		return m.PartSetHeader
 	}
 	return CanonicalPartSetHeader{}
 }
@@ -318,38 +318,38 @@ func init() {
 func init() { proto.RegisterFile("proto/types/canonical.proto", fileDescriptor_3f9b1d584b46f180) }
 
 var fileDescriptor_3f9b1d584b46f180 = []byte{
-	// 489 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcb, 0x6e, 0xd3, 0x40,
-	0x14, 0xcd, 0xa4, 0x4e, 0xe2, 0x4c, 0x52, 0x14, 0x46, 0xa8, 0x58, 0x41, 0xb2, 0x23, 0x2f, 0x2a,
-	0x23, 0x21, 0x5b, 0x6a, 0xff, 0xc0, 0x45, 0x88, 0x20, 0x10, 0x65, 0x5a, 0xb1, 0x60, 0x13, 0x4d,
-	0xec, 0xc1, 0x1e, 0xe1, 0x78, 0x2c, 0x7b, 0xb2, 0xc8, 0x5f, 0xf4, 0x3b, 0xf8, 0x92, 0x2e, 0xbb,
-	0x84, 0x4d, 0x40, 0xce, 0x8f, 0xa0, 0x99, 0x49, 0xe2, 0x88, 0xd7, 0x06, 0xd4, 0x8d, 0x75, 0x1f,
-	0xe7, 0x9e, 0x7b, 0x7c, 0xae, 0x06, 0x3e, 0x29, 0x4a, 0x2e, 0x78, 0x20, 0x56, 0x05, 0xad, 0x82,
-	0x88, 0xe4, 0x3c, 0x67, 0x11, 0xc9, 0x7c, 0x55, 0x45, 0x23, 0x41, 0xf3, 0x98, 0x96, 0x0b, 0x96,
-	0x0b, 0x5f, 0x21, 0xc6, 0xa7, 0x22, 0x65, 0x65, 0x3c, 0x2b, 0x48, 0x29, 0x56, 0x81, 0x1e, 0x4d,
-	0x78, 0xc2, 0x9b, 0x48, 0x4f, 0x8e, 0x1f, 0x1f, 0xd2, 0xaa, 0xef, 0xb6, 0xe1, 0x24, 0x9c, 0x27,
-	0x19, 0xd5, 0xb3, 0xf3, 0xe5, 0xc7, 0x40, 0xb0, 0x05, 0xad, 0x04, 0x59, 0x14, 0x1a, 0xe0, 0xae,
-	0xe0, 0xe8, 0x62, 0x27, 0x23, 0xcc, 0x78, 0xf4, 0x69, 0xfa, 0x1c, 0x21, 0x68, 0xa4, 0xa4, 0x4a,
-	0x2d, 0x30, 0x01, 0xde, 0x10, 0xab, 0x18, 0xbd, 0x83, 0x43, 0xa9, 0xa2, 0x9a, 0xa5, 0x94, 0xc4,
-	0xb4, 0xb4, 0xda, 0x13, 0xe0, 0x0d, 0xce, 0x3c, 0xff, 0x67, 0xc9, 0xfe, 0x9e, 0xed, 0x92, 0x94,
-	0xe2, 0x8a, 0x8a, 0x97, 0x0a, 0x1f, 0x1a, 0xb7, 0x6b, 0xa7, 0x85, 0x07, 0x8a, 0x43, 0x97, 0xdc,
-	0x10, 0x9e, 0xfc, 0x1e, 0x8c, 0x1e, 0xc1, 0x8e, 0xe0, 0x82, 0x64, 0x4a, 0xc1, 0x31, 0xd6, 0xc9,
-	0x5e, 0x56, 0xbb, 0x91, 0xe5, 0x7e, 0x6d, 0xc3, 0x87, 0x0d, 0x49, 0xc9, 0x0b, 0x5e, 0x91, 0x0c,
-	0x9d, 0x43, 0x43, 0x8a, 0x51, 0xe3, 0x0f, 0xce, 0x9c, 0x5f, 0x45, 0x5e, 0xb1, 0x24, 0xa7, 0xf1,
-	0x9b, 0x2a, 0xb9, 0x5e, 0x15, 0x14, 0x2b, 0x30, 0x3a, 0x81, 0xdd, 0x94, 0xb2, 0x24, 0x15, 0x6a,
-	0xc1, 0x08, 0x6f, 0x33, 0x29, 0xa6, 0xe4, 0xcb, 0x3c, 0xb6, 0x8e, 0x54, 0x59, 0x27, 0xe8, 0x29,
-	0xec, 0x17, 0x3c, 0x9b, 0xe9, 0x8e, 0x31, 0x01, 0xde, 0x51, 0x38, 0xac, 0xd7, 0x8e, 0x79, 0xf9,
-	0xf6, 0x35, 0x96, 0x35, 0x6c, 0x16, 0x3c, 0x53, 0x11, 0x7a, 0x05, 0xcd, 0xb9, 0x74, 0x76, 0xc6,
-	0x62, 0xab, 0xa3, 0x6c, 0x73, 0xff, 0x62, 0xdb, 0xf6, 0x08, 0xe1, 0xa0, 0x5e, 0x3b, 0xbd, 0x6d,
-	0x82, 0x7b, 0x8a, 0x60, 0x1a, 0xa3, 0x10, 0xf6, 0xf7, 0x17, 0xb4, 0xba, 0x8a, 0x6c, 0xec, 0xeb,
-	0x1b, 0xfb, 0xbb, 0x1b, 0xfb, 0xd7, 0x3b, 0x44, 0x68, 0x4a, 0xd7, 0x6f, 0xbe, 0x39, 0x00, 0x37,
-	0x63, 0xe8, 0x14, 0x9a, 0x51, 0x4a, 0x58, 0x2e, 0xf5, 0xf4, 0x26, 0xc0, 0xeb, 0xeb, 0x5d, 0x17,
-	0xb2, 0x26, 0x77, 0xa9, 0xe6, 0x34, 0x76, 0x3f, 0xb7, 0xe1, 0xf1, 0x5e, 0xd6, 0x7b, 0x2e, 0xe8,
-	0x7d, 0xf8, 0x7a, 0x68, 0x96, 0xf1, 0x3f, 0xcd, 0xea, 0xfc, 0xbb, 0x59, 0xdd, 0x3f, 0x9b, 0x15,
-	0xbe, 0xb8, 0xad, 0x6d, 0x70, 0x57, 0xdb, 0xe0, 0x7b, 0x6d, 0x83, 0x9b, 0x8d, 0xdd, 0xba, 0xdb,
-	0xd8, 0xad, 0x2f, 0x1b, 0xbb, 0xf5, 0xe1, 0x59, 0xc2, 0x44, 0xba, 0x9c, 0xfb, 0x11, 0x5f, 0x04,
-	0xcd, 0x9f, 0x1c, 0x86, 0x07, 0x8f, 0x77, 0xde, 0x55, 0xc9, 0xf9, 0x8f, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0x6b, 0xbc, 0x84, 0x74, 0x29, 0x04, 0x00, 0x00,
+	// 493 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x93, 0xcf, 0x6e, 0xd3, 0x40,
+	0x10, 0xc6, 0xe3, 0xd4, 0x49, 0x9c, 0x6d, 0x03, 0x61, 0x85, 0x8a, 0x15, 0x24, 0x3b, 0xf2, 0xa1,
+	0x32, 0x12, 0xb2, 0xa5, 0xf6, 0x0d, 0x5c, 0x84, 0x08, 0x02, 0x51, 0xb9, 0x55, 0x0f, 0x5c, 0xac,
+	0x8d, 0xbd, 0xd8, 0x2b, 0x1c, 0xef, 0xca, 0xde, 0x1c, 0x72, 0xe1, 0x19, 0xfa, 0x1c, 0x3c, 0x49,
+	0x8f, 0x3d, 0xc2, 0x25, 0x20, 0xe7, 0x45, 0xd0, 0xee, 0x26, 0xb1, 0xc5, 0xbf, 0x0b, 0xa8, 0x97,
+	0x68, 0x66, 0xf6, 0x9b, 0x99, 0x5f, 0xbe, 0x91, 0xc1, 0x53, 0x56, 0x52, 0x4e, 0x7d, 0xbe, 0x62,
+	0xb8, 0xf2, 0x63, 0x54, 0xd0, 0x82, 0xc4, 0x28, 0xf7, 0x64, 0x15, 0x8e, 0x39, 0x2e, 0x12, 0x5c,
+	0x2e, 0x48, 0xc1, 0x3d, 0xa9, 0x98, 0x9c, 0xf0, 0x8c, 0x94, 0x49, 0xc4, 0x50, 0xc9, 0x57, 0xbe,
+	0x6a, 0x4d, 0x69, 0x4a, 0x9b, 0x48, 0x75, 0x4e, 0x9e, 0xb4, 0xc7, 0xca, 0xdf, 0xed, 0x83, 0x9d,
+	0x52, 0x9a, 0xe6, 0x58, 0xf5, 0xce, 0x97, 0x1f, 0x7c, 0x4e, 0x16, 0xb8, 0xe2, 0x68, 0xc1, 0x94,
+	0xc0, 0xf9, 0x04, 0xc6, 0xe7, 0x3b, 0x8c, 0x20, 0xa7, 0xf1, 0xc7, 0xd9, 0x0b, 0x08, 0x81, 0x9e,
+	0xa1, 0x2a, 0x33, 0xb5, 0xa9, 0xe6, 0x1e, 0x85, 0x32, 0x86, 0xd7, 0xe0, 0xa1, 0xa0, 0x88, 0x2a,
+	0xcc, 0xa3, 0x0c, 0xa3, 0x04, 0x97, 0x66, 0x77, 0xaa, 0xb9, 0x87, 0xa7, 0xae, 0xf7, 0x33, 0xb5,
+	0xb7, 0x1f, 0x78, 0x81, 0x4a, 0x7e, 0x89, 0xf9, 0x2b, 0xa9, 0x0f, 0xf4, 0xdb, 0xb5, 0xdd, 0x09,
+	0x47, 0xac, 0x5d, 0x74, 0x02, 0x70, 0xfc, 0x7b, 0x39, 0x7c, 0x0c, 0x7a, 0x9c, 0x72, 0x94, 0x4b,
+	0x8c, 0x51, 0xa8, 0x92, 0x3d, 0x5b, 0xb7, 0x61, 0x73, 0xbe, 0x76, 0xc1, 0xa3, 0x66, 0x48, 0x49,
+	0x19, 0xad, 0x50, 0x0e, 0xcf, 0x80, 0x2e, 0x70, 0x64, 0xfb, 0x83, 0x53, 0xfb, 0x57, 0xcc, 0x4b,
+	0x92, 0x16, 0x38, 0x79, 0x5b, 0xa5, 0x57, 0x2b, 0x86, 0x43, 0x29, 0x86, 0xc7, 0xa0, 0x9f, 0x61,
+	0x92, 0x66, 0x5c, 0x2e, 0x18, 0x87, 0xdb, 0x4c, 0xc0, 0x94, 0x74, 0x59, 0x24, 0xe6, 0x81, 0x2c,
+	0xab, 0x04, 0x3e, 0x03, 0x43, 0x46, 0xf3, 0x48, 0xbd, 0xe8, 0x53, 0xcd, 0x3d, 0x08, 0x8e, 0xea,
+	0xb5, 0x6d, 0x5c, 0xbc, 0x7b, 0x13, 0x8a, 0x5a, 0x68, 0x30, 0x9a, 0xcb, 0x08, 0xbe, 0x06, 0xc6,
+	0x5c, 0xd8, 0x1b, 0x91, 0xc4, 0xec, 0x49, 0xe3, 0x9c, 0xbf, 0x18, 0xb7, 0xbd, 0x44, 0x70, 0x58,
+	0xaf, 0xed, 0xc1, 0x36, 0x09, 0x07, 0x72, 0xc0, 0x2c, 0x81, 0x01, 0x18, 0xee, 0xcf, 0x68, 0xf6,
+	0xe5, 0xb0, 0x89, 0xa7, 0x0e, 0xed, 0xed, 0x0e, 0xed, 0x5d, 0xed, 0x14, 0x81, 0x21, 0x7c, 0xbf,
+	0xf9, 0x66, 0x6b, 0x61, 0xd3, 0x06, 0x4f, 0x80, 0x11, 0x67, 0x88, 0x14, 0x82, 0x67, 0x30, 0xd5,
+	0xdc, 0xa1, 0xda, 0x75, 0x2e, 0x6a, 0x62, 0x97, 0x7c, 0x9c, 0x25, 0xce, 0xe7, 0x2e, 0x18, 0xed,
+	0xb1, 0xae, 0x29, 0xc7, 0xf7, 0xe1, 0x6b, 0xdb, 0x2c, 0xfd, 0x7f, 0x9a, 0xd5, 0xfb, 0x77, 0xb3,
+	0xfa, 0x7f, 0x36, 0x2b, 0x78, 0x79, 0x5b, 0x5b, 0xda, 0x5d, 0x6d, 0x69, 0xdf, 0x6b, 0x4b, 0xbb,
+	0xd9, 0x58, 0x9d, 0xbb, 0x8d, 0xd5, 0xf9, 0xb2, 0xb1, 0x3a, 0xef, 0x9f, 0xa7, 0x84, 0x67, 0xcb,
+	0xb9, 0x17, 0xd3, 0x85, 0xdf, 0xfc, 0x93, 0x76, 0xd8, 0xfa, 0x82, 0xe7, 0x7d, 0x99, 0x9c, 0xfd,
+	0x08, 0x00, 0x00, 0xff, 0xff, 0x91, 0x72, 0x7f, 0x8c, 0x2e, 0x04, 0x00, 0x00,
 }
 
 func (m *CanonicalBlockID) Marshal() (dAtA []byte, err error) {
@@ -373,7 +373,7 @@ func (m *CanonicalBlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -587,7 +587,7 @@ func (m *CanonicalBlockID) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovCanonical(uint64(l))
 	}
-	l = m.PartsHeader.Size()
+	l = m.PartSetHeader.Size()
 	n += 1 + l + sovCanonical(uint64(l))
 	return n
 }
@@ -738,7 +738,7 @@ func (m *CanonicalBlockID) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -765,7 +765,7 @@ func (m *CanonicalBlockID) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex

proto/types/canonical.proto

@@ -8,8 +8,8 @@ import "proto/types/types.proto";
 import "google/protobuf/timestamp.proto";
 
 message CanonicalBlockID {
-  bytes                  hash         = 1;
-  CanonicalPartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
+  bytes                  hash            = 1;
+  CanonicalPartSetHeader part_set_header = 2 [(gogoproto.nullable) = false];
 }
 
 message CanonicalPartSetHeader {

proto/types/types.pb.go

@@ -211,8 +211,8 @@ func (m *Part) GetProof() merkle.Proof {
 
 // BlockID
 type BlockID struct {
-	Hash        []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
+	Hash          []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	PartSetHeader PartSetHeader `protobuf:"bytes,2,opt,name=part_set_header,json=partSetHeader,proto3" json:"part_set_header"`
 }
 
 func (m *BlockID) Reset()         { *m = BlockID{} }
@@ -255,9 +255,9 @@ func (m *BlockID) GetHash() []byte {
 	return nil
 }
 
-func (m *BlockID) GetPartsHeader() PartSetHeader {
+func (m *BlockID) GetPartSetHeader() PartSetHeader {
 	if m != nil {
-		return m.PartsHeader
+		return m.PartSetHeader
 	}
 	return PartSetHeader{}
 }
@@ -1022,7 +1022,7 @@ func init() {
 func init() { proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }
 
 var fileDescriptor_ff06f8095857fb18 = []byte{
-	// 1312 bytes of a gzipped FileDescriptorProto
+	// 1314 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4f, 0x6f, 0x1a, 0x47,
 	0x14, 0xf7, 0xc2, 0x62, 0xe0, 0x01, 0x36, 0x5e, 0xb9, 0x09, 0xc1, 0x0d, 0xa6, 0x44, 0x49, 0x9d,
 	0x34, 0x82, 0xc8, 0x51, 0xab, 0x56, 0x51, 0x0f, 0x60, 0x93, 0x04, 0xc5, 0xc6, 0x68, 0xa1, 0xa9,
@@ -1041,70 +1041,71 @@ var fileDescriptor_ff06f8095857fb18 = []byte{
 	0x54, 0x88, 0x95, 0x95, 0x8d, 0xac, 0x8e, 0xe3, 0x0a, 0x05, 0x95, 0x87, 0xf2, 0x08, 0xdb, 0xb5,
 	0xc8, 0x41, 0x18, 0x81, 0x13, 0x6e, 0xed, 0x1f, 0x32, 0x12, 0xc8, 0x10, 0x31, 0xd1, 0xee, 0x41,
 	0xc2, 0xf3, 0x29, 0x7d, 0x52, 0x88, 0x97, 0x95, 0x8d, 0xcc, 0xe6, 0x7a, 0x35, 0x42, 0x9a, 0xa8,
-	0xa0, 0x2a, 0x2a, 0xa8, 0x76, 0x38, 0xac, 0xa1, 0xbe, 0x78, 0xb5, 0xbe, 0xa0, 0x8b, 0x98, 0xca,
-	0x10, 0x92, 0x0d, 0x87, 0x0e, 0x9e, 0xb6, 0xb6, 0xa7, 0xfb, 0x51, 0x66, 0xfb, 0xd1, 0x1e, 0x42,
-	0x96, 0x53, 0x1d, 0x18, 0x23, 0xac, 0x04, 0x17, 0x3e, 0xb5, 0x84, 0xa0, 0x65, 0xae, 0x60, 0xb9,
-	0x44, 0x06, 0x43, 0x85, 0xa9, 0xf2, 0x87, 0x0a, 0x8b, 0x92, 0x8e, 0x4f, 0x21, 0x29, 0x09, 0xc3,
-	0xb5, 0x32, 0x9b, 0x57, 0xa3, 0xf9, 0x42, 0x2e, 0xb7, 0xa8, 0x1b, 0x10, 0x37, 0x98, 0x04, 0x32,
-	0x5b, 0x18, 0xa3, 0xdd, 0x80, 0xd4, 0x60, 0x64, 0xda, 0xae, 0x61, 0x5b, 0xb8, 0x9f, 0x74, 0x23,
-	0x73, 0xf2, 0x6a, 0x3d, 0xb9, 0xc5, 0x6d, 0xad, 0x6d, 0x3d, 0x89, 0xce, 0x96, 0xa5, 0x5d, 0x82,
-	0xc5, 0x11, 0xb1, 0x87, 0x23, 0x86, 0xc4, 0xc4, 0x75, 0x39, 0xd3, 0x3e, 0x06, 0x95, 0x8b, 0xa1,
-	0xa0, 0xe2, 0xda, 0xc5, 0xaa, 0x50, 0x4a, 0x35, 0x54, 0x4a, 0xb5, 0x17, 0x2a, 0xa5, 0x91, 0xe2,
-	0x0b, 0x3f, 0xff, 0x6d, 0x5d, 0xd1, 0x31, 0x42, 0xdb, 0x82, 0x9c, 0x63, 0x06, 0xcc, 0xe8, 0x73,
-	0xc6, 0xf8, 0xf2, 0x09, 0x4c, 0x71, 0xe5, 0x2c, 0x1d, 0x92, 0xd3, 0x90, 0x08, 0x1e, 0x25, 0x4c,
-	0x96, 0xb6, 0x01, 0x79, 0x4c, 0x32, 0xa0, 0xe3, 0xb1, 0xcd, 0x0c, 0xa4, 0x7c, 0x11, 0x29, 0x5f,
-	0xe2, 0xf6, 0x2d, 0x34, 0x3f, 0xe4, 0xe4, 0xaf, 0x41, 0xda, 0x32, 0x99, 0x29, 0x20, 0x49, 0x84,
-	0xa4, 0xb8, 0x01, 0x9d, 0xef, 0xc3, 0xf2, 0xbe, 0xe9, 0xd8, 0x96, 0xc9, 0xa8, 0x1f, 0x08, 0x48,
-	0x4a, 0x64, 0x99, 0x99, 0x11, 0x78, 0x07, 0x56, 0x5d, 0x72, 0xc0, 0x8c, 0xd3, 0xe8, 0x34, 0xa2,
-	0x35, 0xee, 0x7b, 0x3c, 0x1f, 0x71, 0x1d, 0x96, 0x06, 0x21, 0xf9, 0x02, 0x0b, 0x88, 0xcd, 0x4d,
-	0xad, 0x08, 0xbb, 0x02, 0x29, 0xd3, 0xf3, 0x04, 0x20, 0x83, 0x80, 0xa4, 0xe9, 0x79, 0xe8, 0xba,
-	0x05, 0x2b, 0x58, 0xa3, 0x4f, 0x82, 0x89, 0xc3, 0x64, 0x92, 0x2c, 0x62, 0x96, 0xb9, 0x43, 0x17,
-	0x76, 0xc4, 0x5e, 0x83, 0x1c, 0xd9, 0xb7, 0x2d, 0xe2, 0x0e, 0x88, 0xc0, 0xe5, 0x10, 0x97, 0x0d,
-	0x8d, 0x08, 0xba, 0x09, 0x79, 0xcf, 0xa7, 0x1e, 0x0d, 0x88, 0x6f, 0x98, 0x96, 0xe5, 0x93, 0x20,
-	0x28, 0x2c, 0x89, 0x7c, 0xa1, 0xbd, 0x2e, 0xcc, 0x95, 0xdb, 0xa0, 0x6e, 0x9b, 0xcc, 0xd4, 0xf2,
-	0x10, 0x67, 0x07, 0x41, 0x41, 0x29, 0xc7, 0x37, 0xb2, 0x3a, 0x1f, 0x9e, 0x7b, 0xe1, 0xfe, 0x8c,
-	0x81, 0xfa, 0x98, 0x32, 0xa2, 0xdd, 0x05, 0x95, 0x1f, 0x1d, 0x2a, 0x72, 0xe9, 0x3c, 0x85, 0x77,
-	0xed, 0xa1, 0x4b, 0xac, 0xdd, 0x60, 0xd8, 0x3b, 0xf4, 0x88, 0x8e, 0xe0, 0x88, 0xc4, 0x62, 0x73,
-	0x12, 0x5b, 0x85, 0x84, 0x4f, 0x27, 0xae, 0x85, 0xca, 0x4b, 0xe8, 0x62, 0xa2, 0x35, 0x21, 0x35,
-	0x55, 0x8e, 0xfa, 0x4f, 0xca, 0x59, 0xe6, 0xca, 0xe1, 0xba, 0x96, 0x06, 0x3d, 0xd9, 0x97, 0x02,
-	0x6a, 0x40, 0x7a, 0xfa, 0x98, 0x49, 0x05, 0xfe, 0x3b, 0x11, 0xcf, 0xc2, 0xb4, 0x0f, 0x60, 0x65,
-	0xaa, 0x87, 0x29, 0xa1, 0x42, 0x85, 0xf9, 0xa9, 0x43, 0x32, 0x3a, 0x27, 0x35, 0x43, 0x3c, 0x4b,
-	0x49, 0xac, 0x6b, 0x26, 0xb5, 0x16, 0xbe, 0x4f, 0xef, 0x42, 0x3a, 0xb0, 0x87, 0xae, 0xc9, 0x26,
-	0x3e, 0x91, 0x6a, 0x9c, 0x19, 0x2a, 0xdf, 0xc4, 0x60, 0x51, 0xa8, 0x3b, 0xc2, 0x9b, 0x72, 0x3e,
-	0x6f, 0xb1, 0x8b, 0x78, 0x8b, 0xbf, 0x39, 0x6f, 0x75, 0x80, 0xe9, 0x66, 0x82, 0x82, 0x5a, 0x8e,
-	0x6f, 0x64, 0x36, 0xd7, 0xce, 0x26, 0x12, 0x5b, 0xec, 0xda, 0x43, 0x79, 0x79, 0x23, 0x41, 0x53,
-	0x05, 0x25, 0x22, 0x4f, 0xe4, 0x3d, 0x48, 0xf7, 0x6d, 0x66, 0x98, 0xbe, 0x6f, 0x1e, 0x22, 0x85,
-	0x99, 0xcd, 0x52, 0x34, 0x2b, 0xef, 0x30, 0x55, 0xde, 0x61, 0xaa, 0x0d, 0x9b, 0xd5, 0x39, 0x4a,
-	0x4f, 0xf5, 0xe5, 0xa8, 0xf2, 0xab, 0x02, 0xe9, 0xe9, 0x82, 0x5a, 0x1d, 0x72, 0x61, 0xa1, 0xc6,
-	0x13, 0xc7, 0x1c, 0x4a, 0x31, 0x5e, 0xbd, 0xb0, 0xda, 0xfb, 0x8e, 0x39, 0xd4, 0x33, 0xb2, 0x40,
-	0x3e, 0x39, 0xff, 0x60, 0x63, 0x17, 0x1c, 0xec, 0x9c, 0x92, 0xe2, 0x6f, 0xa6, 0xa4, 0xb9, 0x33,
-	0x57, 0x4f, 0x9f, 0xf9, 0x8f, 0x31, 0x48, 0x75, 0xf0, 0x82, 0x9a, 0xce, 0xff, 0x71, 0xc5, 0xd6,
-	0x20, 0xed, 0x51, 0xc7, 0x10, 0x1e, 0x15, 0x3d, 0x29, 0x8f, 0x3a, 0xfa, 0x19, 0x1d, 0x25, 0xde,
-	0xd2, 0xfd, 0x5b, 0x7c, 0x0b, 0xac, 0x25, 0x4f, 0xb3, 0xe6, 0x43, 0x56, 0x50, 0x21, 0x1b, 0xe6,
-	0x1d, 0xce, 0x01, 0xf6, 0x5f, 0xd1, 0x2f, 0x0b, 0x67, 0xb7, 0x2d, 0x90, 0xba, 0xc4, 0xf1, 0x08,
-	0xd1, 0x5f, 0x64, 0xc7, 0x2e, 0x5c, 0xa4, 0x73, 0x5d, 0xe2, 0x2a, 0x3f, 0x2b, 0x90, 0xc6, 0x52,
-	0x77, 0x09, 0x33, 0xe7, 0xa8, 0x52, 0xde, 0x9c, 0xaa, 0xab, 0x00, 0x22, 0x4d, 0x60, 0x3f, 0x23,
-	0xf2, 0x00, 0xd3, 0x68, 0xe9, 0xda, 0xcf, 0x88, 0xf6, 0xd1, 0xb4, 0xae, 0xf8, 0xdf, 0xd7, 0x25,
-	0xaf, 0x62, 0x58, 0xdd, 0x65, 0x48, 0xba, 0x93, 0xb1, 0xc1, 0x9f, 0x77, 0x55, 0x88, 0xc2, 0x9d,
-	0x8c, 0x7b, 0x07, 0x41, 0xe5, 0x2b, 0x48, 0xf6, 0x0e, 0xf0, 0x2b, 0x87, 0x2b, 0xc1, 0xa7, 0x54,
-	0xf6, 0x57, 0xf1, 0x49, 0x93, 0xe2, 0x06, 0x6c, 0x27, 0x1a, 0xa8, 0xbc, 0x91, 0x86, 0x9d, 0x80,
-	0x8f, 0xb5, 0x0f, 0x21, 0xd1, 0xf9, 0x0f, 0x9f, 0x51, 0xba, 0x40, 0xdf, 0xfa, 0x49, 0x81, 0x4c,
-	0xe4, 0x36, 0x6a, 0x45, 0xb8, 0xd4, 0xd8, 0xd9, 0xdb, 0x7a, 0xb4, 0x6d, 0xb4, 0xb6, 0x8d, 0xfb,
-	0x3b, 0xf5, 0x07, 0xc6, 0x67, 0xed, 0x47, 0xed, 0xbd, 0xcf, 0xdb, 0xf9, 0x05, 0xad, 0x06, 0xab,
-	0xe8, 0x9b, 0xba, 0xea, 0x8d, 0x6e, 0xb3, 0xdd, 0xcb, 0x2b, 0xc5, 0x77, 0x8e, 0x8e, 0xcb, 0x2b,
-	0x91, 0x34, 0xf5, 0x7e, 0x40, 0x5c, 0x76, 0x36, 0x60, 0x6b, 0x6f, 0x77, 0xb7, 0xd5, 0xcb, 0xc7,
-	0xce, 0x04, 0xc8, 0x87, 0xf5, 0x26, 0xac, 0xcc, 0x07, 0xb4, 0x5b, 0x3b, 0xf9, 0x78, 0x51, 0x3b,
-	0x3a, 0x2e, 0x2f, 0x45, 0xd0, 0x6d, 0xdb, 0x29, 0xa6, 0xbe, 0xfe, 0xb6, 0xb4, 0xf0, 0xc3, 0x77,
-	0x25, 0xe5, 0xd6, 0xf7, 0x0a, 0xe4, 0xe6, 0xae, 0x9e, 0xb6, 0x06, 0x97, 0xbb, 0xad, 0x07, 0xed,
-	0xe6, 0xb6, 0xb1, 0xdb, 0x7d, 0x60, 0xf4, 0xbe, 0xe8, 0x34, 0x23, 0x55, 0xbc, 0x07, 0xd9, 0x8e,
-	0xde, 0x7c, 0xbc, 0xd7, 0x6b, 0xa2, 0x27, 0xaf, 0x14, 0x97, 0x8f, 0x8e, 0xcb, 0x99, 0x8e, 0x4f,
-	0xf6, 0x29, 0x23, 0x18, 0x7f, 0x1d, 0x96, 0x3a, 0x7a, 0x53, 0x6c, 0x56, 0x80, 0x62, 0xc5, 0x95,
-	0xa3, 0xe3, 0x72, 0xae, 0xe3, 0x13, 0xa1, 0x37, 0x84, 0x5d, 0x83, 0x5c, 0x47, 0xdf, 0xeb, 0xec,
-	0x75, 0xeb, 0x3b, 0x02, 0x55, 0x2e, 0xe6, 0x8f, 0x8e, 0xcb, 0xd9, 0xf0, 0xc5, 0xe0, 0xa0, 0xd9,
-	0x3e, 0x1b, 0xf7, 0x5f, 0x9c, 0x94, 0x94, 0x97, 0x27, 0x25, 0xe5, 0xf7, 0x93, 0x92, 0xf2, 0xfc,
-	0x75, 0x69, 0xe1, 0xe5, 0xeb, 0xd2, 0xc2, 0x2f, 0xaf, 0x4b, 0x0b, 0x5f, 0xde, 0x1e, 0xda, 0x6c,
-	0x34, 0xe9, 0x57, 0x07, 0x74, 0x5c, 0x9b, 0x1d, 0x5b, 0x74, 0x18, 0xf9, 0x85, 0xd1, 0x5f, 0xc4,
-	0xc9, 0xdd, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x84, 0xdd, 0x04, 0x77, 0x0c, 0x00, 0x00,
+	0xa0, 0x2a, 0x2a, 0xa8, 0x76, 0x38, 0xac, 0xa1, 0xbe, 0x78, 0xb5, 0xbe, 0xa0, 0x8b, 0x98, 0x8a,
+	0x03, 0xc9, 0x86, 0x43, 0x07, 0x4f, 0x5b, 0xdb, 0xd3, 0xfd, 0x28, 0xb3, 0xfd, 0x68, 0xbb, 0xb0,
+	0xcc, 0xa9, 0x36, 0x02, 0xc2, 0x8c, 0x11, 0x16, 0x83, 0x6b, 0x9f, 0x5a, 0x45, 0x30, 0x33, 0x57,
+	0xb3, 0x5c, 0x25, 0xe7, 0x45, 0x8d, 0x95, 0x3f, 0x54, 0x58, 0x94, 0x9c, 0x7c, 0x0a, 0x49, 0xc9,
+	0x1a, 0x2e, 0x98, 0xd9, 0xbc, 0x1a, 0xcd, 0x18, 0x12, 0xba, 0x45, 0xdd, 0x80, 0xb8, 0xc1, 0x24,
+	0x90, 0xf9, 0xc2, 0x18, 0xed, 0x06, 0xa4, 0x06, 0x23, 0xd3, 0x76, 0x0d, 0xdb, 0xc2, 0x1d, 0xa5,
+	0x1b, 0x99, 0x93, 0x57, 0xeb, 0xc9, 0x2d, 0x6e, 0x6b, 0x6d, 0xeb, 0x49, 0x74, 0xb6, 0x2c, 0xed,
+	0x12, 0x2c, 0x8e, 0x88, 0x3d, 0x1c, 0x31, 0x64, 0x27, 0xae, 0xcb, 0x99, 0xf6, 0x31, 0xa8, 0x5c,
+	0x11, 0x05, 0x15, 0xd7, 0x2e, 0x56, 0x85, 0x5c, 0xaa, 0xa1, 0x5c, 0xaa, 0xbd, 0x50, 0x2e, 0x8d,
+	0x14, 0x5f, 0xf8, 0xf9, 0x6f, 0xeb, 0x8a, 0x8e, 0x11, 0xda, 0x16, 0xe4, 0x1c, 0x33, 0x60, 0x46,
+	0x9f, 0xd3, 0xc6, 0x97, 0x4f, 0x60, 0x8a, 0x2b, 0x67, 0x09, 0x91, 0xc4, 0xca, 0xad, 0x67, 0x78,
+	0x94, 0x30, 0x59, 0xda, 0x06, 0xe4, 0x31, 0xc9, 0x80, 0x8e, 0xc7, 0x36, 0x33, 0x90, 0xf7, 0x45,
+	0xe4, 0x7d, 0x89, 0xdb, 0xb7, 0xd0, 0xfc, 0x90, 0x9f, 0xc0, 0x1a, 0xa4, 0x2d, 0x93, 0x99, 0x02,
+	0x92, 0x44, 0x48, 0x8a, 0x1b, 0xd0, 0xf9, 0x3e, 0x2c, 0xef, 0x9b, 0x8e, 0x6d, 0x99, 0x8c, 0xfa,
+	0x81, 0x80, 0xa4, 0x44, 0x96, 0x99, 0x19, 0x81, 0x77, 0x60, 0xd5, 0x25, 0x07, 0xcc, 0x38, 0x8d,
+	0x4e, 0x23, 0x5a, 0xe3, 0xbe, 0xc7, 0xf3, 0x11, 0xd7, 0x61, 0x69, 0x10, 0x92, 0x2f, 0xb0, 0x80,
+	0xd8, 0xdc, 0xd4, 0x8a, 0xb0, 0x2b, 0x90, 0x32, 0x3d, 0x4f, 0x00, 0x32, 0x08, 0x48, 0x9a, 0x9e,
+	0x87, 0xae, 0x5b, 0xb0, 0x82, 0x35, 0xfa, 0x24, 0x98, 0x38, 0x4c, 0x26, 0xc9, 0x22, 0x66, 0x99,
+	0x3b, 0x74, 0x61, 0x47, 0xec, 0x35, 0xc8, 0x91, 0x7d, 0xdb, 0x22, 0xee, 0x80, 0x08, 0x5c, 0x0e,
+	0x71, 0xd9, 0xd0, 0x88, 0xa0, 0x9b, 0x90, 0xf7, 0x7c, 0xea, 0xd1, 0x80, 0xf8, 0x86, 0x69, 0x59,
+	0x3e, 0x09, 0x82, 0xc2, 0x92, 0xc8, 0x17, 0xda, 0xeb, 0xc2, 0x5c, 0xb9, 0x0d, 0xea, 0xb6, 0xc9,
+	0x4c, 0x2d, 0x0f, 0x71, 0x76, 0x10, 0x14, 0x94, 0x72, 0x7c, 0x23, 0xab, 0xf3, 0xe1, 0xb9, 0xb7,
+	0xee, 0xcf, 0x18, 0xa8, 0x8f, 0x29, 0x23, 0xda, 0x5d, 0x50, 0xf9, 0xd1, 0xa1, 0x22, 0x97, 0xce,
+	0xd3, 0x78, 0xd7, 0x1e, 0xba, 0xc4, 0xda, 0x0d, 0x86, 0xbd, 0x43, 0x8f, 0xe8, 0x08, 0x8e, 0x48,
+	0x2c, 0x36, 0x27, 0xb1, 0x55, 0x48, 0xf8, 0x74, 0xe2, 0x5a, 0xa8, 0xbc, 0x84, 0x2e, 0x26, 0x5a,
+	0x13, 0x52, 0x53, 0xe5, 0xa8, 0xff, 0xa4, 0x9c, 0x65, 0xae, 0x1c, 0xae, 0x6b, 0x69, 0xd0, 0x93,
+	0x7d, 0x29, 0xa0, 0x06, 0xa4, 0xa7, 0x2f, 0x9a, 0x54, 0xe0, 0xbf, 0x13, 0xf1, 0x2c, 0x4c, 0xfb,
+	0x00, 0x56, 0xa6, 0x7a, 0x98, 0x12, 0x2a, 0x54, 0x98, 0x9f, 0x3a, 0x24, 0xa3, 0x73, 0x52, 0x33,
+	0xc4, 0xdb, 0x94, 0xc4, 0xba, 0x66, 0x52, 0x6b, 0xe1, 0x23, 0xf5, 0x2e, 0xa4, 0x03, 0x7b, 0xe8,
+	0x9a, 0x6c, 0xe2, 0x13, 0xa9, 0xc6, 0x99, 0xa1, 0xf2, 0x4d, 0x0c, 0x16, 0x85, 0xba, 0x23, 0xbc,
+	0x29, 0xe7, 0xf3, 0x16, 0xbb, 0x88, 0xb7, 0xf8, 0x9b, 0xf3, 0x56, 0x07, 0x98, 0x6e, 0x26, 0x28,
+	0xa8, 0xe5, 0xf8, 0x46, 0x66, 0x73, 0xed, 0x6c, 0x22, 0xb1, 0xc5, 0xae, 0x3d, 0x94, 0x97, 0x37,
+	0x12, 0x34, 0x55, 0x50, 0x22, 0xf2, 0x4e, 0xde, 0x83, 0x74, 0xdf, 0x66, 0x86, 0xe9, 0xfb, 0xe6,
+	0x21, 0x52, 0x98, 0xd9, 0x2c, 0x45, 0xb3, 0xf2, 0x36, 0x53, 0xe5, 0x6d, 0xa6, 0xda, 0xb0, 0x59,
+	0x9d, 0xa3, 0xf4, 0x54, 0x5f, 0x8e, 0x2a, 0xbf, 0x2a, 0x90, 0x9e, 0x2e, 0xa8, 0xd5, 0x21, 0x17,
+	0x16, 0x6a, 0x3c, 0x71, 0xcc, 0xa1, 0x14, 0xe3, 0xd5, 0x0b, 0xab, 0xbd, 0xef, 0x98, 0x43, 0x3d,
+	0x23, 0x0b, 0xe4, 0x93, 0xf3, 0x0f, 0x36, 0x76, 0xc1, 0xc1, 0xce, 0x29, 0x29, 0xfe, 0x66, 0x4a,
+	0x9a, 0x3b, 0x73, 0xf5, 0xf4, 0x99, 0xff, 0x18, 0x83, 0x54, 0x07, 0x2f, 0xa8, 0xe9, 0xfc, 0x1f,
+	0x57, 0x6c, 0x0d, 0xd2, 0x1e, 0x75, 0x0c, 0xe1, 0x51, 0xd1, 0x93, 0xf2, 0xa8, 0xa3, 0x9f, 0xd1,
+	0x51, 0xe2, 0x2d, 0xdd, 0xbf, 0xc5, 0xb7, 0xc0, 0x5a, 0xf2, 0x34, 0x6b, 0x3e, 0x64, 0x05, 0x15,
+	0xb2, 0x61, 0xde, 0xe1, 0x1c, 0x60, 0x07, 0x16, 0xfd, 0xb2, 0x70, 0x76, 0xdb, 0x02, 0xa9, 0x4b,
+	0x1c, 0x8f, 0x10, 0xfd, 0x45, 0xf6, 0xec, 0xc2, 0x45, 0x3a, 0xd7, 0x25, 0xae, 0xf2, 0xb3, 0x02,
+	0x69, 0x2c, 0x75, 0x97, 0x30, 0x73, 0x8e, 0x2a, 0xe5, 0xcd, 0xa9, 0xba, 0x0a, 0x20, 0xd2, 0x04,
+	0xf6, 0x33, 0x22, 0x0f, 0x30, 0x8d, 0x96, 0xae, 0xfd, 0x8c, 0x68, 0x1f, 0x4d, 0xeb, 0x8a, 0xff,
+	0x7d, 0x5d, 0xf2, 0x2a, 0x86, 0xd5, 0x5d, 0x86, 0xa4, 0x3b, 0x19, 0x1b, 0xfc, 0x79, 0x57, 0x85,
+	0x28, 0xdc, 0xc9, 0xb8, 0x77, 0x10, 0x54, 0xbe, 0x82, 0x64, 0xef, 0x00, 0x3f, 0x75, 0xb8, 0x12,
+	0x7c, 0x4a, 0x65, 0x7f, 0x15, 0xdf, 0x35, 0x29, 0x6e, 0xc0, 0x76, 0xa2, 0x81, 0xca, 0x1b, 0x69,
+	0xd8, 0x09, 0xf8, 0x58, 0xfb, 0x10, 0x12, 0x9d, 0xff, 0xf0, 0x2d, 0xa5, 0x0b, 0xf4, 0xad, 0x9f,
+	0x14, 0xc8, 0x44, 0x6e, 0xa3, 0x56, 0x84, 0x4b, 0x8d, 0x9d, 0xbd, 0xad, 0x47, 0xdb, 0x46, 0x6b,
+	0xdb, 0xb8, 0xbf, 0x53, 0x7f, 0x60, 0x7c, 0xd6, 0x7e, 0xd4, 0xde, 0xfb, 0xbc, 0x9d, 0x5f, 0xd0,
+	0x6a, 0xb0, 0x8a, 0xbe, 0xa9, 0xab, 0xde, 0xe8, 0x36, 0xdb, 0xbd, 0xbc, 0x52, 0x7c, 0xe7, 0xe8,
+	0xb8, 0xbc, 0x12, 0x49, 0x53, 0xef, 0x07, 0xc4, 0x65, 0x67, 0x03, 0xb6, 0xf6, 0x76, 0x77, 0x5b,
+	0xbd, 0x7c, 0xec, 0x4c, 0x80, 0x7c, 0x58, 0x6f, 0xc2, 0xca, 0x7c, 0x40, 0xbb, 0xb5, 0x93, 0x8f,
+	0x17, 0xb5, 0xa3, 0xe3, 0xf2, 0x52, 0x04, 0xdd, 0xb6, 0x9d, 0x62, 0xea, 0xeb, 0x6f, 0x4b, 0x0b,
+	0x3f, 0x7c, 0x57, 0x52, 0x6e, 0x7d, 0xaf, 0x40, 0x6e, 0xee, 0xea, 0x69, 0x6b, 0x70, 0xb9, 0xdb,
+	0x7a, 0xd0, 0x6e, 0x6e, 0x1b, 0xbb, 0xdd, 0x07, 0x46, 0xef, 0x8b, 0x4e, 0x33, 0x52, 0xc5, 0x7b,
+	0x90, 0xed, 0xe8, 0xcd, 0xc7, 0x7b, 0xbd, 0x26, 0x7a, 0xf2, 0x4a, 0x71, 0xf9, 0xe8, 0xb8, 0x9c,
+	0xe9, 0xf8, 0x64, 0x9f, 0x32, 0x82, 0xf1, 0xd7, 0x61, 0xa9, 0xa3, 0x37, 0xc5, 0x66, 0x05, 0x28,
+	0x56, 0x5c, 0x39, 0x3a, 0x2e, 0xe7, 0x3a, 0x3e, 0x11, 0x7a, 0x43, 0xd8, 0x35, 0xc8, 0x75, 0xf4,
+	0xbd, 0xce, 0x5e, 0xb7, 0xbe, 0x23, 0x50, 0xe5, 0x62, 0xfe, 0xe8, 0xb8, 0x9c, 0x0d, 0x5f, 0x0c,
+	0x0e, 0x9a, 0xed, 0xb3, 0x71, 0xff, 0xc5, 0x49, 0x49, 0x79, 0x79, 0x52, 0x52, 0x7e, 0x3f, 0x29,
+	0x29, 0xcf, 0x5f, 0x97, 0x16, 0x5e, 0xbe, 0x2e, 0x2d, 0xfc, 0xf2, 0xba, 0xb4, 0xf0, 0xe5, 0xed,
+	0xa1, 0xcd, 0x46, 0x93, 0x7e, 0x75, 0x40, 0xc7, 0xb5, 0xd9, 0xb1, 0x45, 0x87, 0x91, 0x9f, 0x19,
+	0xfd, 0x45, 0x9c, 0xdc, 0xfd, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xec, 0xc5, 0xfd, 0xa2, 0x7c, 0x0c,
+	0x00, 0x00,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1208,7 +1209,7 @@ func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	{
-		size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -1865,7 +1866,7 @@ func (m *BlockID) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	l = m.PartsHeader.Size()
+	l = m.PartSetHeader.Size()
 	n += 1 + l + sovTypes(uint64(l))
 	return n
 }
@@ -2435,7 +2436,7 @@ func (m *BlockID) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -2462,7 +2463,7 @@ func (m *BlockID) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex

proto/types/types.proto

@@ -48,8 +48,8 @@ message Part {
 
 // BlockID
 message BlockID {
-  bytes         hash         = 1;
-  PartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
+  bytes         hash            = 1;
+  PartSetHeader part_set_header = 2 [(gogoproto.nullable) = false];
 }
 
 // --------------------------------

rpc/client/evidence_test.go

@@ -52,7 +52,7 @@ func makeEvidences(
 		Timestamp:        time.Now().UTC(),
 		BlockID: types.BlockID{
 			Hash: tmhash.Sum([]byte("blockhash")),
-			PartsHeader: types.PartSetHeader{
+			PartSetHeader: types.PartSetHeader{
 				Total: 1000,
 				Hash:  tmhash.Sum([]byte("partset")),
 			},
@@ -189,8 +189,8 @@ func TestBroadcastEvidence_ConflictingHeadersEvidence(t *testing.T) {
 			Commit: types.NewCommit(h1.Height, 1, h1.Commit.BlockID, h1.Commit.Signatures),
 		}
 		h2.Commit.BlockID = types.BlockID{
-			Hash:        h2.Hash(),
-			PartsHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
+			Hash:          h2.Hash(),
+			PartSetHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
 		}
 		vote := &types.Vote{
 			ValidatorAddress: pv.Key.Address,

state/execution_test.go

@@ -42,7 +42,7 @@ func TestApplyBlock(t *testing.T) {
 		mock.Mempool{}, sm.MockEvidencePool{})
 
 	block := makeBlock(state, 1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 	_, retainHeight, err := blockExec.ApplyBlock(state, blockID, block)
 	require.Nil(t, err)
@@ -64,7 +64,7 @@ func TestBeginBlockValidators(t *testing.T) {
 
 	prevHash := state.LastBlockID.Hash
 	prevParts := types.PartSetHeader{}
-	prevBlockID := types.BlockID{Hash: prevHash, PartsHeader: prevParts}
+	prevBlockID := types.BlockID{Hash: prevHash, PartSetHeader: prevParts}
 
 	var (
 		now        = tmtime.Now()
@@ -126,7 +126,7 @@ func TestBeginBlockByzantineValidators(t *testing.T) {
 
 	prevHash := state.LastBlockID.Hash
 	prevParts := types.PartSetHeader{}
-	prevBlockID := types.BlockID{Hash: prevHash, PartsHeader: prevParts}
+	prevBlockID := types.BlockID{Hash: prevHash, PartSetHeader: prevParts}
 
 	height1, val1 := int64(8), state.Validators.Validators[0].Address
 	height2, val2 := int64(3), state.Validators.Validators[1].Address
@@ -335,7 +335,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
 	require.NoError(t, err)
 
 	block := makeBlock(state, 1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 	pubkey := ed25519.GenPrivKey().PubKey()
 	pk, err := cryptoenc.PubKeyToProto(pubkey)
@@ -390,7 +390,7 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
 	)
 
 	block := makeBlock(state, 1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 	vp, err := cryptoenc.PubKeyToProto(state.Validators.Validators[0].PubKey)
 	require.NoError(t, err)

state/helpers_test.go

@@ -59,7 +59,7 @@ func makeAndApplyGoodBlock(state sm.State, height int64, lastCommit *types.Commi
 		return state, types.BlockID{}, err
 	}
 	blockID := types.BlockID{Hash: block.Hash(),
-		PartsHeader: types.PartSetHeader{Total: 3, Hash: tmrand.Bytes(32)}}
+		PartSetHeader: types.PartSetHeader{Total: 3, Hash: tmrand.Bytes(32)}}
 	state, _, err := blockExec.ApplyBlock(state, blockID, block)
 	if err != nil {
 		return state, types.BlockID{}, err
@@ -186,7 +186,7 @@ func makeHeaderPartsResponsesValPubKeyChange(
 		}
 	}
 
-	return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
+	return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
 }
 
 func makeHeaderPartsResponsesValPowerChange(
@@ -210,7 +210,7 @@ func makeHeaderPartsResponsesValPowerChange(
 		}
 	}
 
-	return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
+	return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
 }
 
 func makeHeaderPartsResponsesParams(
@@ -223,7 +223,7 @@ func makeHeaderPartsResponsesParams(
 		BeginBlock: &abci.ResponseBeginBlock{},
 		EndBlock:   &abci.ResponseEndBlock{ConsensusParamUpdates: types.TM2PB.ConsensusParams(&params)},
 	}
-	return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
+	return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
 }
 
 func randomGenesisDoc() *types.GenesisDoc {

state/state_test.go

@@ -429,7 +429,7 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) {
 	assert.EqualValues(t, 0, val1.ProposerPriority)
 
 	block := makeBlock(state, state.LastBlockHeight+1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 	abciResponses := &tmstate.ABCIResponses{
 		BeginBlock: &abci.ResponseBeginBlock{},
 		EndBlock:   &abci.ResponseEndBlock{ValidatorUpdates: nil},
@@ -543,7 +543,7 @@ func TestProposerPriorityProposerAlternates(t *testing.T) {
 	assert.Equal(t, val1PubKey.Address(), state.Validators.Proposer.Address)
 
 	block := makeBlock(state, state.LastBlockHeight+1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 	// no updates:
 	abciResponses := &tmstate.ABCIResponses{
 		BeginBlock: &abci.ResponseBeginBlock{},
@@ -730,7 +730,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		require.NoError(t, err)
 
 		block := makeBlock(oldState, oldState.LastBlockHeight+1)
-		blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+		blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 		updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates)
 		require.NoError(t, err)
@@ -759,7 +759,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		EndBlock:   &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{firstAddedVal}},
 	}
 	block := makeBlock(oldState, oldState.LastBlockHeight+1)
-	blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 	updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates)
 	require.NoError(t, err)
 
@@ -774,7 +774,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		require.NoError(t, err)
 
 		block := makeBlock(lastState, lastState.LastBlockHeight+1)
-		blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+		blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 		updatedStateInner, err := sm.UpdateState(lastState, blockID, &block.Header, abciResponses, validatorUpdates)
 		require.NoError(t, err)
@@ -807,7 +807,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 			EndBlock:   &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{addedVal}},
 		}
 		block := makeBlock(oldState, oldState.LastBlockHeight+1)
-		blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+		blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 		state, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates)
 		require.NoError(t, err)
 	}
@@ -822,7 +822,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		EndBlock:   &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{removeGenesisVal}},
 	}
 	block = makeBlock(oldState, oldState.LastBlockHeight+1)
-	blockID = types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+	blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 	validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates)
 	require.NoError(t, err)
 	updatedState, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates)
@@ -843,7 +843,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates)
 		require.NoError(t, err)
 		block = makeBlock(curState, curState.LastBlockHeight+1)
-		blockID = types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+		blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 		curState, err = sm.UpdateState(curState, blockID, &block.Header, abciResponses, validatorUpdates)
 		require.NoError(t, err)
 		if !bytes.Equal(curState.Validators.Proposer.Address, curState.NextValidators.Proposer.Address) {
@@ -868,7 +868,7 @@ func TestLargeGenesisValidator(t *testing.T) {
 		require.NoError(t, err)
 
 		block := makeBlock(updatedState, updatedState.LastBlockHeight+1)
-		blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
+		blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
 
 		updatedState, err = sm.UpdateState(updatedState, blockID, &block.Header, abciResponses, validatorUpdates)
 		require.NoError(t, err)

state/validation_test.go

@@ -61,7 +61,7 @@ func TestValidateBlockHeader(t *testing.T) {
 		{"Height wrong", func(block *types.Block) { block.Height += 10 }},
 		{"Time wrong", func(block *types.Block) { block.Time = block.Time.Add(-time.Second * 1) }},
 
-		{"LastBlockID wrong", func(block *types.Block) { block.LastBlockID.PartsHeader.Total += 10 }},
+		{"LastBlockID wrong", func(block *types.Block) { block.LastBlockID.PartSetHeader.Total += 10 }},
 		{"LastCommitHash wrong", func(block *types.Block) { block.LastCommitHash = wrongHash }},
 		{"DataHash wrong", func(block *types.Block) { block.DataHash = wrongHash }},
 
@@ -353,7 +353,7 @@ func TestValidateDuplicateEvidenceShouldFail(t *testing.T) {
 
 var blockID = types.BlockID{
 	Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
-	PartsHeader: types.PartSetHeader{
+	PartSetHeader: types.PartSetHeader{
 		Total: 1,
 		Hash:  []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
 	},

store/store.go

@@ -83,7 +83,7 @@ func (bs *BlockStore) LoadBlock(height int64) *types.Block {
 
 	pbb := new(tmproto.Block)
 	buf := []byte{}
-	for i := 0; i < int(blockMeta.BlockID.PartsHeader.Total); i++ {
+	for i := 0; i < int(blockMeta.BlockID.PartSetHeader.Total); i++ {
 		part := bs.LoadBlockPart(height, i)
 		buf = append(buf, part.Bytes...)
 	}
@@ -269,7 +269,7 @@ func (bs *BlockStore) PruneBlocks(height int64) (uint64, error) {
 		batch.Delete(calcBlockHashKey(meta.BlockID.Hash))
 		batch.Delete(calcBlockCommitKey(h))
 		batch.Delete(calcSeenCommitKey(h))
-		for p := 0; p < int(meta.BlockID.PartsHeader.Total); p++ {
+		for p := 0; p < int(meta.BlockID.PartSetHeader.Total); p++ {
 			batch.Delete(calcBlockPartKey(h, p))
 		}
 		pruned++

store/store_test.go

@@ -37,7 +37,7 @@ func makeTestCommit(height int64, timestamp time.Time) *types.Commit {
 		Signature:        []byte("Signature"),
 	}}
 	return types.NewCommit(height, 0,
-		types.BlockID{Hash: []byte(""), PartsHeader: types.PartSetHeader{Hash: []byte(""), Total: 2}}, commitSigs)
+		types.BlockID{Hash: []byte(""), PartSetHeader: types.PartSetHeader{Hash: []byte(""), Total: 2}}, commitSigs)
 }
 
 func makeTxs(height int64) (txs []types.Tx) {

tools/tm-signer-harness/internal/test_harness.go

@@ -222,7 +222,7 @@ func (th *TestHarness) TestSignProposal() error {
 		POLRound: -1,
 		BlockID: types.BlockID{
 			Hash: hash,
-			PartsHeader: types.PartSetHeader{
+			PartSetHeader: types.PartSetHeader{
 				Hash:  hash,
 				Total: 1000000,
 			},
@@ -269,7 +269,7 @@ func (th *TestHarness) TestSignVote() error {
 			Round:  0,
 			BlockID: types.BlockID{
 				Hash: hash,
-				PartsHeader: types.PartSetHeader{
+				PartSetHeader: types.PartSetHeader{
 					Hash:  hash,
 					Total: 1000000,
 				},

types/block.go

@@ -1242,19 +1242,19 @@ func (data *EvidenceData) FromProto(eviData *tmproto.EvidenceData) error {
 
 // BlockID
 type BlockID struct {
-	Hash        tmbytes.HexBytes `json:"hash"`
-	PartsHeader PartSetHeader    `json:"parts"`
+	Hash          tmbytes.HexBytes `json:"hash"`
+	PartSetHeader PartSetHeader    `json:"parts"`
 }
 
 // Equals returns true if the BlockID matches the given BlockID
 func (blockID BlockID) Equals(other BlockID) bool {
 	return bytes.Equal(blockID.Hash, other.Hash) &&
-		blockID.PartsHeader.Equals(other.PartsHeader)
+		blockID.PartSetHeader.Equals(other.PartSetHeader)
 }
 
 // Key returns a machine-readable string representation of the BlockID
 func (blockID BlockID) Key() string {
-	pbph := blockID.PartsHeader.ToProto()
+	pbph := blockID.PartSetHeader.ToProto()
 	bz, err := pbph.Marshal()
 	if err != nil {
 		panic(err)
@@ -1269,8 +1269,8 @@ func (blockID BlockID) ValidateBasic() error {
 	if err := ValidateHash(blockID.Hash); err != nil {
 		return fmt.Errorf("wrong Hash")
 	}
-	if err := blockID.PartsHeader.ValidateBasic(); err != nil {
-		return fmt.Errorf("wrong PartsHeader: %v", err)
+	if err := blockID.PartSetHeader.ValidateBasic(); err != nil {
+		return fmt.Errorf("wrong PartSetHeader: %v", err)
 	}
 	return nil
 }
@@ -1278,19 +1278,19 @@ func (blockID BlockID) ValidateBasic() error {
 // IsZero returns true if this is the BlockID of a nil block.
 func (blockID BlockID) IsZero() bool {
 	return len(blockID.Hash) == 0 &&
-		blockID.PartsHeader.IsZero()
+		blockID.PartSetHeader.IsZero()
 }
 
 // IsComplete returns true if this is a valid BlockID of a non-nil block.
 func (blockID BlockID) IsComplete() bool {
 	return len(blockID.Hash) == tmhash.Size &&
-		blockID.PartsHeader.Total > 0 &&
-		len(blockID.PartsHeader.Hash) == tmhash.Size
+		blockID.PartSetHeader.Total > 0 &&
+		len(blockID.PartSetHeader.Hash) == tmhash.Size
 }
 
 // String returns a human readable string representation of the BlockID
 func (blockID BlockID) String() string {
-	return fmt.Sprintf(`%v:%v`, blockID.Hash, blockID.PartsHeader)
+	return fmt.Sprintf(`%v:%v`, blockID.Hash, blockID.PartSetHeader)
 }
 
 // ToProto converts BlockID to protobuf
@@ -1300,8 +1300,8 @@ func (blockID *BlockID) ToProto() tmproto.BlockID {
 	}
 
 	return tmproto.BlockID{
-		Hash:        blockID.Hash,
-		PartsHeader: blockID.PartsHeader.ToProto(),
+		Hash:          blockID.Hash,
+		PartSetHeader: blockID.PartSetHeader.ToProto(),
 	}
 }
 
@@ -1313,12 +1313,12 @@ func BlockIDFromProto(bID *tmproto.BlockID) (*BlockID, error) {
 	}
 
 	blockID := new(BlockID)
-	ph, err := PartSetHeaderFromProto(&bID.PartsHeader)
+	ph, err := PartSetHeaderFromProto(&bID.PartSetHeader)
 	if err != nil {
 		return nil, err
 	}
 
-	blockID.PartsHeader = *ph
+	blockID.PartSetHeader = *ph
 	blockID.Hash = bID.Hash
 
 	return blockID, blockID.ValidateBasic()

types/block_meta_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestBlockMeta_ToProto(t *testing.T) {
 	h := makeRandHeader()
-	bi := BlockID{Hash: h.Hash(), PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
+	bi := BlockID{Hash: h.Hash(), PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
 
 	bm := &BlockMeta{
 		BlockID:   bi,
@@ -47,11 +47,11 @@ func TestBlockMeta_ToProto(t *testing.T) {
 
 func TestBlockMeta_ValidateBasic(t *testing.T) {
 	h := makeRandHeader()
-	bi := BlockID{Hash: h.Hash(), PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
+	bi := BlockID{Hash: h.Hash(), PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
 	bi2 := BlockID{Hash: tmrand.Bytes(tmhash.Size),
-		PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
+		PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
 	bi3 := BlockID{Hash: []byte("incorrect hash"),
-		PartsHeader: PartSetHeader{Total: 123, Hash: []byte("incorrect hash")}}
+		PartSetHeader: PartSetHeader{Total: 123, Hash: []byte("incorrect hash")}}
 
 	bm := &BlockMeta{
 		BlockID:   bi,

types/block_test.go

@@ -187,7 +187,7 @@ func makeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) BlockID {
 	copy(psH, partSetHash)
 	return BlockID{
 		Hash: h,
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: partSetSize,
 			Hash:  psH,
 		},
@@ -588,7 +588,7 @@ func TestSignedHeaderValidateBasic(t *testing.T) {
 func TestBlockIDValidateBasic(t *testing.T) {
 	validBlockID := BlockID{
 		Hash: bytes.HexBytes{},
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 1,
 			Hash:  bytes.HexBytes{},
 		},
@@ -596,29 +596,29 @@ func TestBlockIDValidateBasic(t *testing.T) {
 
 	invalidBlockID := BlockID{
 		Hash: []byte{0},
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 1,
 			Hash:  []byte{0},
 		},
 	}
 
 	testCases := []struct {
-		testName           string
-		blockIDHash        bytes.HexBytes
-		blockIDPartsHeader PartSetHeader
-		expectErr          bool
+		testName             string
+		blockIDHash          bytes.HexBytes
+		blockIDPartSetHeader PartSetHeader
+		expectErr            bool
 	}{
-		{"Valid BlockID", validBlockID.Hash, validBlockID.PartsHeader, false},
-		{"Invalid BlockID", invalidBlockID.Hash, validBlockID.PartsHeader, true},
-		{"Invalid BlockID", validBlockID.Hash, invalidBlockID.PartsHeader, true},
+		{"Valid BlockID", validBlockID.Hash, validBlockID.PartSetHeader, false},
+		{"Invalid BlockID", invalidBlockID.Hash, validBlockID.PartSetHeader, true},
+		{"Invalid BlockID", validBlockID.Hash, invalidBlockID.PartSetHeader, true},
 	}
 
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			blockID := BlockID{
-				Hash:        tc.blockIDHash,
-				PartsHeader: tc.blockIDPartsHeader,
+				Hash:          tc.blockIDHash,
+				PartSetHeader: tc.blockIDPartSetHeader,
 			}
 			assert.Equal(t, tc.expectErr, blockID.ValidateBasic() != nil, "Validate Basic had an unexpected result")
 		})

types/canonical.go

@@ -25,8 +25,8 @@ func CanonicalizeBlockID(bid tmproto.BlockID) *tmproto.CanonicalBlockID {
 		cbid = nil
 	} else {
 		cbid = &tmproto.CanonicalBlockID{
-			Hash:        bid.Hash,
-			PartsHeader: CanonicalizePartSetHeader(bid.PartsHeader),
+			Hash:          bid.Hash,
+			PartSetHeader: CanonicalizePartSetHeader(bid.PartSetHeader),
 		}
 	}
 

types/canonical_test.go

@@ -12,13 +12,13 @@ import (
 func TestCanonicalizeBlockID(t *testing.T) {
 	randhash := tmrand.Bytes(tmhash.Size)
 	block1 := tmproto.BlockID{Hash: randhash,
-		PartsHeader: tmproto.PartSetHeader{Total: 5, Hash: randhash}}
+		PartSetHeader: tmproto.PartSetHeader{Total: 5, Hash: randhash}}
 	block2 := tmproto.BlockID{Hash: randhash,
-		PartsHeader: tmproto.PartSetHeader{Total: 10, Hash: randhash}}
+		PartSetHeader: tmproto.PartSetHeader{Total: 10, Hash: randhash}}
 	cblock1 := tmproto.CanonicalBlockID{Hash: randhash,
-		PartsHeader: tmproto.CanonicalPartSetHeader{Total: 5, Hash: randhash}}
+		PartSetHeader: tmproto.CanonicalPartSetHeader{Total: 5, Hash: randhash}}
 	cblock2 := tmproto.CanonicalBlockID{Hash: randhash,
-		PartsHeader: tmproto.CanonicalPartSetHeader{Total: 10, Hash: randhash}}
+		PartSetHeader: tmproto.CanonicalPartSetHeader{Total: 10, Hash: randhash}}
 
 	tests := []struct {
 		name string

types/evidence_test.go

@@ -294,7 +294,7 @@ func TestConflictingHeadersEvidence(t *testing.T) {
 
 	commit1, err := MakeCommit(BlockID{
 		Hash: header1.Hash(),
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 100,
 			Hash:  crypto.CRandBytes(tmhash.Size),
 		},
@@ -302,7 +302,7 @@ func TestConflictingHeadersEvidence(t *testing.T) {
 	require.NoError(t, err)
 	commit2, err := MakeCommit(BlockID{
 		Hash: header2.Hash(),
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 100,
 			Hash:  crypto.CRandBytes(tmhash.Size),
 		},
@@ -607,7 +607,7 @@ func TestEvidenceProto(t *testing.T) {
 
 	commit1, err := MakeCommit(BlockID{
 		Hash: header1.Hash(),
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 100,
 			Hash:  crypto.CRandBytes(tmhash.Size),
 		},
@@ -615,7 +615,7 @@ func TestEvidenceProto(t *testing.T) {
 	require.NoError(t, err)
 	commit2, err := MakeCommit(BlockID{
 		Hash: header2.Hash(),
-		PartsHeader: PartSetHeader{
+		PartSetHeader: PartSetHeader{
 			Total: 100,
 			Hash:  crypto.CRandBytes(tmhash.Size),
 		},

types/part_set.go

@@ -104,7 +104,7 @@ func (psh PartSetHeader) Equals(other PartSetHeader) bool {
 
 // ValidateBasic performs basic validation.
 func (psh PartSetHeader) ValidateBasic() error {
-	// Hash can be empty in case of POLBlockID.PartsHeader in Proposal.
+	// Hash can be empty in case of POLBlockID.PartSetHeader in Proposal.
 	if err := ValidateHash(psh.Hash); err != nil {
 		return fmt.Errorf("wrong Hash: %w", err)
 	}

types/proposal_test.go

@@ -29,7 +29,7 @@ func init() {
 		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")}},
+			PartSetHeader: PartSetHeader{Total: 111, Hash: []byte("--June_15_2020_amino_was_removed")}},
 		POLRound:  -1,
 		Timestamp: stamp,
 	}

types/protobuf.go

@@ -71,16 +71,16 @@ func (tm2pb) Validator(val *Validator) abci.Validator {
 	}
 }
 
-func (tm2pb) BlockID(blockID BlockID) abci.BlockID {
-	return abci.BlockID{
-		Hash:        blockID.Hash,
-		PartsHeader: TM2PB.PartSetHeader(blockID.PartsHeader),
+func (tm2pb) BlockID(blockID BlockID) tmproto.BlockID {
+	return tmproto.BlockID{
+		Hash:          blockID.Hash,
+		PartSetHeader: TM2PB.PartSetHeader(blockID.PartSetHeader),
 	}
 }
 
-func (tm2pb) PartSetHeader(header PartSetHeader) abci.PartSetHeader {
-	return abci.PartSetHeader{
-		Total: int32(header.Total),
+func (tm2pb) PartSetHeader(header PartSetHeader) tmproto.PartSetHeader {
+	return tmproto.PartSetHeader{
+		Total: header.Total,
 		Hash:  header.Hash,
 	}
 }

types/vote_set_test.go

@@ -176,7 +176,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 
 	blockHash := crypto.CRandBytes(32)
 	blockPartsTotal := uint32(123)
-	blockPartsHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
+	blockPartSetHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
 
 	voteProto := &Vote{
 		ValidatorAddress: nil, // NOTE: must fill in
@@ -185,7 +185,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		Round:            round,
 		Timestamp:        tmtime.Now(),
 		Type:             tmproto.PrevoteType,
-		BlockID:          BlockID{blockHash, blockPartsHeader},
+		BlockID:          BlockID{blockHash, blockPartSetHeader},
 	}
 
 	// 66 out of 100 voted for nil.
@@ -221,7 +221,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		addr := pubKey.Address()
 		vote := withValidator(voteProto, addr, 67)
 		blockPartsHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
-		_, err = signAddVote(privValidators[67], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		_, err = signAddVote(privValidators[67], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
 		assert.False(t, ok || !blockID.IsZero(),
@@ -234,8 +234,8 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		require.NoError(t, err)
 		addr := pubKey.Address()
 		vote := withValidator(voteProto, addr, 68)
-		blockPartsHeader := PartSetHeader{blockPartsTotal + 1, blockPartsHeader.Hash}
-		_, err = signAddVote(privValidators[68], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		blockPartsHeader := PartSetHeader{blockPartsTotal + 1, blockPartSetHeader.Hash}
+		_, err = signAddVote(privValidators[68], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
 		assert.False(t, ok || !blockID.IsZero(),
@@ -255,7 +255,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 			"there should be no 2/3 majority: last vote added had different BlockHash")
 	}
 
-	// 71st validator voted for the right BlockHash & BlockPartsHeader
+	// 71st validator voted for the right BlockHash & BlockPartSetHeader
 	{
 		pubKey, err := privValidators[70].GetPubKey()
 		require.NoError(t, err)
@@ -264,7 +264,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		_, err = signAddVote(privValidators[70], vote, voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.True(t, ok && blockID.Equals(BlockID{blockHash, blockPartsHeader}),
+		assert.True(t, ok && blockID.Equals(BlockID{blockHash, blockPartSetHeader}),
 			"there should be 2/3 majority")
 	}
 }
@@ -398,7 +398,7 @@ func TestVoteSet_Conflicts(t *testing.T) {
 func TestVoteSet_MakeCommit(t *testing.T) {
 	height, round := int64(1), int32(0)
 	voteSet, _, privValidators := randVoteSet(height, round, tmproto.PrecommitType, 10, 1)
-	blockHash, blockPartsHeader := crypto.CRandBytes(32), PartSetHeader{123, crypto.CRandBytes(32)}
+	blockHash, blockPartSetHeader := crypto.CRandBytes(32), PartSetHeader{123, crypto.CRandBytes(32)}
 
 	voteProto := &Vote{
 		ValidatorAddress: nil,
@@ -407,7 +407,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
 		Round:            round,
 		Timestamp:        tmtime.Now(),
 		Type:             tmproto.PrecommitType,
-		BlockID:          BlockID{blockHash, blockPartsHeader},
+		BlockID:          BlockID{blockHash, blockPartSetHeader},
 	}
 
 	// 6 out of 10 voted for some block.
@@ -432,7 +432,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
 		addr := pv.Address()
 		vote := withValidator(voteProto, addr, 6)
 		vote = withBlockHash(vote, tmrand.Bytes(32))
-		vote = withBlockPartsHeader(vote, PartSetHeader{123, tmrand.Bytes(32)})
+		vote = withBlockPartSetHeader(vote, PartSetHeader{123, tmrand.Bytes(32)})
 
 		_, err = signAddVote(privValidators[6], vote, voteSet)
 		require.NoError(t, err)
@@ -560,8 +560,8 @@ func withBlockHash(vote *Vote, blockHash []byte) *Vote {
 }
 
 // Convenience: Return new vote with different blockParts
-func withBlockPartsHeader(vote *Vote, blockPartsHeader PartSetHeader) *Vote {
+func withBlockPartSetHeader(vote *Vote, blockPartsHeader PartSetHeader) *Vote {
 	vote = vote.Copy()
-	vote.BlockID.PartsHeader = blockPartsHeader
+	vote.BlockID.PartSetHeader = blockPartsHeader
 	return vote
 }

types/vote_test.go

@@ -37,7 +37,7 @@ func exampleVote(t byte) *Vote {
 		Timestamp: stamp,
 		BlockID: BlockID{
 			Hash: tmhash.Sum([]byte("blockID_hash")),
-			PartsHeader: PartSetHeader{
+			PartSetHeader: PartSetHeader{
 				Total: 1000000,
 				Hash:  tmhash.Sum([]byte("blockID_part_set_header_hash")),
 			},
@@ -232,7 +232,7 @@ func TestMaxVoteBytes(t *testing.T) {
 		Type:             tmproto.PrevoteType,
 		BlockID: BlockID{
 			Hash: tmhash.Sum([]byte("blockID_hash")),
-			PartsHeader: PartSetHeader{
+			PartSetHeader: PartSetHeader{
 				Total: math.MaxInt32,
 				Hash:  tmhash.Sum([]byte("blockID_part_set_header_hash")),
 			},