diff --git a/Gopkg.lock b/Gopkg.lock index 012bf2eda..aecf4de72 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -525,7 +525,6 @@ "github.com/gogo/protobuf/gogoproto", "github.com/gogo/protobuf/jsonpb", "github.com/gogo/protobuf/proto", - "github.com/gogo/protobuf/types", "github.com/golang/protobuf/proto", "github.com/golang/protobuf/ptypes/timestamp", "github.com/gorilla/websocket", diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index 79e160065..7873f0975 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -60,7 +60,7 @@ func (m *Request) Reset() { *m = Request{} } func (m *Request) String() string { return proto.CompactTextString(m) } func (*Request) ProtoMessage() {} func (*Request) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{0} + return fileDescriptor_types_c68d3007ea320b94, []int{0} } func (m *Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -482,7 +482,7 @@ func (m *RequestEcho) Reset() { *m = RequestEcho{} } func (m *RequestEcho) String() string { return proto.CompactTextString(m) } func (*RequestEcho) ProtoMessage() {} func (*RequestEcho) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{1} + return fileDescriptor_types_c68d3007ea320b94, []int{1} } func (m *RequestEcho) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -528,7 +528,7 @@ func (m *RequestFlush) Reset() { *m = RequestFlush{} } func (m *RequestFlush) String() string { return proto.CompactTextString(m) } func (*RequestFlush) ProtoMessage() {} func (*RequestFlush) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{2} + return fileDescriptor_types_c68d3007ea320b94, []int{2} } func (m *RequestFlush) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -568,7 +568,7 @@ func (m *RequestInfo) Reset() { *m = RequestInfo{} } func (m *RequestInfo) String() string { return proto.CompactTextString(m) } func (*RequestInfo) ProtoMessage() {} func (*RequestInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{3} + return fileDescriptor_types_c68d3007ea320b94, []int{3} } func (m *RequestInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -617,7 +617,7 @@ func (m *RequestSetOption) Reset() { *m = RequestSetOption{} } func (m *RequestSetOption) String() string { return proto.CompactTextString(m) } func (*RequestSetOption) ProtoMessage() {} func (*RequestSetOption) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{4} + return fileDescriptor_types_c68d3007ea320b94, []int{4} } func (m *RequestSetOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -675,7 +675,7 @@ func (m *RequestInitChain) Reset() { *m = RequestInitChain{} } func (m *RequestInitChain) String() string { return proto.CompactTextString(m) } func (*RequestInitChain) ProtoMessage() {} func (*RequestInitChain) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{5} + return fileDescriptor_types_c68d3007ea320b94, []int{5} } func (m *RequestInitChain) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -753,7 +753,7 @@ func (m *RequestQuery) Reset() { *m = RequestQuery{} } func (m *RequestQuery) String() string { return proto.CompactTextString(m) } func (*RequestQuery) ProtoMessage() {} func (*RequestQuery) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{6} + return fileDescriptor_types_c68d3007ea320b94, []int{6} } func (m *RequestQuery) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -825,7 +825,7 @@ func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} } func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) } func (*RequestBeginBlock) ProtoMessage() {} func (*RequestBeginBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{7} + return fileDescriptor_types_c68d3007ea320b94, []int{7} } func (m *RequestBeginBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -893,7 +893,7 @@ func (m *RequestCheckTx) Reset() { *m = RequestCheckTx{} } func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) } func (*RequestCheckTx) ProtoMessage() {} func (*RequestCheckTx) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{8} + return fileDescriptor_types_c68d3007ea320b94, []int{8} } func (m *RequestCheckTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -940,7 +940,7 @@ func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} } func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) } func (*RequestDeliverTx) ProtoMessage() {} func (*RequestDeliverTx) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{9} + return fileDescriptor_types_c68d3007ea320b94, []int{9} } func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -987,7 +987,7 @@ func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} } func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) } func (*RequestEndBlock) ProtoMessage() {} func (*RequestEndBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{10} + return fileDescriptor_types_c68d3007ea320b94, []int{10} } func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1033,7 +1033,7 @@ func (m *RequestCommit) Reset() { *m = RequestCommit{} } func (m *RequestCommit) String() string { return proto.CompactTextString(m) } func (*RequestCommit) ProtoMessage() {} func (*RequestCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{11} + return fileDescriptor_types_c68d3007ea320b94, []int{11} } func (m *RequestCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1086,7 +1086,7 @@ func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{12} + return fileDescriptor_types_c68d3007ea320b94, []int{12} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1539,7 +1539,7 @@ func (m *ResponseException) Reset() { *m = ResponseException{} } func (m *ResponseException) String() string { return proto.CompactTextString(m) } func (*ResponseException) ProtoMessage() {} func (*ResponseException) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{13} + return fileDescriptor_types_c68d3007ea320b94, []int{13} } func (m *ResponseException) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1586,7 +1586,7 @@ func (m *ResponseEcho) Reset() { *m = ResponseEcho{} } func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } func (*ResponseEcho) ProtoMessage() {} func (*ResponseEcho) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{14} + return fileDescriptor_types_c68d3007ea320b94, []int{14} } func (m *ResponseEcho) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1632,7 +1632,7 @@ func (m *ResponseFlush) Reset() { *m = ResponseFlush{} } func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } func (*ResponseFlush) ProtoMessage() {} func (*ResponseFlush) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{15} + return fileDescriptor_types_c68d3007ea320b94, []int{15} } func (m *ResponseFlush) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1675,7 +1675,7 @@ func (m *ResponseInfo) Reset() { *m = ResponseInfo{} } func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } func (*ResponseInfo) ProtoMessage() {} func (*ResponseInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{16} + return fileDescriptor_types_c68d3007ea320b94, []int{16} } func (m *ResponseInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1747,7 +1747,7 @@ func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} } func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) } func (*ResponseSetOption) ProtoMessage() {} func (*ResponseSetOption) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{17} + return fileDescriptor_types_c68d3007ea320b94, []int{17} } func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1809,7 +1809,7 @@ func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} } func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } func (*ResponseInitChain) ProtoMessage() {} func (*ResponseInitChain) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{18} + return fileDescriptor_types_c68d3007ea320b94, []int{18} } func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1871,7 +1871,7 @@ func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } func (*ResponseQuery) ProtoMessage() {} func (*ResponseQuery) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{19} + return fileDescriptor_types_c68d3007ea320b94, []int{19} } func (m *ResponseQuery) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1967,7 +1967,7 @@ func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} } func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } func (*ResponseBeginBlock) ProtoMessage() {} func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{20} + return fileDescriptor_types_c68d3007ea320b94, []int{20} } func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2020,7 +2020,7 @@ func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } func (*ResponseCheckTx) ProtoMessage() {} func (*ResponseCheckTx) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{21} + return fileDescriptor_types_c68d3007ea320b94, []int{21} } func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2115,7 +2115,7 @@ func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } func (*ResponseDeliverTx) ProtoMessage() {} func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{22} + return fileDescriptor_types_c68d3007ea320b94, []int{22} } func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2206,7 +2206,7 @@ func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} } func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } func (*ResponseEndBlock) ProtoMessage() {} func (*ResponseEndBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{23} + return fileDescriptor_types_c68d3007ea320b94, []int{23} } func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2268,7 +2268,7 @@ func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } func (*ResponseCommit) ProtoMessage() {} func (*ResponseCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{24} + return fileDescriptor_types_c68d3007ea320b94, []int{24} } func (m *ResponseCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2319,7 +2319,7 @@ func (m *ConsensusParams) Reset() { *m = ConsensusParams{} } func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } func (*ConsensusParams) ProtoMessage() {} func (*ConsensusParams) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{25} + return fileDescriptor_types_c68d3007ea320b94, []int{25} } func (m *ConsensusParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2372,8 +2372,7 @@ func (m *ConsensusParams) GetBlockGossip() *BlockGossip { // BlockSize contains limits on the block size. type BlockSize struct { MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"` - MaxTxs int32 `protobuf:"varint,2,opt,name=max_txs,json=maxTxs,proto3" json:"max_txs,omitempty"` - MaxGas int64 `protobuf:"varint,3,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"` + MaxGas int64 `protobuf:"varint,2,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -2383,7 +2382,7 @@ func (m *BlockSize) Reset() { *m = BlockSize{} } func (m *BlockSize) String() string { return proto.CompactTextString(m) } func (*BlockSize) ProtoMessage() {} func (*BlockSize) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{26} + return fileDescriptor_types_c68d3007ea320b94, []int{26} } func (m *BlockSize) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2419,13 +2418,6 @@ func (m *BlockSize) GetMaxBytes() int32 { return 0 } -func (m *BlockSize) GetMaxTxs() int32 { - if m != nil { - return m.MaxTxs - } - return 0 -} - func (m *BlockSize) GetMaxGas() int64 { if m != nil { return m.MaxGas @@ -2446,7 +2438,7 @@ func (m *TxSize) Reset() { *m = TxSize{} } func (m *TxSize) String() string { return proto.CompactTextString(m) } func (*TxSize) ProtoMessage() {} func (*TxSize) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{27} + return fileDescriptor_types_c68d3007ea320b94, []int{27} } func (m *TxSize) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2503,7 +2495,7 @@ func (m *BlockGossip) Reset() { *m = BlockGossip{} } func (m *BlockGossip) String() string { return proto.CompactTextString(m) } func (*BlockGossip) ProtoMessage() {} func (*BlockGossip) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{28} + return fileDescriptor_types_c68d3007ea320b94, []int{28} } func (m *BlockGossip) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2551,7 +2543,7 @@ func (m *LastCommitInfo) Reset() { *m = LastCommitInfo{} } func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) } func (*LastCommitInfo) ProtoMessage() {} func (*LastCommitInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{29} + return fileDescriptor_types_c68d3007ea320b94, []int{29} } func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2624,7 +2616,7 @@ func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{30} + return fileDescriptor_types_c68d3007ea320b94, []int{30} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2770,7 +2762,7 @@ 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_types_bafb6deff4c77e13, []int{31} + return fileDescriptor_types_c68d3007ea320b94, []int{31} } func (m *BlockID) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2825,7 +2817,7 @@ 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_types_bafb6deff4c77e13, []int{32} + return fileDescriptor_types_c68d3007ea320b94, []int{32} } func (m *PartSetHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2882,7 +2874,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_types_bafb6deff4c77e13, []int{33} + return fileDescriptor_types_c68d3007ea320b94, []int{33} } func (m *Validator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2938,7 +2930,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_types_bafb6deff4c77e13, []int{34} + return fileDescriptor_types_c68d3007ea320b94, []int{34} } func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2994,7 +2986,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_types_bafb6deff4c77e13, []int{35} + return fileDescriptor_types_c68d3007ea320b94, []int{35} } func (m *VoteInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3049,7 +3041,7 @@ func (m *PubKey) Reset() { *m = PubKey{} } func (m *PubKey) String() string { return proto.CompactTextString(m) } func (*PubKey) ProtoMessage() {} func (*PubKey) Descriptor() ([]byte, []int) { - return fileDescriptor_types_bafb6deff4c77e13, []int{36} + return fileDescriptor_types_c68d3007ea320b94, []int{36} } func (m *PubKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3107,7 +3099,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_types_bafb6deff4c77e13, []int{37} + return fileDescriptor_types_c68d3007ea320b94, []int{37} } func (m *Evidence) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4688,9 +4680,6 @@ func (this *BlockSize) Equal(that interface{}) bool { if this.MaxBytes != that1.MaxBytes { return false } - if this.MaxTxs != that1.MaxTxs { - return false - } if this.MaxGas != that1.MaxGas { return false } @@ -5212,7 +5201,8 @@ func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBloc return out, nil } -// ABCIApplicationServer is the server API for ABCIApplication service. +// Server API for ABCIApplication service + type ABCIApplicationServer interface { Echo(context.Context, *RequestEcho) (*ResponseEcho, error) Flush(context.Context, *RequestFlush) (*ResponseFlush, error) @@ -6821,13 +6811,8 @@ func (m *BlockSize) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) } - if m.MaxTxs != 0 { - dAtA[i] = 0x10 - i++ - i = encodeVarintTypes(dAtA, i, uint64(m.MaxTxs)) - } if m.MaxGas != 0 { - dAtA[i] = 0x18 + dAtA[i] = 0x10 i++ i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) } @@ -7899,16 +7884,12 @@ func NewPopulatedBlockSize(r randyTypes, easy bool) *BlockSize { if r.Intn(2) == 0 { this.MaxBytes *= -1 } - this.MaxTxs = int32(r.Int31()) - if r.Intn(2) == 0 { - this.MaxTxs *= -1 - } this.MaxGas = int64(r.Int63()) if r.Intn(2) == 0 { this.MaxGas *= -1 } if !easy && r.Intn(10) != 0 { - this.XXX_unrecognized = randUnrecognizedTypes(r, 4) + this.XXX_unrecognized = randUnrecognizedTypes(r, 3) } return this } @@ -8905,9 +8886,6 @@ func (m *BlockSize) Size() (n int) { if m.MaxBytes != 0 { n += 1 + sovTypes(uint64(m.MaxBytes)) } - if m.MaxTxs != 0 { - n += 1 + sovTypes(uint64(m.MaxTxs)) - } if m.MaxGas != 0 { n += 1 + sovTypes(uint64(m.MaxGas)) } @@ -12960,25 +12938,6 @@ func (m *BlockSize) Unmarshal(dAtA []byte) error { } } case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxTxs", wireType) - } - m.MaxTxs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxTxs |= (int32(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxGas", wireType) } @@ -14664,144 +14623,143 @@ var ( ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_bafb6deff4c77e13) } +func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_c68d3007ea320b94) } func init() { - golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_bafb6deff4c77e13) -} - -var fileDescriptor_types_bafb6deff4c77e13 = []byte{ - // 2115 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcf, 0x6e, 0x1b, 0xc9, - 0xd1, 0xd7, 0x50, 0x14, 0xc9, 0x29, 0x4a, 0xa4, 0xdc, 0xb6, 0x25, 0x9a, 0xfb, 0x7d, 0x92, 0x31, - 0x49, 0xbc, 0x52, 0x56, 0x2b, 0x6d, 0xb4, 0x71, 0x20, 0xaf, 0x37, 0x8b, 0x88, 0xb6, 0xb3, 0x12, - 0x76, 0x93, 0x28, 0x63, 0x5b, 0x01, 0x82, 0x00, 0x83, 0x26, 0xa7, 0x45, 0x0e, 0x4c, 0xce, 0xcc, - 0x4e, 0x37, 0xb5, 0x94, 0x9f, 0x61, 0x0f, 0x7b, 0x08, 0x90, 0x73, 0x6e, 0x79, 0x81, 0x00, 0x39, - 0xe6, 0x14, 0xec, 0x31, 0x08, 0x12, 0xe4, 0xe6, 0x24, 0x0a, 0x72, 0x48, 0x9e, 0x20, 0xc7, 0xa0, - 0xab, 0x7b, 0xfe, 0x6a, 0x68, 0xd8, 0xce, 0x2d, 0x17, 0x72, 0xba, 0xab, 0xaa, 0xbb, 0xab, 0xba, - 0xaa, 0x7e, 0x55, 0x0d, 0x6b, 0xb4, 0x3f, 0xf0, 0xf6, 0xc4, 0x45, 0xc8, 0xb8, 0xfa, 0xdd, 0x0d, - 0xa3, 0x40, 0x04, 0x64, 0x09, 0x07, 0xdd, 0x77, 0x87, 0x9e, 0x18, 0x4d, 0xfb, 0xbb, 0x83, 0x60, - 0xb2, 0x37, 0x0c, 0x86, 0xc1, 0x1e, 0x52, 0xfb, 0xd3, 0x33, 0x1c, 0xe1, 0x00, 0xbf, 0x94, 0x54, - 0x77, 0x73, 0x18, 0x04, 0xc3, 0x31, 0x4b, 0xb9, 0x84, 0x37, 0x61, 0x5c, 0xd0, 0x49, 0xa8, 0x19, - 0x0e, 0x32, 0xeb, 0x09, 0xe6, 0xbb, 0x2c, 0x9a, 0x78, 0xbe, 0xc8, 0x7e, 0x8e, 0xbd, 0x3e, 0xdf, - 0x1b, 0x04, 0x93, 0x49, 0xe0, 0x67, 0x0f, 0x64, 0xfd, 0xae, 0x0a, 0x75, 0x9b, 0x7d, 0x36, 0x65, - 0x5c, 0x90, 0x2d, 0xa8, 0xb2, 0xc1, 0x28, 0xe8, 0x54, 0x6e, 0x1b, 0x5b, 0xcd, 0x7d, 0xb2, 0xab, - 0xf8, 0x34, 0xf5, 0xd1, 0x60, 0x14, 0x1c, 0x2d, 0xd8, 0xc8, 0x41, 0xde, 0x81, 0xa5, 0xb3, 0xf1, - 0x94, 0x8f, 0x3a, 0x8b, 0xc8, 0x7a, 0x3d, 0xcf, 0xfa, 0x7d, 0x49, 0x3a, 0x5a, 0xb0, 0x15, 0x8f, - 0x5c, 0xd6, 0xf3, 0xcf, 0x82, 0x4e, 0xb5, 0x6c, 0xd9, 0x63, 0xff, 0x0c, 0x97, 0x95, 0x1c, 0xe4, - 0x00, 0x80, 0x33, 0xe1, 0x04, 0xa1, 0xf0, 0x02, 0xbf, 0xb3, 0x84, 0xfc, 0xeb, 0x79, 0xfe, 0xc7, - 0x4c, 0xfc, 0x08, 0xc9, 0x47, 0x0b, 0xb6, 0xc9, 0xe3, 0x81, 0x94, 0xf4, 0x7c, 0x4f, 0x38, 0x83, - 0x11, 0xf5, 0xfc, 0x4e, 0xad, 0x4c, 0xf2, 0xd8, 0xf7, 0xc4, 0x03, 0x49, 0x96, 0x92, 0x5e, 0x3c, - 0x90, 0xaa, 0x7c, 0x36, 0x65, 0xd1, 0x45, 0xa7, 0x5e, 0xa6, 0xca, 0x8f, 0x25, 0x49, 0xaa, 0x82, - 0x3c, 0xe4, 0x3e, 0x34, 0xfb, 0x6c, 0xe8, 0xf9, 0x4e, 0x7f, 0x1c, 0x0c, 0x9e, 0x75, 0x1a, 0x28, - 0xd2, 0xc9, 0x8b, 0xf4, 0x24, 0x43, 0x4f, 0xd2, 0x8f, 0x16, 0x6c, 0xe8, 0x27, 0x23, 0xb2, 0x0f, - 0x8d, 0xc1, 0x88, 0x0d, 0x9e, 0x39, 0x62, 0xd6, 0x31, 0x51, 0xf2, 0x66, 0x5e, 0xf2, 0x81, 0xa4, - 0x3e, 0x99, 0x1d, 0x2d, 0xd8, 0xf5, 0x81, 0xfa, 0x24, 0x77, 0xc1, 0x64, 0xbe, 0xab, 0xb7, 0x6b, - 0xa2, 0xd0, 0x5a, 0xe1, 0x5e, 0x7c, 0x37, 0xde, 0xac, 0xc1, 0xf4, 0x37, 0xd9, 0x85, 0x9a, 0xbc, - 0x6b, 0x4f, 0x74, 0x96, 0x51, 0xe6, 0x46, 0x61, 0x23, 0xa4, 0x1d, 0x2d, 0xd8, 0x9a, 0x4b, 0x9a, - 0xcf, 0x65, 0x63, 0xef, 0x9c, 0x45, 0xf2, 0x70, 0xd7, 0xcb, 0xcc, 0xf7, 0x50, 0xd1, 0xf1, 0x78, - 0xa6, 0x1b, 0x0f, 0x7a, 0x75, 0x58, 0x3a, 0xa7, 0xe3, 0x29, 0xb3, 0xde, 0x86, 0x66, 0xc6, 0x53, - 0x48, 0x07, 0xea, 0x13, 0xc6, 0x39, 0x1d, 0xb2, 0x8e, 0x71, 0xdb, 0xd8, 0x32, 0xed, 0x78, 0x68, - 0xb5, 0x60, 0x39, 0xeb, 0x27, 0x19, 0x41, 0xe9, 0x0b, 0x52, 0xf0, 0x9c, 0x45, 0x5c, 0x3a, 0x80, - 0x16, 0xd4, 0x43, 0xeb, 0x03, 0x58, 0x2d, 0x3a, 0x01, 0x59, 0x85, 0xc5, 0x67, 0xec, 0x42, 0x73, - 0xca, 0x4f, 0x72, 0x43, 0x1f, 0x08, 0xbd, 0xd8, 0xb4, 0xf5, 0xe9, 0xbe, 0xac, 0x24, 0xc2, 0x89, - 0x1f, 0x90, 0x03, 0xa8, 0xca, 0x40, 0x42, 0xe9, 0xe6, 0x7e, 0x77, 0x57, 0x45, 0xd9, 0x6e, 0x1c, - 0x65, 0xbb, 0x4f, 0xe2, 0x28, 0xeb, 0x35, 0xbe, 0x7a, 0xb1, 0xb9, 0xf0, 0xe5, 0x5f, 0x36, 0x0d, - 0x1b, 0x25, 0xc8, 0x2d, 0x79, 0x95, 0xd4, 0xf3, 0x1d, 0xcf, 0xd5, 0xfb, 0xd4, 0x71, 0x7c, 0xec, - 0x92, 0x43, 0x58, 0x1d, 0x04, 0x3e, 0x67, 0x3e, 0x9f, 0x72, 0x27, 0xa4, 0x11, 0x9d, 0x70, 0x1d, - 0x25, 0xf1, 0xc5, 0x3d, 0x88, 0xc9, 0x27, 0x48, 0xb5, 0xdb, 0x83, 0xfc, 0x04, 0xf9, 0x10, 0xe0, - 0x9c, 0x8e, 0x3d, 0x97, 0x8a, 0x20, 0xe2, 0x9d, 0xea, 0xed, 0xc5, 0x8c, 0xf0, 0x69, 0x4c, 0x78, - 0x1a, 0xba, 0x54, 0xb0, 0x5e, 0x55, 0x9e, 0xcc, 0xce, 0xf0, 0x93, 0x3b, 0xd0, 0xa6, 0x61, 0xe8, - 0x70, 0x41, 0x05, 0x73, 0xfa, 0x17, 0x82, 0x71, 0x8c, 0xa4, 0x65, 0x7b, 0x85, 0x86, 0xe1, 0x63, - 0x39, 0xdb, 0x93, 0x93, 0x96, 0x9b, 0xdc, 0x03, 0x3a, 0x39, 0x21, 0x50, 0x75, 0xa9, 0xa0, 0x68, - 0x8d, 0x65, 0x1b, 0xbf, 0xe5, 0x5c, 0x48, 0xc5, 0x48, 0xeb, 0x88, 0xdf, 0x64, 0x0d, 0x6a, 0x23, - 0xe6, 0x0d, 0x47, 0x02, 0xd5, 0x5a, 0xb4, 0xf5, 0x48, 0x1a, 0x3e, 0x8c, 0x82, 0x73, 0x86, 0x71, - 0xde, 0xb0, 0xd5, 0xc0, 0xfa, 0x87, 0x01, 0xd7, 0xae, 0x04, 0x86, 0x5c, 0x77, 0x44, 0xf9, 0x28, - 0xde, 0x4b, 0x7e, 0x93, 0x77, 0xe4, 0xba, 0xd4, 0x65, 0x91, 0xce, 0x3f, 0x2b, 0x5a, 0xe3, 0x23, - 0x9c, 0xd4, 0x8a, 0x6a, 0x16, 0xf2, 0x08, 0x56, 0xc7, 0x94, 0x0b, 0x47, 0xf9, 0xaf, 0x83, 0xf9, - 0x65, 0x31, 0x17, 0x53, 0x9f, 0xd2, 0xd8, 0xcf, 0xa5, 0x5b, 0x69, 0xf1, 0xd6, 0x38, 0x37, 0x4b, - 0x8e, 0xe0, 0x46, 0xff, 0xe2, 0x39, 0xf5, 0x85, 0xe7, 0x33, 0xe7, 0x8a, 0xcd, 0xdb, 0x7a, 0xa9, - 0x47, 0xe7, 0x9e, 0xcb, 0xfc, 0x41, 0x6c, 0xec, 0xeb, 0x89, 0x48, 0x72, 0x19, 0xdc, 0xba, 0x0d, - 0xad, 0x7c, 0x14, 0x93, 0x16, 0x54, 0xc4, 0x4c, 0x6b, 0x58, 0x11, 0x33, 0xcb, 0x4a, 0x3c, 0x30, - 0x09, 0xa5, 0x2b, 0x3c, 0xdb, 0xd0, 0x2e, 0x84, 0x75, 0xc6, 0xdc, 0x46, 0xd6, 0xdc, 0x56, 0x1b, - 0x56, 0x72, 0xd1, 0x6c, 0x7d, 0xb1, 0x04, 0x0d, 0x9b, 0xf1, 0x50, 0x3a, 0x13, 0x39, 0x00, 0x93, - 0xcd, 0x06, 0x4c, 0x25, 0x52, 0xa3, 0x90, 0xa6, 0x14, 0xcf, 0xa3, 0x98, 0x2e, 0x03, 0x3a, 0x61, - 0x26, 0xdb, 0x39, 0x10, 0xb8, 0x5e, 0x14, 0xca, 0xa2, 0xc0, 0x4e, 0x1e, 0x05, 0x6e, 0x14, 0x78, - 0x0b, 0x30, 0xb0, 0x9d, 0x83, 0x81, 0xe2, 0xc2, 0x39, 0x1c, 0xb8, 0x57, 0x82, 0x03, 0xc5, 0xe3, - 0xcf, 0x01, 0x82, 0x7b, 0x25, 0x40, 0xd0, 0xb9, 0xb2, 0x57, 0x29, 0x12, 0xec, 0xe4, 0x91, 0xa0, - 0xa8, 0x4e, 0x01, 0x0a, 0x3e, 0x2c, 0x83, 0x82, 0x5b, 0x05, 0x99, 0xb9, 0x58, 0xf0, 0xfe, 0x15, - 0x2c, 0x58, 0x2b, 0x88, 0x96, 0x80, 0xc1, 0xbd, 0x5c, 0x96, 0x86, 0x52, 0xdd, 0xca, 0xd3, 0x34, - 0xf9, 0xce, 0x55, 0x1c, 0x59, 0x2f, 0x5e, 0x6d, 0x19, 0x90, 0xec, 0x15, 0x80, 0xe4, 0x66, 0xf1, - 0x94, 0x05, 0x24, 0x49, 0xf1, 0x60, 0x5b, 0xc6, 0x7d, 0xc1, 0xd3, 0x64, 0x8e, 0x60, 0x51, 0x14, - 0x44, 0x3a, 0x61, 0xab, 0x81, 0xb5, 0x25, 0x33, 0x51, 0xea, 0x5f, 0x2f, 0xc1, 0x0e, 0x74, 0xfa, - 0x8c, 0x77, 0x59, 0xbf, 0x30, 0x52, 0x59, 0x8c, 0xe8, 0x6c, 0x16, 0x33, 0x75, 0x16, 0xcb, 0x40, - 0x4a, 0x25, 0x07, 0x29, 0xe4, 0x9b, 0x70, 0x0d, 0xd3, 0x08, 0xda, 0xc5, 0xc9, 0xa5, 0xb5, 0xb6, - 0x24, 0x28, 0x83, 0xa8, 0xfc, 0xf6, 0x2e, 0x5c, 0xcf, 0xf0, 0xca, 0x14, 0x8b, 0x29, 0xac, 0x8a, - 0xc1, 0xbb, 0x9a, 0x70, 0x1f, 0x86, 0xe1, 0x11, 0xe5, 0x23, 0xeb, 0x07, 0xa9, 0xfe, 0x29, 0x5c, - 0x11, 0xa8, 0x0e, 0x02, 0x57, 0xa9, 0xb5, 0x62, 0xe3, 0xb7, 0x84, 0xb0, 0x71, 0x30, 0xc4, 0x5d, - 0x4d, 0x5b, 0x7e, 0x4a, 0xae, 0x24, 0x52, 0x4c, 0x15, 0x12, 0xd6, 0xcf, 0x8d, 0x74, 0xbd, 0x14, - 0xc1, 0xca, 0xc0, 0xc6, 0xf8, 0x6f, 0xc0, 0xa6, 0xf2, 0x7a, 0x60, 0x63, 0xfd, 0xda, 0x48, 0x6f, - 0x24, 0x81, 0x91, 0x37, 0x53, 0x51, 0x3a, 0x87, 0xe7, 0xbb, 0x6c, 0x86, 0x01, 0xbf, 0x68, 0xab, - 0x41, 0x8c, 0xf0, 0x35, 0x34, 0x73, 0x1e, 0xe1, 0xeb, 0x38, 0xa7, 0x06, 0x1a, 0x7e, 0x82, 0x33, - 0x8c, 0xc4, 0x65, 0x5b, 0x0d, 0x32, 0xd9, 0xd3, 0xcc, 0x65, 0xcf, 0x13, 0x20, 0x57, 0x63, 0x94, - 0x7c, 0x00, 0x55, 0x41, 0x87, 0xd2, 0x84, 0xd2, 0x0a, 0xad, 0x5d, 0x55, 0x2f, 0xef, 0x7e, 0x72, - 0x7a, 0x42, 0xbd, 0xa8, 0xb7, 0x26, 0xb5, 0xff, 0xd7, 0x8b, 0xcd, 0x96, 0xe4, 0xd9, 0x09, 0x26, - 0x9e, 0x60, 0x93, 0x50, 0x5c, 0xd8, 0x28, 0x63, 0xfd, 0xc9, 0x90, 0xb9, 0x3b, 0x17, 0xbb, 0xa5, - 0xb6, 0x88, 0x1d, 0xb4, 0x92, 0x81, 0xd9, 0x57, 0xb3, 0xcf, 0xff, 0x03, 0x0c, 0x29, 0x77, 0x3e, - 0xa7, 0xbe, 0x60, 0xae, 0x36, 0x92, 0x39, 0xa4, 0xfc, 0x27, 0x38, 0x21, 0x6b, 0x12, 0x49, 0x9e, - 0x72, 0xe6, 0xa2, 0xb5, 0x16, 0xed, 0xfa, 0x90, 0xf2, 0xa7, 0x9c, 0xb9, 0x89, 0x5e, 0xf5, 0x37, - 0xd0, 0xeb, 0xcf, 0x19, 0xc7, 0x4b, 0x81, 0xeb, 0x7f, 0x41, 0xb3, 0x7f, 0x1a, 0x12, 0x91, 0xf3, - 0xc9, 0x8f, 0x1c, 0xc3, 0xb5, 0xc4, 0xbd, 0x9d, 0x29, 0xba, 0x7d, 0xec, 0x0f, 0x2f, 0x8f, 0x8a, - 0xd5, 0xf3, 0xfc, 0x34, 0x27, 0x3f, 0x84, 0xf5, 0x42, 0x70, 0x26, 0x0b, 0x56, 0x5e, 0x1a, 0xa3, - 0x37, 0xf3, 0x31, 0x1a, 0xaf, 0x17, 0xeb, 0xba, 0xf8, 0x06, 0xba, 0x7e, 0x5d, 0x96, 0x27, 0xd9, - 0x94, 0x5d, 0x76, 0x5b, 0xd6, 0x2f, 0x0d, 0x68, 0x17, 0x0e, 0x43, 0xf6, 0x00, 0x54, 0xc6, 0xe3, - 0xde, 0xf3, 0xb8, 0x54, 0x5e, 0xd5, 0x07, 0x47, 0x93, 0x3d, 0xf6, 0x9e, 0x33, 0xdb, 0xec, 0xc7, - 0x9f, 0xe4, 0x0e, 0xd4, 0xc5, 0x4c, 0x71, 0xe7, 0x0b, 0xb9, 0x27, 0x33, 0x64, 0xad, 0x09, 0xfc, - 0x27, 0x77, 0x61, 0x59, 0x2d, 0x3c, 0x0c, 0x38, 0xf7, 0x42, 0x5d, 0x44, 0x90, 0xec, 0xd2, 0x1f, - 0x23, 0xc5, 0x6e, 0xf6, 0xd3, 0x81, 0xf5, 0x53, 0x30, 0x93, 0x6d, 0xc9, 0x5b, 0x60, 0x4e, 0xe8, - 0x4c, 0x57, 0xb9, 0xf2, 0x6c, 0x4b, 0x76, 0x63, 0x42, 0x67, 0x58, 0xe0, 0x92, 0x75, 0xa8, 0x4b, - 0xa2, 0x98, 0x29, 0x7b, 0x2f, 0xd9, 0xb5, 0x09, 0x9d, 0x3d, 0x99, 0x25, 0x84, 0x21, 0xe5, 0x71, - 0x09, 0x3b, 0xa1, 0xb3, 0x8f, 0x29, 0xb7, 0x3e, 0x82, 0x9a, 0x3a, 0xe4, 0x2b, 0x2d, 0x2c, 0xe5, - 0x2b, 0x39, 0xf9, 0xef, 0x41, 0x33, 0x73, 0x6e, 0xf2, 0x2d, 0xb8, 0xa9, 0x34, 0x0c, 0x69, 0x24, - 0xd0, 0x22, 0xb9, 0x05, 0x09, 0x12, 0x4f, 0x68, 0x24, 0xe4, 0x96, 0xaa, 0x28, 0x7f, 0x0c, 0xad, - 0x7c, 0xe1, 0x2a, 0xf3, 0x5a, 0x14, 0x4c, 0x7d, 0x57, 0x0b, 0xa9, 0x81, 0xec, 0x5a, 0xcf, 0x03, - 0xe5, 0x49, 0xd9, 0x4a, 0xf5, 0x34, 0x10, 0x2c, 0x53, 0xee, 0x2a, 0x1e, 0xeb, 0x0f, 0x55, 0xa8, - 0xa9, 0x2a, 0x9a, 0xdc, 0xc9, 0x34, 0x2e, 0x08, 0x91, 0xbd, 0xe6, 0xe5, 0x8b, 0xcd, 0x3a, 0xa2, - 0xc9, 0xf1, 0xc3, 0xb4, 0x8b, 0x49, 0xf3, 0x66, 0x25, 0x57, 0xe4, 0xc7, 0x2d, 0xd3, 0xe2, 0x6b, - 0xb7, 0x4c, 0xeb, 0x50, 0xf7, 0xa7, 0x13, 0xbc, 0x8d, 0xaa, 0x5a, 0xd2, 0x9f, 0x4e, 0xe4, 0x6d, - 0xbc, 0x05, 0xa6, 0x08, 0x04, 0x1d, 0x23, 0x49, 0xc5, 0x7e, 0x03, 0x27, 0x24, 0xf1, 0x00, 0x56, - 0x32, 0xa0, 0xeb, 0xb9, 0xba, 0xa2, 0x6b, 0x65, 0xbd, 0xe4, 0xf8, 0xa1, 0x56, 0xb7, 0x99, 0x80, - 0xf0, 0xb1, 0x4b, 0xb6, 0xf2, 0x1d, 0x02, 0x62, 0xb5, 0x02, 0x8c, 0x4c, 0x13, 0x20, 0x91, 0x5a, - 0x1e, 0x40, 0x7a, 0xbf, 0x62, 0x51, 0xe8, 0xd1, 0x90, 0x13, 0x48, 0x7c, 0x1b, 0xda, 0x29, 0xdc, - 0x29, 0x16, 0x53, 0xad, 0x92, 0x4e, 0x23, 0xe3, 0x7b, 0x70, 0xc3, 0x67, 0x33, 0xe1, 0x14, 0xb9, - 0x01, 0xb9, 0x89, 0xa4, 0x9d, 0xe6, 0x25, 0xbe, 0x01, 0xad, 0x34, 0x3f, 0x20, 0x6f, 0x53, 0xf5, - 0x69, 0xc9, 0x2c, 0xb2, 0xdd, 0x82, 0x46, 0x52, 0x6c, 0x2c, 0x23, 0x43, 0x9d, 0xaa, 0x1a, 0x23, - 0x29, 0x5f, 0x22, 0xc6, 0xa7, 0x63, 0xa1, 0x17, 0x59, 0x41, 0x1e, 0x2c, 0x5f, 0x6c, 0x35, 0x8f, - 0xbc, 0x5f, 0x83, 0x15, 0xa6, 0xfb, 0x18, 0xc5, 0xd7, 0x42, 0xbe, 0xe5, 0x78, 0x12, 0x99, 0xb6, - 0x61, 0x35, 0x8c, 0x82, 0x30, 0xe0, 0x2c, 0x72, 0xa8, 0xeb, 0x46, 0x8c, 0xf3, 0x4e, 0x5b, 0xad, - 0x17, 0xcf, 0x1f, 0xaa, 0x69, 0xeb, 0x67, 0x50, 0xd7, 0xd6, 0x2f, 0xed, 0xe6, 0xbe, 0x0b, 0xcb, - 0xd2, 0xeb, 0xb9, 0x93, 0xeb, 0xe9, 0xe2, 0x9a, 0x1a, 0x9d, 0x9e, 0x89, 0x5c, 0x6b, 0xd7, 0x44, - 0x7e, 0x35, 0x65, 0xdd, 0x83, 0x95, 0x1c, 0x8f, 0x0c, 0x03, 0x74, 0x8a, 0x38, 0x0c, 0x70, 0x90, - 0xec, 0x5c, 0x49, 0x77, 0xb6, 0xee, 0x83, 0x99, 0x18, 0x5a, 0x96, 0x7e, 0xb1, 0x1e, 0x86, 0xb6, - 0x9d, 0x1a, 0x62, 0xbd, 0x10, 0x7c, 0xce, 0x22, 0x9d, 0x02, 0xd4, 0xc0, 0x7a, 0x0a, 0xed, 0x42, - 0x7a, 0x27, 0x3b, 0x50, 0x0f, 0xa7, 0x7d, 0x27, 0x7e, 0x66, 0x48, 0xf3, 0xd9, 0xc9, 0xb4, 0xff, - 0x09, 0xbb, 0x88, 0x1b, 0xd3, 0x10, 0x47, 0xe9, 0xb2, 0x95, 0xec, 0xb2, 0x63, 0x68, 0xc4, 0xa1, - 0x49, 0xbe, 0x0d, 0x66, 0xe2, 0x23, 0x85, 0x7c, 0x9a, 0x6c, 0xad, 0x17, 0x4d, 0x19, 0xe5, 0x55, - 0x73, 0x6f, 0xe8, 0x33, 0xd7, 0x49, 0xe3, 0x01, 0xf7, 0x68, 0xd8, 0x6d, 0x45, 0xf8, 0x34, 0x76, - 0x7e, 0xeb, 0x3d, 0xa8, 0xa9, 0xb3, 0x49, 0xfb, 0xc8, 0x95, 0xe3, 0x6a, 0x58, 0x7e, 0x97, 0x26, - 0xfe, 0x3f, 0x1a, 0xd0, 0x88, 0xbb, 0xdc, 0x52, 0xa1, 0xdc, 0xa1, 0x2b, 0xaf, 0x7a, 0xe8, 0x79, - 0x4f, 0x05, 0x71, 0x16, 0xa9, 0xbe, 0x76, 0x16, 0xd9, 0x01, 0xa2, 0x92, 0xc5, 0x79, 0x20, 0x3c, - 0x7f, 0xe8, 0x28, 0x5b, 0xab, 0xac, 0xb1, 0x8a, 0x94, 0x53, 0x24, 0x9c, 0xc8, 0xf9, 0xfd, 0x2f, - 0x96, 0xa0, 0x7d, 0xd8, 0x7b, 0x70, 0x7c, 0x18, 0x86, 0x63, 0x6f, 0x40, 0xb1, 0x04, 0xdf, 0x83, - 0x2a, 0x36, 0x19, 0x25, 0xcf, 0x9b, 0xdd, 0xb2, 0x6e, 0x97, 0xec, 0xc3, 0x12, 0xf6, 0x1a, 0xa4, - 0xec, 0x95, 0xb3, 0x5b, 0xda, 0xf4, 0xca, 0x4d, 0x54, 0x37, 0x72, 0xf5, 0xb1, 0xb3, 0x5b, 0xd6, - 0xf9, 0x92, 0x8f, 0xc0, 0x4c, 0xbb, 0x84, 0x79, 0x4f, 0x9e, 0xdd, 0xb9, 0x3d, 0xb0, 0x94, 0x4f, - 0x8b, 0xb3, 0x79, 0x2f, 0x77, 0xdd, 0xb9, 0xcd, 0x22, 0x39, 0x80, 0x7a, 0x5c, 0xb4, 0x96, 0x3f, - 0x4a, 0x76, 0xe7, 0xf4, 0xa7, 0xd2, 0x3c, 0xaa, 0xf0, 0x2f, 0x7b, 0x39, 0xed, 0x96, 0x36, 0xd1, - 0xe4, 0x2e, 0xd4, 0x74, 0x15, 0x52, 0xfa, 0x30, 0xd9, 0x2d, 0xef, 0x32, 0xa5, 0x92, 0x69, 0xeb, - 0x33, 0xef, 0x75, 0xb7, 0x3b, 0xb7, 0xdb, 0x27, 0x87, 0x00, 0x99, 0x62, 0x7f, 0xee, 0xb3, 0x6d, - 0x77, 0x7e, 0x17, 0x4f, 0xee, 0x43, 0x23, 0x7d, 0x99, 0x29, 0x7f, 0x88, 0xed, 0xce, 0x6b, 0xac, - 0x7b, 0xff, 0xf7, 0xef, 0xbf, 0x6d, 0x18, 0xbf, 0xba, 0xdc, 0x30, 0x7e, 0x73, 0xb9, 0x61, 0x7c, - 0x75, 0xb9, 0x61, 0xfc, 0xfe, 0x72, 0xc3, 0xf8, 0xeb, 0xe5, 0x86, 0xf1, 0xdb, 0xbf, 0x6f, 0x18, - 0xfd, 0x1a, 0xba, 0xff, 0xfb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x32, 0xa1, 0x6a, 0x3b, + golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_c68d3007ea320b94) +} + +var fileDescriptor_types_c68d3007ea320b94 = []byte{ + // 2099 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4f, 0x73, 0x1b, 0x49, + 0x15, 0xf7, 0x48, 0xb2, 0xfe, 0x3c, 0xd9, 0x92, 0xd3, 0x76, 0x6c, 0x45, 0x80, 0x9d, 0x1a, 0x20, + 0x6b, 0xb3, 0x5e, 0x7b, 0xf1, 0x12, 0xca, 0xd9, 0x2c, 0x5b, 0x58, 0x49, 0x58, 0xbb, 0x76, 0x01, + 0x33, 0x49, 0xcc, 0x85, 0xaa, 0xa9, 0x96, 0xa6, 0x2d, 0x4d, 0x45, 0x9a, 0x99, 0x9d, 0x6e, 0x79, + 0xe5, 0x7c, 0x86, 0x3d, 0xec, 0x81, 0x2a, 0xce, 0xdc, 0xf8, 0x02, 0x54, 0x71, 0xe4, 0x44, 0xed, + 0x91, 0xa2, 0xa0, 0xb8, 0x05, 0x30, 0xc5, 0x01, 0x3e, 0x01, 0x47, 0xaa, 0x5f, 0xf7, 0xfc, 0xf5, + 0x28, 0x95, 0x84, 0xdb, 0x5e, 0xa4, 0xee, 0x7e, 0xef, 0x75, 0xf7, 0x7b, 0xf3, 0xde, 0xfb, 0xbd, + 0xd7, 0xb0, 0x4e, 0xfb, 0x03, 0x77, 0x5f, 0x5c, 0x06, 0x8c, 0xab, 0xdf, 0xbd, 0x20, 0xf4, 0x85, + 0x4f, 0x16, 0x71, 0xd2, 0x7d, 0x67, 0xe8, 0x8a, 0xd1, 0xb4, 0xbf, 0x37, 0xf0, 0x27, 0xfb, 0x43, + 0x7f, 0xe8, 0xef, 0x23, 0xb5, 0x3f, 0x3d, 0xc7, 0x19, 0x4e, 0x70, 0xa4, 0xa4, 0xba, 0x5b, 0x43, + 0xdf, 0x1f, 0x8e, 0x59, 0xc2, 0x25, 0xdc, 0x09, 0xe3, 0x82, 0x4e, 0x02, 0xcd, 0x70, 0x98, 0xda, + 0x4f, 0x30, 0xcf, 0x61, 0xe1, 0xc4, 0xf5, 0x44, 0x7a, 0x38, 0x76, 0xfb, 0x7c, 0x7f, 0xe0, 0x4f, + 0x26, 0xbe, 0x97, 0xbe, 0x90, 0xf9, 0x87, 0x0a, 0xd4, 0x2c, 0xf6, 0xe9, 0x94, 0x71, 0x41, 0xb6, + 0xa1, 0xc2, 0x06, 0x23, 0xbf, 0x53, 0xba, 0x6d, 0x6c, 0x37, 0x0f, 0xc8, 0x9e, 0xe2, 0xd3, 0xd4, + 0x47, 0x83, 0x91, 0x7f, 0xbc, 0x60, 0x21, 0x07, 0x79, 0x1b, 0x16, 0xcf, 0xc7, 0x53, 0x3e, 0xea, + 0x94, 0x91, 0x75, 0x35, 0xcb, 0xfa, 0x23, 0x49, 0x3a, 0x5e, 0xb0, 0x14, 0x8f, 0xdc, 0xd6, 0xf5, + 0xce, 0xfd, 0x4e, 0xa5, 0x68, 0xdb, 0x13, 0xef, 0x1c, 0xb7, 0x95, 0x1c, 0xe4, 0x10, 0x80, 0x33, + 0x61, 0xfb, 0x81, 0x70, 0x7d, 0xaf, 0xb3, 0x88, 0xfc, 0x1b, 0x59, 0xfe, 0xc7, 0x4c, 0xfc, 0x14, + 0xc9, 0xc7, 0x0b, 0x56, 0x83, 0x47, 0x13, 0x29, 0xe9, 0x7a, 0xae, 0xb0, 0x07, 0x23, 0xea, 0x7a, + 0x9d, 0x6a, 0x91, 0xe4, 0x89, 0xe7, 0x8a, 0x07, 0x92, 0x2c, 0x25, 0xdd, 0x68, 0x22, 0x55, 0xf9, + 0x74, 0xca, 0xc2, 0xcb, 0x4e, 0xad, 0x48, 0x95, 0x9f, 0x49, 0x92, 0x54, 0x05, 0x79, 0xc8, 0x7d, + 0x68, 0xf6, 0xd9, 0xd0, 0xf5, 0xec, 0xfe, 0xd8, 0x1f, 0x3c, 0xeb, 0xd4, 0x51, 0xa4, 0x93, 0x15, + 0xe9, 0x49, 0x86, 0x9e, 0xa4, 0x1f, 0x2f, 0x58, 0xd0, 0x8f, 0x67, 0xe4, 0x00, 0xea, 0x83, 0x11, + 0x1b, 0x3c, 0xb3, 0xc5, 0xac, 0xd3, 0x40, 0xc9, 0x9b, 0x59, 0xc9, 0x07, 0x92, 0xfa, 0x64, 0x76, + 0xbc, 0x60, 0xd5, 0x06, 0x6a, 0x48, 0xee, 0x42, 0x83, 0x79, 0x8e, 0x3e, 0xae, 0x89, 0x42, 0xeb, + 0xb9, 0xef, 0xe2, 0x39, 0xd1, 0x61, 0x75, 0xa6, 0xc7, 0x64, 0x0f, 0xaa, 0xf2, 0x5b, 0xbb, 0xa2, + 0xb3, 0x84, 0x32, 0x6b, 0xb9, 0x83, 0x90, 0x76, 0xbc, 0x60, 0x69, 0x2e, 0x69, 0x3e, 0x87, 0x8d, + 0xdd, 0x0b, 0x16, 0xca, 0xcb, 0xad, 0x16, 0x99, 0xef, 0xa1, 0xa2, 0xe3, 0xf5, 0x1a, 0x4e, 0x34, + 0xe9, 0xd5, 0x60, 0xf1, 0x82, 0x8e, 0xa7, 0xcc, 0x7c, 0x0b, 0x9a, 0x29, 0x4f, 0x21, 0x1d, 0xa8, + 0x4d, 0x18, 0xe7, 0x74, 0xc8, 0x3a, 0xc6, 0x6d, 0x63, 0xbb, 0x61, 0x45, 0x53, 0xb3, 0x05, 0x4b, + 0x69, 0x3f, 0x49, 0x09, 0x4a, 0x5f, 0x90, 0x82, 0x17, 0x2c, 0xe4, 0xd2, 0x01, 0xb4, 0xa0, 0x9e, + 0x9a, 0xef, 0xc3, 0x4a, 0xde, 0x09, 0xc8, 0x0a, 0x94, 0x9f, 0xb1, 0x4b, 0xcd, 0x29, 0x87, 0x64, + 0x4d, 0x5f, 0x08, 0xbd, 0xb8, 0x61, 0xe9, 0xdb, 0x7d, 0x51, 0x8a, 0x85, 0x63, 0x3f, 0x20, 0x87, + 0x50, 0x91, 0x81, 0x84, 0xd2, 0xcd, 0x83, 0xee, 0x9e, 0x8a, 0xb2, 0xbd, 0x28, 0xca, 0xf6, 0x9e, + 0x44, 0x51, 0xd6, 0xab, 0x7f, 0xf9, 0x62, 0x6b, 0xe1, 0x8b, 0xbf, 0x6d, 0x19, 0x16, 0x4a, 0x90, + 0x5b, 0xf2, 0x53, 0x52, 0xd7, 0xb3, 0x5d, 0x47, 0x9f, 0x53, 0xc3, 0xf9, 0x89, 0x43, 0x8e, 0x60, + 0x65, 0xe0, 0x7b, 0x9c, 0x79, 0x7c, 0xca, 0xed, 0x80, 0x86, 0x74, 0xc2, 0x75, 0x94, 0x44, 0x1f, + 0xee, 0x41, 0x44, 0x3e, 0x45, 0xaa, 0xd5, 0x1e, 0x64, 0x17, 0xc8, 0x07, 0x00, 0x17, 0x74, 0xec, + 0x3a, 0x54, 0xf8, 0x21, 0xef, 0x54, 0x6e, 0x97, 0x53, 0xc2, 0x67, 0x11, 0xe1, 0x69, 0xe0, 0x50, + 0xc1, 0x7a, 0x15, 0x79, 0x33, 0x2b, 0xc5, 0x4f, 0xee, 0x40, 0x9b, 0x06, 0x81, 0xcd, 0x05, 0x15, + 0xcc, 0xee, 0x5f, 0x0a, 0xc6, 0x31, 0x92, 0x96, 0xac, 0x65, 0x1a, 0x04, 0x8f, 0xe5, 0x6a, 0x4f, + 0x2e, 0x9a, 0x4e, 0xfc, 0x1d, 0xd0, 0xc9, 0x09, 0x81, 0x8a, 0x43, 0x05, 0x45, 0x6b, 0x2c, 0x59, + 0x38, 0x96, 0x6b, 0x01, 0x15, 0x23, 0xad, 0x23, 0x8e, 0xc9, 0x3a, 0x54, 0x47, 0xcc, 0x1d, 0x8e, + 0x04, 0xaa, 0x55, 0xb6, 0xf4, 0x4c, 0x1a, 0x3e, 0x08, 0xfd, 0x0b, 0x86, 0x71, 0x5e, 0xb7, 0xd4, + 0xc4, 0xfc, 0x97, 0x01, 0x37, 0xae, 0x05, 0x86, 0xdc, 0x77, 0x44, 0xf9, 0x28, 0x3a, 0x4b, 0x8e, + 0xc9, 0xdb, 0x72, 0x5f, 0xea, 0xb0, 0x50, 0xe7, 0x9f, 0x65, 0xad, 0xf1, 0x31, 0x2e, 0x6a, 0x45, + 0x35, 0x0b, 0x79, 0x04, 0x2b, 0x63, 0xca, 0x85, 0xad, 0xfc, 0xd7, 0xc6, 0xfc, 0x52, 0xce, 0xc4, + 0xd4, 0x27, 0x34, 0xf2, 0x73, 0xe9, 0x56, 0x5a, 0xbc, 0x35, 0xce, 0xac, 0x92, 0x63, 0x58, 0xeb, + 0x5f, 0x3e, 0xa7, 0x9e, 0x70, 0x3d, 0x66, 0x5f, 0xb3, 0x79, 0x5b, 0x6f, 0xf5, 0xe8, 0xc2, 0x75, + 0x98, 0x37, 0x88, 0x8c, 0xbd, 0x1a, 0x8b, 0xc4, 0x1f, 0x83, 0x9b, 0xb7, 0xa1, 0x95, 0x8d, 0x62, + 0xd2, 0x82, 0x92, 0x98, 0x69, 0x0d, 0x4b, 0x62, 0x66, 0x9a, 0xb1, 0x07, 0xc6, 0xa1, 0x74, 0x8d, + 0x67, 0x07, 0xda, 0xb9, 0xb0, 0x4e, 0x99, 0xdb, 0x48, 0x9b, 0xdb, 0x6c, 0xc3, 0x72, 0x26, 0x9a, + 0xcd, 0xcf, 0x17, 0xa1, 0x6e, 0x31, 0x1e, 0x48, 0x67, 0x22, 0x87, 0xd0, 0x60, 0xb3, 0x01, 0x53, + 0x89, 0xd4, 0xc8, 0xa5, 0x29, 0xc5, 0xf3, 0x28, 0xa2, 0xcb, 0x80, 0x8e, 0x99, 0xc9, 0x4e, 0x06, + 0x04, 0x56, 0xf3, 0x42, 0x69, 0x14, 0xd8, 0xcd, 0xa2, 0xc0, 0x5a, 0x8e, 0x37, 0x07, 0x03, 0x3b, + 0x19, 0x18, 0xc8, 0x6f, 0x9c, 0xc1, 0x81, 0x7b, 0x05, 0x38, 0x90, 0xbf, 0xfe, 0x1c, 0x20, 0xb8, + 0x57, 0x00, 0x04, 0x9d, 0x6b, 0x67, 0x15, 0x22, 0xc1, 0x6e, 0x16, 0x09, 0xf2, 0xea, 0xe4, 0xa0, + 0xe0, 0x83, 0x22, 0x28, 0xb8, 0x95, 0x93, 0x99, 0x8b, 0x05, 0xef, 0x5d, 0xc3, 0x82, 0xf5, 0x9c, + 0x68, 0x01, 0x18, 0xdc, 0xcb, 0x64, 0x69, 0x28, 0xd4, 0xad, 0x38, 0x4d, 0x93, 0xef, 0x5f, 0xc7, + 0x91, 0x8d, 0xfc, 0xa7, 0x2d, 0x02, 0x92, 0xfd, 0x1c, 0x90, 0xdc, 0xcc, 0xdf, 0x32, 0x87, 0x24, + 0x09, 0x1e, 0xec, 0xc8, 0xb8, 0xcf, 0x79, 0x9a, 0xcc, 0x11, 0x2c, 0x0c, 0xfd, 0x50, 0x27, 0x6c, + 0x35, 0x31, 0xb7, 0x65, 0x26, 0x4a, 0xfc, 0xeb, 0x25, 0xd8, 0x81, 0x4e, 0x9f, 0xf2, 0x2e, 0xf3, + 0x57, 0x46, 0x22, 0x8b, 0x11, 0x9d, 0xce, 0x62, 0x0d, 0x9d, 0xc5, 0x52, 0x90, 0x52, 0xca, 0x40, + 0x0a, 0xf9, 0x0e, 0xdc, 0xc0, 0x34, 0x82, 0x76, 0xb1, 0x33, 0x69, 0xad, 0x2d, 0x09, 0xca, 0x20, + 0x2a, 0xbf, 0xbd, 0x03, 0xab, 0x29, 0x5e, 0x99, 0x62, 0x31, 0x85, 0x55, 0x30, 0x78, 0x57, 0x62, + 0xee, 0xa3, 0x20, 0x38, 0xa6, 0x7c, 0x64, 0xfe, 0x38, 0xd1, 0x3f, 0x81, 0x2b, 0x02, 0x95, 0x81, + 0xef, 0x28, 0xb5, 0x96, 0x2d, 0x1c, 0x4b, 0x08, 0x1b, 0xfb, 0x43, 0x3c, 0xb5, 0x61, 0xc9, 0xa1, + 0xe4, 0x8a, 0x23, 0xa5, 0xa1, 0x42, 0xc2, 0xfc, 0xa5, 0x91, 0xec, 0x97, 0x20, 0x58, 0x11, 0xd8, + 0x18, 0xff, 0x0f, 0xd8, 0x94, 0x5e, 0x0f, 0x6c, 0xcc, 0xdf, 0x1a, 0xc9, 0x17, 0x89, 0x61, 0xe4, + 0xcd, 0x54, 0x94, 0xce, 0xe1, 0x7a, 0x0e, 0x9b, 0x61, 0xc0, 0x97, 0x2d, 0x35, 0x89, 0x10, 0xbe, + 0x8a, 0x66, 0xce, 0x22, 0x7c, 0x0d, 0xd7, 0xd4, 0x44, 0xc3, 0x8f, 0x7f, 0x8e, 0x91, 0xb8, 0x64, + 0xa9, 0x49, 0x2a, 0x7b, 0x36, 0x32, 0xd9, 0xf3, 0x14, 0xc8, 0xf5, 0x18, 0x25, 0xef, 0x43, 0x45, + 0xd0, 0xa1, 0x34, 0xa1, 0xb4, 0x42, 0x6b, 0x4f, 0xd5, 0xcb, 0x7b, 0x1f, 0x9f, 0x9d, 0x52, 0x37, + 0xec, 0xad, 0x4b, 0xed, 0xff, 0xf3, 0x62, 0xab, 0x25, 0x79, 0x76, 0xfd, 0x89, 0x2b, 0xd8, 0x24, + 0x10, 0x97, 0x16, 0xca, 0x98, 0x7f, 0x31, 0x64, 0xee, 0xce, 0xc4, 0x6e, 0xa1, 0x2d, 0x22, 0x07, + 0x2d, 0xa5, 0x60, 0xf6, 0xd5, 0xec, 0xf3, 0x0d, 0x80, 0x21, 0xe5, 0xf6, 0x67, 0xd4, 0x13, 0xcc, + 0xd1, 0x46, 0x6a, 0x0c, 0x29, 0xff, 0x39, 0x2e, 0xc8, 0x9a, 0x44, 0x92, 0xa7, 0x9c, 0x39, 0x68, + 0xad, 0xb2, 0x55, 0x1b, 0x52, 0xfe, 0x94, 0x33, 0x27, 0xd6, 0xab, 0xf6, 0x06, 0x7a, 0xfd, 0x35, + 0xe5, 0x78, 0x09, 0x70, 0x7d, 0x15, 0x34, 0xfb, 0xb7, 0x21, 0x11, 0x39, 0x9b, 0xfc, 0xc8, 0x09, + 0xdc, 0x88, 0xdd, 0xdb, 0x9e, 0xa2, 0xdb, 0x47, 0xfe, 0xf0, 0xf2, 0xa8, 0x58, 0xb9, 0xc8, 0x2e, + 0x73, 0xf2, 0x13, 0xd8, 0xc8, 0x05, 0x67, 0xbc, 0x61, 0xe9, 0xa5, 0x31, 0x7a, 0x33, 0x1b, 0xa3, + 0xd1, 0x7e, 0x91, 0xae, 0xe5, 0x37, 0xd0, 0xf5, 0x5b, 0xb2, 0x3c, 0x49, 0xa7, 0xec, 0xa2, 0xaf, + 0x65, 0xfe, 0xda, 0x80, 0x76, 0xee, 0x32, 0x64, 0x1f, 0x40, 0x65, 0x3c, 0xee, 0x3e, 0x8f, 0x4a, + 0xe5, 0x15, 0x7d, 0x71, 0x34, 0xd9, 0x63, 0xf7, 0x39, 0xb3, 0x1a, 0xfd, 0x68, 0x48, 0xee, 0x40, + 0x4d, 0xcc, 0x14, 0x77, 0xb6, 0x90, 0x7b, 0x32, 0x43, 0xd6, 0xaa, 0xc0, 0x7f, 0x72, 0x17, 0x96, + 0xd4, 0xc6, 0x43, 0x9f, 0x73, 0x37, 0xd0, 0x45, 0x04, 0x49, 0x6f, 0xfd, 0x11, 0x52, 0xac, 0x66, + 0x3f, 0x99, 0x98, 0x47, 0xd0, 0x88, 0x8f, 0x25, 0x5f, 0x83, 0xc6, 0x84, 0xce, 0x74, 0x95, 0x2b, + 0xef, 0xb6, 0x68, 0xd5, 0x27, 0x74, 0x86, 0x05, 0x2e, 0xd9, 0x80, 0x9a, 0x24, 0x0e, 0xa9, 0xb2, + 0x77, 0xd9, 0xaa, 0x4e, 0xe8, 0xec, 0x23, 0xca, 0xcd, 0x0f, 0xa1, 0xaa, 0xee, 0xf2, 0x86, 0xf2, + 0x3f, 0x84, 0x66, 0xea, 0x7a, 0xe4, 0xbb, 0x70, 0x53, 0x29, 0x12, 0xd0, 0x50, 0xa0, 0xe2, 0x99, + 0x0d, 0x09, 0x12, 0x4f, 0x69, 0x28, 0xe4, 0x91, 0xaa, 0xf6, 0x7e, 0x0c, 0xad, 0x6c, 0x7d, 0x2a, + 0xd3, 0x57, 0xe8, 0x4f, 0x3d, 0x47, 0x0b, 0xa9, 0x89, 0x6c, 0x4e, 0x2f, 0x7c, 0xe5, 0x30, 0xe9, + 0x82, 0xf4, 0xcc, 0x17, 0x2c, 0x55, 0xd5, 0x2a, 0x1e, 0xf3, 0x4f, 0x15, 0xa8, 0xaa, 0x62, 0x99, + 0xdc, 0x49, 0xf5, 0x27, 0x88, 0x84, 0xbd, 0xe6, 0xd5, 0x8b, 0xad, 0x1a, 0x82, 0xc6, 0xc9, 0xc3, + 0xa4, 0x59, 0x49, 0xd2, 0x63, 0x29, 0x53, 0xcb, 0x47, 0x9d, 0x51, 0xf9, 0xb5, 0x3b, 0xa3, 0x0d, + 0xa8, 0x79, 0xd3, 0x89, 0x2d, 0x66, 0x1c, 0x23, 0xbc, 0x6c, 0x55, 0xbd, 0xe9, 0xe4, 0xc9, 0x8c, + 0x4b, 0x53, 0x0b, 0x5f, 0xd0, 0x31, 0x92, 0x54, 0x88, 0xd7, 0x71, 0x41, 0x12, 0x0f, 0x61, 0x39, + 0x85, 0xad, 0xae, 0xa3, 0x0b, 0xb7, 0x56, 0xda, 0x19, 0x4e, 0x1e, 0x6a, 0x75, 0x9b, 0x31, 0xd6, + 0x9e, 0x38, 0x64, 0x3b, 0xdb, 0x08, 0x20, 0x24, 0x2b, 0x5c, 0x48, 0xd5, 0xfa, 0x12, 0x90, 0xe5, + 0x05, 0xa4, 0x93, 0x2b, 0x16, 0x05, 0x12, 0x75, 0xb9, 0x80, 0xc4, 0xb7, 0xa0, 0x9d, 0xa0, 0x9a, + 0x62, 0x69, 0xa8, 0x5d, 0x92, 0x65, 0x64, 0x7c, 0x17, 0xd6, 0x3c, 0x36, 0x13, 0x76, 0x9e, 0x1b, + 0x90, 0x9b, 0x48, 0xda, 0x59, 0x56, 0xe2, 0xdb, 0xd0, 0x4a, 0xd2, 0x00, 0xf2, 0x36, 0x55, 0x3b, + 0x16, 0xaf, 0x22, 0xdb, 0x2d, 0xa8, 0xc7, 0x35, 0xc5, 0x12, 0x32, 0xd4, 0xa8, 0x2a, 0x25, 0xe2, + 0x2a, 0x25, 0x64, 0x7c, 0x3a, 0x16, 0x7a, 0x93, 0x65, 0xe4, 0xc1, 0x2a, 0xc5, 0x52, 0xeb, 0xc8, + 0xfb, 0x4d, 0x58, 0x66, 0xba, 0x5d, 0x51, 0x7c, 0x2d, 0xe4, 0x5b, 0x8a, 0x16, 0x91, 0x69, 0x07, + 0x56, 0x82, 0xd0, 0x0f, 0x7c, 0xce, 0x42, 0x9b, 0x3a, 0x4e, 0xc8, 0x38, 0xef, 0xb4, 0xd5, 0x7e, + 0xd1, 0xfa, 0x91, 0x5a, 0x36, 0x7f, 0x01, 0x35, 0x6d, 0xfd, 0xc2, 0xa6, 0xed, 0x07, 0xb0, 0x24, + 0xbd, 0x9e, 0xdb, 0x99, 0xd6, 0x2d, 0x2a, 0x9d, 0xd1, 0xe9, 0x99, 0xc8, 0x74, 0x70, 0x4d, 0xe4, + 0x57, 0x4b, 0xe6, 0x3d, 0x58, 0xce, 0xf0, 0xc8, 0x30, 0x40, 0xa7, 0x88, 0xc2, 0x00, 0x27, 0xf1, + 0xc9, 0xa5, 0xe4, 0x64, 0xf3, 0x3e, 0x34, 0x62, 0x43, 0xcb, 0x0a, 0x2f, 0xd2, 0xc3, 0xd0, 0xb6, + 0x53, 0x53, 0x2c, 0x0b, 0xfc, 0xcf, 0x58, 0xa8, 0xab, 0x3a, 0x35, 0x31, 0x9f, 0x42, 0x3b, 0x97, + 0xc5, 0xc9, 0x2e, 0xd4, 0x82, 0x69, 0xdf, 0x8e, 0x5e, 0x13, 0x92, 0xb4, 0x75, 0x3a, 0xed, 0x7f, + 0xcc, 0x2e, 0xa3, 0xfe, 0x33, 0xc0, 0x59, 0xb2, 0x6d, 0x29, 0xbd, 0xed, 0x18, 0xea, 0x51, 0x68, + 0x92, 0xef, 0x41, 0x23, 0xf6, 0x91, 0x5c, 0xda, 0x8c, 0x8f, 0xd6, 0x9b, 0x26, 0x8c, 0xf2, 0x53, + 0x73, 0x77, 0xe8, 0x31, 0xc7, 0x4e, 0xe2, 0x01, 0xcf, 0xa8, 0x5b, 0x6d, 0x45, 0xf8, 0x24, 0x72, + 0x7e, 0xf3, 0x5d, 0xa8, 0xaa, 0xbb, 0x49, 0xfb, 0xc8, 0x9d, 0xa3, 0xa2, 0x57, 0x8e, 0x0b, 0xf3, + 0xfb, 0x9f, 0x0d, 0xa8, 0x47, 0xcd, 0x6c, 0xa1, 0x50, 0xe6, 0xd2, 0xa5, 0x57, 0xbd, 0xf4, 0xbc, + 0x17, 0x81, 0x28, 0x8b, 0x54, 0x5e, 0x3b, 0x8b, 0xec, 0x02, 0x51, 0xc9, 0xe2, 0xc2, 0x17, 0xae, + 0x37, 0xb4, 0x95, 0xad, 0x55, 0xd6, 0x58, 0x41, 0xca, 0x19, 0x12, 0x4e, 0xe5, 0xfa, 0xc1, 0xe7, + 0x8b, 0xd0, 0x3e, 0xea, 0x3d, 0x38, 0x39, 0x0a, 0x82, 0xb1, 0x3b, 0xa0, 0x58, 0x69, 0xef, 0x43, + 0x05, 0x7b, 0x89, 0x82, 0x57, 0xcc, 0x6e, 0x51, 0x53, 0x4b, 0x0e, 0x60, 0x11, 0x5b, 0x0a, 0x52, + 0xf4, 0x98, 0xd9, 0x2d, 0xec, 0x6d, 0xe5, 0x21, 0xaa, 0xe9, 0xb8, 0xfe, 0xa6, 0xd9, 0x2d, 0x6a, + 0x70, 0xc9, 0x87, 0xd0, 0x48, 0x9a, 0x81, 0x79, 0x2f, 0x9b, 0xdd, 0xb9, 0xad, 0xae, 0x94, 0x4f, + 0x6a, 0xb0, 0x79, 0x0f, 0x74, 0xdd, 0xb9, 0x3d, 0x21, 0x39, 0x84, 0x5a, 0x54, 0x9b, 0x16, 0xbf, + 0x3d, 0x76, 0xe7, 0xb4, 0xa1, 0xd2, 0x3c, 0xaa, 0xbe, 0x2f, 0x7a, 0x20, 0xed, 0x16, 0xf6, 0xca, + 0xe4, 0x2e, 0x54, 0x75, 0xb1, 0x51, 0xf8, 0xfe, 0xd8, 0x2d, 0x6e, 0x26, 0xa5, 0x92, 0x49, 0x87, + 0x33, 0xef, 0x11, 0xb7, 0x3b, 0xb7, 0xa9, 0x27, 0x47, 0x00, 0xa9, 0x9a, 0x7e, 0xee, 0xeb, 0x6c, + 0x77, 0x7e, 0xb3, 0x4e, 0xee, 0x43, 0x3d, 0x79, 0x80, 0x29, 0x7e, 0x6f, 0xed, 0xce, 0xeb, 0x9f, + 0x7b, 0x5f, 0xff, 0xef, 0x3f, 0x36, 0x8d, 0xdf, 0x5c, 0x6d, 0x1a, 0xbf, 0xbb, 0xda, 0x34, 0xbe, + 0xbc, 0xda, 0x34, 0xfe, 0x78, 0xb5, 0x69, 0xfc, 0xfd, 0x6a, 0xd3, 0xf8, 0xfd, 0x3f, 0x37, 0x8d, + 0x7e, 0x15, 0xdd, 0xff, 0xbd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x48, 0x26, 0x13, 0xca, 0x22, 0x18, 0x00, 0x00, } diff --git a/abci/types/types.proto b/abci/types/types.proto index ae550c0a5..75a53ac46 100644 --- a/abci/types/types.proto +++ b/abci/types/types.proto @@ -207,8 +207,7 @@ message ConsensusParams { // BlockSize contains limits on the block size. message BlockSize { int32 max_bytes = 1; - int32 max_txs = 2; - int64 max_gas = 3; + int64 max_gas = 2; } // TxSize contains limits on the tx size. diff --git a/abci/types/types_test.go b/abci/types/types_test.go deleted file mode 100644 index baa8155cd..000000000 --- a/abci/types/types_test.go +++ /dev/null @@ -1,31 +0,0 @@ -package types - -import ( - "testing" - - asrt "github.com/stretchr/testify/assert" -) - -func TestConsensusParams(t *testing.T) { - assert := asrt.New(t) - - params := &ConsensusParams{ - BlockSize: &BlockSize{MaxGas: 12345}, - BlockGossip: &BlockGossip{BlockPartSizeBytes: 54321}, - } - var noParams *ConsensusParams // nil - - // no error with nil fields - assert.Nil(noParams.GetBlockSize()) - assert.EqualValues(noParams.GetBlockSize().GetMaxGas(), 0) - - // get values with real fields - assert.NotNil(params.GetBlockSize()) - assert.EqualValues(params.GetBlockSize().GetMaxTxs(), 0) - assert.EqualValues(params.GetBlockSize().GetMaxGas(), 12345) - assert.NotNil(params.GetBlockGossip()) - assert.EqualValues(params.GetBlockGossip().GetBlockPartSizeBytes(), 54321) - assert.Nil(params.GetTxSize()) - assert.EqualValues(params.GetTxSize().GetMaxBytes(), 0) - -} diff --git a/consensus/mempool_test.go b/consensus/mempool_test.go index 81d7693f9..16a167fd6 100644 --- a/consensus/mempool_test.go +++ b/consensus/mempool_test.go @@ -148,7 +148,7 @@ func TestMempoolRmBadTx(t *testing.T) { // check for the tx for { - txs := cs.mempool.Reap(1) + txs := cs.mempool.ReapMaxBytes(len(txBytes)) if len(txs) == 0 { emptyMempoolCh <- struct{}{} return diff --git a/consensus/reactor_test.go b/consensus/reactor_test.go index 4a6d4b9dc..364b6fb0a 100644 --- a/consensus/reactor_test.go +++ b/consensus/reactor_test.go @@ -194,7 +194,8 @@ func newMockEvidencePool(val []byte) *mockEvidencePool { } } -func (m *mockEvidencePool) PendingEvidence() []types.Evidence { +// NOTE: maxBytes is ignored +func (m *mockEvidencePool) PendingEvidence(maxBytes int) []types.Evidence { if m.height > 0 { return m.ev } @@ -207,7 +208,7 @@ func (m *mockEvidencePool) Update(block *types.Block, state sm.State) { panic("block has no evidence") } } - m.height += 1 + m.height++ } //------------------------------------ diff --git a/consensus/state.go b/consensus/state.go index debe94dad..65f5b6b36 100644 --- a/consensus/state.go +++ b/consensus/state.go @@ -153,6 +153,7 @@ func NewConsensusState( cs.setProposal = cs.defaultSetProposal cs.updateToState(state) + // Don't call scheduleRound0 yet. // We do that upon Start(). cs.reconstructLastCommit(state) @@ -946,14 +947,25 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts return } + maxBytes := cs.state.ConsensusParams.BlockSize.MaxBytes + // bound evidence to 1/10th of the block + evidence := cs.evpool.PendingEvidence(maxBytes / 10) // Mempool validated transactions - txs := cs.mempool.Reap(cs.state.ConsensusParams.BlockSize.MaxTxs) - evidence := cs.evpool.PendingEvidence() + txs := cs.mempool.ReapMaxBytes(maxDataBytes(maxBytes, cs.state.Validators.Size(), len(evidence))) proposerAddr := cs.privValidator.GetAddress() block, parts := cs.state.MakeBlock(cs.Height, txs, commit, evidence, proposerAddr) + return block, parts } +func maxDataBytes(maxBytes, valsCount, evidenceCount int) int { + return maxBytes - + types.MaxAminoOverheadForBlock - + types.MaxHeaderBytes - + (valsCount * types.MaxVoteBytes) - + (evidenceCount * types.MaxEvidenceBytes) +} + // Enter: `timeoutPropose` after entering Propose. // Enter: proposal block and POL is ready. // Enter: any +2/3 prevotes for future round. @@ -1438,7 +1450,11 @@ func (cs *ConsensusState) addProposalBlockPart(msg *BlockPartMessage, peerID p2p } if added && cs.ProposalBlockParts.IsComplete() { // Added and completed! - _, err = cdc.UnmarshalBinaryReader(cs.ProposalBlockParts.GetReader(), &cs.ProposalBlock, int64(cs.state.ConsensusParams.BlockSize.MaxBytes)) + _, err = cdc.UnmarshalBinaryReader( + cs.ProposalBlockParts.GetReader(), + &cs.ProposalBlock, + int64(cs.state.ConsensusParams.BlockSize.MaxBytes), + ) if err != nil { return true, err } diff --git a/docs/architecture/adr-020-block-size.md b/docs/architecture/adr-020-block-size.md new file mode 100644 index 000000000..d40766b52 --- /dev/null +++ b/docs/architecture/adr-020-block-size.md @@ -0,0 +1,72 @@ +# ADR 020: Limiting txs size inside a block + +## Changelog + +13-08-2018: Initial Draft +15-08-2018: Second version after Dev's comments +28-08-2018: Third version after Ethan's comments +30-08-2018: AminoOverheadForBlock => MaxAminoOverheadForBlock, added MaxAminoOverheadForTx + +## Context + +We currently use MaxTxs to reap txs from the mempool when proposing a block, +but enforce MaxBytes when unmarshalling a block, so we could easily propose a +block thats too large to be valid. + +We should just remove MaxTxs all together and stick with MaxBytes, and have a +`mempool.ReapMaxBytes`. + +But we can't just reap BlockSize.MaxBytes, since MaxBytes is for the entire block, +not for the txs inside the block. There's extra amino overhead + the actual +headers on top of the actual transactions + evidence + last commit. + +## Proposed solution + +Therefore, we should + +1) Get rid of MaxTxs. +2) Rename MaxTxsBytes to MaxBytes. + +When we need to ReapMaxBytes from the mempool, we calculate the upper bound as follows: + +``` +ExactLastCommitBytes = {number of validators currently enabled} * {MaxVoteBytes} +MaxEvidenceBytesPerBlock = MaxBytes / 10 +ExactEvidenceBytes = cs.evpool.PendingEvidence(MaxEvidenceBytesPerBlock) * MaxEvidenceBytes + +mempool.ReapMaxBytes(MaxBytes - MaxAminoOverheadForBlock - ExactLastCommitBytes - ExactEvidenceBytes - MaxHeaderBytes) +``` + +where MaxVoteBytes, MaxEvidenceBytes, MaxHeaderBytes and MaxAminoOverheadForBlock +are constants defined inside the `types` package: + +- MaxVoteBytes - 170 bytes +- MaxEvidenceBytes - 364 bytes +- MaxHeaderBytes - 476 bytes (~276 bytes hashes + 200 bytes - 50 UTF-8 encoded + symbols of chain ID 4 bytes each in the worst case + amino overhead) +- MaxAminoOverheadForBlock - 4 bytes (assuming MaxHeaderBytes includes amino + overhead for encoding header, MaxVoteBytes - for encoding vote, etc.) + +NOTE while reaping the `max int` bytes in mempool, we should account that every +transaction will take `len(tx)+aminoOverhead`, where aminoOverhead=1-4 bytes. +Therefore, MaxAminoOverheadForTx should be added. + +We should write a test that fails if the underlying structs got changed, but +MaxXXX stayed the same. + +## Status + +Proposed. + +## Consequences + +### Positive + +* one way to limit the size of a block +* less variables to configure + +### Negative + +* constants that need to be adjusted if the underlying structs got changed + +### Neutral diff --git a/evidence/pool.go b/evidence/pool.go index 247629b6b..21cab5e07 100644 --- a/evidence/pool.go +++ b/evidence/pool.go @@ -57,9 +57,10 @@ func (evpool *EvidencePool) PriorityEvidence() []types.Evidence { return evpool.evidenceStore.PriorityEvidence() } -// PendingEvidence returns all uncommitted evidence. -func (evpool *EvidencePool) PendingEvidence() []types.Evidence { - return evpool.evidenceStore.PendingEvidence() +// PendingEvidence returns uncommitted evidence up to maxBytes. +// If maxBytes is -1, all evidence is returned. +func (evpool *EvidencePool) PendingEvidence(maxBytes int) []types.Evidence { + return evpool.evidenceStore.PendingEvidence(maxBytes) } // State returns the current state of the evpool. diff --git a/evidence/reactor_test.go b/evidence/reactor_test.go index 1687f25a3..23fd008af 100644 --- a/evidence/reactor_test.go +++ b/evidence/reactor_test.go @@ -79,11 +79,11 @@ func waitForEvidence(t *testing.T, evs types.EvidenceList, reactors []*EvidenceR func _waitForEvidence(t *testing.T, wg *sync.WaitGroup, evs types.EvidenceList, reactorIdx int, reactors []*EvidenceReactor) { evpool := reactors[reactorIdx].evpool - for len(evpool.PendingEvidence()) != len(evs) { + for len(evpool.PendingEvidence(-1)) != len(evs) { time.Sleep(time.Millisecond * 100) } - reapedEv := evpool.PendingEvidence() + reapedEv := evpool.PendingEvidence(-1) // put the reaped evidence in a map so we can quickly check we got everything evMap := make(map[string]types.Evidence) for _, e := range reapedEv { diff --git a/evidence/store.go b/evidence/store.go index ba2e0afdd..60656f052 100644 --- a/evidence/store.go +++ b/evidence/store.go @@ -78,7 +78,7 @@ func NewEvidenceStore(db dbm.DB) *EvidenceStore { // PriorityEvidence returns the evidence from the outqueue, sorted by highest priority. func (store *EvidenceStore) PriorityEvidence() (evidence []types.Evidence) { // reverse the order so highest priority is first - l := store.ListEvidence(baseKeyOutqueue) + l := store.listEvidence(baseKeyOutqueue, -1) l2 := make([]types.Evidence, len(l)) for i := range l { l2[i] = l[len(l)-1-i] @@ -86,18 +86,26 @@ func (store *EvidenceStore) PriorityEvidence() (evidence []types.Evidence) { return l2 } -// PendingEvidence returns all known uncommitted evidence. -func (store *EvidenceStore) PendingEvidence() (evidence []types.Evidence) { - return store.ListEvidence(baseKeyPending) +// PendingEvidence returns known uncommitted evidence up to maxBytes. +// If maxBytes is -1, all evidence is returned. +func (store *EvidenceStore) PendingEvidence(maxBytes int) (evidence []types.Evidence) { + return store.listEvidence(baseKeyPending, maxBytes) } -// ListEvidence lists the evidence for the given prefix key. +// listEvidence lists the evidence for the given prefix key up to maxBytes. // It is wrapped by PriorityEvidence and PendingEvidence for convenience. -func (store *EvidenceStore) ListEvidence(prefixKey string) (evidence []types.Evidence) { +// If maxBytes is -1, there's no cap on the size of returned evidence. +func (store *EvidenceStore) listEvidence(prefixKey string, maxBytes int) (evidence []types.Evidence) { + var bytes int iter := dbm.IteratePrefix(store.db, []byte(prefixKey)) for ; iter.Valid(); iter.Next() { val := iter.Value() + if maxBytes > 0 && bytes+len(val) > maxBytes { + return evidence + } + bytes += len(val) + var ei EvidenceInfo err := cdc.UnmarshalBinaryBare(val, &ei) if err != nil { diff --git a/evidence/store_test.go b/evidence/store_test.go index 1eb5b7f6a..35eb28d01 100644 --- a/evidence/store_test.go +++ b/evidence/store_test.go @@ -35,7 +35,7 @@ func TestStoreMark(t *testing.T) { // before we do anything, priority/pending are empty priorityEv := store.PriorityEvidence() - pendingEv := store.PendingEvidence() + pendingEv := store.PendingEvidence(-1) assert.Equal(0, len(priorityEv)) assert.Equal(0, len(pendingEv)) @@ -53,21 +53,21 @@ func TestStoreMark(t *testing.T) { // new evidence should be returns in priority/pending priorityEv = store.PriorityEvidence() - pendingEv = store.PendingEvidence() + pendingEv = store.PendingEvidence(-1) assert.Equal(1, len(priorityEv)) assert.Equal(1, len(pendingEv)) // priority is now empty store.MarkEvidenceAsBroadcasted(ev) priorityEv = store.PriorityEvidence() - pendingEv = store.PendingEvidence() + pendingEv = store.PendingEvidence(-1) assert.Equal(0, len(priorityEv)) assert.Equal(1, len(pendingEv)) // priority and pending are now empty store.MarkEvidenceAsCommitted(ev) priorityEv = store.PriorityEvidence() - pendingEv = store.PendingEvidence() + pendingEv = store.PendingEvidence(-1) assert.Equal(0, len(priorityEv)) assert.Equal(0, len(pendingEv)) diff --git a/mempool/mempool.go b/mempool/mempool.go index b86dd81f3..ec93202e3 100644 --- a/mempool/mempool.go +++ b/mempool/mempool.go @@ -80,6 +80,8 @@ type Mempool struct { recheckEnd *clist.CElement // re-checking stops here notifiedTxsAvailable bool txsAvailable chan struct{} // fires once for each height, when the mempool is not empty + // Filter mempool to only accept txs for which filter(tx) returns true. + filter func(types.Tx) bool // Keep a cache of already-seen txs. // This reduces the pressure on the proxyApp. @@ -139,6 +141,14 @@ func (mem *Mempool) SetLogger(l log.Logger) { mem.logger = l } +// SetFilter sets a filter for mempool to only accept txs for which f(tx) +// returns true. +func (mem *Mempool) SetFilter(f func(types.Tx) bool) { + mem.proxyMtx.Lock() + mem.filter = f + mem.proxyMtx.Unlock() +} + // WithMetrics sets the metrics. func WithMetrics(metrics *Metrics) MempoolOption { return func(mem *Mempool) { mem.metrics = metrics } @@ -240,6 +250,10 @@ func (mem *Mempool) CheckTx(tx types.Tx, cb func(*abci.Response)) (err error) { return ErrMempoolIsFull } + if mem.filter != nil && !mem.filter(tx) { + return + } + // CACHE if !mem.cache.Push(tx) { return ErrTxInCache @@ -367,9 +381,10 @@ func (mem *Mempool) notifyTxsAvailable() { } } -// Reap returns a list of transactions currently in the mempool. -// If maxTxs is -1, there is no cap on the number of returned transactions. -func (mem *Mempool) Reap(maxTxs int) types.Txs { +// ReapMaxBytes reaps transactions from the mempool up to n bytes total. +// If max is negative, there is no cap on the size of all returned +// transactions (~ all available transactions). +func (mem *Mempool) ReapMaxBytes(max int) types.Txs { mem.proxyMtx.Lock() defer mem.proxyMtx.Unlock() @@ -378,19 +393,39 @@ func (mem *Mempool) Reap(maxTxs int) types.Txs { time.Sleep(time.Millisecond * 10) } - txs := mem.collectTxs(maxTxs) + var cur int + // TODO: we will get a performance boost if we have a good estimate of avg + // size per tx, and set the initial capacity based off of that. + // txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), max/mem.avgTxSize)) + txs := make([]types.Tx, 0, mem.txs.Len()) + for e := mem.txs.Front(); e != nil; e = e.Next() { + memTx := e.Value.(*mempoolTx) + if max > 0 && cur+len(memTx.tx)+types.MaxAminoOverheadForTx > max { + return txs + } + cur += len(memTx.tx) + types.MaxAminoOverheadForTx + txs = append(txs, memTx.tx) + } return txs } -// maxTxs: -1 means uncapped, 0 means none -func (mem *Mempool) collectTxs(maxTxs int) types.Txs { - if maxTxs == 0 { - return []types.Tx{} - } else if maxTxs < 0 { - maxTxs = mem.txs.Len() +// ReapMaxTxs reaps up to max transactions from the mempool. +// If max is negative, function panics. +func (mem *Mempool) ReapMaxTxs(max int) types.Txs { + mem.proxyMtx.Lock() + defer mem.proxyMtx.Unlock() + + if max < 0 { + panic("Called ReapMaxTxs with negative max") + } + + for atomic.LoadInt32(&mem.rechecking) > 0 { + // TODO: Something better? + time.Sleep(time.Millisecond * 10) } - txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), maxTxs)) - for e := mem.txs.Front(); e != nil && len(txs) < maxTxs; e = e.Next() { + + txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), max)) + for e := mem.txs.Front(); e != nil && len(txs) <= max; e = e.Next() { memTx := e.Value.(*mempoolTx) txs = append(txs, memTx.tx) } @@ -400,7 +435,7 @@ func (mem *Mempool) collectTxs(maxTxs int) types.Txs { // Update informs the mempool that the given txs were committed and can be discarded. // NOTE: this should be called *after* block is committed by consensus. // NOTE: unsafe; Lock/Unlock must be managed by caller -func (mem *Mempool) Update(height int64, txs types.Txs) error { +func (mem *Mempool) Update(height int64, txs types.Txs, filter func(types.Tx) bool) error { // First, create a lookup map of txns in new txs. txsMap := make(map[string]struct{}, len(txs)) for _, tx := range txs { @@ -411,6 +446,10 @@ func (mem *Mempool) Update(height int64, txs types.Txs) error { mem.height = height mem.notifiedTxsAvailable = false + if filter != nil { + mem.filter = filter + } + // Remove transactions that are already in txs. goodTxs := mem.filterTxs(txsMap) // Recheck mempool txs if any txs were committed in the block @@ -423,7 +462,10 @@ func (mem *Mempool) Update(height int64, txs types.Txs) error { // mem.recheckCursor re-scans mem.txs and possibly removes some txs. // Before mem.Reap(), we should wait for mem.recheckCursor to be nil. } + + // Update metrics mem.metrics.Size.Set(float64(mem.Size())) + return nil } diff --git a/mempool/mempool_test.go b/mempool/mempool_test.go index c29578efd..0dbe2bb6f 100644 --- a/mempool/mempool_test.go +++ b/mempool/mempool_test.go @@ -91,7 +91,7 @@ func TestTxsAvailable(t *testing.T) { // it should fire once now for the new height // since there are still txs left committedTxs, txs := txs[:50], txs[50:] - if err := mempool.Update(1, committedTxs); err != nil { + if err := mempool.Update(1, committedTxs, nil); err != nil { t.Error(err) } ensureFire(t, mempool.TxsAvailable(), timeoutMS) @@ -103,7 +103,7 @@ func TestTxsAvailable(t *testing.T) { // now call update with all the txs. it should not fire as there are no txs left committedTxs = append(txs, moreTxs...) - if err := mempool.Update(2, committedTxs); err != nil { + if err := mempool.Update(2, committedTxs, nil); err != nil { t.Error(err) } ensureNoFire(t, mempool.TxsAvailable(), timeoutMS) @@ -149,7 +149,7 @@ func TestSerialReap(t *testing.T) { } reapCheck := func(exp int) { - txs := mempool.Reap(-1) + txs := mempool.ReapMaxBytes(-1) require.Equal(t, len(txs), exp, fmt.Sprintf("Expected to reap %v txs but got %v", exp, len(txs))) } @@ -160,7 +160,7 @@ func TestSerialReap(t *testing.T) { binary.BigEndian.PutUint64(txBytes, uint64(i)) txs = append(txs, txBytes) } - if err := mempool.Update(0, txs); err != nil { + if err := mempool.Update(0, txs, nil); err != nil { t.Error(err) } } diff --git a/mempool/reactor_test.go b/mempool/reactor_test.go index b4362032a..8ac400b0a 100644 --- a/mempool/reactor_test.go +++ b/mempool/reactor_test.go @@ -86,7 +86,7 @@ func _waitForTxs(t *testing.T, wg *sync.WaitGroup, txs types.Txs, reactorIdx int time.Sleep(time.Millisecond * 100) } - reapedTxs := mempool.Reap(len(txs)) + reapedTxs := mempool.ReapMaxTxs(len(txs)) for i, tx := range txs { assert.Equal(t, tx, reapedTxs[i], fmt.Sprintf("txs at index %d on reactor %d don't match: %v vs %v", i, reactorIdx, tx, reapedTxs[i])) } diff --git a/node/node.go b/node/node.go index 7f96e0e0a..7e6603d9d 100644 --- a/node/node.go +++ b/node/node.go @@ -83,7 +83,7 @@ func DefaultNewNode(config *cfg.Config, logger log.Logger) (*Node, error) { // Generate node PrivKey nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile()) if err != nil { - return nil,err + return nil, err } return NewNode(config, privval.LoadOrGenFilePV(config.PrivValidatorFile()), @@ -248,6 +248,8 @@ func NewNode(config *cfg.Config, mempl.WithMetrics(memplMetrics), ) mempool.SetLogger(mempoolLogger) + maxBytes := state.ConsensusParams.TxSize.MaxBytes + mempool.SetFilter(func(tx types.Tx) bool { return len(tx) <= maxBytes }) mempool.InitWAL() // no need to have the mempool wal during tests mempoolReactor := mempl.NewMempoolReactor(config.Mempool, mempool) mempoolReactor.SetLogger(mempoolLogger) @@ -401,7 +403,7 @@ func NewNode(config *cfg.Config, sw: sw, addrBook: addrBook, - nodeKey: nodeKey, + nodeKey: nodeKey, stateDB: stateDB, blockStore: blockStore, @@ -434,7 +436,6 @@ func (n *Node) OnStart() error { n.Logger.With("module", "p2p")) n.sw.AddListener(l) - nodeInfo := n.makeNodeInfo(n.nodeKey.ID()) n.sw.SetNodeInfo(nodeInfo) n.sw.SetNodeKey(n.nodeKey) diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go index e7e9042a7..3eabaa979 100644 --- a/rpc/client/rpc_test.go +++ b/rpc/client/rpc_test.go @@ -242,7 +242,7 @@ func TestBroadcastTxSync(t *testing.T) { require.Equal(initMempoolSize+1, mempool.Size()) - txs := mempool.Reap(1) + txs := mempool.ReapMaxTxs(len(tx)) require.EqualValues(tx, txs[0]) mempool.Flush() } diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go index 47776d3e4..728d77f63 100644 --- a/rpc/core/mempool.go +++ b/rpc/core/mempool.go @@ -243,7 +243,7 @@ func UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error) { // reuse per_page validator limit = validatePerPage(limit) - txs := mempool.Reap(limit) + txs := mempool.ReapMaxTxs(limit) return &ctypes.ResultUnconfirmedTxs{len(txs), txs}, nil } diff --git a/rpc/core/pipe.go b/rpc/core/pipe.go index 9c162e9e4..1d1f61466 100644 --- a/rpc/core/pipe.go +++ b/rpc/core/pipe.go @@ -7,6 +7,7 @@ import ( crypto "github.com/tendermint/tendermint/crypto" dbm "github.com/tendermint/tendermint/libs/db" "github.com/tendermint/tendermint/libs/log" + mempl "github.com/tendermint/tendermint/mempool" "github.com/tendermint/tendermint/p2p" "github.com/tendermint/tendermint/proxy" sm "github.com/tendermint/tendermint/state" @@ -53,7 +54,6 @@ var ( // interfaces defined in types and above stateDB dbm.DB blockStore sm.BlockStore - mempool sm.Mempool evidencePool sm.EvidencePool consensusState Consensus p2pSwitch P2P @@ -65,6 +65,7 @@ var ( txIndexer txindex.TxIndexer consensusReactor *consensus.ConsensusReactor eventBus *types.EventBus // thread safe + mempool *mempl.Mempool logger log.Logger ) @@ -77,7 +78,7 @@ func SetBlockStore(bs sm.BlockStore) { blockStore = bs } -func SetMempool(mem sm.Mempool) { +func SetMempool(mem *mempl.Mempool) { mempool = mem } diff --git a/state/execution.go b/state/execution.go index ab689f5fb..b1859c220 100644 --- a/state/execution.go +++ b/state/execution.go @@ -92,7 +92,7 @@ func (blockExec *BlockExecutor) ApplyBlock(state State, blockID types.BlockID, b } // Lock mempool, commit app state, update mempoool. - appHash, err := blockExec.Commit(block) + appHash, err := blockExec.Commit(state, block) if err != nil { return state, fmt.Errorf("Commit failed for application: %v", err) } @@ -119,7 +119,7 @@ func (blockExec *BlockExecutor) ApplyBlock(state State, blockID types.BlockID, b // It returns the result of calling abci.Commit (the AppHash), and an error. // The Mempool must be locked during commit and update because state is typically reset on Commit and old txs must be replayed // against committed state before new txs are run in the mempool, lest they be invalid. -func (blockExec *BlockExecutor) Commit(block *types.Block) ([]byte, error) { +func (blockExec *BlockExecutor) Commit(state State, block *types.Block) ([]byte, error) { blockExec.mempool.Lock() defer blockExec.mempool.Unlock() @@ -145,7 +145,9 @@ func (blockExec *BlockExecutor) Commit(block *types.Block) ([]byte, error) { "appHash", fmt.Sprintf("%X", res.Data)) // Update mempool. - if err := blockExec.mempool.Update(block.Height, block.Txs); err != nil { + maxBytes := state.ConsensusParams.TxSize.MaxBytes + filter := func(tx types.Tx) bool { return len(tx) <= maxBytes } + if err := blockExec.mempool.Update(block.Height, block.Txs, filter); err != nil { return nil, err } diff --git a/state/services.go b/state/services.go index c51fa9752..13ab7383f 100644 --- a/state/services.go +++ b/state/services.go @@ -22,8 +22,8 @@ type Mempool interface { Size() int CheckTx(types.Tx, func(*abci.Response)) error - Reap(int) types.Txs - Update(height int64, txs types.Txs) error + ReapMaxBytes(max int) types.Txs + Update(height int64, txs types.Txs, filter func(types.Tx) bool) error Flush() FlushAppConn() error @@ -32,19 +32,18 @@ type Mempool interface { } // MockMempool is an empty implementation of a Mempool, useful for testing. -type MockMempool struct { -} - -func (m MockMempool) Lock() {} -func (m MockMempool) Unlock() {} -func (m MockMempool) Size() int { return 0 } -func (m MockMempool) CheckTx(tx types.Tx, cb func(*abci.Response)) error { return nil } -func (m MockMempool) Reap(n int) types.Txs { return types.Txs{} } -func (m MockMempool) Update(height int64, txs types.Txs) error { return nil } -func (m MockMempool) Flush() {} -func (m MockMempool) FlushAppConn() error { return nil } -func (m MockMempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) } -func (m MockMempool) EnableTxsAvailable() {} +type MockMempool struct{} + +func (MockMempool) Lock() {} +func (MockMempool) Unlock() {} +func (MockMempool) Size() int { return 0 } +func (MockMempool) CheckTx(tx types.Tx, cb func(*abci.Response)) error { return nil } +func (MockMempool) ReapMaxBytes(max int) types.Txs { return types.Txs{} } +func (MockMempool) Update(height int64, txs types.Txs, filter func(types.Tx) bool) error { return nil } +func (MockMempool) Flush() {} +func (MockMempool) FlushAppConn() error { return nil } +func (MockMempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) } +func (MockMempool) EnableTxsAvailable() {} //------------------------------------------------------ // blockstore @@ -72,15 +71,14 @@ type BlockStore interface { // EvidencePool defines the EvidencePool interface used by the ConsensusState. type EvidencePool interface { - PendingEvidence() []types.Evidence + PendingEvidence(int) []types.Evidence AddEvidence(types.Evidence) error Update(*types.Block, State) } // MockMempool is an empty implementation of a Mempool, useful for testing. -type MockEvidencePool struct { -} +type MockEvidencePool struct{} -func (m MockEvidencePool) PendingEvidence() []types.Evidence { return nil } -func (m MockEvidencePool) AddEvidence(types.Evidence) error { return nil } -func (m MockEvidencePool) Update(*types.Block, State) {} +func (m MockEvidencePool) PendingEvidence(int) []types.Evidence { return nil } +func (m MockEvidencePool) AddEvidence(types.Evidence) error { return nil } +func (m MockEvidencePool) Update(*types.Block, State) {} diff --git a/state/state_test.go b/state/state_test.go index d8a8c0b82..9a793c8e7 100644 --- a/state/state_test.go +++ b/state/state_test.go @@ -373,13 +373,10 @@ func TestConsensusParamsChangesSaveLoad(t *testing.T) { } } -func makeParams(blockBytes, blockTx, blockGas, txBytes, - txGas, partSize int) types.ConsensusParams { - +func makeParams(txsBytes, blockGas, txBytes, txGas, partSize int) types.ConsensusParams { return types.ConsensusParams{ BlockSize: types.BlockSize{ - MaxBytes: blockBytes, - MaxTxs: blockTx, + MaxBytes: txsBytes, MaxGas: int64(blockGas), }, TxSize: types.TxSize{ @@ -397,7 +394,7 @@ func pk() []byte { } func TestApplyUpdates(t *testing.T) { - initParams := makeParams(1, 2, 3, 4, 5, 6) + initParams := makeParams(1, 2, 3, 4, 5) cases := [...]struct { init types.ConsensusParams @@ -412,19 +409,19 @@ func TestApplyUpdates(t *testing.T) { MaxBytes: 123, }, }, - makeParams(1, 2, 3, 123, 5, 6)}, + makeParams(1, 2, 123, 4, 5)}, 3: {initParams, abci.ConsensusParams{ BlockSize: &abci.BlockSize{ - MaxTxs: 44, - MaxGas: 55, + MaxBytes: 1, + MaxGas: 55, }, }, - makeParams(1, 44, 55, 4, 5, 6)}, + makeParams(1, 55, 3, 4, 5)}, 4: {initParams, abci.ConsensusParams{ BlockSize: &abci.BlockSize{ - MaxTxs: 789, + MaxBytes: 1, }, TxSize: &abci.TxSize{ MaxGas: 888, @@ -433,7 +430,7 @@ func TestApplyUpdates(t *testing.T) { BlockPartSizeBytes: 2002, }, }, - makeParams(1, 789, 3, 4, 888, 2002)}, + makeParams(1, 2, 3, 888, 2002)}, } for i, tc := range cases { diff --git a/types/block.go b/types/block.go index 8588d5571..1037caccc 100644 --- a/types/block.go +++ b/types/block.go @@ -13,6 +13,17 @@ import ( cmn "github.com/tendermint/tendermint/libs/common" ) +const ( + // MaxHeaderBytes is a maximum header size (including amino overhead). + MaxHeaderBytes = 478 + + // MaxAminoOverheadForBlock - amino overhead to encode the block. + MaxAminoOverheadForBlock = 4 + + // MaxChainIDLen is a maximum length of the chain ID. + MaxChainIDLen = 50 +) + // Block defines the atomic unit of a Tendermint blockchain. // TODO: add Version byte type Block struct { diff --git a/types/block_test.go b/types/block_test.go index 8e5957761..3ca1da616 100644 --- a/types/block_test.go +++ b/types/block_test.go @@ -2,11 +2,13 @@ package types import ( "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/crypto" + "github.com/tendermint/tendermint/crypto/tmhash" cmn "github.com/tendermint/tendermint/libs/common" ) @@ -118,7 +120,7 @@ func TestBlockMakePartSetWithEvidence(t *testing.T) { partSet := MakeBlock(h, txs, commit, evList).MakePartSet(1024) assert.NotNil(t, partSet) - assert.Equal(t, 3, partSet.Total()) + assert.Equal(t, 2, partSet.Total()) } func TestBlockHashesTo(t *testing.T) { @@ -159,16 +161,16 @@ func TestBlockString(t *testing.T) { } func makeBlockIDRandom() BlockID { - blockHash, blockPartsHeader := crypto.CRandBytes(32), PartSetHeader{123, crypto.CRandBytes(32)} + blockHash, blockPartsHeader := crypto.CRandBytes(tmhash.Size), PartSetHeader{123, crypto.CRandBytes(tmhash.Size)} return BlockID{blockHash, blockPartsHeader} } -func makeBlockID(hash string, partSetSize int, partSetHash string) BlockID { +func makeBlockID(hash []byte, partSetSize int, partSetHash []byte) BlockID { return BlockID{ - Hash: []byte(hash), + Hash: hash, PartsHeader: PartSetHeader{ Total: partSetSize, - Hash: []byte(partSetHash), + Hash: partSetHash, }, } @@ -233,6 +235,40 @@ func TestCommitValidateBasic(t *testing.T) { assert.Error(t, commit.ValidateBasic()) } +func TestMaxHeaderBytes(t *testing.T) { + // Construct a UTF-8 string of MaxChainIDLen length using the supplementary + // characters. + // Each supplementary character takes 4 bytes. + // http://www.i18nguy.com/unicode/supplementary-test.html + maxChainID := "" + for i := 0; i < MaxChainIDLen; i++ { + maxChainID += "𠜎" + } + + h := Header{ + ChainID: maxChainID, + Height: 10, + Time: time.Now().UTC(), + NumTxs: 100, + TotalTxs: 200, + LastBlockID: makeBlockID(make([]byte, 20), 300, make([]byte, 20)), + LastCommitHash: tmhash.Sum([]byte("last_commit_hash")), + DataHash: tmhash.Sum([]byte("data_hash")), + ValidatorsHash: tmhash.Sum([]byte("validators_hash")), + NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")), + ConsensusHash: tmhash.Sum([]byte("consensus_hash")), + AppHash: tmhash.Sum([]byte("app_hash")), + LastResultsHash: tmhash.Sum([]byte("last_results_hash")), + EvidenceHash: tmhash.Sum([]byte("evidence_hash")), + ProposerAddress: tmhash.Sum([]byte("proposer_address")), + } + + bz, err := cdc.MarshalBinary(h) + require.NoError(t, err) + + assert.Equal(t, MaxHeaderBytes, len(bz)) +} + func randCommit() *Commit { lastID := makeBlockIDRandom() h := int64(3) diff --git a/types/evidence.go b/types/evidence.go index 92675868f..096e3503f 100644 --- a/types/evidence.go +++ b/types/evidence.go @@ -10,6 +10,11 @@ import ( "github.com/tendermint/tendermint/crypto/merkle" ) +const ( + // MaxEvidenceBytes is a maximum size of any evidence (including amino overhead). + MaxEvidenceBytes = 364 +) + // ErrEvidenceInvalid wraps a piece of evidence and the error denoting how or why it is invalid. type ErrEvidenceInvalid struct { Evidence Evidence diff --git a/types/evidence_test.go b/types/evidence_test.go index 54eba01cd..fab26b618 100644 --- a/types/evidence_test.go +++ b/types/evidence_test.go @@ -4,6 +4,9 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto/secp256k1" + "github.com/tendermint/tendermint/crypto/tmhash" ) type voteData struct { @@ -31,10 +34,11 @@ func makeVote(val PrivValidator, chainID string, valIndex int, height int64, rou func TestEvidence(t *testing.T) { val := NewMockPV() val2 := NewMockPV() - blockID := makeBlockID("blockhash", 1000, "partshash") - blockID2 := makeBlockID("blockhash2", 1000, "partshash") - blockID3 := makeBlockID("blockhash", 10000, "partshash") - blockID4 := makeBlockID("blockhash", 10000, "partshash2") + + blockID := makeBlockID([]byte("blockhash"), 1000, []byte("partshash")) + blockID2 := makeBlockID([]byte("blockhash2"), 1000, []byte("partshash")) + blockID3 := makeBlockID([]byte("blockhash"), 10000, []byte("partshash")) + blockID4 := makeBlockID([]byte("blockhash"), 10000, []byte("partshash2")) const chainID = "mychain" @@ -89,10 +93,27 @@ func TestEvidenceList(t *testing.T) { assert.False(t, evl.Has(&DuplicateVoteEvidence{})) } +func TestMaxEvidenceBytes(t *testing.T) { + val := NewMockPV() + blockID := makeBlockID(tmhash.Sum([]byte("blockhash")), 1000, tmhash.Sum([]byte("partshash"))) + blockID2 := makeBlockID(tmhash.Sum([]byte("blockhash2")), 1000, tmhash.Sum([]byte("partshash"))) + const chainID = "mychain" + ev := &DuplicateVoteEvidence{ + PubKey: secp256k1.GenPrivKey().PubKey(), // use secp because it's pubkey is longer + VoteA: makeVote(val, chainID, 0, 10, 2, 1, blockID), + VoteB: makeVote(val, chainID, 0, 10, 2, 1, blockID2), + } + + bz, err := cdc.MarshalBinary(ev) + require.NoError(t, err) + + assert.Equal(t, MaxEvidenceBytes, len(bz)) +} + func randomDuplicatedVoteEvidence() *DuplicateVoteEvidence { val := NewMockPV() - blockID := makeBlockID("blockhash", 1000, "partshash") - blockID2 := makeBlockID("blockhash2", 1000, "partshash") + blockID := makeBlockID([]byte("blockhash"), 1000, []byte("partshash")) + blockID2 := makeBlockID([]byte("blockhash2"), 1000, []byte("partshash")) const chainID = "mychain" return &DuplicateVoteEvidence{ VoteA: makeVote(val, chainID, 0, 10, 2, 1, blockID), diff --git a/types/params.go b/types/params.go index 3056c82a0..77f68eb7b 100644 --- a/types/params.go +++ b/types/params.go @@ -22,9 +22,8 @@ type ConsensusParams struct { // BlockSize contain limits on the block size. type BlockSize struct { - MaxBytes int `json:"max_bytes"` // NOTE: must not be 0 nor greater than 100MB - MaxTxs int `json:"max_txs"` - MaxGas int64 `json:"max_gas"` + MaxBytes int `json:"max_txs_bytes"` // NOTE: must not be 0 nor greater than 100MB + MaxGas int64 `json:"max_gas"` } // TxSize contain limits on the tx size. @@ -56,9 +55,8 @@ func DefaultConsensusParams() *ConsensusParams { // DefaultBlockSize returns a default BlockSize. func DefaultBlockSize() BlockSize { return BlockSize{ - MaxBytes: 22020096, // 21MB - MaxTxs: 10000, - MaxGas: -1, + MaxBytes: 22020096, // 21MB + MaxGas: -1, } } @@ -110,7 +108,6 @@ func (params *ConsensusParams) Hash() []byte { "block_gossip_part_size_bytes": aminoHasher(params.BlockGossip.BlockPartSizeBytes), "block_size_max_bytes": aminoHasher(params.BlockSize.MaxBytes), "block_size_max_gas": aminoHasher(params.BlockSize.MaxGas), - "block_size_max_txs": aminoHasher(params.BlockSize.MaxTxs), "tx_size_max_bytes": aminoHasher(params.TxSize.MaxBytes), "tx_size_max_gas": aminoHasher(params.TxSize.MaxGas), }) @@ -132,9 +129,6 @@ func (params ConsensusParams) Update(params2 *abci.ConsensusParams) ConsensusPar if params2.BlockSize.MaxBytes > 0 { res.BlockSize.MaxBytes = int(params2.BlockSize.MaxBytes) } - if params2.BlockSize.MaxTxs > 0 { - res.BlockSize.MaxTxs = int(params2.BlockSize.MaxTxs) - } if params2.BlockSize.MaxGas > 0 { res.BlockSize.MaxGas = params2.BlockSize.MaxGas } diff --git a/types/params_test.go b/types/params_test.go index e8e13dba0..119109ce0 100644 --- a/types/params_test.go +++ b/types/params_test.go @@ -9,9 +9,9 @@ import ( abci "github.com/tendermint/tendermint/abci/types" ) -func newConsensusParams(blockSize, partSize int) ConsensusParams { +func newConsensusParams(txsBytes, partSize int) ConsensusParams { return ConsensusParams{ - BlockSize: BlockSize{MaxBytes: blockSize}, + BlockSize: BlockSize{MaxBytes: txsBytes}, BlockGossip: BlockGossip{BlockPartSizeBytes: partSize}, } } @@ -33,22 +33,19 @@ func TestConsensusParamsValidation(t *testing.T) { {newConsensusParams(101*1024*1024, 400), false}, {newConsensusParams(1024*1024*1024, 400), false}, } - for _, testCase := range testCases { - if testCase.valid { - assert.NoError(t, testCase.params.Validate(), "expected no error for valid params") + for _, tc := range testCases { + if tc.valid { + assert.NoError(t, tc.params.Validate(), "expected no error for valid params") } else { - assert.Error(t, testCase.params.Validate(), "expected error for non valid params") + assert.Error(t, tc.params.Validate(), "expected error for non valid params") } } } -func makeParams(blockBytes, blockTx, blockGas, txBytes, - txGas, partSize int) ConsensusParams { - +func makeParams(txsBytes, blockGas, txBytes, txGas, partSize int) ConsensusParams { return ConsensusParams{ BlockSize: BlockSize{ - MaxBytes: blockBytes, - MaxTxs: blockTx, + MaxBytes: txsBytes, MaxGas: int64(blockGas), }, TxSize: TxSize{ @@ -63,14 +60,11 @@ func makeParams(blockBytes, blockTx, blockGas, txBytes, func TestConsensusParamsHash(t *testing.T) { params := []ConsensusParams{ - makeParams(1, 2, 3, 4, 5, 6), - makeParams(7, 2, 3, 4, 5, 6), - makeParams(1, 7, 3, 4, 5, 6), - makeParams(1, 2, 7, 4, 5, 6), - makeParams(1, 2, 3, 7, 5, 6), - makeParams(1, 2, 3, 4, 7, 6), - makeParams(1, 2, 3, 4, 5, 7), - makeParams(6, 5, 4, 3, 2, 1), + makeParams(6, 2, 3, 4, 5), + makeParams(1, 6, 3, 4, 5), + makeParams(1, 2, 6, 4, 5), + makeParams(1, 2, 3, 6, 5), + makeParams(1, 2, 3, 4, 6), } hashes := make([][]byte, len(params)) @@ -96,18 +90,17 @@ func TestConsensusParamsUpdate(t *testing.T) { }{ // empty updates { - makeParams(1, 2, 3, 4, 5, 6), + makeParams(1, 2, 3, 4, 5), &abci.ConsensusParams{}, - makeParams(1, 2, 3, 4, 5, 6), + makeParams(1, 2, 3, 4, 5), }, // negative BlockPartSizeBytes { - makeParams(1, 2, 3, 4, 5, 6), + makeParams(1, 2, 3, 4, 5), &abci.ConsensusParams{ BlockSize: &abci.BlockSize{ MaxBytes: -100, - MaxTxs: -200, - MaxGas: -300, + MaxGas: -200, }, TxSize: &abci.TxSize{ MaxBytes: -400, @@ -117,26 +110,25 @@ func TestConsensusParamsUpdate(t *testing.T) { BlockPartSizeBytes: -600, }, }, - makeParams(1, 2, 3, 4, 5, 6), + makeParams(1, 2, 3, 4, 5), }, // fine updates { - makeParams(1, 2, 3, 4, 5, 6), + makeParams(1, 2, 3, 4, 5), &abci.ConsensusParams{ BlockSize: &abci.BlockSize{ MaxBytes: 100, - MaxTxs: 200, - MaxGas: 300, + MaxGas: 200, }, TxSize: &abci.TxSize{ - MaxBytes: 400, - MaxGas: 500, + MaxBytes: 300, + MaxGas: 400, }, BlockGossip: &abci.BlockGossip{ - BlockPartSizeBytes: 600, + BlockPartSizeBytes: 500, }, }, - makeParams(100, 200, 300, 400, 500, 600), + makeParams(100, 200, 300, 400, 500), }, } for _, tc := range testCases { diff --git a/types/protobuf.go b/types/protobuf.go index 30e74f15e..9c448cd84 100644 --- a/types/protobuf.go +++ b/types/protobuf.go @@ -115,10 +115,8 @@ func (tm2pb) ValidatorUpdates(vals *ValidatorSet) []abci.ValidatorUpdate { func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams { return &abci.ConsensusParams{ BlockSize: &abci.BlockSize{ - - MaxBytes: int32(params.BlockSize.MaxBytes), - MaxTxs: int32(params.BlockSize.MaxTxs), - MaxGas: params.BlockSize.MaxGas, + MaxBytes: int32(params.BlockSize.MaxBytes), + MaxGas: params.BlockSize.MaxGas, }, TxSize: &abci.TxSize{ MaxBytes: int32(params.TxSize.MaxBytes), @@ -217,9 +215,8 @@ func (pb2tm) ValidatorUpdates(vals []abci.ValidatorUpdate) ([]*Validator, error) func (pb2tm) ConsensusParams(csp *abci.ConsensusParams) ConsensusParams { return ConsensusParams{ BlockSize: BlockSize{ - MaxBytes: int(csp.BlockSize.MaxBytes), // XXX - MaxTxs: int(csp.BlockSize.MaxTxs), // XXX - MaxGas: csp.BlockSize.MaxGas, + MaxBytes: int(csp.BlockSize.MaxBytes), // XXX + MaxGas: csp.BlockSize.MaxGas, }, TxSize: TxSize{ MaxBytes: int(csp.TxSize.MaxBytes), // XXX diff --git a/types/protobuf_test.go b/types/protobuf_test.go index 8bdf094ba..2a511225b 100644 --- a/types/protobuf_test.go +++ b/types/protobuf_test.go @@ -89,8 +89,8 @@ func TestABCIHeader(t *testing.T) { func TestABCIEvidence(t *testing.T) { val := NewMockPV() - blockID := makeBlockID("blockhash", 1000, "partshash") - blockID2 := makeBlockID("blockhash2", 1000, "partshash") + blockID := makeBlockID([]byte("blockhash"), 1000, []byte("partshash")) + blockID2 := makeBlockID([]byte("blockhash2"), 1000, []byte("partshash")) const chainID = "mychain" ev := &DuplicateVoteEvidence{ PubKey: val.GetPubKey(), diff --git a/types/tx.go b/types/tx.go index 489f0b232..53fd79c5b 100644 --- a/types/tx.go +++ b/types/tx.go @@ -11,6 +11,11 @@ import ( cmn "github.com/tendermint/tendermint/libs/common" ) +const ( + // MaxAminoOverheadForTx - amino overhead to encode a transaction. + MaxAminoOverheadForTx = 4 +) + // Tx is an arbitrary byte array. // NOTE: Tx has no types at this level, so when wire encoded it's just length-prefixed. // Might we want types here ? diff --git a/types/vote.go b/types/vote.go index 9a6180d75..ac163e8de 100644 --- a/types/vote.go +++ b/types/vote.go @@ -10,6 +10,11 @@ import ( cmn "github.com/tendermint/tendermint/libs/common" ) +const ( + // MaxVoteBytes is a maximum vote size (including amino overhead). + MaxVoteBytes = 170 +) + var ( ErrVoteUnexpectedStep = errors.New("Unexpected step") ErrVoteInvalidValidatorIndex = errors.New("Invalid validator index") diff --git a/types/vote_test.go b/types/vote_test.go index 836baa615..679fcd569 100644 --- a/types/vote_test.go +++ b/types/vote_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/crypto/ed25519" + "github.com/tendermint/tendermint/crypto/tmhash" ) func examplePrevote() *Vote { @@ -24,17 +25,17 @@ func exampleVote(t byte) *Vote { } return &Vote{ - ValidatorAddress: []byte("addr"), + ValidatorAddress: tmhash.Sum([]byte("validator_address")), ValidatorIndex: 56789, Height: 12345, Round: 2, Timestamp: stamp, Type: t, BlockID: BlockID{ - Hash: []byte("hash"), + Hash: tmhash.Sum([]byte("blockID_hash")), PartsHeader: PartSetHeader{ Total: 1000000, - Hash: []byte("parts_hash"), + Hash: tmhash.Sum([]byte("blockID_part_set_header_hash")), }, }, } @@ -45,7 +46,7 @@ func TestVoteSignable(t *testing.T) { signBytes := vote.SignBytes("test_chain_id") signStr := string(signBytes) - expected := `{"@chain_id":"test_chain_id","@type":"vote","block_id":{"hash":"68617368","parts":{"hash":"70617274735F68617368","total":"1000000"}},"height":"12345","round":"2","timestamp":"2017-12-25T03:00:01.234Z","type":2}` + expected := `{"@chain_id":"test_chain_id","@type":"vote","block_id":{"hash":"8B01023386C371778ECB6368573E539AFC3CC860","parts":{"hash":"72DB3D959635DFF1BB567BEDAA70573392C51596","total":"1000000"}},"height":"12345","round":"2","timestamp":"2017-12-25T03:00:01.234Z","type":2}` if signStr != expected { // NOTE: when this fails, you probably want to fix up consensus/replay_test too t.Errorf("Got unexpected sign string for Vote. Expected:\n%v\nGot:\n%v", expected, signStr) @@ -119,3 +120,16 @@ func TestVoteVerify(t *testing.T) { assert.Equal(t, ErrVoteInvalidSignature, err) } } + +func TestMaxVoteBytes(t *testing.T) { + vote := examplePrevote() + + privVal := NewMockPV() + err := privVal.SignVote("test_chain_id", vote) + require.NoError(t, err) + + bz, err := cdc.MarshalBinary(vote) + require.NoError(t, err) + + assert.Equal(t, MaxVoteBytes, len(bz)) +}