mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-07-19 22:42:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

types: rename partsheader to partsetheader (#5029)

Browse Source 
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
This commit is contained in:
Marko
2020-06-22 09:38:03 +02:00
committed by GitHub
parent dc87c09d93
commit 51da4fe356
51 changed files with 587 additions and 1032 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CHANGELOG_PENDING.md
+1
View File
@@ -52,6 +52,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
- [types] \#4852 Vote & Proposal `SignBytes` is now func `VoteSignBytes` & `ProposalSignBytes`
- [privval] \#4985 `privval` reactor migration to Protobuf encoding
- [evidence] \#4949 `evidence` reactor migration to Protobuf encoding
- [types] \#5029 Rename all values from `PartsHeader` to `PartSetHeader` to have consistency
- Apps
abci/types/types.pb.go
+173 -614
View File
@@ -2767,110 +2767,6 @@ func (m *TxResult) GetResult() ResponseDeliverTx {
return ResponseDeliverTx{}
}
type BlockID struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
}
func (m *BlockID) Reset() { *m = BlockID{} }
func (m *BlockID) String() string { return proto.CompactTextString(m) }
func (*BlockID) ProtoMessage() {}
func (*BlockID) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{39}
}
func (m *BlockID) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BlockID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BlockID.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *BlockID) XXX_Merge(src proto.Message) {
xxx_messageInfo_BlockID.Merge(m, src)
}
func (m *BlockID) XXX_Size() int {
return m.Size()
}
func (m *BlockID) XXX_DiscardUnknown() {
xxx_messageInfo_BlockID.DiscardUnknown(m)
}
var xxx_messageInfo_BlockID proto.InternalMessageInfo
func (m *BlockID) GetHash() []byte {
if m != nil {
return m.Hash
}
return nil
}
func (m *BlockID) GetPartsHeader() PartSetHeader {
if m != nil {
return m.PartsHeader
}
return PartSetHeader{}
}
type PartSetHeader struct {
Total int32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}
func (m *PartSetHeader) Reset() { *m = PartSetHeader{} }
func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
func (*PartSetHeader) ProtoMessage() {}
func (*PartSetHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{40}
}
func (m *PartSetHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *PartSetHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_PartSetHeader.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *PartSetHeader) XXX_Merge(src proto.Message) {
xxx_messageInfo_PartSetHeader.Merge(m, src)
}
func (m *PartSetHeader) XXX_Size() int {
return m.Size()
}
func (m *PartSetHeader) XXX_DiscardUnknown() {
xxx_messageInfo_PartSetHeader.DiscardUnknown(m)
}
var xxx_messageInfo_PartSetHeader proto.InternalMessageInfo
func (m *PartSetHeader) GetTotal() int32 {
if m != nil {
return m.Total
}
return 0
}
func (m *PartSetHeader) GetHash() []byte {
if m != nil {
return m.Hash
}
return nil
}
// Validator
type Validator struct {
Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
@@ -2882,7 +2778,7 @@ func (m *Validator) Reset() { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{41}
return fileDescriptor_5056eb770c93415b, []int{39}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2935,7 +2831,7 @@ func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} }
func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) }
func (*ValidatorUpdate) ProtoMessage() {}
func (*ValidatorUpdate) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{42}
return fileDescriptor_5056eb770c93415b, []int{40}
}
func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2988,7 +2884,7 @@ func (m *VoteInfo) Reset() { *m = VoteInfo{} }
func (m *VoteInfo) String() string { return proto.CompactTextString(m) }
func (*VoteInfo) ProtoMessage() {}
func (*VoteInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{43}
return fileDescriptor_5056eb770c93415b, []int{41}
}
func (m *VoteInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3043,7 +2939,7 @@ func (m *Evidence) Reset() { *m = Evidence{} }
func (m *Evidence) String() string { return proto.CompactTextString(m) }
func (*Evidence) ProtoMessage() {}
func (*Evidence) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{44}
return fileDescriptor_5056eb770c93415b, []int{42}
}
func (m *Evidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3119,7 +3015,7 @@ func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (*Snapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_5056eb770c93415b, []int{45}
return fileDescriptor_5056eb770c93415b, []int{43}
}
func (m *Snapshot) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3226,8 +3122,6 @@ func init() {
proto.RegisterType((*EventAttribute)(nil), "tendermint.abci.types.EventAttribute")
proto.RegisterType((*Event)(nil), "tendermint.abci.types.Event")
proto.RegisterType((*TxResult)(nil), "tendermint.abci.types.TxResult")
proto.RegisterType((*BlockID)(nil), "tendermint.abci.types.BlockID")
proto.RegisterType((*PartSetHeader)(nil), "tendermint.abci.types.PartSetHeader")
proto.RegisterType((*Validator)(nil), "tendermint.abci.types.Validator")
proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.types.ValidatorUpdate")
proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.types.VoteInfo")
@@ -3238,176 +3132,173 @@ func init() {
func init() { proto.RegisterFile("proto/abci/types.proto", fileDescriptor_5056eb770c93415b) }
var fileDescriptor_5056eb770c93415b = []byte{
// 2704 bytes of a gzipped FileDescriptorProto
// 2650 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x73, 0x1b, 0xc7,
0x11, 0xc6, 0x02, 0x20, 0x1e, 0x0d, 0x02, 0x04, 0x47, 0xb2, 0x0c, 0x23, 0x36, 0xa9, 0xac, 0x2c,
0x59, 0x7e, 0x04, 0xb4, 0xe9, 0x2a, 0x97, 0x1d, 0x39, 0x71, 0x08, 0x8a, 0x0a, 0x18, 0xc9, 0x22,
0xbd, 0x24, 0x15, 0x3b, 0xa9, 0xf2, 0x66, 0xb0, 0x3b, 0x04, 0xd6, 0x04, 0x76, 0xd7, 0xbb, 0x03,
0x9a, 0x48, 0xe5, 0x90, 0xca, 0x25, 0x95, 0x9b, 0xf2, 0x03, 0xf2, 0x1f, 0x72, 0x48, 0x95, 0xf3,
0x11, 0xc6, 0x02, 0x20, 0x1e, 0x4d, 0x02, 0x04, 0x47, 0xb2, 0x0c, 0x23, 0x36, 0xa9, 0xac, 0x2c,
0x59, 0x7e, 0x04, 0xb4, 0xe9, 0x2a, 0x97, 0x1d, 0x29, 0x71, 0x08, 0x8a, 0x0a, 0x18, 0xc9, 0x22,
0xb5, 0x24, 0x15, 0x39, 0xa9, 0xf2, 0x66, 0xb0, 0x3b, 0x04, 0xd6, 0x04, 0x76, 0xd7, 0xbb, 0x03,
0x8a, 0x48, 0xe5, 0x90, 0xca, 0x25, 0x95, 0x9b, 0xf2, 0x03, 0xf2, 0x1f, 0x72, 0x48, 0x95, 0xf3,
0x07, 0x52, 0xe5, 0xca, 0xc9, 0xc7, 0x9c, 0x9c, 0x94, 0x94, 0x53, 0xf2, 0x1f, 0x52, 0xa9, 0x79,
0xec, 0x0b, 0xc4, 0x63, 0xe1, 0xe8, 0x96, 0xdb, 0x4c, 0x6f, 0x77, 0xcf, 0x4c, 0xcf, 0x4c, 0xf7,
0xd7, 0x3d, 0x0b, 0xd7, 0x5c, 0xcf, 0xa1, 0xce, 0x16, 0xee, 0x1a, 0xd6, 0x16, 0x1d, 0xbb, 0xc4,
0x6f, 0x71, 0x02, 0x7a, 0x8e, 0x12, 0xdb, 0x24, 0xde, 0xd0, 0xb2, 0x69, 0x8b, 0x7d, 0x6c, 0xf1,
0x8f, 0xcd, 0x4d, 0xc1, 0x6e, 0x78, 0x63, 0x97, 0x3a, 0x5b, 0x43, 0xe2, 0x9d, 0x0d, 0x48, 0x5c,
0xae, 0xf9, 0xbc, 0x60, 0xe0, 0xa4, 0xc4, 0x87, 0x97, 0x12, 0x92, 0x67, 0x64, 0x9c, 0xfc, 0xdc,
0x88, 0xcb, 0xb9, 0xd8, 0xc3, 0xc3, 0xe0, 0xcb, 0x66, 0xcf, 0x71, 0x7a, 0x03, 0xb2, 0xc5, 0x7b,
0xdd, 0xd1, 0xe9, 0x16, 0xb5, 0x86, 0xc4, 0xa7, 0x78, 0xe8, 0x4a, 0x86, 0x5b, 0xb4, 0x6f, 0x79,
0xa6, 0xee, 0x62, 0x8f, 0x8e, 0x05, 0xd7, 0x56, 0xcf, 0xe9, 0x39, 0x51, 0x4b, 0xf0, 0xa9, 0xff,
0x2e, 0x41, 0x51, 0x23, 0x9f, 0x8f, 0x88, 0x4f, 0xd1, 0xbb, 0x90, 0x27, 0x46, 0xdf, 0x69, 0x64,
0xaf, 0x2b, 0xb7, 0x2b, 0xdb, 0x6a, 0x6b, 0xea, 0x6a, 0x5b, 0x92, 0x7b, 0xcf, 0xe8, 0x3b, 0x9d,
0x8c, 0xc6, 0x25, 0xd0, 0x1d, 0x58, 0x39, 0x1d, 0x8c, 0xfc, 0x7e, 0x23, 0xc7, 0x45, 0x6f, 0xcc,
0x17, 0xbd, 0xc7, 0x58, 0x3b, 0x19, 0x4d, 0xc8, 0xb0, 0x61, 0x2d, 0xfb, 0xd4, 0x69, 0xe4, 0xd3,
0x0c, 0xbb, 0x6f, 0x9f, 0xf2, 0x61, 0x99, 0x04, 0xea, 0x00, 0xf8, 0x84, 0xea, 0x8e, 0x4b, 0x2d,
0xc7, 0x6e, 0xac, 0x70, 0xf9, 0x57, 0xe6, 0xcb, 0x1f, 0x11, 0x7a, 0xc0, 0xd9, 0x3b, 0x19, 0xad,
0xec, 0x07, 0x1d, 0xa6, 0xc9, 0xb2, 0x2d, 0xaa, 0x1b, 0x7d, 0x6c, 0xd9, 0x8d, 0x42, 0x1a, 0x4d,
0xfb, 0xb6, 0x45, 0x77, 0x19, 0x3b, 0xd3, 0x64, 0x05, 0x1d, 0x66, 0x8a, 0xcf, 0x47, 0xc4, 0x1b,
0x37, 0x8a, 0x69, 0x4c, 0xf1, 0x11, 0x63, 0x65, 0xa6, 0xe0, 0x32, 0xe8, 0x3e, 0x54, 0xba, 0xa4,
0x67, 0xd9, 0x7a, 0x77, 0xe0, 0x18, 0x67, 0x8d, 0x12, 0x57, 0x71, 0x7b, 0xbe, 0x8a, 0x36, 0x13,
0x68, 0x33, 0xfe, 0x4e, 0x46, 0x83, 0x6e, 0xd8, 0x43, 0x6d, 0x28, 0x19, 0x7d, 0x62, 0x9c, 0xe9,
0xf4, 0xa2, 0x51, 0xe6, 0x9a, 0x6e, 0xce, 0xd7, 0xb4, 0xcb, 0xb8, 0x8f, 0x2f, 0x3a, 0x19, 0xad,
0x68, 0x88, 0x26, 0xb3, 0x8b, 0x49, 0x06, 0xd6, 0x39, 0xf1, 0x98, 0x96, 0x2b, 0x69, 0xec, 0x72,
0x57, 0xf0, 0x73, 0x3d, 0x65, 0x33, 0xe8, 0xa0, 0x3d, 0x28, 0x13, 0xdb, 0x94, 0x0b, 0xab, 0x70,
0x45, 0xb7, 0x16, 0x9c, 0x30, 0xdb, 0x0c, 0x96, 0x55, 0x22, 0xb2, 0x8d, 0x7e, 0x08, 0x05, 0xc3,
0x19, 0x0e, 0x2d, 0xda, 0x58, 0xe5, 0x3a, 0x5e, 0x5e, 0xb0, 0x24, 0xce, 0xdb, 0xc9, 0x68, 0x52,
0x0a, 0x1d, 0x43, 0x6d, 0x60, 0xf9, 0x54, 0xf7, 0x6d, 0xec, 0xfa, 0x7d, 0x87, 0xfa, 0x8d, 0x2a,
0xd7, 0xf3, 0xfa, 0x7c, 0x3d, 0x0f, 0x2c, 0x9f, 0x1e, 0x05, 0x22, 0x9d, 0x8c, 0x56, 0x1d, 0xc4,
0x09, 0x4c, 0xab, 0x73, 0x7a, 0x4a, 0xbc, 0x50, 0x6d, 0xa3, 0x96, 0x46, 0xeb, 0x01, 0x93, 0x09,
0xb4, 0x30, 0xad, 0x4e, 0x9c, 0x80, 0x30, 0x5c, 0x19, 0x38, 0xd8, 0x0c, 0x95, 0xea, 0x46, 0x7f,
0x64, 0x9f, 0x35, 0xd6, 0xb8, 0xea, 0xad, 0x05, 0x13, 0x76, 0xb0, 0x19, 0x28, 0xda, 0x65, 0x62,
0x9d, 0x8c, 0xb6, 0x3e, 0x98, 0x24, 0x22, 0x13, 0xae, 0x62, 0xd7, 0x1d, 0x8c, 0x27, 0xc7, 0xa8,
0xf3, 0x31, 0xde, 0x9c, 0x3f, 0xc6, 0x0e, 0x93, 0x9c, 0x1c, 0x04, 0xe1, 0x4b, 0xd4, 0x76, 0x11,
0x56, 0xce, 0xf1, 0x60, 0x44, 0xd4, 0x57, 0xa0, 0x12, 0x73, 0x1f, 0xa8, 0x01, 0xc5, 0x21, 0xf1,
0x7d, 0xdc, 0x23, 0x0d, 0xe5, 0xba, 0x72, 0xbb, 0xac, 0x05, 0x5d, 0xb5, 0x06, 0xab, 0x71, 0x67,
0xa1, 0x0e, 0x43, 0x41, 0xe6, 0x00, 0x98, 0xe0, 0x39, 0xf1, 0x7c, 0x76, 0xeb, 0xa5, 0xa0, 0xec,
0xa2, 0x1b, 0x50, 0xe5, 0x47, 0x4c, 0x0f, 0xbe, 0x33, 0x67, 0x96, 0xd7, 0x56, 0x39, 0xf1, 0x91,
0x64, 0xda, 0x84, 0x8a, 0xbb, 0xed, 0x86, 0x2c, 0x39, 0xce, 0x02, 0xee, 0xb6, 0x2b, 0x19, 0xd4,
0xef, 0x43, 0x7d, 0xd2, 0x5f, 0xa0, 0x3a, 0xe4, 0xce, 0xc8, 0x58, 0x8e, 0xc7, 0x9a, 0xe8, 0xaa,
0x5c, 0x16, 0x1f, 0xa3, 0xac, 0xc9, 0x35, 0xfe, 0x31, 0x1b, 0x0a, 0x87, 0x2e, 0x82, 0xf9, 0x38,
0xe6, 0xa1, 0xb9, 0x74, 0x65, 0xbb, 0xd9, 0x12, 0xee, 0xbb, 0x15, 0xb8, 0xef, 0xd6, 0x71, 0xe0,
0xbe, 0xdb, 0xa5, 0xaf, 0xbe, 0xd9, 0xcc, 0x3c, 0xfe, 0xfb, 0xa6, 0xa2, 0x71, 0x09, 0xf4, 0x02,
0xbb, 0xc5, 0xd8, 0xb2, 0x75, 0xcb, 0x94, 0xe3, 0x14, 0x79, 0x7f, 0xdf, 0x44, 0x1f, 0x41, 0xdd,
0x70, 0x6c, 0x9f, 0xd8, 0xfe, 0xc8, 0xd7, 0x45, 0x78, 0x90, 0x0e, 0x78, 0xd6, 0xcd, 0xda, 0x0d,
0xd8, 0x0f, 0x39, 0xb7, 0xb6, 0x66, 0x24, 0x09, 0xe8, 0x01, 0xc0, 0x39, 0x1e, 0x58, 0x26, 0xa6,
0x8e, 0xe7, 0x37, 0xf2, 0xd7, 0x73, 0x73, 0x94, 0x3d, 0x0a, 0x18, 0x4f, 0x5c, 0x13, 0x53, 0xd2,
0xce, 0xb3, 0x99, 0x6b, 0x31, 0x79, 0x74, 0x0b, 0xd6, 0xb0, 0xeb, 0xea, 0x3e, 0xc5, 0x94, 0xe8,
0xdd, 0x31, 0x25, 0x3e, 0x77, 0xd2, 0xab, 0x5a, 0x15, 0xbb, 0xee, 0x11, 0xa3, 0xb6, 0x19, 0x51,
0x35, 0xc3, 0xdd, 0xe6, 0xfe, 0x10, 0x21, 0xc8, 0x9b, 0x98, 0x62, 0x6e, 0xad, 0x55, 0x8d, 0xb7,
0x19, 0xcd, 0xc5, 0xb4, 0x2f, 0x6d, 0xc0, 0xdb, 0xe8, 0x1a, 0x14, 0xfa, 0xc4, 0xea, 0xf5, 0x29,
0x5f, 0x76, 0x4e, 0x93, 0x3d, 0xb6, 0x31, 0xae, 0xe7, 0x9c, 0x13, 0x1e, 0x52, 0x4a, 0x9a, 0xe8,
0xa8, 0x8f, 0xb3, 0xb0, 0x7e, 0xc9, 0x67, 0x32, 0xbd, 0x7d, 0xec, 0xf7, 0x83, 0xb1, 0x58, 0x1b,
0xbd, 0xc3, 0xf4, 0x62, 0x93, 0x78, 0x32, 0x14, 0x36, 0xe2, 0x16, 0x10, 0x8b, 0xef, 0xf0, 0xef,
0x72, 0xcd, 0x92, 0x1b, 0x9d, 0x40, 0x7d, 0x80, 0x7d, 0xaa, 0x0b, 0x5f, 0xa3, 0xf3, 0xa8, 0x96,
0x9b, 0xeb, 0x79, 0x1f, 0xe0, 0xc0, 0x47, 0xb1, 0x73, 0x2d, 0xd5, 0xd5, 0x06, 0x09, 0x2a, 0xfa,
0x18, 0xae, 0x76, 0xc7, 0xbf, 0xc4, 0x36, 0xb5, 0x6c, 0xa2, 0x5f, 0xda, 0x9e, 0xcd, 0x19, 0xaa,
0xf7, 0xce, 0x2d, 0x93, 0xd8, 0x46, 0xb0, 0x2f, 0x57, 0x42, 0x15, 0xe1, 0xbe, 0xf9, 0xea, 0xc7,
0x50, 0x4b, 0xfa, 0x7e, 0x54, 0x83, 0x2c, 0xbd, 0x90, 0xc6, 0xc8, 0xd2, 0x0b, 0xf4, 0x0e, 0xe4,
0x99, 0x3a, 0x6e, 0x88, 0xda, 0xcc, 0xe0, 0x2c, 0xa5, 0x8f, 0xc7, 0x2e, 0xd1, 0x38, 0xbf, 0xaa,
0x86, 0x97, 0x20, 0x8c, 0x07, 0x93, 0xba, 0xd5, 0x57, 0x61, 0x6d, 0xc2, 0xd5, 0xc7, 0x76, 0x54,
0x89, 0xef, 0xa8, 0xba, 0x06, 0xd5, 0x84, 0x47, 0x57, 0xaf, 0xc1, 0xd5, 0x69, 0xae, 0x59, 0xb5,
0x43, 0x7a, 0xc2, 0xb9, 0xa2, 0x3b, 0x50, 0x0a, 0x7d, 0xb3, 0xb8, 0x84, 0xb3, 0xec, 0x16, 0x88,
0x68, 0xa1, 0x00, 0xbb, 0x83, 0xec, 0x1c, 0xf3, 0x73, 0x92, 0xe5, 0xd3, 0x2f, 0x62, 0xd7, 0xed,
0x60, 0xbf, 0xaf, 0xfe, 0x02, 0x1a, 0xb3, 0x3c, 0xee, 0xc4, 0x62, 0xf2, 0xe1, 0xf1, 0xbc, 0x06,
0x85, 0x53, 0xc7, 0x1b, 0x62, 0xca, 0x95, 0x55, 0x35, 0xd9, 0x63, 0xc7, 0x56, 0x78, 0xdf, 0x1c,
0x27, 0x8b, 0x8e, 0xaa, 0xc3, 0x0b, 0x33, 0xfd, 0x2d, 0x13, 0xb1, 0x6c, 0x93, 0x08, 0xab, 0x56,
0x35, 0xd1, 0x89, 0x14, 0x89, 0xc9, 0x8a, 0x0e, 0x1b, 0xd6, 0xe7, 0x2b, 0xe6, 0xfa, 0xcb, 0x9a,
0xec, 0xa9, 0x7f, 0x29, 0x43, 0x49, 0x23, 0xbe, 0xcb, 0x5c, 0x01, 0xea, 0x40, 0x99, 0x5c, 0x18,
0x44, 0x20, 0x2a, 0x65, 0x01, 0xfe, 0x10, 0x32, 0x7b, 0x01, 0x3f, 0x0b, 0xf8, 0xa1, 0x30, 0x7a,
0x2f, 0x81, 0x26, 0x6f, 0x2c, 0x52, 0x12, 0x87, 0x93, 0xef, 0x27, 0xe1, 0xe4, 0xcb, 0x0b, 0x64,
0x27, 0xf0, 0xe4, 0x7b, 0x09, 0x3c, 0xb9, 0x68, 0xe0, 0x04, 0xa0, 0xdc, 0x9f, 0x02, 0x28, 0x17,
0x2d, 0x7f, 0x06, 0xa2, 0xdc, 0x9f, 0x82, 0x28, 0x6f, 0x2f, 0x9c, 0xcb, 0x54, 0x48, 0xf9, 0x7e,
0x12, 0x52, 0x2e, 0x32, 0xc7, 0x04, 0xa6, 0x7c, 0x30, 0x0d, 0x53, 0xbe, 0xba, 0x40, 0xc7, 0x4c,
0x50, 0xb9, 0x7b, 0x09, 0x54, 0xde, 0x5a, 0xa0, 0x6a, 0x0a, 0xaa, 0xdc, 0x4f, 0xa0, 0x4a, 0x48,
0x65, 0x9b, 0x19, 0xb0, 0xf2, 0xde, 0x65, 0x58, 0xf9, 0xca, 0xa2, 0xa3, 0x36, 0x0d, 0x57, 0x7e,
0x30, 0x81, 0x2b, 0x6f, 0x2e, 0x5a, 0xd5, 0x24, 0xb0, 0x3c, 0x99, 0x01, 0x2c, 0xdf, 0x58, 0xa0,
0x68, 0x01, 0xb2, 0x3c, 0x99, 0x81, 0x2c, 0x17, 0xa9, 0x5d, 0x00, 0x2d, 0xbb, 0xf3, 0xa0, 0xe5,
0x9b, 0x8b, 0xa6, 0x9c, 0x0e, 0x5b, 0x92, 0xb9, 0xd8, 0xf2, 0xad, 0x05, 0x83, 0x2c, 0x0f, 0x2e,
0x5f, 0x65, 0xe1, 0x7d, 0xc2, 0x25, 0x31, 0x57, 0x48, 0x3c, 0xcf, 0xf1, 0x24, 0x6e, 0x13, 0x1d,
0xf5, 0x36, 0x03, 0x1c, 0x91, 0xe3, 0x99, 0x03, 0x44, 0x79, 0xe0, 0x89, 0xb9, 0x19, 0xf5, 0xcf,
0xd7, 0x3d, 0x0b, 0x57, 0x5c, 0xcf, 0xa1, 0xce, 0x26, 0xee, 0x18, 0xd6, 0x26, 0x1d, 0xb9, 0xc4,
0x6f, 0x72, 0x02, 0x7a, 0x89, 0x12, 0xdb, 0x24, 0xde, 0xc0, 0xb2, 0x69, 0x93, 0x7d, 0x6c, 0xf2,
0x8f, 0x8d, 0x0d, 0xc1, 0x6e, 0x78, 0x23, 0x97, 0x3a, 0x9b, 0x03, 0xe2, 0x9d, 0xf6, 0x49, 0x5c,
0xae, 0xf1, 0xb2, 0x60, 0xe0, 0xa4, 0xc4, 0x87, 0xd7, 0x12, 0x92, 0xa7, 0x64, 0x94, 0xfc, 0x5c,
0x8f, 0xcb, 0xb9, 0xd8, 0xc3, 0x83, 0xe0, 0xcb, 0x46, 0xd7, 0x71, 0xba, 0x7d, 0xb2, 0xc9, 0x7b,
0x9d, 0xe1, 0xc9, 0x26, 0xb5, 0x06, 0xc4, 0xa7, 0x78, 0xe0, 0x4a, 0x86, 0x1b, 0xb4, 0x67, 0x79,
0xa6, 0xee, 0x62, 0x8f, 0x8e, 0x04, 0xd7, 0x66, 0xd7, 0xe9, 0x3a, 0x51, 0x4b, 0xf0, 0xa9, 0xff,
0x2e, 0x41, 0x51, 0x23, 0x5f, 0x0c, 0x89, 0x4f, 0xd1, 0x87, 0x90, 0x27, 0x46, 0xcf, 0xa9, 0x67,
0xaf, 0x2a, 0x37, 0x97, 0xb7, 0xd4, 0xe6, 0xc4, 0xd5, 0x36, 0x25, 0xf7, 0xae, 0xd1, 0x73, 0xda,
0x19, 0x8d, 0x4b, 0xa0, 0x5b, 0xb0, 0x74, 0xd2, 0x1f, 0xfa, 0xbd, 0x7a, 0x8e, 0x8b, 0x5e, 0x9b,
0x2d, 0x7a, 0x97, 0xb1, 0xb6, 0x33, 0x9a, 0x90, 0x61, 0xc3, 0x5a, 0xf6, 0x89, 0x53, 0xcf, 0xa7,
0x19, 0x76, 0xcf, 0x3e, 0xe1, 0xc3, 0x32, 0x09, 0xd4, 0x06, 0xf0, 0x09, 0xd5, 0x1d, 0x97, 0x5a,
0x8e, 0x5d, 0x5f, 0xe2, 0xf2, 0x6f, 0xcc, 0x96, 0x3f, 0x24, 0x74, 0x9f, 0xb3, 0xb7, 0x33, 0x5a,
0xd9, 0x0f, 0x3a, 0x4c, 0x93, 0x65, 0x5b, 0x54, 0x37, 0x7a, 0xd8, 0xb2, 0xeb, 0x85, 0x34, 0x9a,
0xf6, 0x6c, 0x8b, 0xee, 0x30, 0x76, 0xa6, 0xc9, 0x0a, 0x3a, 0xcc, 0x14, 0x5f, 0x0c, 0x89, 0x37,
0xaa, 0x17, 0xd3, 0x98, 0xe2, 0x21, 0x63, 0x65, 0xa6, 0xe0, 0x32, 0xe8, 0x1e, 0x2c, 0x77, 0x48,
0xd7, 0xb2, 0xf5, 0x4e, 0xdf, 0x31, 0x4e, 0xeb, 0x25, 0xae, 0xe2, 0xe6, 0x6c, 0x15, 0x2d, 0x26,
0xd0, 0x62, 0xfc, 0xed, 0x8c, 0x06, 0x9d, 0xb0, 0x87, 0x5a, 0x50, 0x32, 0x7a, 0xc4, 0x38, 0xd5,
0xe9, 0x79, 0xbd, 0xcc, 0x35, 0x5d, 0x9f, 0xad, 0x69, 0x87, 0x71, 0x1f, 0x9d, 0xb7, 0x33, 0x5a,
0xd1, 0x10, 0x4d, 0x66, 0x17, 0x93, 0xf4, 0xad, 0x33, 0xe2, 0x31, 0x2d, 0x97, 0xd2, 0xd8, 0xe5,
0x8e, 0xe0, 0xe7, 0x7a, 0xca, 0x66, 0xd0, 0x41, 0xbb, 0x50, 0x26, 0xb6, 0x29, 0x17, 0xb6, 0xcc,
0x15, 0xdd, 0x98, 0x73, 0xc2, 0x6c, 0x33, 0x58, 0x56, 0x89, 0xc8, 0x36, 0xfa, 0x21, 0x14, 0x0c,
0x67, 0x30, 0xb0, 0x68, 0x7d, 0x85, 0xeb, 0x78, 0x7d, 0xce, 0x92, 0x38, 0x6f, 0x3b, 0xa3, 0x49,
0x29, 0x74, 0x04, 0xd5, 0xbe, 0xe5, 0x53, 0xdd, 0xb7, 0xb1, 0xeb, 0xf7, 0x1c, 0xea, 0xd7, 0x2b,
0x5c, 0xcf, 0xdb, 0xb3, 0xf5, 0xdc, 0xb7, 0x7c, 0x7a, 0x18, 0x88, 0xb4, 0x33, 0x5a, 0xa5, 0x1f,
0x27, 0x30, 0xad, 0xce, 0xc9, 0x09, 0xf1, 0x42, 0xb5, 0xf5, 0x6a, 0x1a, 0xad, 0xfb, 0x4c, 0x26,
0xd0, 0xc2, 0xb4, 0x3a, 0x71, 0x02, 0xc2, 0x70, 0xa9, 0xef, 0x60, 0x33, 0x54, 0xaa, 0x1b, 0xbd,
0xa1, 0x7d, 0x5a, 0x5f, 0xe5, 0xaa, 0x37, 0xe7, 0x4c, 0xd8, 0xc1, 0x66, 0xa0, 0x68, 0x87, 0x89,
0xb5, 0x33, 0xda, 0x5a, 0x7f, 0x9c, 0x88, 0x4c, 0xb8, 0x8c, 0x5d, 0xb7, 0x3f, 0x1a, 0x1f, 0xa3,
0xc6, 0xc7, 0x78, 0x77, 0xf6, 0x18, 0xdb, 0x4c, 0x72, 0x7c, 0x10, 0x84, 0x2f, 0x50, 0x5b, 0x45,
0x58, 0x3a, 0xc3, 0xfd, 0x21, 0x51, 0xdf, 0x80, 0xe5, 0x98, 0xfb, 0x40, 0x75, 0x28, 0x0e, 0x88,
0xef, 0xe3, 0x2e, 0xa9, 0x2b, 0x57, 0x95, 0x9b, 0x65, 0x2d, 0xe8, 0xaa, 0x55, 0x58, 0x89, 0x3b,
0x0b, 0x75, 0x10, 0x0a, 0x32, 0x07, 0xc0, 0x04, 0xcf, 0x88, 0xe7, 0xb3, 0x5b, 0x2f, 0x05, 0x65,
0x17, 0x5d, 0x83, 0x0a, 0x3f, 0x62, 0x7a, 0xf0, 0x9d, 0x39, 0xb3, 0xbc, 0xb6, 0xc2, 0x89, 0x8f,
0x24, 0xd3, 0x06, 0x2c, 0xbb, 0x5b, 0x6e, 0xc8, 0x92, 0xe3, 0x2c, 0xe0, 0x6e, 0xb9, 0x92, 0x41,
0xfd, 0x3e, 0xd4, 0xc6, 0xfd, 0x05, 0xaa, 0x41, 0xee, 0x94, 0x8c, 0xe4, 0x78, 0xac, 0x89, 0x2e,
0xcb, 0x65, 0xf1, 0x31, 0xca, 0x9a, 0x5c, 0xe3, 0x1f, 0xb3, 0xa1, 0x70, 0xe8, 0x22, 0x98, 0x8f,
0x63, 0x1e, 0x9a, 0x4b, 0x2f, 0x6f, 0x35, 0x9a, 0xc2, 0x7d, 0x37, 0x03, 0xf7, 0xdd, 0x3c, 0x0a,
0xdc, 0x77, 0xab, 0xf4, 0xd5, 0x37, 0x1b, 0x99, 0xa7, 0x7f, 0xdf, 0x50, 0x34, 0x2e, 0x81, 0x5e,
0x61, 0xb7, 0x18, 0x5b, 0xb6, 0x6e, 0x99, 0x72, 0x9c, 0x22, 0xef, 0xef, 0x99, 0xe8, 0x21, 0xd4,
0x0c, 0xc7, 0xf6, 0x89, 0xed, 0x0f, 0x7d, 0x5d, 0x84, 0x07, 0xe9, 0x80, 0xa7, 0xdd, 0xac, 0x9d,
0x80, 0xfd, 0x80, 0x73, 0x6b, 0xab, 0x46, 0x92, 0x80, 0xee, 0x03, 0x9c, 0xe1, 0xbe, 0x65, 0x62,
0xea, 0x78, 0x7e, 0x3d, 0x7f, 0x35, 0x37, 0x43, 0xd9, 0xa3, 0x80, 0xf1, 0xd8, 0x35, 0x31, 0x25,
0xad, 0x3c, 0x9b, 0xb9, 0x16, 0x93, 0x47, 0x37, 0x60, 0x15, 0xbb, 0xae, 0xee, 0x53, 0x4c, 0x89,
0xde, 0x19, 0x51, 0xe2, 0x73, 0x27, 0xbd, 0xa2, 0x55, 0xb0, 0xeb, 0x1e, 0x32, 0x6a, 0x8b, 0x11,
0x55, 0x33, 0xdc, 0x6d, 0xee, 0x0f, 0x11, 0x82, 0xbc, 0x89, 0x29, 0xe6, 0xd6, 0x5a, 0xd1, 0x78,
0x9b, 0xd1, 0x5c, 0x4c, 0x7b, 0xd2, 0x06, 0xbc, 0x8d, 0xae, 0x40, 0xa1, 0x47, 0xac, 0x6e, 0x8f,
0xf2, 0x65, 0xe7, 0x34, 0xd9, 0x63, 0x1b, 0xe3, 0x7a, 0xce, 0x19, 0xe1, 0x21, 0xa5, 0xa4, 0x89,
0x8e, 0xfa, 0x34, 0x0b, 0x6b, 0x17, 0x7c, 0x26, 0xd3, 0xdb, 0xc3, 0x7e, 0x2f, 0x18, 0x8b, 0xb5,
0xd1, 0x07, 0x4c, 0x2f, 0x36, 0x89, 0x27, 0x43, 0x61, 0x3d, 0x6e, 0x01, 0xb1, 0xf8, 0x36, 0xff,
0x2e, 0xd7, 0x2c, 0xb9, 0xd1, 0x31, 0xd4, 0xfa, 0xd8, 0xa7, 0xba, 0xf0, 0x35, 0x3a, 0x8f, 0x6a,
0xb9, 0x99, 0x9e, 0xf7, 0x3e, 0x0e, 0x7c, 0x14, 0x3b, 0xd7, 0x52, 0x5d, 0xb5, 0x9f, 0xa0, 0xa2,
0xc7, 0x70, 0xb9, 0x33, 0xfa, 0x25, 0xb6, 0xa9, 0x65, 0x13, 0xfd, 0xc2, 0xf6, 0x6c, 0x4c, 0x51,
0xbd, 0x7b, 0x66, 0x99, 0xc4, 0x36, 0x82, 0x7d, 0xb9, 0x14, 0xaa, 0x08, 0xf7, 0xcd, 0x57, 0x1f,
0x43, 0x35, 0xe9, 0xfb, 0x51, 0x15, 0xb2, 0xf4, 0x5c, 0x1a, 0x23, 0x4b, 0xcf, 0xd1, 0x07, 0x90,
0x67, 0xea, 0xb8, 0x21, 0xaa, 0x53, 0x83, 0xb3, 0x94, 0x3e, 0x1a, 0xb9, 0x44, 0xe3, 0xfc, 0xaa,
0x1a, 0x5e, 0x82, 0x30, 0x1e, 0x8c, 0xeb, 0x56, 0xdf, 0x84, 0xd5, 0x31, 0x57, 0x1f, 0xdb, 0x51,
0x25, 0xbe, 0xa3, 0xea, 0x2a, 0x54, 0x12, 0x1e, 0x5d, 0xbd, 0x02, 0x97, 0x27, 0xb9, 0x66, 0xd5,
0x0e, 0xe9, 0x09, 0xe7, 0x8a, 0x6e, 0x41, 0x29, 0xf4, 0xcd, 0xe2, 0x12, 0x4e, 0xb3, 0x5b, 0x20,
0xa2, 0x85, 0x02, 0xec, 0x0e, 0xb2, 0x73, 0xcc, 0xcf, 0x49, 0x96, 0x4f, 0xbf, 0x88, 0x5d, 0xb7,
0x8d, 0xfd, 0x9e, 0xfa, 0x0b, 0xa8, 0x4f, 0xf3, 0xb8, 0x63, 0x8b, 0xc9, 0x87, 0xc7, 0xf3, 0x0a,
0x14, 0x4e, 0x1c, 0x6f, 0x80, 0x29, 0x57, 0x56, 0xd1, 0x64, 0x8f, 0x1d, 0x5b, 0xe1, 0x7d, 0x73,
0x9c, 0x2c, 0x3a, 0xaa, 0x0e, 0xaf, 0x4c, 0xf5, 0xb7, 0x4c, 0xc4, 0xb2, 0x4d, 0x22, 0xac, 0x5a,
0xd1, 0x44, 0x27, 0x52, 0x24, 0x26, 0x2b, 0x3a, 0x6c, 0x58, 0x9f, 0xaf, 0x98, 0xeb, 0x2f, 0x6b,
0xb2, 0xa7, 0xfe, 0xa5, 0x0c, 0x25, 0x8d, 0xf8, 0x2e, 0x73, 0x05, 0xa8, 0x0d, 0x65, 0x72, 0x6e,
0x10, 0x81, 0xa8, 0x94, 0x39, 0xf8, 0x43, 0xc8, 0xec, 0x06, 0xfc, 0x2c, 0xe0, 0x87, 0xc2, 0xe8,
0xa3, 0x04, 0x9a, 0xbc, 0x36, 0x4f, 0x49, 0x1c, 0x4e, 0xde, 0x4e, 0xc2, 0xc9, 0xd7, 0xe7, 0xc8,
0x8e, 0xe1, 0xc9, 0x8f, 0x12, 0x78, 0x72, 0xde, 0xc0, 0x09, 0x40, 0xb9, 0x37, 0x01, 0x50, 0xce,
0x5b, 0xfe, 0x14, 0x44, 0xb9, 0x37, 0x01, 0x51, 0xde, 0x9c, 0x3b, 0x97, 0x89, 0x90, 0xf2, 0x76,
0x12, 0x52, 0xce, 0x33, 0xc7, 0x18, 0xa6, 0xbc, 0x3f, 0x09, 0x53, 0xbe, 0x39, 0x47, 0xc7, 0x54,
0x50, 0xb9, 0x73, 0x01, 0x54, 0xde, 0x98, 0xa3, 0x6a, 0x02, 0xaa, 0xdc, 0x4b, 0xa0, 0x4a, 0x48,
0x65, 0x9b, 0x29, 0xb0, 0xf2, 0xee, 0x45, 0x58, 0xf9, 0xc6, 0xbc, 0xa3, 0x36, 0x09, 0x57, 0x7e,
0x3c, 0x86, 0x2b, 0xaf, 0xcf, 0x5b, 0xd5, 0x38, 0xb0, 0x3c, 0x9e, 0x02, 0x2c, 0xdf, 0x99, 0xa3,
0x68, 0x0e, 0xb2, 0x3c, 0x9e, 0x82, 0x2c, 0xe7, 0xa9, 0x9d, 0x03, 0x2d, 0x3b, 0xb3, 0xa0, 0xe5,
0xbb, 0xf3, 0xa6, 0x9c, 0x0e, 0x5b, 0x92, 0x99, 0xd8, 0xf2, 0xbd, 0x39, 0x83, 0x2c, 0x0e, 0x2e,
0xdf, 0x64, 0xe1, 0x7d, 0xcc, 0x25, 0x31, 0x57, 0x48, 0x3c, 0xcf, 0xf1, 0x24, 0x6e, 0x13, 0x1d,
0xf5, 0x26, 0x03, 0x1c, 0x91, 0xe3, 0x99, 0x01, 0x44, 0x79, 0xe0, 0x89, 0xb9, 0x19, 0xf5, 0xcf,
0x4a, 0x24, 0xcb, 0xa3, 0x73, 0x1c, 0xac, 0x94, 0x25, 0x58, 0x89, 0xe1, 0xd3, 0x6c, 0x12, 0x9f,
0x6e, 0x42, 0x85, 0x85, 0x92, 0x09, 0xe8, 0x89, 0xdd, 0x00, 0x7a, 0xa2, 0xd7, 0x60, 0x9d, 0x63,
0x08, 0x81, 0x62, 0x65, 0xfc, 0xc8, 0xf3, 0x60, 0xb8, 0xc6, 0x3e, 0x88, 0xa3, 0x2b, 0x02, 0xc9,
0xf7, 0xe0, 0x4a, 0x8c, 0x37, 0x0c, 0x51, 0x02, 0x63, 0xd5, 0x43, 0xee, 0x1d, 0x19, 0xab, 0x3e,
0x8c, 0x0c, 0x14, 0xc1, 0x5a, 0x04, 0x79, 0xc3, 0x31, 0x89, 0x0c, 0x20, 0xbc, 0xcd, 0xa0, 0xee,
0xc0, 0xe9, 0xc9, 0x30, 0xc1, 0x9a, 0x8c, 0x2b, 0xf4, 0xa9, 0x65, 0xe1, 0x2c, 0xd5, 0x3f, 0x29,
0x91, 0xbe, 0x08, 0xe9, 0x4e, 0x03, 0xa5, 0xca, 0xb3, 0x04, 0xa5, 0xd9, 0xff, 0x0d, 0x94, 0xaa,
0xff, 0x51, 0xa2, 0x2d, 0x0d, 0xe1, 0xe6, 0xb7, 0x33, 0x41, 0x14, 0x7e, 0x57, 0xf8, 0x06, 0xc9,
0xf0, 0x2b, 0x33, 0x85, 0x02, 0xdf, 0x86, 0x64, 0xa6, 0x50, 0x14, 0x01, 0x99, 0x77, 0xd0, 0x07,
0x50, 0x76, 0x3d, 0xc7, 0x39, 0xd5, 0x1d, 0xd7, 0x97, 0x7e, 0x39, 0x01, 0xb0, 0x44, 0x59, 0xa8,
0x25, 0x0a, 0x4a, 0xad, 0x43, 0xc6, 0x7a, 0xe0, 0xfa, 0x5a, 0xc9, 0x95, 0xad, 0x18, 0xc0, 0x28,
0x27, 0xf0, 0xef, 0x8b, 0x50, 0x66, 0x8b, 0xf0, 0x5d, 0x6c, 0x10, 0xee, 0x5e, 0xcb, 0x5a, 0x44,
0x50, 0x4d, 0x40, 0x97, 0xdd, 0x3c, 0x7a, 0x08, 0x05, 0x72, 0x4e, 0x6c, 0xca, 0x76, 0x8b, 0x19,
0xf8, 0xc5, 0x99, 0xb0, 0x92, 0xd8, 0xb4, 0xdd, 0x60, 0x66, 0xfd, 0xd7, 0x37, 0x9b, 0x75, 0x21,
0xf3, 0x86, 0x33, 0xb4, 0x28, 0x19, 0xba, 0x74, 0xac, 0x49, 0x2d, 0xea, 0x6f, 0xb3, 0x0c, 0xdd,
0x25, 0x42, 0xc0, 0x54, 0x43, 0x07, 0xd7, 0x27, 0x1b, 0xc3, 0xfa, 0xe9, 0x8c, 0xff, 0x12, 0x40,
0x0f, 0xfb, 0xfa, 0x17, 0xd8, 0xa6, 0xc4, 0x94, 0x3b, 0x50, 0xee, 0x61, 0xff, 0xa7, 0x9c, 0xc0,
0x40, 0x1b, 0xfb, 0x3c, 0xf2, 0x89, 0xc9, 0xb7, 0x22, 0xa7, 0x15, 0x7b, 0xd8, 0x3f, 0xf1, 0x89,
0x19, 0x5b, 0x6b, 0xf1, 0x59, 0xac, 0x35, 0x69, 0xef, 0xd2, 0xa4, 0xbd, 0x7f, 0x97, 0x8d, 0xee,
0x49, 0x04, 0x86, 0xff, 0x3f, 0x6d, 0xf1, 0x07, 0x9e, 0x1c, 0x27, 0xe3, 0x30, 0xfa, 0x04, 0xd6,
0xc3, 0xfb, 0xa9, 0x8f, 0xf8, 0xbd, 0x0d, 0x4e, 0xe1, 0x72, 0xd7, 0xbc, 0x7e, 0x9e, 0x24, 0xfb,
0xe8, 0x53, 0x78, 0x7e, 0xc2, 0x1b, 0x85, 0x03, 0x64, 0x97, 0x72, 0x4a, 0xcf, 0x25, 0x9d, 0x52,
0xa0, 0x3f, 0xb2, 0x5e, 0xee, 0x99, 0xdc, 0x9a, 0x7d, 0x96, 0x90, 0xc5, 0x11, 0xc6, 0xd4, 0x33,
0x71, 0x03, 0xaa, 0x1e, 0xa1, 0xd8, 0xb2, 0xf5, 0x44, 0xfa, 0xbb, 0x2a, 0x88, 0x22, 0x38, 0xa8,
0x8f, 0xe0, 0xb9, 0xa9, 0x18, 0x03, 0xfd, 0x00, 0xca, 0x11, 0x48, 0x51, 0xe6, 0xe6, 0x90, 0x61,
0x2e, 0x14, 0x49, 0xa8, 0x5f, 0x2a, 0x91, 0xe2, 0x64, 0x8e, 0x75, 0x1f, 0x0a, 0x1e, 0xf1, 0x47,
0x03, 0x91, 0xef, 0xd4, 0xb6, 0xdf, 0x5e, 0x06, 0xa3, 0x30, 0xea, 0x68, 0x40, 0x35, 0xa9, 0x42,
0xfd, 0x08, 0x0a, 0x82, 0x82, 0x00, 0x0a, 0x3b, 0xbb, 0xbb, 0x7b, 0x87, 0xc7, 0xf5, 0x0c, 0x2a,
0xc3, 0xca, 0x4e, 0xfb, 0x40, 0x3b, 0xae, 0x2b, 0x8c, 0xac, 0xed, 0xfd, 0x64, 0x6f, 0xf7, 0xb8,
0x9e, 0x45, 0xeb, 0x50, 0x15, 0x6d, 0xfd, 0xde, 0x81, 0xf6, 0xe1, 0xce, 0x71, 0x3d, 0x17, 0x23,
0x1d, 0xed, 0x3d, 0xbc, 0xbb, 0xa7, 0xd5, 0xf3, 0xea, 0x5b, 0x2c, 0x93, 0x9a, 0x01, 0x61, 0xa2,
0x9c, 0x49, 0x89, 0xe5, 0x4c, 0xea, 0xef, 0xb3, 0xd0, 0x9c, 0x8d, 0x48, 0xd0, 0xe1, 0xc4, 0x8a,
0xdf, 0x5d, 0x1a, 0xd4, 0x4c, 0x2c, 0x1b, 0xdd, 0x84, 0x9a, 0x47, 0x4e, 0x09, 0x35, 0xfa, 0x02,
0x2d, 0x89, 0x78, 0x57, 0xd5, 0xaa, 0x92, 0xca, 0x85, 0x7c, 0xc1, 0xf6, 0x19, 0x31, 0xa8, 0x2e,
0x92, 0x38, 0x71, 0xfe, 0xca, 0x8c, 0x8d, 0x51, 0x8f, 0x04, 0x51, 0x3d, 0x5a, 0x64, 0xc4, 0x32,
0xac, 0x68, 0x7b, 0xc7, 0xda, 0x27, 0xf5, 0x2c, 0x42, 0x50, 0xe3, 0x4d, 0xfd, 0xe8, 0xe1, 0xce,
0xe1, 0x51, 0xe7, 0x80, 0x19, 0xf1, 0x0a, 0xac, 0x05, 0x46, 0x0c, 0x88, 0x79, 0xf5, 0xaf, 0x0a,
0xac, 0x4d, 0x5c, 0x0f, 0xf4, 0x2e, 0xac, 0x08, 0x08, 0xae, 0xcc, 0x2d, 0xe2, 0xf3, 0xfb, 0x2e,
0x6f, 0x94, 0x10, 0x40, 0xef, 0x43, 0x89, 0xc8, 0x4a, 0x85, 0xbc, 0x92, 0xd7, 0x2f, 0x57, 0x5b,
0x82, 0x5a, 0x86, 0x14, 0x0d, 0x25, 0x58, 0x08, 0x0d, 0xef, 0xbc, 0xcc, 0x16, 0xbf, 0x7b, 0x59,
0x3c, 0xf4, 0x16, 0x52, 0x3e, 0x92, 0x51, 0x77, 0xa1, 0x12, 0x9b, 0x14, 0xfa, 0x0e, 0x94, 0x87,
0xf8, 0x42, 0xd6, 0xaa, 0x44, 0x09, 0xa2, 0x34, 0xc4, 0x17, 0xbc, 0x4c, 0x85, 0x9e, 0x87, 0x22,
0xfb, 0xd8, 0xc3, 0xc2, 0x79, 0xe4, 0xb4, 0xc2, 0x10, 0x5f, 0xfc, 0x18, 0xfb, 0xaa, 0x01, 0xb5,
0x64, 0x21, 0x87, 0x9d, 0x26, 0xcf, 0x19, 0xd9, 0x26, 0xd7, 0xb1, 0xa2, 0x89, 0x0e, 0xba, 0x03,
0x2b, 0xe7, 0x8e, 0xf0, 0x3d, 0xf3, 0x6e, 0xdd, 0x23, 0x87, 0x92, 0x58, 0x39, 0x48, 0xc8, 0xa8,
0x0f, 0xa1, 0xc6, 0xbd, 0xc8, 0x0e, 0xa5, 0x9e, 0xd5, 0x1d, 0x51, 0x12, 0xaf, 0x48, 0xae, 0x4e,
0xa9, 0x48, 0x86, 0x38, 0x23, 0x44, 0x29, 0x39, 0x51, 0x0e, 0xe3, 0x1d, 0xf5, 0xd7, 0x0a, 0xac,
0x70, 0x85, 0xcc, 0xc5, 0xf0, 0x1a, 0x8f, 0x44, 0xb0, 0xac, 0x8d, 0x0c, 0x00, 0x1c, 0x0c, 0x14,
0xcc, 0xf7, 0xe6, 0x3c, 0xe7, 0x16, 0x4e, 0xab, 0xfd, 0xa2, 0xf4, 0x72, 0x57, 0x23, 0x05, 0x31,
0x4f, 0x17, 0x53, 0xab, 0x3e, 0x56, 0xa0, 0x74, 0x7c, 0x21, 0x4f, 0xe8, 0x8c, 0xd2, 0x0f, 0x9b,
0xfd, 0x3e, 0x9f, 0xbd, 0x28, 0x96, 0x88, 0x8e, 0xac, 0x25, 0xe5, 0xc2, 0x3a, 0xd5, 0xbd, 0xf0,
0x26, 0xe6, 0x97, 0x4b, 0x27, 0x83, 0x12, 0x9e, 0x74, 0x3b, 0x03, 0x28, 0xf2, 0xf3, 0xb0, 0x7f,
0x77, 0x6a, 0x65, 0xf0, 0x43, 0x58, 0x75, 0xb1, 0x47, 0x7d, 0x3d, 0x51, 0x1f, 0x9c, 0x95, 0x91,
0x1f, 0x62, 0x8f, 0x1e, 0x11, 0x9a, 0xa8, 0x15, 0x56, 0xb8, 0xbc, 0x20, 0xa9, 0xef, 0x41, 0x35,
0xc1, 0xc3, 0x16, 0x4b, 0x1d, 0x8a, 0x07, 0xc1, 0xb9, 0xe1, 0x9d, 0x70, 0x26, 0xd9, 0x68, 0x26,
0xea, 0x1d, 0x28, 0x87, 0xc7, 0x9a, 0xe5, 0x1b, 0xd8, 0x34, 0x3d, 0xe2, 0xfb, 0x72, 0xb6, 0x41,
0x97, 0x97, 0x42, 0x9d, 0x2f, 0x64, 0xcd, 0x27, 0xa7, 0x89, 0x8e, 0x6a, 0xc1, 0xda, 0x44, 0x04,
0x45, 0x3f, 0x82, 0xa2, 0x3b, 0xea, 0xea, 0xc1, 0x81, 0x9a, 0xb8, 0x47, 0x12, 0x8a, 0x9e, 0x91,
0xb1, 0xdf, 0x3a, 0x1c, 0x75, 0x07, 0x96, 0x71, 0x9f, 0x8c, 0x03, 0xd3, 0xb9, 0xa3, 0xee, 0x7d,
0x71, 0xf8, 0xc4, 0x50, 0xd9, 0xf8, 0x50, 0xbf, 0x82, 0x52, 0x70, 0x9e, 0xd1, 0xdd, 0xf8, 0x6d,
0x55, 0x2e, 0x5f, 0xf6, 0x69, 0x01, 0x5e, 0x0e, 0x12, 0x09, 0xb2, 0x0c, 0xc9, 0xb7, 0x7a, 0x36,
0x31, 0xf5, 0x28, 0xf9, 0xe1, 0x63, 0x96, 0xb4, 0x35, 0xf1, 0xe1, 0x41, 0x90, 0xf9, 0xa8, 0xff,
0x54, 0xa0, 0x14, 0x38, 0x8f, 0xa9, 0xe7, 0x3c, 0x31, 0xa5, 0xec, 0xb7, 0x9d, 0xd2, 0xac, 0x42,
0x74, 0x50, 0xf6, 0xcf, 0x2f, 0x5d, 0xf6, 0x7f, 0x03, 0x10, 0xdf, 0x7b, 0xfd, 0xdc, 0xa1, 0x96,
0xdd, 0xd3, 0x85, 0x65, 0x05, 0xb0, 0xab, 0xf3, 0x2f, 0x8f, 0xf8, 0x87, 0x43, 0x6e, 0xe4, 0xdf,
0x28, 0x50, 0x0a, 0xc3, 0xf0, 0xb2, 0x65, 0xc7, 0x6b, 0x50, 0x90, 0xa1, 0x46, 0xd4, 0x1d, 0x65,
0x2f, 0x3c, 0x75, 0xf9, 0xd8, 0xf9, 0x6f, 0x42, 0x69, 0x48, 0x28, 0xe6, 0x88, 0x44, 0xa4, 0x99,
0x61, 0xff, 0xb5, 0x1b, 0x50, 0x89, 0xd5, 0x81, 0x51, 0x11, 0x72, 0x0f, 0xc9, 0x17, 0xf5, 0x0c,
0xaa, 0x40, 0x51, 0x23, 0xbc, 0xf4, 0x53, 0x57, 0xb6, 0xbf, 0xac, 0xc0, 0xda, 0x4e, 0x7b, 0x77,
0x9f, 0x45, 0x42, 0xcb, 0xc0, 0x3c, 0x05, 0x3d, 0x80, 0x3c, 0xcf, 0xc2, 0x53, 0xbc, 0x38, 0x37,
0xd3, 0xd4, 0x11, 0x91, 0x06, 0x2b, 0x3c, 0x59, 0x47, 0x69, 0x1e, 0xa2, 0x9b, 0xa9, 0xca, 0x8b,
0x6c, 0x92, 0xfc, 0x0c, 0xa7, 0x78, 0x9f, 0x6e, 0xa6, 0xa9, 0x39, 0xa2, 0x4f, 0xa1, 0x1c, 0x65,
0xe1, 0x69, 0x5f, 0xad, 0x9b, 0xa9, 0xab, 0x91, 0x4c, 0x7f, 0x94, 0x6d, 0xa4, 0x7d, 0xb3, 0x6d,
0xa6, 0xf6, 0x9b, 0xe8, 0x63, 0x28, 0x06, 0x79, 0x5d, 0xba, 0x77, 0xe5, 0x66, 0xca, 0x4a, 0x21,
0xdb, 0x3e, 0x91, 0x98, 0xa7, 0x79, 0x3c, 0x6f, 0xa6, 0x2a, 0x87, 0xa2, 0x13, 0x28, 0x48, 0x40,
0x9d, 0xea, 0xc5, 0xb8, 0x99, 0xae, 0xfe, 0xc7, 0x8c, 0x1c, 0x95, 0x3e, 0xd2, 0xfe, 0x30, 0xd0,
0x4c, 0x5d, 0x07, 0x46, 0x18, 0x20, 0x96, 0xa3, 0xa7, 0xfe, 0x13, 0xa0, 0x99, 0xbe, 0xbe, 0x8b,
0x7e, 0x0e, 0xa5, 0x30, 0x13, 0x4b, 0xf9, 0x22, 0xdf, 0x4c, 0x5b, 0x62, 0x45, 0x9f, 0x41, 0x35,
0x99, 0x7c, 0x2c, 0xf3, 0xce, 0xde, 0x5c, 0xaa, 0x76, 0xca, 0xc6, 0x4a, 0xe6, 0x23, 0xcb, 0xbc,
0xbe, 0x37, 0x97, 0x2a, 0xa8, 0xa2, 0x73, 0x58, 0xbf, 0x9c, 0x42, 0x2c, 0xfb, 0x24, 0xdf, 0x5c,
0xba, 0xd0, 0x8a, 0xc6, 0x80, 0xa6, 0xa4, 0x21, 0x4b, 0xbf, 0xd3, 0x37, 0x97, 0xaf, 0xbe, 0xb6,
0xf7, 0xbe, 0x7a, 0xb2, 0xa1, 0x7c, 0xfd, 0x64, 0x43, 0xf9, 0xc7, 0x93, 0x0d, 0xe5, 0xf1, 0xd3,
0x8d, 0xcc, 0xd7, 0x4f, 0x37, 0x32, 0x7f, 0x7b, 0xba, 0x91, 0xf9, 0xd9, 0xeb, 0x3d, 0x8b, 0xf6,
0x47, 0xdd, 0x96, 0xe1, 0x0c, 0xb7, 0x22, 0xb5, 0xf1, 0x66, 0xf4, 0x27, 0x55, 0xb7, 0xc0, 0x83,
0xdf, 0xdb, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x52, 0xf1, 0x66, 0x15, 0x64, 0x25, 0x00, 0x00,
0x6e, 0xc0, 0x32, 0x0b, 0x25, 0x63, 0xd0, 0x13, 0xbb, 0x01, 0xf4, 0x44, 0x6f, 0xc1, 0x1a, 0xc7,
0x10, 0x02, 0xc5, 0xca, 0xf8, 0x91, 0xe7, 0xc1, 0x70, 0x95, 0x7d, 0x10, 0x47, 0x57, 0x04, 0x92,
0xef, 0xc1, 0xa5, 0x18, 0x6f, 0x18, 0xa2, 0x04, 0xc6, 0xaa, 0x85, 0xdc, 0xdb, 0x32, 0x56, 0x7d,
0x12, 0x19, 0x28, 0x82, 0xb5, 0x08, 0xf2, 0x86, 0x63, 0x12, 0x19, 0x40, 0x78, 0x9b, 0x41, 0xdd,
0xbe, 0xd3, 0x95, 0x61, 0x82, 0x35, 0x19, 0x57, 0xe8, 0x53, 0xcb, 0xc2, 0x59, 0xaa, 0x7f, 0x52,
0x22, 0x7d, 0x11, 0xd2, 0x9d, 0x04, 0x4a, 0x95, 0x17, 0x09, 0x4a, 0xb3, 0xff, 0x1b, 0x28, 0x55,
0xff, 0xa3, 0x44, 0x5b, 0x1a, 0xc2, 0xcd, 0x6f, 0x67, 0x82, 0x28, 0xfc, 0x2e, 0xf1, 0x0d, 0x92,
0xe1, 0x57, 0x66, 0x0a, 0x05, 0xbe, 0x0d, 0xc9, 0x4c, 0xa1, 0x28, 0x02, 0x32, 0xef, 0xa0, 0x8f,
0xa1, 0xec, 0x7a, 0x8e, 0x73, 0xa2, 0x3b, 0xae, 0x2f, 0xfd, 0x72, 0x02, 0x60, 0x89, 0xb2, 0x50,
0x53, 0x14, 0x94, 0x9a, 0x07, 0x8c, 0x75, 0xdf, 0xf5, 0xb5, 0x92, 0x2b, 0x5b, 0x31, 0x80, 0x51,
0x4e, 0xe0, 0xdf, 0x57, 0xa1, 0xcc, 0x16, 0xe1, 0xbb, 0xd8, 0x20, 0xdc, 0xbd, 0x96, 0xb5, 0x88,
0xa0, 0x9a, 0x80, 0x2e, 0xba, 0x79, 0xf4, 0x00, 0x0a, 0xe4, 0x8c, 0xd8, 0x94, 0xed, 0x16, 0x33,
0xf0, 0xab, 0x53, 0x61, 0x25, 0xb1, 0x69, 0xab, 0xce, 0xcc, 0xfa, 0xaf, 0x6f, 0x36, 0x6a, 0x42,
0xe6, 0x1d, 0x67, 0x60, 0x51, 0x32, 0x70, 0xe9, 0x48, 0x93, 0x5a, 0xd4, 0xdf, 0x66, 0x19, 0xba,
0x4b, 0x84, 0x80, 0x89, 0x86, 0x0e, 0xae, 0x4f, 0x36, 0x86, 0xf5, 0xd3, 0x19, 0xff, 0x35, 0x80,
0x2e, 0xf6, 0xf5, 0x27, 0xd8, 0xa6, 0xc4, 0x94, 0x3b, 0x50, 0xee, 0x62, 0xff, 0xa7, 0x9c, 0xc0,
0x40, 0x1b, 0xfb, 0x3c, 0xf4, 0x89, 0xc9, 0xb7, 0x22, 0xa7, 0x15, 0xbb, 0xd8, 0x3f, 0xf6, 0x89,
0x19, 0x5b, 0x6b, 0xf1, 0x45, 0xac, 0x35, 0x69, 0xef, 0xd2, 0xb8, 0xbd, 0x7f, 0x97, 0x8d, 0xee,
0x49, 0x04, 0x86, 0xff, 0x3f, 0x6d, 0xf1, 0x07, 0x9e, 0x1c, 0x27, 0xe3, 0x30, 0xfa, 0x14, 0xd6,
0xc2, 0xfb, 0xa9, 0x0f, 0xf9, 0xbd, 0x0d, 0x4e, 0xe1, 0x62, 0xd7, 0xbc, 0x76, 0x96, 0x24, 0xfb,
0xe8, 0x33, 0x78, 0x79, 0xcc, 0x1b, 0x85, 0x03, 0x64, 0x17, 0x72, 0x4a, 0x2f, 0x25, 0x9d, 0x52,
0xa0, 0x3f, 0xb2, 0x5e, 0xee, 0x85, 0xdc, 0x9a, 0x3d, 0x96, 0x90, 0xc5, 0x11, 0xc6, 0xc4, 0x33,
0x71, 0x0d, 0x2a, 0x1e, 0xa1, 0xd8, 0xb2, 0xf5, 0x44, 0xfa, 0xbb, 0x22, 0x88, 0x22, 0x38, 0xa8,
0x8f, 0xe0, 0xa5, 0x89, 0x18, 0x03, 0xfd, 0x00, 0xca, 0x11, 0x48, 0x51, 0x66, 0xe6, 0x90, 0x61,
0x2e, 0x14, 0x49, 0xa8, 0x5f, 0x2a, 0x91, 0xe2, 0x64, 0x8e, 0x75, 0x0f, 0x0a, 0x1e, 0xf1, 0x87,
0x7d, 0x91, 0xef, 0x54, 0xb7, 0xde, 0x5f, 0x04, 0xa3, 0x30, 0xea, 0xb0, 0x4f, 0x35, 0xa9, 0x42,
0x7d, 0x08, 0x05, 0x41, 0x41, 0x00, 0x85, 0xed, 0x9d, 0x9d, 0xdd, 0x83, 0xa3, 0x5a, 0x06, 0x95,
0x61, 0x69, 0xbb, 0xb5, 0xaf, 0x1d, 0xd5, 0x14, 0x46, 0xd6, 0x76, 0x7f, 0xb2, 0xbb, 0x73, 0x54,
0xcb, 0xa2, 0x35, 0xa8, 0x88, 0xb6, 0x7e, 0x77, 0x5f, 0xfb, 0x64, 0xfb, 0xa8, 0x96, 0x8b, 0x91,
0x0e, 0x77, 0x1f, 0xdc, 0xd9, 0xd5, 0x6a, 0x79, 0xf5, 0x3d, 0x96, 0x49, 0x4d, 0x81, 0x30, 0x51,
0xce, 0xa4, 0xc4, 0x72, 0x26, 0xf5, 0xf7, 0x59, 0x68, 0x4c, 0x47, 0x24, 0xe8, 0x60, 0x6c, 0xc5,
0x1f, 0x2e, 0x0c, 0x6a, 0xc6, 0x96, 0x8d, 0xae, 0x43, 0xd5, 0x23, 0x27, 0x84, 0x1a, 0x3d, 0x81,
0x96, 0x44, 0xbc, 0xab, 0x68, 0x15, 0x49, 0xe5, 0x42, 0xbe, 0x60, 0xfb, 0x9c, 0x18, 0x54, 0x17,
0x49, 0x9c, 0x38, 0x7f, 0x65, 0xc6, 0xc6, 0xa8, 0x87, 0x82, 0xa8, 0x1e, 0xce, 0x33, 0x62, 0x19,
0x96, 0xb4, 0xdd, 0x23, 0xed, 0xd3, 0x5a, 0x16, 0x21, 0xa8, 0xf2, 0xa6, 0x7e, 0xf8, 0x60, 0xfb,
0xe0, 0xb0, 0xbd, 0xcf, 0x8c, 0x78, 0x09, 0x56, 0x03, 0x23, 0x06, 0xc4, 0xbc, 0xfa, 0x57, 0x05,
0x56, 0xc7, 0xae, 0x07, 0xfa, 0x10, 0x96, 0x04, 0x04, 0x57, 0x66, 0x16, 0xf1, 0xf9, 0x7d, 0x97,
0x37, 0x4a, 0x08, 0xa0, 0xdb, 0x50, 0x22, 0xb2, 0x52, 0x21, 0xaf, 0xe4, 0xd5, 0x8b, 0xd5, 0x96,
0xa0, 0x96, 0x21, 0x45, 0x43, 0x09, 0x16, 0x42, 0xc3, 0x3b, 0x2f, 0xb3, 0xc5, 0xef, 0x5e, 0x14,
0x0f, 0xbd, 0x85, 0x94, 0x8f, 0x64, 0xd4, 0x1d, 0x58, 0x8e, 0x4d, 0x0a, 0x7d, 0x07, 0xca, 0x03,
0x7c, 0x2e, 0x6b, 0x55, 0xa2, 0x04, 0x51, 0x1a, 0xe0, 0x73, 0x5e, 0xa6, 0x42, 0x2f, 0x43, 0x91,
0x7d, 0xec, 0x62, 0xe1, 0x3c, 0x72, 0x5a, 0x61, 0x80, 0xcf, 0x7f, 0x8c, 0x7d, 0xd5, 0x80, 0x6a,
0xb2, 0x90, 0xc3, 0x4e, 0x93, 0xe7, 0x0c, 0x6d, 0x93, 0xeb, 0x58, 0xd2, 0x44, 0x07, 0xdd, 0x82,
0xa5, 0x33, 0x47, 0xf8, 0x9e, 0x59, 0xb7, 0xee, 0x91, 0x43, 0x49, 0xac, 0x1c, 0x24, 0x64, 0xd4,
0x07, 0x50, 0xe5, 0x5e, 0x64, 0x9b, 0x52, 0xcf, 0xea, 0x0c, 0x29, 0x89, 0x57, 0x24, 0x57, 0x26,
0x54, 0x24, 0x43, 0x9c, 0x11, 0xa2, 0x94, 0x9c, 0x28, 0x87, 0xf1, 0x8e, 0xfa, 0x6b, 0x05, 0x96,
0xb8, 0x42, 0xe6, 0x62, 0x78, 0x8d, 0x47, 0x22, 0x58, 0xd6, 0x46, 0x06, 0x00, 0x0e, 0x06, 0x0a,
0xe6, 0x7b, 0x7d, 0x96, 0x73, 0x0b, 0xa7, 0xd5, 0x7a, 0x55, 0x7a, 0xb9, 0xcb, 0x91, 0x82, 0x98,
0xa7, 0x8b, 0xa9, 0x55, 0x9f, 0x2a, 0x50, 0x3a, 0x3a, 0x97, 0x27, 0x74, 0x4a, 0xe9, 0x87, 0xcd,
0x7e, 0x8f, 0xcf, 0x5e, 0x14, 0x4b, 0x44, 0x47, 0xd6, 0x92, 0x72, 0x61, 0x9d, 0xea, 0x6e, 0x78,
0x13, 0xf3, 0x8b, 0xa5, 0x93, 0x41, 0x09, 0x4f, 0xba, 0x9d, 0x5b, 0x50, 0x0e, 0x4f, 0x0b, 0x83,
0xf1, 0xd8, 0x34, 0x3d, 0xe2, 0xfb, 0xd2, 0xc8, 0x41, 0x97, 0x57, 0x18, 0x9d, 0x27, 0xb2, 0x94,
0x92, 0xd3, 0x44, 0x47, 0xb5, 0x60, 0x75, 0x2c, 0x30, 0xa1, 0x1f, 0x41, 0xd1, 0x1d, 0x76, 0xf4,
0x60, 0x9f, 0xc6, 0x8e, 0xa7, 0x44, 0x78, 0xa7, 0x64, 0xe4, 0x37, 0x0f, 0x86, 0x9d, 0xbe, 0x65,
0xdc, 0x23, 0xa3, 0x60, 0x46, 0xee, 0xb0, 0x73, 0x4f, 0xec, 0xa9, 0x18, 0x2a, 0x1b, 0x1f, 0xea,
0x57, 0x50, 0x0a, 0x8e, 0x09, 0xba, 0x13, 0xbf, 0x04, 0xca, 0xc5, 0x3b, 0x34, 0x29, 0x6e, 0xca,
0x41, 0x22, 0x41, 0x96, 0x78, 0xf8, 0x56, 0xd7, 0x26, 0xa6, 0x1e, 0xe5, 0x14, 0x7c, 0xcc, 0x92,
0xb6, 0x2a, 0x3e, 0xdc, 0x0f, 0x12, 0x0a, 0xf5, 0x9f, 0x0a, 0x94, 0x82, 0x3b, 0x39, 0xf1, 0xf8,
0x24, 0xa6, 0x94, 0xfd, 0xb6, 0x53, 0x9a, 0x56, 0xdf, 0x0d, 0xaa, 0xe9, 0xf9, 0x85, 0xab, 0xe9,
0xef, 0x00, 0xa2, 0x0e, 0xc5, 0x7d, 0xfd, 0xcc, 0xa1, 0x96, 0xdd, 0xd5, 0x85, 0x65, 0x05, 0x5e,
0xaa, 0xf1, 0x2f, 0x8f, 0xf8, 0x87, 0x03, 0x6e, 0xe4, 0xdf, 0x28, 0x50, 0x0a, 0xa3, 0xdb, 0xa2,
0xd5, 0xbc, 0x2b, 0x50, 0x90, 0x1e, 0x5c, 0x94, 0xf3, 0x64, 0x2f, 0x2c, 0x38, 0xe7, 0x63, 0x05,
0xe7, 0x06, 0x94, 0x06, 0x84, 0x62, 0x1e, 0xe8, 0x45, 0xf6, 0x16, 0xf6, 0xdf, 0xba, 0x06, 0xcb,
0xb1, 0xf2, 0x2a, 0x2a, 0x42, 0xee, 0x01, 0x79, 0x52, 0xcb, 0xa0, 0x65, 0x28, 0x6a, 0x84, 0x57,
0x54, 0x6a, 0xca, 0xd6, 0x97, 0xcb, 0xb0, 0xba, 0xdd, 0xda, 0xd9, 0x63, 0x01, 0xc6, 0x32, 0x30,
0xcf, 0xec, 0xf6, 0x21, 0xcf, 0x93, 0xdb, 0x14, 0x0f, 0xb9, 0x8d, 0x34, 0xe5, 0x39, 0xa4, 0xc1,
0x12, 0xcf, 0x81, 0x51, 0x9a, 0xf7, 0xdd, 0x46, 0xaa, 0xaa, 0x1d, 0x9b, 0x24, 0x3f, 0xc3, 0x29,
0x9e, 0x7d, 0x1b, 0x69, 0x4a, 0x79, 0xe8, 0x33, 0x28, 0x47, 0xc9, 0x6d, 0xda, 0xc7, 0xe0, 0x46,
0xea, 0x22, 0x1f, 0xd3, 0x1f, 0x81, 0xf8, 0xb4, 0x4f, 0xa1, 0x8d, 0xd4, 0xee, 0x08, 0x3d, 0x86,
0x62, 0x90, 0x2e, 0xa5, 0x7b, 0xae, 0x6d, 0xa4, 0x2c, 0xc0, 0xb1, 0xed, 0x13, 0xf9, 0x6e, 0x9a,
0x37, 0xe9, 0x46, 0xaa, 0x2a, 0x23, 0x3a, 0x86, 0x82, 0xc4, 0xa9, 0xa9, 0x1e, 0x62, 0x1b, 0xe9,
0xca, 0x6a, 0xcc, 0xc8, 0x51, 0x45, 0x21, 0xed, 0x3b, 0x7c, 0x23, 0x75, 0x79, 0x15, 0x61, 0x80,
0x58, 0xea, 0x9b, 0xfa, 0x81, 0xbd, 0x91, 0xbe, 0x6c, 0x8a, 0x7e, 0x0e, 0xa5, 0x30, 0xc1, 0x49,
0xf9, 0xd0, 0xdd, 0x48, 0x5b, 0xb9, 0x44, 0x9f, 0x43, 0x25, 0x89, 0xe9, 0x17, 0x79, 0xbe, 0x6e,
0x2c, 0x54, 0x92, 0x64, 0x63, 0x25, 0x61, 0xfe, 0x22, 0x8f, 0xda, 0x8d, 0x85, 0xea, 0x94, 0xe8,
0x0c, 0xd6, 0x2e, 0x22, 0xf3, 0x45, 0x5f, 0xba, 0x1b, 0x0b, 0xd7, 0x2f, 0xd1, 0x08, 0xd0, 0x04,
0x74, 0xbf, 0xf0, 0xf3, 0x77, 0x63, 0xf1, 0xa2, 0x66, 0x6b, 0xf7, 0xab, 0x67, 0xeb, 0xca, 0xd7,
0xcf, 0xd6, 0x95, 0x7f, 0x3c, 0x5b, 0x57, 0x9e, 0x3e, 0x5f, 0xcf, 0x7c, 0xfd, 0x7c, 0x3d, 0xf3,
0xb7, 0xe7, 0xeb, 0x99, 0x9f, 0xbd, 0xdd, 0xb5, 0x68, 0x6f, 0xd8, 0x69, 0x1a, 0xce, 0x60, 0x33,
0x52, 0x1b, 0x6f, 0x46, 0x3f, 0x28, 0x75, 0x0a, 0x3c, 0xf8, 0xbd, 0xff, 0xdf, 0x00, 0x00, 0x00,
0xff, 0xff, 0x41, 0x23, 0x27, 0x2d, 0xbb, 0x24, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -6326,81 +6217,6 @@ func (m *TxResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *BlockID) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *BlockID) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if len(m.Hash) > 0 {
i -= len(m.Hash)
copy(dAtA[i:], m.Hash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PartSetHeader) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *PartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Hash) > 0 {
i -= len(m.Hash)
copy(dAtA[i:], m.Hash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash)))
i--
dAtA[i] = 0x12
}
if m.Total != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Total))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *Validator) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -6542,12 +6358,12 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x28
}
n49, err49 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err49 != nil {
return 0, err49
n48, err48 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err48 != nil {
return 0, err48
}
i -= n49
i = encodeVarintTypes(dAtA, i, uint64(n49))
i -= n48
i = encodeVarintTypes(dAtA, i, uint64(n48))
i--
dAtA[i] = 0x22
if m.Height != 0 {
@@ -7739,37 +7555,6 @@ func (m *TxResult) Size() (n int) {
return n
}
func (m *BlockID) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Hash)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.PartsHeader.Size()
n += 1 + l + sovTypes(uint64(l))
return n
}
func (m *PartSetHeader) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Total != 0 {
n += 1 + sovTypes(uint64(m.Total))
}
l = len(m.Hash)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
return n
}
func (m *Validator) Size() (n int) {
if m == nil {
return 0
@@ -13828,232 +13613,6 @@ func (m *TxResult) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *BlockID) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: BlockID: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BlockID: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
if m.Hash == nil {
m.Hash = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PartSetHeader) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PartSetHeader: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PartSetHeader: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
}
m.Total = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Total |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
if m.Hash == nil {
m.Hash = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Validator) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
blockchain/v0/reactor.go
+2 -2
View File
@@ -350,8 +350,8 @@ FOR_LOOP:
}
firstParts := first.MakePartSet(types.BlockPartSizeBytes)
firstPartsHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
firstPartSetHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
// Finally, verify the first block using the second's commit
// NOTE: we can probably make this more efficient, but note that calling
// first.Hash() doesn't verify the tx contents, so MakePartSet() is
blockchain/v0/reactor_test.go
+1 -1
View File
@@ -110,7 +110,7 @@ func newBlockchainReactor(
thisBlock := makeBlock(blockHeight, state, lastCommit)
thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
if err != nil {
blockchain/v1/reactor.go
+2 -2
View File
@@ -454,8 +454,8 @@ func (bcR *BlockchainReactor) processBlock() error {
chainID := bcR.initialState.ChainID
firstParts := first.MakePartSet(types.BlockPartSizeBytes)
firstPartsHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
firstPartSetHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
// Finally, verify the first block using the second's commit
// NOTE: we can probably make this more efficient, but note that calling
// first.Hash() doesn't verify the tx contents, so MakePartSet() is
blockchain/v1/reactor_test.go
+1 -1
View File
@@ -132,7 +132,7 @@ func newBlockchainReactor(
thisBlock := makeBlock(blockHeight, state, lastCommit)
thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
if err != nil {
blockchain/v2/processor.go
+2 -2
View File
@@ -148,8 +148,8 @@ func (state *pcState) handle(event Event) (Event, error) {
first, second := firstItem.block, secondItem.block
firstParts := first.MakePartSet(types.BlockPartSizeBytes)
firstPartsHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
firstPartSetHeader := firstParts.Header()
firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
err = state.context.verifyCommit(tmState.ChainID, firstID, first.Height, second.LastCommit)
if err != nil {
blockchain/v2/reactor_test.go
+1 -1
View File
@@ -530,7 +530,7 @@ func newReactorStore(
thisBlock := makeBlock(blockHeight, state, lastCommit)
thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
blockID := types.BlockID{Hash: thisBlock.Hash(), PartsHeader: thisParts.Header()}
blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
if err != nil {
consensus/byzantine_test.go
+2 -2
View File
@@ -179,7 +179,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
// Create a new proposal block from state/txs from the mempool.
block1, blockParts1 := cs.createProposalBlock()
polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartsHeader: blockParts1.Header()}
polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
proposal1 := types.NewProposal(height, round, polRound, propBlockID)
p1 := proposal1.ToProto()
if err := cs.privValidator.SignProposal(cs.state.ChainID, p1); err != nil {
@@ -190,7 +190,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
// Create a new proposal block from state/txs from the mempool.
block2, blockParts2 := cs.createProposalBlock()
polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartsHeader: blockParts2.Header()}
polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
proposal2 := types.NewProposal(height, round, polRound, propBlockID)
p2 := proposal2.ToProto()
if err := cs.privValidator.SignProposal(cs.state.ChainID, p2); err != nil {
consensus/common_test.go
+2 -2
View File
@@ -103,7 +103,7 @@ func (vs *validatorStub) signVote(
Round: vs.Round,
Timestamp: tmtime.Now(),
Type: voteType,
BlockID: types.BlockID{Hash: hash, PartsHeader: header},
BlockID: types.BlockID{Hash: hash, PartSetHeader: header},
}
v := vote.ToProto()
err = vs.PrivValidator.SignVote(config.ChainID(), v)
@@ -200,7 +200,7 @@ func decideProposal(
}
// Make proposal
polRound, propBlockID := validRound, types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}
polRound, propBlockID := validRound, types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
proposal = types.NewProposal(height, round, polRound, propBlockID)
p := proposal.ToProto()
if err := vs.SignProposal(chainID, p); err != nil {
consensus/msgs.go
+12 -12
View File
@@ -36,16 +36,16 @@ func MsgToProto(msg Message) (*tmcons.Message, error) {
},
}
case *NewValidBlockMessage:
pbPartsHeader := msg.BlockPartsHeader.ToProto()
pbPartSetHeader := msg.BlockPartSetHeader.ToProto()
pbBits := msg.BlockParts.ToProto()
pb = tmcons.Message{
Sum: &tmcons.Message_NewValidBlock{
NewValidBlock: &tmcons.NewValidBlock{
Height: msg.Height,
Round: msg.Round,
BlockPartsHeader: pbPartsHeader,
BlockParts: pbBits,
IsCommit: msg.IsCommit,
Height: msg.Height,
Round: msg.Round,
BlockPartSetHeader: pbPartSetHeader,
BlockParts: pbBits,
IsCommit: msg.IsCommit,
},
},
}
@@ -165,7 +165,7 @@ func MsgFromProto(msg *tmcons.Message) (Message, error) {
LastCommitRound: msg.NewRoundStep.LastCommitRound,
}
case *tmcons.Message_NewValidBlock:
pbPartsHeader, err := types.PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartsHeader)
pbPartSetHeader, err := types.PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartSetHeader)
if err != nil {
return nil, fmt.Errorf("parts to proto error: %w", err)
}
@@ -174,11 +174,11 @@ func MsgFromProto(msg *tmcons.Message) (Message, error) {
pbBits.FromProto(msg.NewValidBlock.BlockParts)
pb = &NewValidBlockMessage{
Height: msg.NewValidBlock.Height,
Round: msg.NewValidBlock.Round,
BlockPartsHeader: *pbPartsHeader,
BlockParts: pbBits,
IsCommit: msg.NewValidBlock.IsCommit,
Height: msg.NewValidBlock.Height,
Round: msg.NewValidBlock.Round,
BlockPartSetHeader: *pbPartSetHeader,
BlockParts: pbBits,
IsCommit: msg.NewValidBlock.IsCommit,
}
case *tmcons.Message_Proposal:
pbP, err := types.ProposalFromProto(&msg.Proposal.Proposal)
consensus/msgs_test.go
+12 -12
View File
@@ -23,8 +23,8 @@ func TestMsgToProto(t *testing.T) {
}
pbPsh := psh.ToProto()
bi := types.BlockID{
Hash: tmrand.Bytes(32),
PartsHeader: psh,
Hash: tmrand.Bytes(32),
PartSetHeader: psh,
}
pbBi := bi.ToProto()
bits := bits.NewBitArray(1)
@@ -90,19 +90,19 @@ func TestMsgToProto(t *testing.T) {
}, false},
{"successful NewValidBlockMessage", &NewValidBlockMessage{
Height: 1,
Round: 1,
BlockPartsHeader: psh,
BlockParts: bits,
IsCommit: false,
Height: 1,
Round: 1,
BlockPartSetHeader: psh,
BlockParts: bits,
IsCommit: false,
}, &tmcons.Message{
Sum: &tmcons.Message_NewValidBlock{
NewValidBlock: &tmcons.NewValidBlock{
Height: 1,
Round: 1,
BlockPartsHeader: pbPsh,
BlockParts: pbBits,
IsCommit: false,
Height: 1,
Round: 1,
BlockPartSetHeader: pbPsh,
BlockParts: pbBits,
IsCommit: false,
},
},
}, false},
consensus/reactor.go
+29 -29
View File
@@ -415,11 +415,11 @@ func (conR *Reactor) broadcastNewRoundStepMessage(rs *cstypes.RoundState) {
func (conR *Reactor) broadcastNewValidBlockMessage(rs *cstypes.RoundState) {
csMsg := &NewValidBlockMessage{
Height: rs.Height,
Round: rs.Round,
BlockPartsHeader: rs.ProposalBlockParts.Header(),
BlockParts: rs.ProposalBlockParts.BitArray(),
IsCommit: rs.Step == cstypes.RoundStepCommit,
Height: rs.Height,
Round: rs.Round,
BlockPartSetHeader: rs.ProposalBlockParts.Header(),
BlockParts: rs.ProposalBlockParts.BitArray(),
IsCommit: rs.Step == cstypes.RoundStepCommit,
}
conR.Switch.Broadcast(StateChannel, MustEncode(csMsg))
}
@@ -484,7 +484,7 @@ OUTER_LOOP:
prs := ps.GetRoundState()
// Send proposal Block parts?
if rs.ProposalBlockParts.HasHeader(prs.ProposalBlockPartsHeader) {
if rs.ProposalBlockParts.HasHeader(prs.ProposalBlockPartSetHeader) {
if index, ok := rs.ProposalBlockParts.BitArray().Sub(prs.ProposalBlockParts.Copy()).PickRandom(); ok {
part := rs.ProposalBlockParts.GetPart(index)
msg := &BlockPartMessage{
@@ -512,7 +512,7 @@ OUTER_LOOP:
"blockstoreBase", conR.conS.blockStore.Base(), "blockstoreHeight", conR.conS.blockStore.Height())
time.Sleep(conR.conS.config.PeerGossipSleepDuration)
} else {
ps.InitProposalBlockParts(blockMeta.BlockID.PartsHeader)
ps.InitProposalBlockParts(blockMeta.BlockID.PartSetHeader)
}
// continue the loop since prs is a copy and not effected by this initialization
continue OUTER_LOOP
@@ -577,9 +577,9 @@ func (conR *Reactor) gossipDataForCatchup(logger log.Logger, rs *cstypes.RoundSt
"blockstoreBase", conR.conS.blockStore.Base(), "blockstoreHeight", conR.conS.blockStore.Height())
time.Sleep(conR.conS.config.PeerGossipSleepDuration)
return
} else if !blockMeta.BlockID.PartsHeader.Equals(prs.ProposalBlockPartsHeader) {
logger.Info("Peer ProposalBlockPartsHeader mismatch, sleeping",
"blockPartsHeader", blockMeta.BlockID.PartsHeader, "peerBlockPartsHeader", prs.ProposalBlockPartsHeader)
} else if !blockMeta.BlockID.PartSetHeader.Equals(prs.ProposalBlockPartSetHeader) {
logger.Info("Peer ProposalBlockPartSetHeader mismatch, sleeping",
"blockPartSetHeader", blockMeta.BlockID.PartSetHeader, "peerBlockPartSetHeader", prs.ProposalBlockPartSetHeader)
time.Sleep(conR.conS.config.PeerGossipSleepDuration)
return
}
@@ -587,7 +587,7 @@ func (conR *Reactor) gossipDataForCatchup(logger log.Logger, rs *cstypes.RoundSt
part := conR.conS.blockStore.LoadBlockPart(prs.Height, index)
if part == nil {
logger.Error("Could not load part", "index", index,
"blockPartsHeader", blockMeta.BlockID.PartsHeader, "peerBlockPartsHeader", prs.ProposalBlockPartsHeader)
"blockPartSetHeader", blockMeta.BlockID.PartSetHeader, "peerBlockPartSetHeader", prs.ProposalBlockPartSetHeader)
time.Sleep(conR.conS.config.PeerGossipSleepDuration)
return
}
@@ -996,14 +996,14 @@ func (ps *PeerState) SetHasProposal(proposal *types.Proposal) {
return
}
ps.PRS.ProposalBlockPartsHeader = proposal.BlockID.PartsHeader
ps.PRS.ProposalBlockParts = bits.NewBitArray(int(proposal.BlockID.PartsHeader.Total))
ps.PRS.ProposalBlockPartSetHeader = proposal.BlockID.PartSetHeader
ps.PRS.ProposalBlockParts = bits.NewBitArray(int(proposal.BlockID.PartSetHeader.Total))
ps.PRS.ProposalPOLRound = proposal.POLRound
ps.PRS.ProposalPOL = nil // Nil until ProposalPOLMessage received.
}
// InitProposalBlockParts initializes the peer's proposal block parts header and bit array.
func (ps *PeerState) InitProposalBlockParts(partsHeader types.PartSetHeader) {
func (ps *PeerState) InitProposalBlockParts(partSetHeader types.PartSetHeader) {
ps.mtx.Lock()
defer ps.mtx.Unlock()
@@ -1011,8 +1011,8 @@ func (ps *PeerState) InitProposalBlockParts(partsHeader types.PartSetHeader) {
return
}
ps.PRS.ProposalBlockPartsHeader = partsHeader
ps.PRS.ProposalBlockParts = bits.NewBitArray(int(partsHeader.Total))
ps.PRS.ProposalBlockPartSetHeader = partSetHeader
ps.PRS.ProposalBlockParts = bits.NewBitArray(int(partSetHeader.Total))
}
// SetHasProposalBlockPart sets the given block part index as known for the peer.
@@ -1262,7 +1262,7 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) {
ps.PRS.StartTime = startTime
if psHeight != msg.Height || psRound != msg.Round {
ps.PRS.Proposal = false
ps.PRS.ProposalBlockPartsHeader = types.PartSetHeader{}
ps.PRS.ProposalBlockPartSetHeader = types.PartSetHeader{}
ps.PRS.ProposalBlockParts = nil
ps.PRS.ProposalPOLRound = -1
ps.PRS.ProposalPOL = nil
@@ -1305,7 +1305,7 @@ func (ps *PeerState) ApplyNewValidBlockMessage(msg *NewValidBlockMessage) {
return
}
ps.PRS.ProposalBlockPartsHeader = msg.BlockPartsHeader
ps.PRS.ProposalBlockPartSetHeader = msg.BlockPartSetHeader
ps.PRS.ProposalBlockParts = msg.BlockParts
}
@@ -1453,11 +1453,11 @@ func (m *NewRoundStepMessage) String() string {
//i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
// In case the block is also committed, then IsCommit flag is set to true.
type NewValidBlockMessage struct {
Height int64
Round int32
BlockPartsHeader types.PartSetHeader
BlockParts *bits.BitArray
IsCommit bool
Height int64
Round int32
BlockPartSetHeader types.PartSetHeader
BlockParts *bits.BitArray
IsCommit bool
}
// ValidateBasic performs basic validation.
@@ -1468,16 +1468,16 @@ func (m *NewValidBlockMessage) ValidateBasic() error {
if m.Round < 0 {
return errors.New("negative Round")
}
if err := m.BlockPartsHeader.ValidateBasic(); err != nil {
return fmt.Errorf("wrong BlockPartsHeader: %v", err)
if err := m.BlockPartSetHeader.ValidateBasic(); err != nil {
return fmt.Errorf("wrong BlockPartSetHeader: %v", err)
}
if m.BlockParts.Size() == 0 {
return errors.New("empty blockParts")
}
if m.BlockParts.Size() != int(m.BlockPartsHeader.Total) {
return fmt.Errorf("blockParts bit array size %d not equal to BlockPartsHeader.Total %d",
if m.BlockParts.Size() != int(m.BlockPartSetHeader.Total) {
return fmt.Errorf("blockParts bit array size %d not equal to BlockPartSetHeader.Total %d",
m.BlockParts.Size(),
m.BlockPartsHeader.Total)
m.BlockPartSetHeader.Total)
}
if m.BlockParts.Size() > int(types.MaxBlockPartsCount) {
return fmt.Errorf("blockParts bit array is too big: %d, max: %d", m.BlockParts.Size(), types.MaxBlockPartsCount)
@@ -1488,7 +1488,7 @@ func (m *NewValidBlockMessage) ValidateBasic() error {
// String returns a string representation.
func (m *NewValidBlockMessage) String() string {
return fmt.Sprintf("[ValidBlockMessage H:%v R:%v BP:%v BA:%v IsCommit:%v]",
m.Height, m.Round, m.BlockPartsHeader, m.BlockParts, m.IsCommit)
m.Height, m.Round, m.BlockPartSetHeader, m.BlockParts, m.IsCommit)
}
//-------------------------------------
consensus/reactor_test.go
+11 -8
View File
@@ -737,16 +737,19 @@ func TestNewValidBlockMessageValidateBasic(t *testing.T) {
{func(msg *NewValidBlockMessage) { msg.Height = -1 }, "negative Height"},
{func(msg *NewValidBlockMessage) { msg.Round = -1 }, "negative Round"},
{
func(msg *NewValidBlockMessage) { msg.BlockPartsHeader.Total = 2 },
"blockParts bit array size 1 not equal to BlockPartsHeader.Total 2",
func(msg *NewValidBlockMessage) { msg.BlockPartSetHeader.Total = 2 },
"blockParts bit array size 1 not equal to BlockPartSetHeader.Total 2",
},
{
func(msg *NewValidBlockMessage) { msg.BlockPartsHeader.Total = 0; msg.BlockParts = bits.NewBitArray(0) },
func(msg *NewValidBlockMessage) {
msg.BlockPartSetHeader.Total = 0
msg.BlockParts = bits.NewBitArray(0)
},
"empty blockParts",
},
{
func(msg *NewValidBlockMessage) { msg.BlockParts = bits.NewBitArray(int(types.MaxBlockPartsCount) + 1) },
"blockParts bit array size 1602 not equal to BlockPartsHeader.Total 1",
"blockParts bit array size 1602 not equal to BlockPartSetHeader.Total 1",
},
}
@@ -756,7 +759,7 @@ func TestNewValidBlockMessageValidateBasic(t *testing.T) {
msg := &NewValidBlockMessage{
Height: 1,
Round: 0,
BlockPartsHeader: types.PartSetHeader{
BlockPartSetHeader: types.PartSetHeader{
Total: 1,
},
BlockParts: bits.NewBitArray(1),
@@ -881,7 +884,7 @@ func TestVoteSetMaj23MessageValidateBasic(t *testing.T) {
validBlockID := types.BlockID{}
invalidBlockID := types.BlockID{
Hash: bytes.HexBytes{},
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1,
Hash: []byte{0},
},
@@ -928,12 +931,12 @@ func TestVoteSetBitsMessageValidateBasic(t *testing.T) {
{func(msg *VoteSetBitsMessage) {
msg.BlockID = types.BlockID{
Hash: bytes.HexBytes{},
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1,
Hash: []byte{0},
},
}
}, "wrong BlockID: wrong PartsHeader: wrong Hash:"},
}, "wrong BlockID: wrong PartSetHeader: wrong Hash:"},
{func(msg *VoteSetBitsMessage) { msg.Votes = bits.NewBitArray(types.MaxVotesCount + 1) },
"votes bit array is too big: 10001, max: 10000"},
}
consensus/replay.go
+1 -1
View File
@@ -70,7 +70,7 @@ func (cs *State) readReplayMessage(msg *TimedWALMessage, newStepSub types.Subscr
case *ProposalMessage:
p := msg.Proposal
cs.Logger.Info("Replay: Proposal", "height", p.Height, "round", p.Round, "header",
p.BlockID.PartsHeader, "pol", p.POLRound, "peer", peerID)
p.BlockID.PartSetHeader, "pol", p.POLRound, "peer", peerID)
case *BlockPartMessage:
cs.Logger.Info("Replay: BlockPart", "height", msg.Height, "round", msg.Round, "peer", peerID)
case *VoteMessage:
consensus/replay_test.go
+7 -7
View File
@@ -359,7 +359,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
assert.Nil(t, err)
propBlock, _ := css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
propBlockParts := propBlock.MakePartSet(partSize)
blockID := types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
proposal := types.NewProposal(vss[1].Height, round, -1, blockID)
p := proposal.ToProto()
@@ -391,7 +391,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
assert.Nil(t, err)
propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
propBlockParts = propBlock.MakePartSet(partSize)
blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
proposal = types.NewProposal(vss[2].Height, round, -1, blockID)
p = proposal.ToProto()
@@ -430,7 +430,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
assert.Nil(t, err)
propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
propBlockParts = propBlock.MakePartSet(partSize)
blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
newVss := make([]*validatorStub, nVals+1)
copy(newVss, vss[:nVals+1])
sort.Sort(ValidatorStubsByPower(newVss))
@@ -509,7 +509,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
assert.Nil(t, err)
propBlock, _ = css[0].createProposalBlock() //changeProposer(t, cs1, vs2)
propBlockParts = propBlock.MakePartSet(partSize)
blockID = types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
newVss = make([]*validatorStub, nVals+3)
copy(newVss, vss[:nVals+3])
sort.Sort(ValidatorStubsByPower(newVss))
@@ -767,7 +767,7 @@ func applyBlock(stateDB dbm.DB, st sm.State, blk *types.Block, proxyApp proxy.Ap
testPartSize := types.BlockPartSizeBytes
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
blkID := types.BlockID{Hash: blk.Hash(), PartsHeader: blk.MakePartSet(testPartSize).Header()}
blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()}
newState, _, err := blockExec.ApplyBlock(st, blkID, blk)
if err != nil {
panic(err)
@@ -1102,7 +1102,7 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {
case msgInfo:
switch msg := m.Msg.(type) {
case *ProposalMessage:
return &msg.Proposal.BlockID.PartsHeader
return &msg.Proposal.BlockID.PartSetHeader
case *BlockPartMessage:
return msg.Part
case *VoteMessage:
@@ -1154,7 +1154,7 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
block := bs.chain[height-1]
return &types.BlockMeta{
BlockID: types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
Header: block.Header,
}
}
consensus/state.go
+13 -13
View File
@@ -1030,7 +1030,7 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
cs.wal.FlushAndSync()
// Make proposal
propBlockID := types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}
propBlockID := types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
proposal := types.NewProposal(height, round, cs.ValidRound, propBlockID)
p := proposal.ToProto()
if err := cs.privValidator.SignProposal(cs.state.ChainID, p); err == nil {
@@ -1268,7 +1268,7 @@ func (cs *State) enterPrecommit(height int64, round int32) {
logger.Info("enterPrecommit: +2/3 prevoted locked block. Relocking")
cs.LockedRound = round
cs.eventBus.PublishEventRelock(cs.RoundStateEvent())
cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartsHeader)
cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartSetHeader)
return
}
@@ -1283,7 +1283,7 @@ func (cs *State) enterPrecommit(height int64, round int32) {
cs.LockedBlock = cs.ProposalBlock
cs.LockedBlockParts = cs.ProposalBlockParts
cs.eventBus.PublishEventLock(cs.RoundStateEvent())
cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartsHeader)
cs.signAddVote(tmproto.PrecommitType, blockID.Hash, blockID.PartSetHeader)
return
}
@@ -1294,9 +1294,9 @@ func (cs *State) enterPrecommit(height int64, round int32) {
cs.LockedRound = -1
cs.LockedBlock = nil
cs.LockedBlockParts = nil
if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
cs.ProposalBlock = nil
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
}
cs.eventBus.PublishEventUnlock(cs.RoundStateEvent())
cs.signAddVote(tmproto.PrecommitType, nil, types.PartSetHeader{})
@@ -1396,7 +1396,7 @@ func (cs *State) enterCommit(height int64, commitRound int32) {
// If we don't have the block being committed, set up to get it.
if !cs.ProposalBlock.HashesTo(blockID.Hash) {
if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
logger.Info(
"Commit is for a block we don't know about. Set ProposalBlock=nil",
"proposal",
@@ -1406,7 +1406,7 @@ func (cs *State) enterCommit(height int64, commitRound int32) {
// We're getting the wrong block.
// Set up ProposalBlockParts and keep waiting.
cs.ProposalBlock = nil
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
}
@@ -1463,7 +1463,7 @@ func (cs *State) finalizeCommit(height int64) {
if !ok {
panic("Cannot finalizeCommit, commit does not have two thirds majority")
}
if !blockParts.HasHeader(blockID.PartsHeader) {
if !blockParts.HasHeader(blockID.PartSetHeader) {
panic("Expected ProposalBlockParts header to be commit header")
}
if !block.HashesTo(blockID.Hash) {
@@ -1526,7 +1526,7 @@ func (cs *State) finalizeCommit(height int64) {
var retainHeight int64
stateCopy, retainHeight, err = cs.blockExec.ApplyBlock(
stateCopy,
types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()},
types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()},
block)
if err != nil {
cs.Logger.Error("Error on ApplyBlock. Did the application crash? Please restart tendermint", "err", err)
@@ -1697,7 +1697,7 @@ func (cs *State) defaultSetProposal(proposal *types.Proposal) error {
// This happens if we're already in cstypes.RoundStepCommit or if there is a valid block in the current round.
// TODO: We can check if Proposal is for a different block as this is a sign of misbehavior!
if cs.ProposalBlockParts == nil {
cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockID.PartsHeader)
cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockID.PartSetHeader)
}
cs.Logger.Info("Received proposal", "proposal", proposal)
return nil
@@ -1930,8 +1930,8 @@ func (cs *State) addVote(
// We're getting the wrong block.
cs.ProposalBlock = nil
}
if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
}
cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
@@ -2010,7 +2010,7 @@ func (cs *State) signVote(
Round: cs.Round,
Timestamp: cs.voteTime(),
Type: msgType,
BlockID: types.BlockID{Hash: hash, PartsHeader: header},
BlockID: types.BlockID{Hash: hash, PartSetHeader: header},
}
v := vote.ToProto()
err = cs.privValidator.SignVote(cs.state.ChainID, v)
consensus/state_test.go
+5 -5
View File
@@ -204,7 +204,7 @@ func TestStateBadProposal(t *testing.T) {
stateHash[0] = (stateHash[0] + 1) % 255
propBlock.AppHash = stateHash
propBlockParts := propBlock.MakePartSet(partSize)
blockID := types.BlockID{Hash: propBlock.Hash(), PartsHeader: propBlockParts.Header()}
blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
proposal := types.NewProposal(vs2.Height, round, -1, blockID)
p := proposal.ToProto()
if err := vs2.SignProposal(config.ChainID(), p); err != nil {
@@ -311,10 +311,10 @@ func TestStateFullRound2(t *testing.T) {
// we should be stuck in limbo waiting for more prevotes
rs := cs1.GetRoundState()
propBlockHash, propPartsHeader := rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header()
propBlockHash, propPartSetHeader := rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header()
// prevote arrives from vs2:
signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propPartsHeader, vs2)
signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propPartSetHeader, vs2)
ensurePrevote(voteCh, height, round) // prevote
ensurePrecommit(voteCh, height, round) //precommit
@@ -324,7 +324,7 @@ func TestStateFullRound2(t *testing.T) {
// we should be stuck in limbo waiting for more precommits
// precommit arrives from vs2:
signAddVotes(cs1, tmproto.PrecommitType, propBlockHash, propPartsHeader, vs2)
signAddVotes(cs1, tmproto.PrecommitType, propBlockHash, propPartSetHeader, vs2)
ensurePrecommit(voteCh, height, round)
// wait to finish commit, propose in next height
@@ -994,7 +994,7 @@ func TestStateLockPOLSafety2(t *testing.T) {
_, propBlock0 := decideProposal(cs1, vss[0], height, round)
propBlockHash0 := propBlock0.Hash()
propBlockParts0 := propBlock0.MakePartSet(partSize)
propBlockID0 := types.BlockID{Hash: propBlockHash0, PartsHeader: propBlockParts0.Header()}
propBlockID0 := types.BlockID{Hash: propBlockHash0, PartSetHeader: propBlockParts0.Header()}
// the others sign a polka but we don't see it
prevotes := signVotes(tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4)
consensus/types/height_vote_set_test.go
+1 -1
View File
@@ -71,7 +71,7 @@ func makeVoteHR(t *testing.T, height int64, valIndex, round int32, privVals []ty
Round: round,
Timestamp: tmtime.Now(),
Type: tmproto.PrecommitType,
BlockID: types.BlockID{Hash: randBytes, PartsHeader: types.PartSetHeader{}},
BlockID: types.BlockID{Hash: randBytes, PartSetHeader: types.PartSetHeader{}},
}
chainID := config.ChainID()
consensus/types/peer_round_state.go
+6 -5
View File
@@ -21,10 +21,11 @@ type PeerRoundState struct {
StartTime time.Time `json:"start_time"`
// True if peer has proposal for this round
Proposal bool `json:"proposal"`
ProposalBlockPartsHeader types.PartSetHeader `json:"proposal_block_parts_header"` //
ProposalBlockParts *bits.BitArray `json:"proposal_block_parts"` //
ProposalPOLRound int32 `json:"proposal_pol_round"` // Proposal's POL round. -1 if none.
Proposal bool `json:"proposal"`
ProposalBlockPartSetHeader types.PartSetHeader `json:"proposal_block_part_set_header"`
ProposalBlockParts *bits.BitArray `json:"proposal_block_parts"`
// Proposal's POL round. -1 if none.
ProposalPOLRound int32 `json:"proposal_pol_round"`
// nil until ProposalPOLMessage received.
ProposalPOL *bits.BitArray `json:"proposal_pol"`
@@ -57,7 +58,7 @@ func (prs PeerRoundState) StringIndented(indent string) string {
%s Catchup %v (round %v)
%s}`,
indent, prs.Height, prs.Round, prs.Step, prs.StartTime,
indent, prs.ProposalBlockPartsHeader, prs.ProposalBlockParts,
indent, prs.ProposalBlockPartSetHeader, prs.ProposalBlockParts,
indent, prs.ProposalPOL, prs.ProposalPOLRound,
indent, prs.Prevotes,
indent, prs.Precommits,
consensus/types/round_state.go
+2 -2
View File
@@ -149,8 +149,8 @@ func (rs *RoundState) CompleteProposalEvent() types.EventDataCompleteProposal {
// We must construct BlockID from ProposalBlock and ProposalBlockParts
// cs.Proposal is not guaranteed to be set when this function is called
blockID := types.BlockID{
Hash: rs.ProposalBlock.Hash(),
PartsHeader: rs.ProposalBlockParts.Header(),
Hash: rs.ProposalBlock.Hash(),
PartSetHeader: rs.ProposalBlockParts.Header(),
}
return types.EventDataCompleteProposal{
evidence/pool_test.go
+2 -2
View File
@@ -303,14 +303,14 @@ func TestPotentialAmnesiaEvidence(t *testing.T) {
//evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
firstBlockID = types.BlockID{
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
},
}
secondBlockID = types.BlockID{
Hash: []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
light/helpers_test.go
+2 -2
View File
@@ -81,8 +81,8 @@ func (pkz privKeys) signHeader(header *types.Header, first, last int) *types.Com
vset := pkz.ToValidators(1, 1)
blockID := types.BlockID{
Hash: header.Hash(),
PartsHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
Hash: header.Hash(),
PartSetHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
}
// Fill in the votes we want.
privval/file_test.go
+7 -7
View File
@@ -56,7 +56,7 @@ func TestResetValidator(t *testing.T) {
height, round := int64(10), int32(1)
voteType := tmproto.PrevoteType
randBytes := tmrand.Bytes(tmhash.Size)
blockID := types.BlockID{Hash: randBytes, PartsHeader: types.PartSetHeader{}}
blockID := types.BlockID{Hash: randBytes, PartSetHeader: types.PartSetHeader{}}
vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
err = privVal.SignVote("mychainid", vote.ToProto())
assert.NoError(t, err, "expected no error signing vote")
@@ -170,9 +170,9 @@ func TestSignVote(t *testing.T) {
randbytes2 := tmrand.Bytes(tmhash.Size)
block1 := types.BlockID{Hash: randbytes,
PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
block2 := types.BlockID{Hash: randbytes2,
PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
PartSetHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
height, round := int64(10), int32(1)
voteType := tmproto.PrevoteType
@@ -223,9 +223,9 @@ func TestSignProposal(t *testing.T) {
randbytes2 := tmrand.Bytes(tmhash.Size)
block1 := types.BlockID{Hash: randbytes,
PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
block2 := types.BlockID{Hash: randbytes2,
PartsHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
PartSetHeader: types.PartSetHeader{Total: 10, Hash: randbytes2}}
height, round := int64(10), int32(1)
// sign a proposal for first time
@@ -267,7 +267,7 @@ func TestDifferByTimestamp(t *testing.T) {
privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
randbytes := tmrand.Bytes(tmhash.Size)
block1 := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
block1 := types.BlockID{Hash: randbytes, PartSetHeader: types.PartSetHeader{Total: 5, Hash: randbytes}}
height, round := int64(10), int32(1)
chainID := "mychainid"
@@ -297,7 +297,7 @@ func TestDifferByTimestamp(t *testing.T) {
// test vote
{
voteType := tmproto.PrevoteType
blockID := types.BlockID{Hash: randbytes, PartsHeader: types.PartSetHeader{}}
blockID := types.BlockID{Hash: randbytes, PartSetHeader: types.PartSetHeader{}}
vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
v := vote.ToProto()
err := privVal.SignVote("mychainid", v)
privval/signer_client_test.go
+10 -10
View File
@@ -104,7 +104,7 @@ func TestSignerProposal(t *testing.T) {
Height: 1,
Round: 2,
POLRound: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
}
want := &types.Proposal{
@@ -112,7 +112,7 @@ func TestSignerProposal(t *testing.T) {
Height: 1,
Round: 2,
POLRound: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
}
@@ -135,7 +135,7 @@ func TestSignerVote(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -145,7 +145,7 @@ func TestSignerVote(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -170,7 +170,7 @@ func TestSignerVoteResetDeadline(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -180,7 +180,7 @@ func TestSignerVoteResetDeadline(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -215,7 +215,7 @@ func TestSignerVoteKeepAlive(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -225,7 +225,7 @@ func TestSignerVoteKeepAlive(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
@@ -266,7 +266,7 @@ func TestSignerSignProposalErrors(t *testing.T) {
Height: 1,
Round: 2,
POLRound: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
Signature: []byte("signature"),
}
@@ -291,7 +291,7 @@ func TestSignerSignVoteErrors(t *testing.T) {
Type: tmproto.PrecommitType,
Height: 1,
Round: 2,
BlockID: types.BlockID{Hash: hash, PartsHeader: types.PartSetHeader{Hash: hash, Total: 2}},
BlockID: types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
Timestamp: ts,
ValidatorAddress: valAddr,
ValidatorIndex: 1,
proto/abci/types.proto
-10
View File
@@ -323,16 +323,6 @@ message TxResult {
//----------------------------------------
// Blockchain Types
message BlockID {
bytes hash = 1;
PartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
}
message PartSetHeader {
int32 total = 1;
bytes hash = 2;
}
// Validator
message Validator {
bytes address = 1;
proto/consensus/msgs.pb.go
+66 -66
View File
@@ -107,11 +107,11 @@ func (m *NewRoundStep) GetLastCommitRound() int32 {
//i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
// In case the block is also committed, then IsCommit flag is set to true.
type NewValidBlock struct {
Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
Round int32 `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
BlockPartsHeader types.PartSetHeader `protobuf:"bytes,3,opt,name=block_parts_header,json=blockPartsHeader,proto3" json:"block_parts_header"`
BlockParts *bits.BitArray `protobuf:"bytes,4,opt,name=block_parts,json=blockParts,proto3" json:"block_parts,omitempty"`
IsCommit bool `protobuf:"varint,5,opt,name=is_commit,json=isCommit,proto3" json:"is_commit,omitempty"`
Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
Round int32 `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
BlockPartSetHeader types.PartSetHeader `protobuf:"bytes,3,opt,name=block_part_set_header,json=blockPartSetHeader,proto3" json:"block_part_set_header"`
BlockParts *bits.BitArray `protobuf:"bytes,4,opt,name=block_parts,json=blockParts,proto3" json:"block_parts,omitempty"`
IsCommit bool `protobuf:"varint,5,opt,name=is_commit,json=isCommit,proto3" json:"is_commit,omitempty"`
}
func (m *NewValidBlock) Reset() { *m = NewValidBlock{} }
@@ -161,9 +161,9 @@ func (m *NewValidBlock) GetRound() int32 {
return 0
}
func (m *NewValidBlock) GetBlockPartsHeader() types.PartSetHeader {
func (m *NewValidBlock) GetBlockPartSetHeader() types.PartSetHeader {
if m != nil {
return m.BlockPartsHeader
return m.BlockPartSetHeader
}
return types.PartSetHeader{}
}
@@ -801,61 +801,61 @@ func init() {
func init() { proto.RegisterFile("proto/consensus/msgs.proto", fileDescriptor_9de64017f8b3fc88) }
var fileDescriptor_9de64017f8b3fc88 = []byte{
// 858 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x8f, 0xdb, 0x44,
0x18, 0xb6, 0x59, 0x67, 0x93, 0x7d, 0xbd, 0x1f, 0x65, 0x54, 0x4a, 0x48, 0x45, 0xb2, 0x18, 0x09,
0xad, 0x10, 0x72, 0xaa, 0xec, 0x01, 0xa9, 0x42, 0x02, 0xcc, 0x47, 0xdd, 0x55, 0xd3, 0x46, 0x4e,
0xd5, 0x03, 0x17, 0xcb, 0x89, 0x47, 0xce, 0xd0, 0xd8, 0x63, 0x79, 0x26, 0x59, 0x72, 0xe5, 0x17,
0xf0, 0x03, 0xf8, 0x1b, 0x48, 0xfc, 0x84, 0x1e, 0x7b, 0xe4, 0x54, 0xa1, 0xec, 0x1f, 0x40, 0x42,
0xe2, 0x8c, 0xe6, 0x23, 0xb1, 0xb7, 0xf5, 0x2e, 0xec, 0x05, 0x89, 0xcb, 0xca, 0x33, 0xef, 0xfb,
0x3c, 0xf3, 0x7e, 0x3e, 0x1b, 0xe8, 0xe4, 0x05, 0xe5, 0xb4, 0x3f, 0xa5, 0x19, 0xc3, 0x19, 0x5b,
0xb0, 0x7e, 0xca, 0x12, 0xe6, 0xca, 0x4b, 0x74, 0x9b, 0xe3, 0x2c, 0xc6, 0x45, 0x4a, 0x32, 0xee,
0x6e, 0x1d, 0x3a, 0x1f, 0xf1, 0x19, 0x29, 0xe2, 0x30, 0x8f, 0x0a, 0xbe, 0xea, 0x2b, 0x74, 0x42,
0x13, 0x5a, 0x7e, 0x29, 0x74, 0xe7, 0x5d, 0x75, 0xc3, 0x57, 0x39, 0x66, 0xea, 0xaf, 0x36, 0xdc,
0x55, 0x86, 0x39, 0x99, 0xb0, 0xfe, 0x84, 0xf0, 0x4b, 0x46, 0xe7, 0x17, 0x13, 0xf6, 0x1f, 0xe3,
0xf3, 0x80, 0x2e, 0xb2, 0x78, 0xcc, 0x71, 0x8e, 0xee, 0xc0, 0xee, 0x0c, 0x93, 0x64, 0xc6, 0xdb,
0xe6, 0xb1, 0x79, 0xb2, 0x13, 0xe8, 0x13, 0xba, 0x0d, 0x8d, 0x42, 0x38, 0xb5, 0xdf, 0x3a, 0x36,
0x4f, 0x1a, 0x81, 0x3a, 0x20, 0x04, 0x16, 0xe3, 0x38, 0x6f, 0xef, 0x1c, 0x9b, 0x27, 0x07, 0x81,
0xfc, 0x46, 0x9f, 0x42, 0x9b, 0xe1, 0x29, 0xcd, 0x62, 0x16, 0x32, 0x92, 0x4d, 0x71, 0xc8, 0x78,
0x54, 0xf0, 0x90, 0x93, 0x14, 0xb7, 0x2d, 0xc9, 0xf9, 0x8e, 0xb6, 0x8f, 0x85, 0x79, 0x2c, 0xac,
0x4f, 0x49, 0x8a, 0xd1, 0xc7, 0xf0, 0xf6, 0x3c, 0x62, 0x3c, 0x9c, 0xd2, 0x34, 0x25, 0x3c, 0x54,
0xcf, 0x35, 0xe4, 0x73, 0x47, 0xc2, 0xf0, 0x95, 0xbc, 0x97, 0xa1, 0x3a, 0x7f, 0x98, 0x70, 0xf0,
0x18, 0x9f, 0x3f, 0x8b, 0xe6, 0x24, 0xf6, 0xe6, 0x74, 0xfa, 0xfc, 0x86, 0x81, 0x8f, 0x01, 0x4d,
0x04, 0x4c, 0xd6, 0x95, 0x85, 0x33, 0x1c, 0xc5, 0xb8, 0x90, 0x69, 0xd8, 0x83, 0x9e, 0x5b, 0x69,
0x84, 0x2a, 0xd6, 0x28, 0x2a, 0xf8, 0x18, 0x73, 0x5f, 0xba, 0x79, 0xd6, 0x8b, 0x57, 0x3d, 0x23,
0xb8, 0x25, 0x09, 0x84, 0x85, 0xa9, 0x7b, 0xf4, 0x39, 0xd8, 0x15, 0x52, 0x99, 0xac, 0x3d, 0xe8,
0x56, 0xd9, 0x44, 0x13, 0x5c, 0xd1, 0x04, 0xd7, 0x23, 0xfc, 0xcb, 0xa2, 0x88, 0x56, 0x01, 0x94,
0x34, 0xe8, 0x2e, 0xec, 0x11, 0xa6, 0xf3, 0x97, 0x99, 0xb7, 0x82, 0x16, 0x61, 0x2a, 0x6f, 0xc7,
0x87, 0xd6, 0xa8, 0xa0, 0x39, 0x65, 0xd1, 0x1c, 0x7d, 0x06, 0xad, 0x5c, 0x7f, 0xcb, 0x74, 0xed,
0x41, 0xa7, 0x26, 0x68, 0xed, 0xa1, 0xe3, 0xdd, 0x22, 0x9c, 0x9f, 0x4d, 0xb0, 0x37, 0xc6, 0xd1,
0x93, 0x47, 0x57, 0x96, 0xee, 0x13, 0x40, 0x1b, 0x4c, 0x98, 0xd3, 0x79, 0x58, 0xad, 0xe3, 0xad,
0x8d, 0x65, 0x44, 0xe7, 0xb2, 0x25, 0xe8, 0x01, 0xec, 0x57, 0xbd, 0x75, 0x31, 0xff, 0x21, 0x7d,
0x1d, 0x9b, 0x5d, 0x61, 0x73, 0x9e, 0xc3, 0x9e, 0xb7, 0xa9, 0xc9, 0x0d, 0xdb, 0x7a, 0x0f, 0x2c,
0x51, 0x7b, 0xfd, 0xf6, 0x9d, 0xfa, 0x46, 0xea, 0x37, 0xa5, 0xa7, 0x33, 0x00, 0xeb, 0x19, 0xe5,
0x62, 0xf8, 0xac, 0x25, 0xe5, 0x58, 0x57, 0xb3, 0x06, 0x29, 0xbc, 0x02, 0xe9, 0xe3, 0xfc, 0x68,
0x42, 0xd3, 0x8f, 0x98, 0xc4, 0xdd, 0x2c, 0xbe, 0x53, 0xb0, 0x04, 0x9b, 0x8c, 0xef, 0xb0, 0x6e,
0xd0, 0xc6, 0x24, 0xc9, 0x70, 0x3c, 0x64, 0xc9, 0xd3, 0x55, 0x8e, 0x03, 0xe9, 0x2c, 0xa8, 0x48,
0x16, 0xe3, 0x1f, 0xe4, 0x40, 0x35, 0x02, 0x75, 0x70, 0x7e, 0x35, 0x61, 0x5f, 0x44, 0x30, 0xc6,
0x7c, 0x18, 0x7d, 0x3f, 0x38, 0xfd, 0x2f, 0x22, 0xf9, 0x06, 0x5a, 0x6a, 0xc0, 0x49, 0xac, 0xa7,
0xfb, 0xbd, 0x37, 0x81, 0xb2, 0x77, 0x0f, 0xbf, 0xf6, 0x8e, 0x44, 0x95, 0xd7, 0xaf, 0x7a, 0x4d,
0x7d, 0x11, 0x34, 0x25, 0xf6, 0x61, 0xec, 0xfc, 0x69, 0x82, 0xad, 0x43, 0xf7, 0x08, 0x67, 0xff,
0x9f, 0xc8, 0xd1, 0x7d, 0x68, 0x88, 0x09, 0x60, 0x72, 0x39, 0xff, 0xed, 0x70, 0x2b, 0x88, 0xf3,
0x97, 0x05, 0xcd, 0x21, 0x66, 0x2c, 0x4a, 0x30, 0x3a, 0x83, 0xc3, 0x0c, 0x9f, 0xab, 0x85, 0x0a,
0xa5, 0x82, 0xaa, 0xb9, 0x73, 0xdc, 0xba, 0xff, 0x01, 0x6e, 0x55, 0xa1, 0x7d, 0x23, 0xd8, 0xcf,
0xaa, 0x8a, 0x3d, 0x84, 0x23, 0xc1, 0xb5, 0x14, 0x52, 0x18, 0xca, 0x40, 0x65, 0xbd, 0xec, 0xc1,
0x87, 0x57, 0x92, 0x95, 0xb2, 0xe9, 0x1b, 0xc1, 0x41, 0x76, 0x49, 0x47, 0xab, 0xd2, 0x52, 0xb3,
0xc2, 0x25, 0xcf, 0x46, 0x41, 0xfc, 0x8a, 0xb4, 0xa0, 0x6f, 0x5f, 0x13, 0x01, 0x55, 0xeb, 0x0f,
0xae, 0x67, 0x18, 0x3d, 0x79, 0xe4, 0x5f, 0xd6, 0x00, 0xf4, 0x05, 0x40, 0x29, 0xa5, 0xba, 0xda,
0xbd, 0x7a, 0x96, 0xad, 0x56, 0xf8, 0x46, 0xb0, 0xb7, 0x15, 0x53, 0x21, 0x05, 0x72, 0xa1, 0x77,
0xdf, 0x94, 0xc7, 0x12, 0x2b, 0xa6, 0xd0, 0x37, 0xd4, 0x5a, 0xa3, 0xfb, 0xd0, 0x9a, 0x45, 0x2c,
0x94, 0xa8, 0xa6, 0x44, 0xbd, 0x5f, 0x8f, 0xd2, 0xbb, 0xef, 0x1b, 0x41, 0x73, 0xa6, 0x65, 0xe0,
0x0c, 0x0e, 0x05, 0x2e, 0x64, 0x98, 0x87, 0xa9, 0x58, 0xc7, 0x76, 0xeb, 0xba, 0x86, 0x56, 0x17,
0x57, 0x34, 0x74, 0x59, 0x5d, 0xe4, 0x07, 0x70, 0xb0, 0xe5, 0x12, 0xf3, 0xd4, 0xde, 0xbb, 0xae,
0x88, 0x95, 0x45, 0x12, 0x45, 0x5c, 0x96, 0x47, 0xaf, 0x01, 0x3b, 0x6c, 0x91, 0x7a, 0x67, 0x2f,
0xd6, 0x5d, 0xf3, 0xe5, 0xba, 0x6b, 0xfe, 0xbe, 0xee, 0x9a, 0x3f, 0x5d, 0x74, 0x8d, 0x97, 0x17,
0x5d, 0xe3, 0xb7, 0x8b, 0xae, 0xf1, 0xdd, 0xbd, 0x84, 0xf0, 0xd9, 0x62, 0xe2, 0x4e, 0x69, 0xda,
0x2f, 0xc9, 0xab, 0x9f, 0xaf, 0xfd, 0x5c, 0x99, 0xec, 0xca, 0x8b, 0xd3, 0xbf, 0x03, 0x00, 0x00,
0xff, 0xff, 0x6c, 0xa7, 0x03, 0xea, 0xc8, 0x08, 0x00, 0x00,
// 860 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xdd, 0x8e, 0xdb, 0x44,
0x14, 0xb6, 0x59, 0x67, 0x93, 0x3d, 0xde, 0x1f, 0x18, 0xb5, 0x25, 0x6c, 0x45, 0xb2, 0x18, 0x09,
0xad, 0x10, 0x72, 0xaa, 0xec, 0x05, 0x52, 0x85, 0x04, 0x98, 0x9f, 0xba, 0xab, 0xa6, 0x8d, 0x9c,
0xaa, 0x42, 0xdc, 0x58, 0x4e, 0x3c, 0x72, 0x86, 0xc6, 0x1e, 0xcb, 0x33, 0xc9, 0x92, 0x5b, 0x9e,
0x80, 0x07, 0xe0, 0x35, 0x90, 0x78, 0x84, 0x5e, 0xf6, 0x92, 0xab, 0x0a, 0x65, 0x1f, 0x01, 0xc1,
0x35, 0x9a, 0x9f, 0xc4, 0x4e, 0xeb, 0x2e, 0xec, 0x0d, 0x52, 0x6f, 0xa2, 0x99, 0x39, 0xe7, 0x7c,
0x73, 0xe6, 0x3b, 0xe7, 0x7c, 0x0e, 0x1c, 0xe7, 0x05, 0xe5, 0xb4, 0x37, 0xa1, 0x19, 0xc3, 0x19,
0x9b, 0xb3, 0x5e, 0xca, 0x12, 0xe6, 0xca, 0x43, 0x74, 0x83, 0xe3, 0x2c, 0xc6, 0x45, 0x4a, 0x32,
0xee, 0x6e, 0x1c, 0x8e, 0x3f, 0xe2, 0x53, 0x52, 0xc4, 0x61, 0x1e, 0x15, 0x7c, 0xd9, 0x53, 0xd1,
0x09, 0x4d, 0x68, 0xb9, 0x52, 0xd1, 0xc7, 0xef, 0xaa, 0x13, 0xbe, 0xcc, 0x31, 0x53, 0xbf, 0xda,
0x70, 0x5b, 0x19, 0x66, 0x64, 0xcc, 0x7a, 0x63, 0xc2, 0xb7, 0x8c, 0xce, 0xaf, 0x26, 0xec, 0x3f,
0xc4, 0x17, 0x01, 0x9d, 0x67, 0xf1, 0x88, 0xe3, 0x1c, 0xdd, 0x82, 0xdd, 0x29, 0x26, 0xc9, 0x94,
0xb7, 0xcd, 0x13, 0xf3, 0x74, 0x27, 0xd0, 0x3b, 0x74, 0x03, 0x1a, 0x85, 0x70, 0x6a, 0xbf, 0x75,
0x62, 0x9e, 0x36, 0x02, 0xb5, 0x41, 0x08, 0x2c, 0xc6, 0x71, 0xde, 0xde, 0x39, 0x31, 0x4f, 0x0f,
0x02, 0xb9, 0x46, 0x9f, 0x42, 0x9b, 0xe1, 0x09, 0xcd, 0x62, 0x16, 0x32, 0x92, 0x4d, 0x70, 0xc8,
0x78, 0x54, 0xf0, 0x90, 0x93, 0x14, 0xb7, 0x2d, 0x89, 0x79, 0x53, 0xdb, 0x47, 0xc2, 0x3c, 0x12,
0xd6, 0xc7, 0x24, 0xc5, 0xe8, 0x63, 0x78, 0x67, 0x16, 0x31, 0x1e, 0x4e, 0x68, 0x9a, 0x12, 0x1e,
0xaa, 0xeb, 0x1a, 0xf2, 0xba, 0x23, 0x61, 0xf8, 0x4a, 0x9e, 0xcb, 0x54, 0x9d, 0xbf, 0x4c, 0x38,
0x78, 0x88, 0x2f, 0x9e, 0x44, 0x33, 0x12, 0x7b, 0x33, 0x3a, 0x79, 0x7a, 0xcd, 0xc4, 0xbf, 0x83,
0x9b, 0x63, 0x11, 0x26, 0x79, 0x0d, 0x19, 0xe6, 0xe1, 0x14, 0x47, 0x31, 0x2e, 0xe4, 0x4b, 0xec,
0x7e, 0xd7, 0xad, 0xd4, 0x42, 0xf1, 0x35, 0x8c, 0x0a, 0x3e, 0xc2, 0xdc, 0x97, 0x6e, 0x9e, 0xf5,
0xec, 0x45, 0xd7, 0x08, 0x90, 0xc4, 0xd8, 0xb2, 0xa0, 0xcf, 0xc1, 0x2e, 0x91, 0x99, 0x7c, 0xb1,
0xdd, 0xef, 0x54, 0xf1, 0x44, 0x25, 0x5c, 0x51, 0x09, 0xd7, 0x23, 0xfc, 0xcb, 0xa2, 0x88, 0x96,
0x01, 0x6c, 0x80, 0x18, 0xba, 0x0d, 0x7b, 0x84, 0x69, 0x12, 0xe4, 0xf3, 0x5b, 0x41, 0x8b, 0x30,
0xf5, 0x78, 0xc7, 0x87, 0xd6, 0xb0, 0xa0, 0x39, 0x65, 0xd1, 0x0c, 0x7d, 0x06, 0xad, 0x5c, 0xaf,
0xe5, 0x9b, 0xed, 0xfe, 0x71, 0x4d, 0xda, 0xda, 0x43, 0x67, 0xbc, 0x89, 0x70, 0x7e, 0x31, 0xc1,
0x5e, 0x1b, 0x87, 0x8f, 0x1e, 0xbc, 0x96, 0xbf, 0x4f, 0x00, 0xad, 0x63, 0xc2, 0x9c, 0xce, 0xc2,
0x2a, 0x99, 0x6f, 0xaf, 0x2d, 0x43, 0x3a, 0x93, 0x75, 0x41, 0xf7, 0x60, 0xbf, 0xea, 0xad, 0xe9,
0xfc, 0x97, 0xe7, 0xeb, 0xdc, 0xec, 0x0a, 0x9a, 0xf3, 0x14, 0xf6, 0xbc, 0x35, 0x27, 0xd7, 0xac,
0xed, 0x1d, 0xb0, 0x04, 0xf7, 0xfa, 0xee, 0x5b, 0xf5, 0xa5, 0xd4, 0x77, 0x4a, 0x4f, 0xa7, 0x0f,
0xd6, 0x13, 0xca, 0x45, 0x07, 0x5a, 0x0b, 0xca, 0xb1, 0x66, 0xb3, 0x26, 0x52, 0x78, 0x05, 0xd2,
0xc7, 0xf9, 0xc9, 0x84, 0xa6, 0x1f, 0x31, 0x19, 0x77, 0xbd, 0xfc, 0xce, 0xc0, 0x12, 0x68, 0x32,
0xbf, 0xc3, 0xba, 0x56, 0x1b, 0x91, 0x24, 0xc3, 0xf1, 0x80, 0x25, 0x8f, 0x97, 0x39, 0x0e, 0xa4,
0xb3, 0x80, 0x22, 0x59, 0x8c, 0x7f, 0x94, 0x0d, 0xd5, 0x08, 0xd4, 0xc6, 0xf9, 0xcd, 0x84, 0x7d,
0x91, 0xc1, 0x08, 0xf3, 0x41, 0xf4, 0x43, 0xff, 0xec, 0xff, 0xc8, 0xe4, 0x1b, 0x68, 0xa9, 0x06,
0x27, 0xb1, 0xee, 0xee, 0xf7, 0x5e, 0x0d, 0x94, 0xb5, 0xbb, 0xff, 0xb5, 0x77, 0x24, 0x58, 0x5e,
0xbd, 0xe8, 0x36, 0xf5, 0x41, 0xd0, 0x94, 0xb1, 0xf7, 0x63, 0xe7, 0x4f, 0x13, 0x6c, 0x9d, 0xba,
0x47, 0x38, 0x7b, 0x73, 0x32, 0x47, 0x77, 0xa1, 0x21, 0x3a, 0x80, 0xc9, 0xe1, 0xfc, 0xaf, 0xcd,
0xad, 0x42, 0x9c, 0xbf, 0x2d, 0x68, 0x0e, 0x30, 0x63, 0x51, 0x82, 0xd1, 0x39, 0x1c, 0x66, 0xf8,
0x42, 0x0d, 0x54, 0x28, 0x65, 0x54, 0xf5, 0x9d, 0xe3, 0xd6, 0x7d, 0x08, 0xdc, 0xaa, 0x4c, 0xfb,
0x46, 0xb0, 0x9f, 0x55, 0x65, 0x7b, 0x00, 0x47, 0x02, 0x6b, 0x21, 0xf4, 0x30, 0x94, 0x89, 0x4a,
0xbe, 0xec, 0xfe, 0x87, 0xaf, 0x05, 0x2b, 0xb5, 0xd3, 0x37, 0x82, 0x83, 0x6c, 0x4b, 0x4c, 0xab,
0xd2, 0x52, 0x33, 0xc2, 0x25, 0xce, 0x5a, 0x41, 0xfc, 0x8a, 0xb4, 0xa0, 0x6f, 0x5f, 0x12, 0x01,
0xc5, 0xf5, 0x07, 0x57, 0x23, 0x0c, 0x1f, 0x3d, 0xf0, 0xb7, 0x35, 0x00, 0x7d, 0x01, 0x50, 0x4a,
0xa9, 0x66, 0xbb, 0x5b, 0x8f, 0xb2, 0xd1, 0x0a, 0xdf, 0x08, 0xf6, 0x36, 0x62, 0x2a, 0xa4, 0x40,
0x0e, 0xf4, 0xee, 0xab, 0xf2, 0x58, 0xc6, 0x8a, 0x2e, 0xf4, 0x0d, 0x35, 0xd6, 0xe8, 0x2e, 0xb4,
0xa6, 0x11, 0x0b, 0x65, 0x54, 0x53, 0x46, 0xbd, 0x5f, 0x1f, 0xa5, 0x67, 0xdf, 0x37, 0x82, 0xe6,
0x54, 0xcb, 0xc0, 0x39, 0x1c, 0x8a, 0x38, 0xf9, 0x39, 0x49, 0xc5, 0x38, 0xb6, 0x5b, 0x57, 0x15,
0xb4, 0x3a, 0xb8, 0xa2, 0xa0, 0x8b, 0xea, 0x20, 0xdf, 0x83, 0x83, 0x0d, 0x96, 0xe8, 0xa7, 0xf6,
0xde, 0x55, 0x24, 0x56, 0x06, 0x49, 0x90, 0xb8, 0x28, 0xb7, 0x5e, 0x03, 0x76, 0xd8, 0x3c, 0xf5,
0xce, 0x9f, 0xad, 0x3a, 0xe6, 0xf3, 0x55, 0xc7, 0xfc, 0x63, 0xd5, 0x31, 0x7f, 0xbe, 0xec, 0x18,
0xcf, 0x2f, 0x3b, 0xc6, 0xef, 0x97, 0x1d, 0xe3, 0xfb, 0x3b, 0x09, 0xe1, 0xd3, 0xf9, 0xd8, 0x9d,
0xd0, 0xb4, 0x57, 0x82, 0x57, 0x97, 0x2f, 0xfd, 0x67, 0x19, 0xef, 0xca, 0x83, 0xb3, 0x7f, 0x02,
0x00, 0x00, 0xff, 0xff, 0xc8, 0x89, 0x05, 0x9a, 0xcd, 0x08, 0x00, 0x00,
}
func (m *NewRoundStep) Marshal() (dAtA []byte, err error) {
@@ -949,7 +949,7 @@ func (m *NewValidBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x22
}
{
size, err := m.BlockPartsHeader.MarshalToSizedBuffer(dAtA[:i])
size, err := m.BlockPartSetHeader.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -1542,7 +1542,7 @@ func (m *NewValidBlock) Size() (n int) {
if m.Round != 0 {
n += 1 + sovMsgs(uint64(m.Round))
}
l = m.BlockPartsHeader.Size()
l = m.BlockPartSetHeader.Size()
n += 1 + l + sovMsgs(uint64(l))
if m.BlockParts != nil {
l = m.BlockParts.Size()
@@ -2019,7 +2019,7 @@ func (m *NewValidBlock) Unmarshal(dAtA []byte) error {
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockPartsHeader", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockPartSetHeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -2046,7 +2046,7 @@ func (m *NewValidBlock) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.BlockPartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
if err := m.BlockPartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
proto/consensus/msgs.proto
+5 -5
View File
@@ -21,11 +21,11 @@ message NewRoundStep {
//i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
// In case the block is also committed, then IsCommit flag is set to true.
message NewValidBlock {
int64 height = 1;
int32 round = 2;
tendermint.types.PartSetHeader block_parts_header = 3 [(gogoproto.nullable) = false];
tendermint.libs.bits.BitArray block_parts = 4;
bool is_commit = 5;
int64 height = 1;
int32 round = 2;
tendermint.types.PartSetHeader block_part_set_header = 3 [(gogoproto.nullable) = false];
tendermint.libs.bits.BitArray block_parts = 4;
bool is_commit = 5;
}
// ProposalMessage is sent when a new block is proposed.
proto/types/canonical.pb.go
+40 -40
View File
@@ -29,8 +29,8 @@ var _ = time.Kitchen
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type CanonicalBlockID struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
PartsHeader CanonicalPartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
PartSetHeader CanonicalPartSetHeader `protobuf:"bytes,2,opt,name=part_set_header,json=partSetHeader,proto3" json:"part_set_header"`
}
func (m *CanonicalBlockID) Reset() { *m = CanonicalBlockID{} }
@@ -73,9 +73,9 @@ func (m *CanonicalBlockID) GetHash() []byte {
return nil
}
func (m *CanonicalBlockID) GetPartsHeader() CanonicalPartSetHeader {
func (m *CanonicalBlockID) GetPartSetHeader() CanonicalPartSetHeader {
if m != nil {
return m.PartsHeader
return m.PartSetHeader
}
return CanonicalPartSetHeader{}
}
@@ -318,38 +318,38 @@ func init() {
func init() { proto.RegisterFile("proto/types/canonical.proto", fileDescriptor_3f9b1d584b46f180) }
var fileDescriptor_3f9b1d584b46f180 = []byte{
// 489 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcb, 0x6e, 0xd3, 0x40,
0x14, 0xcd, 0xa4, 0x4e, 0xe2, 0x4c, 0x52, 0x14, 0x46, 0xa8, 0x58, 0x41, 0xb2, 0x23, 0x2f, 0x2a,
0x23, 0x21, 0x5b, 0x6a, 0xff, 0xc0, 0x45, 0x88, 0x20, 0x10, 0x65, 0x5a, 0xb1, 0x60, 0x13, 0x4d,
0xec, 0xc1, 0x1e, 0xe1, 0x78, 0x2c, 0x7b, 0xb2, 0xc8, 0x5f, 0xf4, 0x3b, 0xf8, 0x92, 0x2e, 0xbb,
0x84, 0x4d, 0x40, 0xce, 0x8f, 0xa0, 0x99, 0x49, 0xe2, 0x88, 0xd7, 0x06, 0xd4, 0x8d, 0x75, 0x1f,
0xe7, 0x9e, 0x7b, 0x7c, 0xae, 0x06, 0x3e, 0x29, 0x4a, 0x2e, 0x78, 0x20, 0x56, 0x05, 0xad, 0x82,
0x88, 0xe4, 0x3c, 0x67, 0x11, 0xc9, 0x7c, 0x55, 0x45, 0x23, 0x41, 0xf3, 0x98, 0x96, 0x0b, 0x96,
0x0b, 0x5f, 0x21, 0xc6, 0xa7, 0x22, 0x65, 0x65, 0x3c, 0x2b, 0x48, 0x29, 0x56, 0x81, 0x1e, 0x4d,
0x78, 0xc2, 0x9b, 0x48, 0x4f, 0x8e, 0x1f, 0x1f, 0xd2, 0xaa, 0xef, 0xb6, 0xe1, 0x24, 0x9c, 0x27,
0x19, 0xd5, 0xb3, 0xf3, 0xe5, 0xc7, 0x40, 0xb0, 0x05, 0xad, 0x04, 0x59, 0x14, 0x1a, 0xe0, 0xae,
0xe0, 0xe8, 0x62, 0x27, 0x23, 0xcc, 0x78, 0xf4, 0x69, 0xfa, 0x1c, 0x21, 0x68, 0xa4, 0xa4, 0x4a,
0x2d, 0x30, 0x01, 0xde, 0x10, 0xab, 0x18, 0xbd, 0x83, 0x43, 0xa9, 0xa2, 0x9a, 0xa5, 0x94, 0xc4,
0xb4, 0xb4, 0xda, 0x13, 0xe0, 0x0d, 0xce, 0x3c, 0xff, 0x67, 0xc9, 0xfe, 0x9e, 0xed, 0x92, 0x94,
0xe2, 0x8a, 0x8a, 0x97, 0x0a, 0x1f, 0x1a, 0xb7, 0x6b, 0xa7, 0x85, 0x07, 0x8a, 0x43, 0x97, 0xdc,
0x10, 0x9e, 0xfc, 0x1e, 0x8c, 0x1e, 0xc1, 0x8e, 0xe0, 0x82, 0x64, 0x4a, 0xc1, 0x31, 0xd6, 0xc9,
0x5e, 0x56, 0xbb, 0x91, 0xe5, 0x7e, 0x6d, 0xc3, 0x87, 0x0d, 0x49, 0xc9, 0x0b, 0x5e, 0x91, 0x0c,
0x9d, 0x43, 0x43, 0x8a, 0x51, 0xe3, 0x0f, 0xce, 0x9c, 0x5f, 0x45, 0x5e, 0xb1, 0x24, 0xa7, 0xf1,
0x9b, 0x2a, 0xb9, 0x5e, 0x15, 0x14, 0x2b, 0x30, 0x3a, 0x81, 0xdd, 0x94, 0xb2, 0x24, 0x15, 0x6a,
0xc1, 0x08, 0x6f, 0x33, 0x29, 0xa6, 0xe4, 0xcb, 0x3c, 0xb6, 0x8e, 0x54, 0x59, 0x27, 0xe8, 0x29,
0xec, 0x17, 0x3c, 0x9b, 0xe9, 0x8e, 0x31, 0x01, 0xde, 0x51, 0x38, 0xac, 0xd7, 0x8e, 0x79, 0xf9,
0xf6, 0x35, 0x96, 0x35, 0x6c, 0x16, 0x3c, 0x53, 0x11, 0x7a, 0x05, 0xcd, 0xb9, 0x74, 0x76, 0xc6,
0x62, 0xab, 0xa3, 0x6c, 0x73, 0xff, 0x62, 0xdb, 0xf6, 0x08, 0xe1, 0xa0, 0x5e, 0x3b, 0xbd, 0x6d,
0x82, 0x7b, 0x8a, 0x60, 0x1a, 0xa3, 0x10, 0xf6, 0xf7, 0x17, 0xb4, 0xba, 0x8a, 0x6c, 0xec, 0xeb,
0x1b, 0xfb, 0xbb, 0x1b, 0xfb, 0xd7, 0x3b, 0x44, 0x68, 0x4a, 0xd7, 0x6f, 0xbe, 0x39, 0x00, 0x37,
0x63, 0xe8, 0x14, 0x9a, 0x51, 0x4a, 0x58, 0x2e, 0xf5, 0xf4, 0x26, 0xc0, 0xeb, 0xeb, 0x5d, 0x17,
0xb2, 0x26, 0x77, 0xa9, 0xe6, 0x34, 0x76, 0x3f, 0xb7, 0xe1, 0xf1, 0x5e, 0xd6, 0x7b, 0x2e, 0xe8,
0x7d, 0xf8, 0x7a, 0x68, 0x96, 0xf1, 0x3f, 0xcd, 0xea, 0xfc, 0xbb, 0x59, 0xdd, 0x3f, 0x9b, 0x15,
0xbe, 0xb8, 0xad, 0x6d, 0x70, 0x57, 0xdb, 0xe0, 0x7b, 0x6d, 0x83, 0x9b, 0x8d, 0xdd, 0xba, 0xdb,
0xd8, 0xad, 0x2f, 0x1b, 0xbb, 0xf5, 0xe1, 0x59, 0xc2, 0x44, 0xba, 0x9c, 0xfb, 0x11, 0x5f, 0x04,
0xcd, 0x9f, 0x1c, 0x86, 0x07, 0x8f, 0x77, 0xde, 0x55, 0xc9, 0xf9, 0x8f, 0x00, 0x00, 0x00, 0xff,
0xff, 0x6b, 0xbc, 0x84, 0x74, 0x29, 0x04, 0x00, 0x00,
// 493 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x93, 0xcf, 0x6e, 0xd3, 0x40,
0x10, 0xc6, 0xe3, 0xd4, 0x49, 0x9c, 0x6d, 0x03, 0x61, 0x85, 0x8a, 0x15, 0x24, 0x3b, 0xf2, 0xa1,
0x32, 0x12, 0xb2, 0xa5, 0xf6, 0x0d, 0x5c, 0x84, 0x08, 0x02, 0x51, 0xb9, 0x55, 0x0f, 0x5c, 0xac,
0x8d, 0xbd, 0xd8, 0x2b, 0x1c, 0xef, 0xca, 0xde, 0x1c, 0x72, 0xe1, 0x19, 0xfa, 0x1c, 0x3c, 0x49,
0x8f, 0x3d, 0xc2, 0x25, 0x20, 0xe7, 0x45, 0xd0, 0xee, 0x26, 0xb1, 0xc5, 0xbf, 0x0b, 0xa8, 0x97,
0x68, 0x66, 0xf6, 0x9b, 0x99, 0x5f, 0xbe, 0x91, 0xc1, 0x53, 0x56, 0x52, 0x4e, 0x7d, 0xbe, 0x62,
0xb8, 0xf2, 0x63, 0x54, 0xd0, 0x82, 0xc4, 0x28, 0xf7, 0x64, 0x15, 0x8e, 0x39, 0x2e, 0x12, 0x5c,
0x2e, 0x48, 0xc1, 0x3d, 0xa9, 0x98, 0x9c, 0xf0, 0x8c, 0x94, 0x49, 0xc4, 0x50, 0xc9, 0x57, 0xbe,
0x6a, 0x4d, 0x69, 0x4a, 0x9b, 0x48, 0x75, 0x4e, 0x9e, 0xb4, 0xc7, 0xca, 0xdf, 0xed, 0x83, 0x9d,
0x52, 0x9a, 0xe6, 0x58, 0xf5, 0xce, 0x97, 0x1f, 0x7c, 0x4e, 0x16, 0xb8, 0xe2, 0x68, 0xc1, 0x94,
0xc0, 0xf9, 0x04, 0xc6, 0xe7, 0x3b, 0x8c, 0x20, 0xa7, 0xf1, 0xc7, 0xd9, 0x0b, 0x08, 0x81, 0x9e,
0xa1, 0x2a, 0x33, 0xb5, 0xa9, 0xe6, 0x1e, 0x85, 0x32, 0x86, 0xd7, 0xe0, 0xa1, 0xa0, 0x88, 0x2a,
0xcc, 0xa3, 0x0c, 0xa3, 0x04, 0x97, 0x66, 0x77, 0xaa, 0xb9, 0x87, 0xa7, 0xae, 0xf7, 0x33, 0xb5,
0xb7, 0x1f, 0x78, 0x81, 0x4a, 0x7e, 0x89, 0xf9, 0x2b, 0xa9, 0x0f, 0xf4, 0xdb, 0xb5, 0xdd, 0x09,
0x47, 0xac, 0x5d, 0x74, 0x02, 0x70, 0xfc, 0x7b, 0x39, 0x7c, 0x0c, 0x7a, 0x9c, 0x72, 0x94, 0x4b,
0x8c, 0x51, 0xa8, 0x92, 0x3d, 0x5b, 0xb7, 0x61, 0x73, 0xbe, 0x76, 0xc1, 0xa3, 0x66, 0x48, 0x49,
0x19, 0xad, 0x50, 0x0e, 0xcf, 0x80, 0x2e, 0x70, 0x64, 0xfb, 0x83, 0x53, 0xfb, 0x57, 0xcc, 0x4b,
0x92, 0x16, 0x38, 0x79, 0x5b, 0xa5, 0x57, 0x2b, 0x86, 0x43, 0x29, 0x86, 0xc7, 0xa0, 0x9f, 0x61,
0x92, 0x66, 0x5c, 0x2e, 0x18, 0x87, 0xdb, 0x4c, 0xc0, 0x94, 0x74, 0x59, 0x24, 0xe6, 0x81, 0x2c,
0xab, 0x04, 0x3e, 0x03, 0x43, 0x46, 0xf3, 0x48, 0xbd, 0xe8, 0x53, 0xcd, 0x3d, 0x08, 0x8e, 0xea,
0xb5, 0x6d, 0x5c, 0xbc, 0x7b, 0x13, 0x8a, 0x5a, 0x68, 0x30, 0x9a, 0xcb, 0x08, 0xbe, 0x06, 0xc6,
0x5c, 0xd8, 0x1b, 0x91, 0xc4, 0xec, 0x49, 0xe3, 0x9c, 0xbf, 0x18, 0xb7, 0xbd, 0x44, 0x70, 0x58,
0xaf, 0xed, 0xc1, 0x36, 0x09, 0x07, 0x72, 0xc0, 0x2c, 0x81, 0x01, 0x18, 0xee, 0xcf, 0x68, 0xf6,
0xe5, 0xb0, 0x89, 0xa7, 0x0e, 0xed, 0xed, 0x0e, 0xed, 0x5d, 0xed, 0x14, 0x81, 0x21, 0x7c, 0xbf,
0xf9, 0x66, 0x6b, 0x61, 0xd3, 0x06, 0x4f, 0x80, 0x11, 0x67, 0x88, 0x14, 0x82, 0x67, 0x30, 0xd5,
0xdc, 0xa1, 0xda, 0x75, 0x2e, 0x6a, 0x62, 0x97, 0x7c, 0x9c, 0x25, 0xce, 0xe7, 0x2e, 0x18, 0xed,
0xb1, 0xae, 0x29, 0xc7, 0xf7, 0xe1, 0x6b, 0xdb, 0x2c, 0xfd, 0x7f, 0x9a, 0xd5, 0xfb, 0x77, 0xb3,
0xfa, 0x7f, 0x36, 0x2b, 0x78, 0x79, 0x5b, 0x5b, 0xda, 0x5d, 0x6d, 0x69, 0xdf, 0x6b, 0x4b, 0xbb,
0xd9, 0x58, 0x9d, 0xbb, 0x8d, 0xd5, 0xf9, 0xb2, 0xb1, 0x3a, 0xef, 0x9f, 0xa7, 0x84, 0x67, 0xcb,
0xb9, 0x17, 0xd3, 0x85, 0xdf, 0xfc, 0x93, 0x76, 0xd8, 0xfa, 0x82, 0xe7, 0x7d, 0x99, 0x9c, 0xfd,
0x08, 0x00, 0x00, 0xff, 0xff, 0x91, 0x72, 0x7f, 0x8c, 0x2e, 0x04, 0x00, 0x00,
}
func (m *CanonicalBlockID) Marshal() (dAtA []byte, err error) {
@@ -373,7 +373,7 @@ func (m *CanonicalBlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
var l int
_ = l
{
size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -587,7 +587,7 @@ func (m *CanonicalBlockID) Size() (n int) {
if l > 0 {
n += 1 + l + sovCanonical(uint64(l))
}
l = m.PartsHeader.Size()
l = m.PartSetHeader.Size()
n += 1 + l + sovCanonical(uint64(l))
return n
}
@@ -738,7 +738,7 @@ func (m *CanonicalBlockID) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -765,7 +765,7 @@ func (m *CanonicalBlockID) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
proto/types/canonical.proto
+2 -2
View File
@@ -8,8 +8,8 @@ import "proto/types/types.proto";
import "google/protobuf/timestamp.proto";
message CanonicalBlockID {
bytes hash = 1;
CanonicalPartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
bytes hash = 1;
CanonicalPartSetHeader part_set_header = 2 [(gogoproto.nullable) = false];
}
message CanonicalPartSetHeader {
proto/types/types.pb.go
+74 -73
View File
@@ -211,8 +211,8 @@ func (m *Part) GetProof() merkle.Proof {
// BlockID
type BlockID struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
PartSetHeader PartSetHeader `protobuf:"bytes,2,opt,name=part_set_header,json=partSetHeader,proto3" json:"part_set_header"`
}
func (m *BlockID) Reset() { *m = BlockID{} }
@@ -255,9 +255,9 @@ func (m *BlockID) GetHash() []byte {
return nil
}
func (m *BlockID) GetPartsHeader() PartSetHeader {
func (m *BlockID) GetPartSetHeader() PartSetHeader {
if m != nil {
return m.PartsHeader
return m.PartSetHeader
}
return PartSetHeader{}
}
@@ -1022,7 +1022,7 @@ func init() {
func init() { proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }
var fileDescriptor_ff06f8095857fb18 = []byte{
// 1312 bytes of a gzipped FileDescriptorProto
// 1314 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4f, 0x6f, 0x1a, 0x47,
0x14, 0xf7, 0xc2, 0x62, 0xe0, 0x01, 0x36, 0x5e, 0xb9, 0x09, 0xc1, 0x0d, 0xa6, 0x44, 0x49, 0x9d,
0x34, 0x82, 0xc8, 0x51, 0xab, 0x56, 0x51, 0x0f, 0x60, 0x93, 0x04, 0xc5, 0xc6, 0x68, 0xa1, 0xa9,
@@ -1041,70 +1041,71 @@ var fileDescriptor_ff06f8095857fb18 = []byte{
0x54, 0x88, 0x95, 0x95, 0x8d, 0xac, 0x8e, 0xe3, 0x0a, 0x05, 0x95, 0x87, 0xf2, 0x08, 0xdb, 0xb5,
0xc8, 0x41, 0x18, 0x81, 0x13, 0x6e, 0xed, 0x1f, 0x32, 0x12, 0xc8, 0x10, 0x31, 0xd1, 0xee, 0x41,
0xc2, 0xf3, 0x29, 0x7d, 0x52, 0x88, 0x97, 0x95, 0x8d, 0xcc, 0xe6, 0x7a, 0x35, 0x42, 0x9a, 0xa8,
0xa0, 0x2a, 0x2a, 0xa8, 0x76, 0x38, 0xac, 0xa1, 0xbe, 0x78, 0xb5, 0xbe, 0xa0, 0x8b, 0x98, 0xca,
0x10, 0x92, 0x0d, 0x87, 0x0e, 0x9e, 0xb6, 0xb6, 0xa7, 0xfb, 0x51, 0x66, 0xfb, 0xd1, 0x1e, 0x42,
0x96, 0x53, 0x1d, 0x18, 0x23, 0xac, 0x04, 0x17, 0x3e, 0xb5, 0x84, 0xa0, 0x65, 0xae, 0x60, 0xb9,
0x44, 0x06, 0x43, 0x85, 0xa9, 0xf2, 0x87, 0x0a, 0x8b, 0x92, 0x8e, 0x4f, 0x21, 0x29, 0x09, 0xc3,
0xb5, 0x32, 0x9b, 0x57, 0xa3, 0xf9, 0x42, 0x2e, 0xb7, 0xa8, 0x1b, 0x10, 0x37, 0x98, 0x04, 0x32,
0x5b, 0x18, 0xa3, 0xdd, 0x80, 0xd4, 0x60, 0x64, 0xda, 0xae, 0x61, 0x5b, 0xb8, 0x9f, 0x74, 0x23,
0x73, 0xf2, 0x6a, 0x3d, 0xb9, 0xc5, 0x6d, 0xad, 0x6d, 0x3d, 0x89, 0xce, 0x96, 0xa5, 0x5d, 0x82,
0xc5, 0x11, 0xb1, 0x87, 0x23, 0x86, 0xc4, 0xc4, 0x75, 0x39, 0xd3, 0x3e, 0x06, 0x95, 0x8b, 0xa1,
0xa0, 0xe2, 0xda, 0xc5, 0xaa, 0x50, 0x4a, 0x35, 0x54, 0x4a, 0xb5, 0x17, 0x2a, 0xa5, 0x91, 0xe2,
0x0b, 0x3f, 0xff, 0x6d, 0x5d, 0xd1, 0x31, 0x42, 0xdb, 0x82, 0x9c, 0x63, 0x06, 0xcc, 0xe8, 0x73,
0xc6, 0xf8, 0xf2, 0x09, 0x4c, 0x71, 0xe5, 0x2c, 0x1d, 0x92, 0xd3, 0x90, 0x08, 0x1e, 0x25, 0x4c,
0x96, 0xb6, 0x01, 0x79, 0x4c, 0x32, 0xa0, 0xe3, 0xb1, 0xcd, 0x0c, 0xa4, 0x7c, 0x11, 0x29, 0x5f,
0xe2, 0xf6, 0x2d, 0x34, 0x3f, 0xe4, 0xe4, 0xaf, 0x41, 0xda, 0x32, 0x99, 0x29, 0x20, 0x49, 0x84,
0xa4, 0xb8, 0x01, 0x9d, 0xef, 0xc3, 0xf2, 0xbe, 0xe9, 0xd8, 0x96, 0xc9, 0xa8, 0x1f, 0x08, 0x48,
0x4a, 0x64, 0x99, 0x99, 0x11, 0x78, 0x07, 0x56, 0x5d, 0x72, 0xc0, 0x8c, 0xd3, 0xe8, 0x34, 0xa2,
0x35, 0xee, 0x7b, 0x3c, 0x1f, 0x71, 0x1d, 0x96, 0x06, 0x21, 0xf9, 0x02, 0x0b, 0x88, 0xcd, 0x4d,
0xad, 0x08, 0xbb, 0x02, 0x29, 0xd3, 0xf3, 0x04, 0x20, 0x83, 0x80, 0xa4, 0xe9, 0x79, 0xe8, 0xba,
0x05, 0x2b, 0x58, 0xa3, 0x4f, 0x82, 0x89, 0xc3, 0x64, 0x92, 0x2c, 0x62, 0x96, 0xb9, 0x43, 0x17,
0x76, 0xc4, 0x5e, 0x83, 0x1c, 0xd9, 0xb7, 0x2d, 0xe2, 0x0e, 0x88, 0xc0, 0xe5, 0x10, 0x97, 0x0d,
0x8d, 0x08, 0xba, 0x09, 0x79, 0xcf, 0xa7, 0x1e, 0x0d, 0x88, 0x6f, 0x98, 0x96, 0xe5, 0x93, 0x20,
0x28, 0x2c, 0x89, 0x7c, 0xa1, 0xbd, 0x2e, 0xcc, 0x95, 0xdb, 0xa0, 0x6e, 0x9b, 0xcc, 0xd4, 0xf2,
0x10, 0x67, 0x07, 0x41, 0x41, 0x29, 0xc7, 0x37, 0xb2, 0x3a, 0x1f, 0x9e, 0x7b, 0xe1, 0xfe, 0x8c,
0x81, 0xfa, 0x98, 0x32, 0xa2, 0xdd, 0x05, 0x95, 0x1f, 0x1d, 0x2a, 0x72, 0xe9, 0x3c, 0x85, 0x77,
0xed, 0xa1, 0x4b, 0xac, 0xdd, 0x60, 0xd8, 0x3b, 0xf4, 0x88, 0x8e, 0xe0, 0x88, 0xc4, 0x62, 0x73,
0x12, 0x5b, 0x85, 0x84, 0x4f, 0x27, 0xae, 0x85, 0xca, 0x4b, 0xe8, 0x62, 0xa2, 0x35, 0x21, 0x35,
0x55, 0x8e, 0xfa, 0x4f, 0xca, 0x59, 0xe6, 0xca, 0xe1, 0xba, 0x96, 0x06, 0x3d, 0xd9, 0x97, 0x02,
0x6a, 0x40, 0x7a, 0xfa, 0x98, 0x49, 0x05, 0xfe, 0x3b, 0x11, 0xcf, 0xc2, 0xb4, 0x0f, 0x60, 0x65,
0xaa, 0x87, 0x29, 0xa1, 0x42, 0x85, 0xf9, 0xa9, 0x43, 0x32, 0x3a, 0x27, 0x35, 0x43, 0x3c, 0x4b,
0x49, 0xac, 0x6b, 0x26, 0xb5, 0x16, 0xbe, 0x4f, 0xef, 0x42, 0x3a, 0xb0, 0x87, 0xae, 0xc9, 0x26,
0x3e, 0x91, 0x6a, 0x9c, 0x19, 0x2a, 0xdf, 0xc4, 0x60, 0x51, 0xa8, 0x3b, 0xc2, 0x9b, 0x72, 0x3e,
0x6f, 0xb1, 0x8b, 0x78, 0x8b, 0xbf, 0x39, 0x6f, 0x75, 0x80, 0xe9, 0x66, 0x82, 0x82, 0x5a, 0x8e,
0x6f, 0x64, 0x36, 0xd7, 0xce, 0x26, 0x12, 0x5b, 0xec, 0xda, 0x43, 0x79, 0x79, 0x23, 0x41, 0x53,
0x05, 0x25, 0x22, 0x4f, 0xe4, 0x3d, 0x48, 0xf7, 0x6d, 0x66, 0x98, 0xbe, 0x6f, 0x1e, 0x22, 0x85,
0x99, 0xcd, 0x52, 0x34, 0x2b, 0xef, 0x30, 0x55, 0xde, 0x61, 0xaa, 0x0d, 0x9b, 0xd5, 0x39, 0x4a,
0x4f, 0xf5, 0xe5, 0xa8, 0xf2, 0xab, 0x02, 0xe9, 0xe9, 0x82, 0x5a, 0x1d, 0x72, 0x61, 0xa1, 0xc6,
0x13, 0xc7, 0x1c, 0x4a, 0x31, 0x5e, 0xbd, 0xb0, 0xda, 0xfb, 0x8e, 0x39, 0xd4, 0x33, 0xb2, 0x40,
0x3e, 0x39, 0xff, 0x60, 0x63, 0x17, 0x1c, 0xec, 0x9c, 0x92, 0xe2, 0x6f, 0xa6, 0xa4, 0xb9, 0x33,
0x57, 0x4f, 0x9f, 0xf9, 0x8f, 0x31, 0x48, 0x75, 0xf0, 0x82, 0x9a, 0xce, 0xff, 0x71, 0xc5, 0xd6,
0x20, 0xed, 0x51, 0xc7, 0x10, 0x1e, 0x15, 0x3d, 0x29, 0x8f, 0x3a, 0xfa, 0x19, 0x1d, 0x25, 0xde,
0xd2, 0xfd, 0x5b, 0x7c, 0x0b, 0xac, 0x25, 0x4f, 0xb3, 0xe6, 0x43, 0x56, 0x50, 0x21, 0x1b, 0xe6,
0x1d, 0xce, 0x01, 0xf6, 0x5f, 0xd1, 0x2f, 0x0b, 0x67, 0xb7, 0x2d, 0x90, 0xba, 0xc4, 0xf1, 0x08,
0xd1, 0x5f, 0x64, 0xc7, 0x2e, 0x5c, 0xa4, 0x73, 0x5d, 0xe2, 0x2a, 0x3f, 0x2b, 0x90, 0xc6, 0x52,
0x77, 0x09, 0x33, 0xe7, 0xa8, 0x52, 0xde, 0x9c, 0xaa, 0xab, 0x00, 0x22, 0x4d, 0x60, 0x3f, 0x23,
0xf2, 0x00, 0xd3, 0x68, 0xe9, 0xda, 0xcf, 0x88, 0xf6, 0xd1, 0xb4, 0xae, 0xf8, 0xdf, 0xd7, 0x25,
0xaf, 0x62, 0x58, 0xdd, 0x65, 0x48, 0xba, 0x93, 0xb1, 0xc1, 0x9f, 0x77, 0x55, 0x88, 0xc2, 0x9d,
0x8c, 0x7b, 0x07, 0x41, 0xe5, 0x2b, 0x48, 0xf6, 0x0e, 0xf0, 0x2b, 0x87, 0x2b, 0xc1, 0xa7, 0x54,
0xf6, 0x57, 0xf1, 0x49, 0x93, 0xe2, 0x06, 0x6c, 0x27, 0x1a, 0xa8, 0xbc, 0x91, 0x86, 0x9d, 0x80,
0x8f, 0xb5, 0x0f, 0x21, 0xd1, 0xf9, 0x0f, 0x9f, 0x51, 0xba, 0x40, 0xdf, 0xfa, 0x49, 0x81, 0x4c,
0xe4, 0x36, 0x6a, 0x45, 0xb8, 0xd4, 0xd8, 0xd9, 0xdb, 0x7a, 0xb4, 0x6d, 0xb4, 0xb6, 0x8d, 0xfb,
0x3b, 0xf5, 0x07, 0xc6, 0x67, 0xed, 0x47, 0xed, 0xbd, 0xcf, 0xdb, 0xf9, 0x05, 0xad, 0x06, 0xab,
0xe8, 0x9b, 0xba, 0xea, 0x8d, 0x6e, 0xb3, 0xdd, 0xcb, 0x2b, 0xc5, 0x77, 0x8e, 0x8e, 0xcb, 0x2b,
0x91, 0x34, 0xf5, 0x7e, 0x40, 0x5c, 0x76, 0x36, 0x60, 0x6b, 0x6f, 0x77, 0xb7, 0xd5, 0xcb, 0xc7,
0xce, 0x04, 0xc8, 0x87, 0xf5, 0x26, 0xac, 0xcc, 0x07, 0xb4, 0x5b, 0x3b, 0xf9, 0x78, 0x51, 0x3b,
0x3a, 0x2e, 0x2f, 0x45, 0xd0, 0x6d, 0xdb, 0x29, 0xa6, 0xbe, 0xfe, 0xb6, 0xb4, 0xf0, 0xc3, 0x77,
0x25, 0xe5, 0xd6, 0xf7, 0x0a, 0xe4, 0xe6, 0xae, 0x9e, 0xb6, 0x06, 0x97, 0xbb, 0xad, 0x07, 0xed,
0xe6, 0xb6, 0xb1, 0xdb, 0x7d, 0x60, 0xf4, 0xbe, 0xe8, 0x34, 0x23, 0x55, 0xbc, 0x07, 0xd9, 0x8e,
0xde, 0x7c, 0xbc, 0xd7, 0x6b, 0xa2, 0x27, 0xaf, 0x14, 0x97, 0x8f, 0x8e, 0xcb, 0x99, 0x8e, 0x4f,
0xf6, 0x29, 0x23, 0x18, 0x7f, 0x1d, 0x96, 0x3a, 0x7a, 0x53, 0x6c, 0x56, 0x80, 0x62, 0xc5, 0x95,
0xa3, 0xe3, 0x72, 0xae, 0xe3, 0x13, 0xa1, 0x37, 0x84, 0x5d, 0x83, 0x5c, 0x47, 0xdf, 0xeb, 0xec,
0x75, 0xeb, 0x3b, 0x02, 0x55, 0x2e, 0xe6, 0x8f, 0x8e, 0xcb, 0xd9, 0xf0, 0xc5, 0xe0, 0xa0, 0xd9,
0x3e, 0x1b, 0xf7, 0x5f, 0x9c, 0x94, 0x94, 0x97, 0x27, 0x25, 0xe5, 0xf7, 0x93, 0x92, 0xf2, 0xfc,
0x75, 0x69, 0xe1, 0xe5, 0xeb, 0xd2, 0xc2, 0x2f, 0xaf, 0x4b, 0x0b, 0x5f, 0xde, 0x1e, 0xda, 0x6c,
0x34, 0xe9, 0x57, 0x07, 0x74, 0x5c, 0x9b, 0x1d, 0x5b, 0x74, 0x18, 0xf9, 0x85, 0xd1, 0x5f, 0xc4,
0xc9, 0xdd, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x84, 0xdd, 0x04, 0x77, 0x0c, 0x00, 0x00,
0xa0, 0x2a, 0x2a, 0xa8, 0x76, 0x38, 0xac, 0xa1, 0xbe, 0x78, 0xb5, 0xbe, 0xa0, 0x8b, 0x98, 0x8a,
0x03, 0xc9, 0x86, 0x43, 0x07, 0x4f, 0x5b, 0xdb, 0xd3, 0xfd, 0x28, 0xb3, 0xfd, 0x68, 0xbb, 0xb0,
0xcc, 0xa9, 0x36, 0x02, 0xc2, 0x8c, 0x11, 0x16, 0x83, 0x6b, 0x9f, 0x5a, 0x45, 0x30, 0x33, 0x57,
0xb3, 0x5c, 0x25, 0xe7, 0x45, 0x8d, 0x95, 0x3f, 0x54, 0x58, 0x94, 0x9c, 0x7c, 0x0a, 0x49, 0xc9,
0x1a, 0x2e, 0x98, 0xd9, 0xbc, 0x1a, 0xcd, 0x18, 0x12, 0xba, 0x45, 0xdd, 0x80, 0xb8, 0xc1, 0x24,
0x90, 0xf9, 0xc2, 0x18, 0xed, 0x06, 0xa4, 0x06, 0x23, 0xd3, 0x76, 0x0d, 0xdb, 0xc2, 0x1d, 0xa5,
0x1b, 0x99, 0x93, 0x57, 0xeb, 0xc9, 0x2d, 0x6e, 0x6b, 0x6d, 0xeb, 0x49, 0x74, 0xb6, 0x2c, 0xed,
0x12, 0x2c, 0x8e, 0x88, 0x3d, 0x1c, 0x31, 0x64, 0x27, 0xae, 0xcb, 0x99, 0xf6, 0x31, 0xa8, 0x5c,
0x11, 0x05, 0x15, 0xd7, 0x2e, 0x56, 0x85, 0x5c, 0xaa, 0xa1, 0x5c, 0xaa, 0xbd, 0x50, 0x2e, 0x8d,
0x14, 0x5f, 0xf8, 0xf9, 0x6f, 0xeb, 0x8a, 0x8e, 0x11, 0xda, 0x16, 0xe4, 0x1c, 0x33, 0x60, 0x46,
0x9f, 0xd3, 0xc6, 0x97, 0x4f, 0x60, 0x8a, 0x2b, 0x67, 0x09, 0x91, 0xc4, 0xca, 0xad, 0x67, 0x78,
0x94, 0x30, 0x59, 0xda, 0x06, 0xe4, 0x31, 0xc9, 0x80, 0x8e, 0xc7, 0x36, 0x33, 0x90, 0xf7, 0x45,
0xe4, 0x7d, 0x89, 0xdb, 0xb7, 0xd0, 0xfc, 0x90, 0x9f, 0xc0, 0x1a, 0xa4, 0x2d, 0x93, 0x99, 0x02,
0x92, 0x44, 0x48, 0x8a, 0x1b, 0xd0, 0xf9, 0x3e, 0x2c, 0xef, 0x9b, 0x8e, 0x6d, 0x99, 0x8c, 0xfa,
0x81, 0x80, 0xa4, 0x44, 0x96, 0x99, 0x19, 0x81, 0x77, 0x60, 0xd5, 0x25, 0x07, 0xcc, 0x38, 0x8d,
0x4e, 0x23, 0x5a, 0xe3, 0xbe, 0xc7, 0xf3, 0x11, 0xd7, 0x61, 0x69, 0x10, 0x92, 0x2f, 0xb0, 0x80,
0xd8, 0xdc, 0xd4, 0x8a, 0xb0, 0x2b, 0x90, 0x32, 0x3d, 0x4f, 0x00, 0x32, 0x08, 0x48, 0x9a, 0x9e,
0x87, 0xae, 0x5b, 0xb0, 0x82, 0x35, 0xfa, 0x24, 0x98, 0x38, 0x4c, 0x26, 0xc9, 0x22, 0x66, 0x99,
0x3b, 0x74, 0x61, 0x47, 0xec, 0x35, 0xc8, 0x91, 0x7d, 0xdb, 0x22, 0xee, 0x80, 0x08, 0x5c, 0x0e,
0x71, 0xd9, 0xd0, 0x88, 0xa0, 0x9b, 0x90, 0xf7, 0x7c, 0xea, 0xd1, 0x80, 0xf8, 0x86, 0x69, 0x59,
0x3e, 0x09, 0x82, 0xc2, 0x92, 0xc8, 0x17, 0xda, 0xeb, 0xc2, 0x5c, 0xb9, 0x0d, 0xea, 0xb6, 0xc9,
0x4c, 0x2d, 0x0f, 0x71, 0x76, 0x10, 0x14, 0x94, 0x72, 0x7c, 0x23, 0xab, 0xf3, 0xe1, 0xb9, 0xb7,
0xee, 0xcf, 0x18, 0xa8, 0x8f, 0x29, 0x23, 0xda, 0x5d, 0x50, 0xf9, 0xd1, 0xa1, 0x22, 0x97, 0xce,
0xd3, 0x78, 0xd7, 0x1e, 0xba, 0xc4, 0xda, 0x0d, 0x86, 0xbd, 0x43, 0x8f, 0xe8, 0x08, 0x8e, 0x48,
0x2c, 0x36, 0x27, 0xb1, 0x55, 0x48, 0xf8, 0x74, 0xe2, 0x5a, 0xa8, 0xbc, 0x84, 0x2e, 0x26, 0x5a,
0x13, 0x52, 0x53, 0xe5, 0xa8, 0xff, 0xa4, 0x9c, 0x65, 0xae, 0x1c, 0xae, 0x6b, 0x69, 0xd0, 0x93,
0x7d, 0x29, 0xa0, 0x06, 0xa4, 0xa7, 0x2f, 0x9a, 0x54, 0xe0, 0xbf, 0x13, 0xf1, 0x2c, 0x4c, 0xfb,
0x00, 0x56, 0xa6, 0x7a, 0x98, 0x12, 0x2a, 0x54, 0x98, 0x9f, 0x3a, 0x24, 0xa3, 0x73, 0x52, 0x33,
0xc4, 0xdb, 0x94, 0xc4, 0xba, 0x66, 0x52, 0x6b, 0xe1, 0x23, 0xf5, 0x2e, 0xa4, 0x03, 0x7b, 0xe8,
0x9a, 0x6c, 0xe2, 0x13, 0xa9, 0xc6, 0x99, 0xa1, 0xf2, 0x4d, 0x0c, 0x16, 0x85, 0xba, 0x23, 0xbc,
0x29, 0xe7, 0xf3, 0x16, 0xbb, 0x88, 0xb7, 0xf8, 0x9b, 0xf3, 0x56, 0x07, 0x98, 0x6e, 0x26, 0x28,
0xa8, 0xe5, 0xf8, 0x46, 0x66, 0x73, 0xed, 0x6c, 0x22, 0xb1, 0xc5, 0xae, 0x3d, 0x94, 0x97, 0x37,
0x12, 0x34, 0x55, 0x50, 0x22, 0xf2, 0x4e, 0xde, 0x83, 0x74, 0xdf, 0x66, 0x86, 0xe9, 0xfb, 0xe6,
0x21, 0x52, 0x98, 0xd9, 0x2c, 0x45, 0xb3, 0xf2, 0x36, 0x53, 0xe5, 0x6d, 0xa6, 0xda, 0xb0, 0x59,
0x9d, 0xa3, 0xf4, 0x54, 0x5f, 0x8e, 0x2a, 0xbf, 0x2a, 0x90, 0x9e, 0x2e, 0xa8, 0xd5, 0x21, 0x17,
0x16, 0x6a, 0x3c, 0x71, 0xcc, 0xa1, 0x14, 0xe3, 0xd5, 0x0b, 0xab, 0xbd, 0xef, 0x98, 0x43, 0x3d,
0x23, 0x0b, 0xe4, 0x93, 0xf3, 0x0f, 0x36, 0x76, 0xc1, 0xc1, 0xce, 0x29, 0x29, 0xfe, 0x66, 0x4a,
0x9a, 0x3b, 0x73, 0xf5, 0xf4, 0x99, 0xff, 0x18, 0x83, 0x54, 0x07, 0x2f, 0xa8, 0xe9, 0xfc, 0x1f,
0x57, 0x6c, 0x0d, 0xd2, 0x1e, 0x75, 0x0c, 0xe1, 0x51, 0xd1, 0x93, 0xf2, 0xa8, 0xa3, 0x9f, 0xd1,
0x51, 0xe2, 0x2d, 0xdd, 0xbf, 0xc5, 0xb7, 0xc0, 0x5a, 0xf2, 0x34, 0x6b, 0x3e, 0x64, 0x05, 0x15,
0xb2, 0x61, 0xde, 0xe1, 0x1c, 0x60, 0x07, 0x16, 0xfd, 0xb2, 0x70, 0x76, 0xdb, 0x02, 0xa9, 0x4b,
0x1c, 0x8f, 0x10, 0xfd, 0x45, 0xf6, 0xec, 0xc2, 0x45, 0x3a, 0xd7, 0x25, 0xae, 0xf2, 0xb3, 0x02,
0x69, 0x2c, 0x75, 0x97, 0x30, 0x73, 0x8e, 0x2a, 0xe5, 0xcd, 0xa9, 0xba, 0x0a, 0x20, 0xd2, 0x04,
0xf6, 0x33, 0x22, 0x0f, 0x30, 0x8d, 0x96, 0xae, 0xfd, 0x8c, 0x68, 0x1f, 0x4d, 0xeb, 0x8a, 0xff,
0x7d, 0x5d, 0xf2, 0x2a, 0x86, 0xd5, 0x5d, 0x86, 0xa4, 0x3b, 0x19, 0x1b, 0xfc, 0x79, 0x57, 0x85,
0x28, 0xdc, 0xc9, 0xb8, 0x77, 0x10, 0x54, 0xbe, 0x82, 0x64, 0xef, 0x00, 0x3f, 0x75, 0xb8, 0x12,
0x7c, 0x4a, 0x65, 0x7f, 0x15, 0xdf, 0x35, 0x29, 0x6e, 0xc0, 0x76, 0xa2, 0x81, 0xca, 0x1b, 0x69,
0xd8, 0x09, 0xf8, 0x58, 0xfb, 0x10, 0x12, 0x9d, 0xff, 0xf0, 0x2d, 0xa5, 0x0b, 0xf4, 0xad, 0x9f,
0x14, 0xc8, 0x44, 0x6e, 0xa3, 0x56, 0x84, 0x4b, 0x8d, 0x9d, 0xbd, 0xad, 0x47, 0xdb, 0x46, 0x6b,
0xdb, 0xb8, 0xbf, 0x53, 0x7f, 0x60, 0x7c, 0xd6, 0x7e, 0xd4, 0xde, 0xfb, 0xbc, 0x9d, 0x5f, 0xd0,
0x6a, 0xb0, 0x8a, 0xbe, 0xa9, 0xab, 0xde, 0xe8, 0x36, 0xdb, 0xbd, 0xbc, 0x52, 0x7c, 0xe7, 0xe8,
0xb8, 0xbc, 0x12, 0x49, 0x53, 0xef, 0x07, 0xc4, 0x65, 0x67, 0x03, 0xb6, 0xf6, 0x76, 0x77, 0x5b,
0xbd, 0x7c, 0xec, 0x4c, 0x80, 0x7c, 0x58, 0x6f, 0xc2, 0xca, 0x7c, 0x40, 0xbb, 0xb5, 0x93, 0x8f,
0x17, 0xb5, 0xa3, 0xe3, 0xf2, 0x52, 0x04, 0xdd, 0xb6, 0x9d, 0x62, 0xea, 0xeb, 0x6f, 0x4b, 0x0b,
0x3f, 0x7c, 0x57, 0x52, 0x6e, 0x7d, 0xaf, 0x40, 0x6e, 0xee, 0xea, 0x69, 0x6b, 0x70, 0xb9, 0xdb,
0x7a, 0xd0, 0x6e, 0x6e, 0x1b, 0xbb, 0xdd, 0x07, 0x46, 0xef, 0x8b, 0x4e, 0x33, 0x52, 0xc5, 0x7b,
0x90, 0xed, 0xe8, 0xcd, 0xc7, 0x7b, 0xbd, 0x26, 0x7a, 0xf2, 0x4a, 0x71, 0xf9, 0xe8, 0xb8, 0x9c,
0xe9, 0xf8, 0x64, 0x9f, 0x32, 0x82, 0xf1, 0xd7, 0x61, 0xa9, 0xa3, 0x37, 0xc5, 0x66, 0x05, 0x28,
0x56, 0x5c, 0x39, 0x3a, 0x2e, 0xe7, 0x3a, 0x3e, 0x11, 0x7a, 0x43, 0xd8, 0x35, 0xc8, 0x75, 0xf4,
0xbd, 0xce, 0x5e, 0xb7, 0xbe, 0x23, 0x50, 0xe5, 0x62, 0xfe, 0xe8, 0xb8, 0x9c, 0x0d, 0x5f, 0x0c,
0x0e, 0x9a, 0xed, 0xb3, 0x71, 0xff, 0xc5, 0x49, 0x49, 0x79, 0x79, 0x52, 0x52, 0x7e, 0x3f, 0x29,
0x29, 0xcf, 0x5f, 0x97, 0x16, 0x5e, 0xbe, 0x2e, 0x2d, 0xfc, 0xf2, 0xba, 0xb4, 0xf0, 0xe5, 0xed,
0xa1, 0xcd, 0x46, 0x93, 0x7e, 0x75, 0x40, 0xc7, 0xb5, 0xd9, 0xb1, 0x45, 0x87, 0x91, 0x9f, 0x19,
0xfd, 0x45, 0x9c, 0xdc, 0xfd, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xec, 0xc5, 0xfd, 0xa2, 0x7c, 0x0c,
0x00, 0x00,
}
func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1208,7 +1209,7 @@ func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
var l int
_ = l
{
size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -1865,7 +1866,7 @@ func (m *BlockID) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.PartsHeader.Size()
l = m.PartSetHeader.Size()
n += 1 + l + sovTypes(uint64(l))
return n
}
@@ -2435,7 +2436,7 @@ func (m *BlockID) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -2462,7 +2463,7 @@ func (m *BlockID) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
proto/types/types.proto
+2 -2
View File
@@ -48,8 +48,8 @@ message Part {
// BlockID
message BlockID {
bytes hash = 1;
PartSetHeader parts_header = 2 [(gogoproto.nullable) = false];
bytes hash = 1;
PartSetHeader part_set_header = 2 [(gogoproto.nullable) = false];
}
// --------------------------------
rpc/client/evidence_test.go
+3 -3
View File
@@ -52,7 +52,7 @@ func makeEvidences(
Timestamp: time.Now().UTC(),
BlockID: types.BlockID{
Hash: tmhash.Sum([]byte("blockhash")),
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1000,
Hash: tmhash.Sum([]byte("partset")),
},
@@ -189,8 +189,8 @@ func TestBroadcastEvidence_ConflictingHeadersEvidence(t *testing.T) {
Commit: types.NewCommit(h1.Height, 1, h1.Commit.BlockID, h1.Commit.Signatures),
}
h2.Commit.BlockID = types.BlockID{
Hash: h2.Hash(),
PartsHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
Hash: h2.Hash(),
PartSetHeader: types.PartSetHeader{Total: 1, Hash: crypto.CRandBytes(32)},
}
vote := &types.Vote{
ValidatorAddress: pv.Key.Address,
state/execution_test.go
+5 -5
View File
@@ -42,7 +42,7 @@ func TestApplyBlock(t *testing.T) {
mock.Mempool{}, sm.MockEvidencePool{})
block := makeBlock(state, 1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
_, retainHeight, err := blockExec.ApplyBlock(state, blockID, block)
require.Nil(t, err)
@@ -64,7 +64,7 @@ func TestBeginBlockValidators(t *testing.T) {
prevHash := state.LastBlockID.Hash
prevParts := types.PartSetHeader{}
prevBlockID := types.BlockID{Hash: prevHash, PartsHeader: prevParts}
prevBlockID := types.BlockID{Hash: prevHash, PartSetHeader: prevParts}
var (
now = tmtime.Now()
@@ -126,7 +126,7 @@ func TestBeginBlockByzantineValidators(t *testing.T) {
prevHash := state.LastBlockID.Hash
prevParts := types.PartSetHeader{}
prevBlockID := types.BlockID{Hash: prevHash, PartsHeader: prevParts}
prevBlockID := types.BlockID{Hash: prevHash, PartSetHeader: prevParts}
height1, val1 := int64(8), state.Validators.Validators[0].Address
height2, val2 := int64(3), state.Validators.Validators[1].Address
@@ -335,7 +335,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
require.NoError(t, err)
block := makeBlock(state, 1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
pubkey := ed25519.GenPrivKey().PubKey()
pk, err := cryptoenc.PubKeyToProto(pubkey)
@@ -390,7 +390,7 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
)
block := makeBlock(state, 1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
vp, err := cryptoenc.PubKeyToProto(state.Validators.Validators[0].PubKey)
require.NoError(t, err)
state/helpers_test.go
+4 -4
View File
@@ -59,7 +59,7 @@ func makeAndApplyGoodBlock(state sm.State, height int64, lastCommit *types.Commi
return state, types.BlockID{}, err
}
blockID := types.BlockID{Hash: block.Hash(),
PartsHeader: types.PartSetHeader{Total: 3, Hash: tmrand.Bytes(32)}}
PartSetHeader: types.PartSetHeader{Total: 3, Hash: tmrand.Bytes(32)}}
state, _, err := blockExec.ApplyBlock(state, blockID, block)
if err != nil {
return state, types.BlockID{}, err
@@ -186,7 +186,7 @@ func makeHeaderPartsResponsesValPubKeyChange(
}
}
return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
}
func makeHeaderPartsResponsesValPowerChange(
@@ -210,7 +210,7 @@ func makeHeaderPartsResponsesValPowerChange(
}
}
return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
}
func makeHeaderPartsResponsesParams(
@@ -223,7 +223,7 @@ func makeHeaderPartsResponsesParams(
BeginBlock: &abci.ResponseBeginBlock{},
EndBlock: &abci.ResponseEndBlock{ConsensusParamUpdates: types.TM2PB.ConsensusParams(&params)},
}
return block.Header, types.BlockID{Hash: block.Hash(), PartsHeader: types.PartSetHeader{}}, abciResponses
return block.Header, types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{}}, abciResponses
}
func randomGenesisDoc() *types.GenesisDoc {
state/state_test.go
+9 -9
View File
@@ -429,7 +429,7 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) {
assert.EqualValues(t, 0, val1.ProposerPriority)
block := makeBlock(state, state.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
abciResponses := &tmstate.ABCIResponses{
BeginBlock: &abci.ResponseBeginBlock{},
EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: nil},
@@ -543,7 +543,7 @@ func TestProposerPriorityProposerAlternates(t *testing.T) {
assert.Equal(t, val1PubKey.Address(), state.Validators.Proposer.Address)
block := makeBlock(state, state.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
// no updates:
abciResponses := &tmstate.ABCIResponses{
BeginBlock: &abci.ResponseBeginBlock{},
@@ -730,7 +730,7 @@ func TestLargeGenesisValidator(t *testing.T) {
require.NoError(t, err)
block := makeBlock(oldState, oldState.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
@@ -759,7 +759,7 @@ func TestLargeGenesisValidator(t *testing.T) {
EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{firstAddedVal}},
}
block := makeBlock(oldState, oldState.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
@@ -774,7 +774,7 @@ func TestLargeGenesisValidator(t *testing.T) {
require.NoError(t, err)
block := makeBlock(lastState, lastState.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
updatedStateInner, err := sm.UpdateState(lastState, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
@@ -807,7 +807,7 @@ func TestLargeGenesisValidator(t *testing.T) {
EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{addedVal}},
}
block := makeBlock(oldState, oldState.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
state, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
}
@@ -822,7 +822,7 @@ func TestLargeGenesisValidator(t *testing.T) {
EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{removeGenesisVal}},
}
block = makeBlock(oldState, oldState.LastBlockHeight+1)
blockID = types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates)
require.NoError(t, err)
updatedState, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates)
@@ -843,7 +843,7 @@ func TestLargeGenesisValidator(t *testing.T) {
validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates)
require.NoError(t, err)
block = makeBlock(curState, curState.LastBlockHeight+1)
blockID = types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
curState, err = sm.UpdateState(curState, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
if !bytes.Equal(curState.Validators.Proposer.Address, curState.NextValidators.Proposer.Address) {
@@ -868,7 +868,7 @@ func TestLargeGenesisValidator(t *testing.T) {
require.NoError(t, err)
block := makeBlock(updatedState, updatedState.LastBlockHeight+1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
updatedState, err = sm.UpdateState(updatedState, blockID, &block.Header, abciResponses, validatorUpdates)
require.NoError(t, err)
state/validation_test.go
+2 -2
View File
@@ -61,7 +61,7 @@ func TestValidateBlockHeader(t *testing.T) {
{"Height wrong", func(block *types.Block) { block.Height += 10 }},
{"Time wrong", func(block *types.Block) { block.Time = block.Time.Add(-time.Second * 1) }},
{"LastBlockID wrong", func(block *types.Block) { block.LastBlockID.PartsHeader.Total += 10 }},
{"LastBlockID wrong", func(block *types.Block) { block.LastBlockID.PartSetHeader.Total += 10 }},
{"LastCommitHash wrong", func(block *types.Block) { block.LastCommitHash = wrongHash }},
{"DataHash wrong", func(block *types.Block) { block.DataHash = wrongHash }},
@@ -353,7 +353,7 @@ func TestValidateDuplicateEvidenceShouldFail(t *testing.T) {
var blockID = types.BlockID{
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
},
store/store.go
+2 -2
View File
@@ -83,7 +83,7 @@ func (bs *BlockStore) LoadBlock(height int64) *types.Block {
pbb := new(tmproto.Block)
buf := []byte{}
for i := 0; i < int(blockMeta.BlockID.PartsHeader.Total); i++ {
for i := 0; i < int(blockMeta.BlockID.PartSetHeader.Total); i++ {
part := bs.LoadBlockPart(height, i)
buf = append(buf, part.Bytes...)
}
@@ -269,7 +269,7 @@ func (bs *BlockStore) PruneBlocks(height int64) (uint64, error) {
batch.Delete(calcBlockHashKey(meta.BlockID.Hash))
batch.Delete(calcBlockCommitKey(h))
batch.Delete(calcSeenCommitKey(h))
for p := 0; p < int(meta.BlockID.PartsHeader.Total); p++ {
for p := 0; p < int(meta.BlockID.PartSetHeader.Total); p++ {
batch.Delete(calcBlockPartKey(h, p))
}
pruned++
store/store_test.go
+1 -1
View File
@@ -37,7 +37,7 @@ func makeTestCommit(height int64, timestamp time.Time) *types.Commit {
Signature: []byte("Signature"),
}}
return types.NewCommit(height, 0,
types.BlockID{Hash: []byte(""), PartsHeader: types.PartSetHeader{Hash: []byte(""), Total: 2}}, commitSigs)
types.BlockID{Hash: []byte(""), PartSetHeader: types.PartSetHeader{Hash: []byte(""), Total: 2}}, commitSigs)
}
func makeTxs(height int64) (txs []types.Tx) {
tools/tm-signer-harness/internal/test_harness.go
+2 -2
View File
@@ -222,7 +222,7 @@ func (th *TestHarness) TestSignProposal() error {
POLRound: -1,
BlockID: types.BlockID{
Hash: hash,
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Hash: hash,
Total: 1000000,
},
@@ -269,7 +269,7 @@ func (th *TestHarness) TestSignVote() error {
Round: 0,
BlockID: types.BlockID{
Hash: hash,
PartsHeader: types.PartSetHeader{
PartSetHeader: types.PartSetHeader{
Hash: hash,
Total: 1000000,
},
types/block.go
+14 -14
View File
@@ -1242,19 +1242,19 @@ func (data *EvidenceData) FromProto(eviData *tmproto.EvidenceData) error {
// BlockID
type BlockID struct {
Hash tmbytes.HexBytes `json:"hash"`
PartsHeader PartSetHeader `json:"parts"`
Hash tmbytes.HexBytes `json:"hash"`
PartSetHeader PartSetHeader `json:"parts"`
}
// Equals returns true if the BlockID matches the given BlockID
func (blockID BlockID) Equals(other BlockID) bool {
return bytes.Equal(blockID.Hash, other.Hash) &&
blockID.PartsHeader.Equals(other.PartsHeader)
blockID.PartSetHeader.Equals(other.PartSetHeader)
}
// Key returns a machine-readable string representation of the BlockID
func (blockID BlockID) Key() string {
pbph := blockID.PartsHeader.ToProto()
pbph := blockID.PartSetHeader.ToProto()
bz, err := pbph.Marshal()
if err != nil {
panic(err)
@@ -1269,8 +1269,8 @@ func (blockID BlockID) ValidateBasic() error {
if err := ValidateHash(blockID.Hash); err != nil {
return fmt.Errorf("wrong Hash")
}
if err := blockID.PartsHeader.ValidateBasic(); err != nil {
return fmt.Errorf("wrong PartsHeader: %v", err)
if err := blockID.PartSetHeader.ValidateBasic(); err != nil {
return fmt.Errorf("wrong PartSetHeader: %v", err)
}
return nil
}
@@ -1278,19 +1278,19 @@ func (blockID BlockID) ValidateBasic() error {
// IsZero returns true if this is the BlockID of a nil block.
func (blockID BlockID) IsZero() bool {
return len(blockID.Hash) == 0 &&
blockID.PartsHeader.IsZero()
blockID.PartSetHeader.IsZero()
}
// IsComplete returns true if this is a valid BlockID of a non-nil block.
func (blockID BlockID) IsComplete() bool {
return len(blockID.Hash) == tmhash.Size &&
blockID.PartsHeader.Total > 0 &&
len(blockID.PartsHeader.Hash) == tmhash.Size
blockID.PartSetHeader.Total > 0 &&
len(blockID.PartSetHeader.Hash) == tmhash.Size
}
// String returns a human readable string representation of the BlockID
func (blockID BlockID) String() string {
return fmt.Sprintf(`%v:%v`, blockID.Hash, blockID.PartsHeader)
return fmt.Sprintf(`%v:%v`, blockID.Hash, blockID.PartSetHeader)
}
// ToProto converts BlockID to protobuf
@@ -1300,8 +1300,8 @@ func (blockID *BlockID) ToProto() tmproto.BlockID {
}
return tmproto.BlockID{
Hash: blockID.Hash,
PartsHeader: blockID.PartsHeader.ToProto(),
Hash: blockID.Hash,
PartSetHeader: blockID.PartSetHeader.ToProto(),
}
}
@@ -1313,12 +1313,12 @@ func BlockIDFromProto(bID *tmproto.BlockID) (*BlockID, error) {
}
blockID := new(BlockID)
ph, err := PartSetHeaderFromProto(&bID.PartsHeader)
ph, err := PartSetHeaderFromProto(&bID.PartSetHeader)
if err != nil {
return nil, err
}
blockID.PartsHeader = *ph
blockID.PartSetHeader = *ph
blockID.Hash = bID.Hash
return blockID, blockID.ValidateBasic()
types/block_meta_test.go
+4 -4
View File
@@ -10,7 +10,7 @@ import (
func TestBlockMeta_ToProto(t *testing.T) {
h := makeRandHeader()
bi := BlockID{Hash: h.Hash(), PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
bi := BlockID{Hash: h.Hash(), PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
bm := &BlockMeta{
BlockID: bi,
@@ -47,11 +47,11 @@ func TestBlockMeta_ToProto(t *testing.T) {
func TestBlockMeta_ValidateBasic(t *testing.T) {
h := makeRandHeader()
bi := BlockID{Hash: h.Hash(), PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
bi := BlockID{Hash: h.Hash(), PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
bi2 := BlockID{Hash: tmrand.Bytes(tmhash.Size),
PartsHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
PartSetHeader: PartSetHeader{Total: 123, Hash: tmrand.Bytes(tmhash.Size)}}
bi3 := BlockID{Hash: []byte("incorrect hash"),
PartsHeader: PartSetHeader{Total: 123, Hash: []byte("incorrect hash")}}
PartSetHeader: PartSetHeader{Total: 123, Hash: []byte("incorrect hash")}}
bm := &BlockMeta{
BlockID: bi,
types/block_test.go
+12 -12
View File
@@ -187,7 +187,7 @@ func makeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) BlockID {
copy(psH, partSetHash)
return BlockID{
Hash: h,
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: partSetSize,
Hash: psH,
},
@@ -588,7 +588,7 @@ func TestSignedHeaderValidateBasic(t *testing.T) {
func TestBlockIDValidateBasic(t *testing.T) {
validBlockID := BlockID{
Hash: bytes.HexBytes{},
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 1,
Hash: bytes.HexBytes{},
},
@@ -596,29 +596,29 @@ func TestBlockIDValidateBasic(t *testing.T) {
invalidBlockID := BlockID{
Hash: []byte{0},
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 1,
Hash: []byte{0},
},
}
testCases := []struct {
testName string
blockIDHash bytes.HexBytes
blockIDPartsHeader PartSetHeader
expectErr bool
testName string
blockIDHash bytes.HexBytes
blockIDPartSetHeader PartSetHeader
expectErr bool
}{
{"Valid BlockID", validBlockID.Hash, validBlockID.PartsHeader, false},
{"Invalid BlockID", invalidBlockID.Hash, validBlockID.PartsHeader, true},
{"Invalid BlockID", validBlockID.Hash, invalidBlockID.PartsHeader, true},
{"Valid BlockID", validBlockID.Hash, validBlockID.PartSetHeader, false},
{"Invalid BlockID", invalidBlockID.Hash, validBlockID.PartSetHeader, true},
{"Invalid BlockID", validBlockID.Hash, invalidBlockID.PartSetHeader, true},
}
for _, tc := range testCases {
tc := tc
t.Run(tc.testName, func(t *testing.T) {
blockID := BlockID{
Hash: tc.blockIDHash,
PartsHeader: tc.blockIDPartsHeader,
Hash: tc.blockIDHash,
PartSetHeader: tc.blockIDPartSetHeader,
}
assert.Equal(t, tc.expectErr, blockID.ValidateBasic() != nil, "Validate Basic had an unexpected result")
})
types/canonical.go
+2 -2
View File
@@ -25,8 +25,8 @@ func CanonicalizeBlockID(bid tmproto.BlockID) *tmproto.CanonicalBlockID {
cbid = nil
} else {
cbid = &tmproto.CanonicalBlockID{
Hash: bid.Hash,
PartsHeader: CanonicalizePartSetHeader(bid.PartsHeader),
Hash: bid.Hash,
PartSetHeader: CanonicalizePartSetHeader(bid.PartSetHeader),
}
}
types/canonical_test.go
+4 -4
View File
@@ -12,13 +12,13 @@ import (
func TestCanonicalizeBlockID(t *testing.T) {
randhash := tmrand.Bytes(tmhash.Size)
block1 := tmproto.BlockID{Hash: randhash,
PartsHeader: tmproto.PartSetHeader{Total: 5, Hash: randhash}}
PartSetHeader: tmproto.PartSetHeader{Total: 5, Hash: randhash}}
block2 := tmproto.BlockID{Hash: randhash,
PartsHeader: tmproto.PartSetHeader{Total: 10, Hash: randhash}}
PartSetHeader: tmproto.PartSetHeader{Total: 10, Hash: randhash}}
cblock1 := tmproto.CanonicalBlockID{Hash: randhash,
PartsHeader: tmproto.CanonicalPartSetHeader{Total: 5, Hash: randhash}}
PartSetHeader: tmproto.CanonicalPartSetHeader{Total: 5, Hash: randhash}}
cblock2 := tmproto.CanonicalBlockID{Hash: randhash,
PartsHeader: tmproto.CanonicalPartSetHeader{Total: 10, Hash: randhash}}
PartSetHeader: tmproto.CanonicalPartSetHeader{Total: 10, Hash: randhash}}
tests := []struct {
name string
types/evidence_test.go
+4 -4
View File
@@ -294,7 +294,7 @@ func TestConflictingHeadersEvidence(t *testing.T) {
commit1, err := MakeCommit(BlockID{
Hash: header1.Hash(),
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 100,
Hash: crypto.CRandBytes(tmhash.Size),
},
@@ -302,7 +302,7 @@ func TestConflictingHeadersEvidence(t *testing.T) {
require.NoError(t, err)
commit2, err := MakeCommit(BlockID{
Hash: header2.Hash(),
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 100,
Hash: crypto.CRandBytes(tmhash.Size),
},
@@ -607,7 +607,7 @@ func TestEvidenceProto(t *testing.T) {
commit1, err := MakeCommit(BlockID{
Hash: header1.Hash(),
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 100,
Hash: crypto.CRandBytes(tmhash.Size),
},
@@ -615,7 +615,7 @@ func TestEvidenceProto(t *testing.T) {
require.NoError(t, err)
commit2, err := MakeCommit(BlockID{
Hash: header2.Hash(),
PartsHeader: PartSetHeader{
PartSetHeader: PartSetHeader{
Total: 100,
Hash: crypto.CRandBytes(tmhash.Size),
},
types/part_set.go
+1 -1
View File
@@ -104,7 +104,7 @@ func (psh PartSetHeader) Equals(other PartSetHeader) bool {
// ValidateBasic performs basic validation.
func (psh PartSetHeader) ValidateBasic() error {
// Hash can be empty in case of POLBlockID.PartsHeader in Proposal.
// Hash can be empty in case of POLBlockID.PartSetHeader in Proposal.
if err := ValidateHash(psh.Hash); err != nil {
return fmt.Errorf("wrong Hash: %w", err)
}
types/proposal_test.go
+1 -1
View File
@@ -29,7 +29,7 @@ func init() {
Height: 12345,
Round: 23456,
BlockID: BlockID{Hash: []byte("--June_15_2020_amino_was_removed"),
PartsHeader: PartSetHeader{Total: 111, Hash: []byte("--June_15_2020_amino_was_removed")}},
PartSetHeader: PartSetHeader{Total: 111, Hash: []byte("--June_15_2020_amino_was_removed")}},
POLRound: -1,
Timestamp: stamp,
}
types/protobuf.go
+7 -7
View File
@@ -71,16 +71,16 @@ func (tm2pb) Validator(val *Validator) abci.Validator {
}
}
func (tm2pb) BlockID(blockID BlockID) abci.BlockID {
return abci.BlockID{
Hash: blockID.Hash,
PartsHeader: TM2PB.PartSetHeader(blockID.PartsHeader),
func (tm2pb) BlockID(blockID BlockID) tmproto.BlockID {
return tmproto.BlockID{
Hash: blockID.Hash,
PartSetHeader: TM2PB.PartSetHeader(blockID.PartSetHeader),
}
}
func (tm2pb) PartSetHeader(header PartSetHeader) abci.PartSetHeader {
return abci.PartSetHeader{
Total: int32(header.Total),
func (tm2pb) PartSetHeader(header PartSetHeader) tmproto.PartSetHeader {
return tmproto.PartSetHeader{
Total: header.Total,
Hash: header.Hash,
}
}
types/vote_set_test.go
+12 -12
View File
@@ -176,7 +176,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
blockHash := crypto.CRandBytes(32)
blockPartsTotal := uint32(123)
blockPartsHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
blockPartSetHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
voteProto := &Vote{
ValidatorAddress: nil, // NOTE: must fill in
@@ -185,7 +185,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
Round: round,
Timestamp: tmtime.Now(),
Type: tmproto.PrevoteType,
BlockID: BlockID{blockHash, blockPartsHeader},
BlockID: BlockID{blockHash, blockPartSetHeader},
}
// 66 out of 100 voted for nil.
@@ -221,7 +221,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
addr := pubKey.Address()
vote := withValidator(voteProto, addr, 67)
blockPartsHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
_, err = signAddVote(privValidators[67], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
_, err = signAddVote(privValidators[67], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
require.NoError(t, err)
blockID, ok = voteSet.TwoThirdsMajority()
assert.False(t, ok || !blockID.IsZero(),
@@ -234,8 +234,8 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
require.NoError(t, err)
addr := pubKey.Address()
vote := withValidator(voteProto, addr, 68)
blockPartsHeader := PartSetHeader{blockPartsTotal + 1, blockPartsHeader.Hash}
_, err = signAddVote(privValidators[68], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
blockPartsHeader := PartSetHeader{blockPartsTotal + 1, blockPartSetHeader.Hash}
_, err = signAddVote(privValidators[68], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
require.NoError(t, err)
blockID, ok = voteSet.TwoThirdsMajority()
assert.False(t, ok || !blockID.IsZero(),
@@ -255,7 +255,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
"there should be no 2/3 majority: last vote added had different BlockHash")
}
// 71st validator voted for the right BlockHash & BlockPartsHeader
// 71st validator voted for the right BlockHash & BlockPartSetHeader
{
pubKey, err := privValidators[70].GetPubKey()
require.NoError(t, err)
@@ -264,7 +264,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
_, err = signAddVote(privValidators[70], vote, voteSet)
require.NoError(t, err)
blockID, ok = voteSet.TwoThirdsMajority()
assert.True(t, ok && blockID.Equals(BlockID{blockHash, blockPartsHeader}),
assert.True(t, ok && blockID.Equals(BlockID{blockHash, blockPartSetHeader}),
"there should be 2/3 majority")
}
}
@@ -398,7 +398,7 @@ func TestVoteSet_Conflicts(t *testing.T) {
func TestVoteSet_MakeCommit(t *testing.T) {
height, round := int64(1), int32(0)
voteSet, _, privValidators := randVoteSet(height, round, tmproto.PrecommitType, 10, 1)
blockHash, blockPartsHeader := crypto.CRandBytes(32), PartSetHeader{123, crypto.CRandBytes(32)}
blockHash, blockPartSetHeader := crypto.CRandBytes(32), PartSetHeader{123, crypto.CRandBytes(32)}
voteProto := &Vote{
ValidatorAddress: nil,
@@ -407,7 +407,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
Round: round,
Timestamp: tmtime.Now(),
Type: tmproto.PrecommitType,
BlockID: BlockID{blockHash, blockPartsHeader},
BlockID: BlockID{blockHash, blockPartSetHeader},
}
// 6 out of 10 voted for some block.
@@ -432,7 +432,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
addr := pv.Address()
vote := withValidator(voteProto, addr, 6)
vote = withBlockHash(vote, tmrand.Bytes(32))
vote = withBlockPartsHeader(vote, PartSetHeader{123, tmrand.Bytes(32)})
vote = withBlockPartSetHeader(vote, PartSetHeader{123, tmrand.Bytes(32)})
_, err = signAddVote(privValidators[6], vote, voteSet)
require.NoError(t, err)
@@ -560,8 +560,8 @@ func withBlockHash(vote *Vote, blockHash []byte) *Vote {
}
// Convenience: Return new vote with different blockParts
func withBlockPartsHeader(vote *Vote, blockPartsHeader PartSetHeader) *Vote {
func withBlockPartSetHeader(vote *Vote, blockPartsHeader PartSetHeader) *Vote {
vote = vote.Copy()
vote.BlockID.PartsHeader = blockPartsHeader
vote.BlockID.PartSetHeader = blockPartsHeader
return vote
}
types/vote_test.go
+2 -2
View File
@@ -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")),
},