diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index ac259c55f..0d62b6e91 100644 --- a/CHANGELOG_PENDING.md +++ b/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 diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index 52fc3726b..aea2ad00a 100644 --- a/abci/types/types.pb.go +++ b/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 diff --git a/blockchain/v0/reactor.go b/blockchain/v0/reactor.go index 8d809c2c0..f2a19c0ef 100644 --- a/blockchain/v0/reactor.go +++ b/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 diff --git a/blockchain/v0/reactor_test.go b/blockchain/v0/reactor_test.go index f8c231544..46cb60fbb 100644 --- a/blockchain/v0/reactor_test.go +++ b/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 { diff --git a/blockchain/v1/reactor.go b/blockchain/v1/reactor.go index 3a61916e4..060d05635 100644 --- a/blockchain/v1/reactor.go +++ b/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 diff --git a/blockchain/v1/reactor_test.go b/blockchain/v1/reactor_test.go index 4d65c11b0..e76779e72 100644 --- a/blockchain/v1/reactor_test.go +++ b/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 { diff --git a/blockchain/v2/processor.go b/blockchain/v2/processor.go index 539c6c88e..d4b2c637b 100644 --- a/blockchain/v2/processor.go +++ b/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 { diff --git a/blockchain/v2/reactor_test.go b/blockchain/v2/reactor_test.go index 59b29d34d..7a2f48795 100644 --- a/blockchain/v2/reactor_test.go +++ b/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 { diff --git a/consensus/byzantine_test.go b/consensus/byzantine_test.go index c7ff8c1a0..e4792fe07 100644 --- a/consensus/byzantine_test.go +++ b/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 { diff --git a/consensus/common_test.go b/consensus/common_test.go index ecdbadb0f..ff43af3b2 100644 --- a/consensus/common_test.go +++ b/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 { diff --git a/consensus/msgs.go b/consensus/msgs.go index c218da6c8..86843e7dd 100644 --- a/consensus/msgs.go +++ b/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) diff --git a/consensus/msgs_test.go b/consensus/msgs_test.go index b4cfbcd89..759503b60 100644 --- a/consensus/msgs_test.go +++ b/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}, diff --git a/consensus/reactor.go b/consensus/reactor.go index b35d5e5f3..84e6c03f1 100644 --- a/consensus/reactor.go +++ b/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) } //------------------------------------- diff --git a/consensus/reactor_test.go b/consensus/reactor_test.go index 57aec1f3b..952b10cd2 100644 --- a/consensus/reactor_test.go +++ b/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"}, } diff --git a/consensus/replay.go b/consensus/replay.go index 47f3edcd9..1cf4fc425 100644 --- a/consensus/replay.go +++ b/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: diff --git a/consensus/replay_test.go b/consensus/replay_test.go index 01156e8ce..cd04fdf78 100644 --- a/consensus/replay_test.go +++ b/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, } } diff --git a/consensus/state.go b/consensus/state.go index 6b446db7e..c9e32b65d 100644 --- a/consensus/state.go +++ b/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) diff --git a/consensus/state_test.go b/consensus/state_test.go index 0bc07e152..55ebf689f 100644 --- a/consensus/state_test.go +++ b/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) diff --git a/consensus/types/height_vote_set_test.go b/consensus/types/height_vote_set_test.go index 774badda4..c9bba1b75 100644 --- a/consensus/types/height_vote_set_test.go +++ b/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() diff --git a/consensus/types/peer_round_state.go b/consensus/types/peer_round_state.go index 38ec526ce..07283c5b4 100644 --- a/consensus/types/peer_round_state.go +++ b/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, diff --git a/consensus/types/round_state.go b/consensus/types/round_state.go index 532afeac0..9e67b76c0 100644 --- a/consensus/types/round_state.go +++ b/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{ diff --git a/evidence/pool_test.go b/evidence/pool_test.go index d028c657b..9bb03db1d 100644 --- a/evidence/pool_test.go +++ b/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"), }, diff --git a/light/helpers_test.go b/light/helpers_test.go index 7348ca601..f96d4a2dd 100644 --- a/light/helpers_test.go +++ b/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. diff --git a/privval/file_test.go b/privval/file_test.go index 23f215411..2d60cf816 100644 --- a/privval/file_test.go +++ b/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) diff --git a/privval/signer_client_test.go b/privval/signer_client_test.go index f0a2be9f2..a7708091c 100644 --- a/privval/signer_client_test.go +++ b/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, diff --git a/proto/abci/types.proto b/proto/abci/types.proto index bcd13131c..3b94899f4 100644 --- a/proto/abci/types.proto +++ b/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; diff --git a/proto/consensus/msgs.pb.go b/proto/consensus/msgs.pb.go index 52a700702..3b05faaff 100644 --- a/proto/consensus/msgs.pb.go +++ b/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 diff --git a/proto/consensus/msgs.proto b/proto/consensus/msgs.proto index db5d5a846..663182b91 100644 --- a/proto/consensus/msgs.proto +++ b/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. diff --git a/proto/types/canonical.pb.go b/proto/types/canonical.pb.go index f4f4fa017..caeda9fbc 100644 --- a/proto/types/canonical.pb.go +++ b/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 diff --git a/proto/types/canonical.proto b/proto/types/canonical.proto index 8ca2f213f..4be38bc0e 100644 --- a/proto/types/canonical.proto +++ b/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 { diff --git a/proto/types/types.pb.go b/proto/types/types.pb.go index 521bd033a..8728cbffc 100644 --- a/proto/types/types.pb.go +++ b/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 diff --git a/proto/types/types.proto b/proto/types/types.proto index 470e8b991..16fdcc225 100644 --- a/proto/types/types.proto +++ b/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]; } // -------------------------------- diff --git a/rpc/client/evidence_test.go b/rpc/client/evidence_test.go index b64753216..45738f5b5 100644 --- a/rpc/client/evidence_test.go +++ b/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, diff --git a/state/execution_test.go b/state/execution_test.go index c37f0d5e8..9d1b4aea2 100644 --- a/state/execution_test.go +++ b/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) diff --git a/state/helpers_test.go b/state/helpers_test.go index 9c3bfc88c..64b89cc4f 100644 --- a/state/helpers_test.go +++ b/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(¶ms)}, } - 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 { diff --git a/state/state_test.go b/state/state_test.go index 3db2f37ed..b05ec19d9 100644 --- a/state/state_test.go +++ b/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) diff --git a/state/validation_test.go b/state/validation_test.go index 808e9d0d4..ba00a9035 100644 --- a/state/validation_test.go +++ b/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"), }, diff --git a/store/store.go b/store/store.go index 333157612..252c2bdf6 100644 --- a/store/store.go +++ b/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++ diff --git a/store/store_test.go b/store/store_test.go index 952fed860..ec6b8552a 100644 --- a/store/store_test.go +++ b/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) { diff --git a/tools/tm-signer-harness/internal/test_harness.go b/tools/tm-signer-harness/internal/test_harness.go index d1018edca..a50c96443 100644 --- a/tools/tm-signer-harness/internal/test_harness.go +++ b/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, }, diff --git a/types/block.go b/types/block.go index 3356fd526..a07235ace 100644 --- a/types/block.go +++ b/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() diff --git a/types/block_meta_test.go b/types/block_meta_test.go index 3de643210..3ab750fef 100644 --- a/types/block_meta_test.go +++ b/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, diff --git a/types/block_test.go b/types/block_test.go index 860aa3f0b..afb5803d6 100644 --- a/types/block_test.go +++ b/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") }) diff --git a/types/canonical.go b/types/canonical.go index 7347bd99a..291580840 100644 --- a/types/canonical.go +++ b/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), } } diff --git a/types/canonical_test.go b/types/canonical_test.go index 3b17e2d76..74a7ae569 100644 --- a/types/canonical_test.go +++ b/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 diff --git a/types/evidence_test.go b/types/evidence_test.go index 336ba96c2..d4b77de94 100644 --- a/types/evidence_test.go +++ b/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), }, diff --git a/types/part_set.go b/types/part_set.go index afa292b16..d99812591 100644 --- a/types/part_set.go +++ b/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) } diff --git a/types/proposal_test.go b/types/proposal_test.go index f3bdb750f..68a6fda68 100644 --- a/types/proposal_test.go +++ b/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, } diff --git a/types/protobuf.go b/types/protobuf.go index d48af0de9..a9935cea5 100644 --- a/types/protobuf.go +++ b/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, } } diff --git a/types/vote_set_test.go b/types/vote_set_test.go index 30aa0be8c..de6419877 100644 --- a/types/vote_set_test.go +++ b/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 } diff --git a/types/vote_test.go b/types/vote_test.go index 902fdaa09..57fb2c1f1 100644 --- a/types/vote_test.go +++ b/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")), },