mirror of
https://github.com/fluencelabs/tendermint
synced 2025-04-25 14:52:17 +00:00
reap max bytes from the mempool & check transaction size
See ADR 020: Limiting txs size inside a block docs/architecture/adr-020-block-size.md Refs #2035
This commit is contained in:
Anton Kaliaev
parent
7b2f7090fd
commit
d73c5cbdb1
1
Gopkg.lock
generated
1
Gopkg.lock
generated
@ -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",
|
||||
|
||||
@ -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)
|
||||
golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_c68d3007ea320b94)
|
||||
}
|
||||
|
||||
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,
|
||||
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,
|
||||
}
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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)
|
||||
|
||||
}
|
||||
@ -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
|
||||
|
||||
@ -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++
|
||||
}
|
||||
|
||||
//------------------------------------
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
72
docs/architecture/adr-020-block-size.md
Normal file
72
docs/architecture/adr-020-block-size.md
Normal file
@ -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
|
||||
@ -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.
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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))
|
||||
|
||||
|
||||
@ -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")
|
||||
}
|
||||
txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), maxTxs))
|
||||
for e := mem.txs.Front(); e != nil && len(txs) < maxTxs; e = e.Next() {
|
||||
|
||||
for atomic.LoadInt32(&mem.rechecking) > 0 {
|
||||
// TODO: Something better?
|
||||
time.Sleep(time.Millisecond * 10)
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@ -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]))
|
||||
}
|
||||
|
||||
@ -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)
|
||||
@ -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)
|
||||
|
||||
@ -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()
|
||||
}
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
|
||||
@ -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 {
|
||||
}
|
||||
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() {}
|
||||
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) PendingEvidence(int) []types.Evidence { return nil }
|
||||
func (m MockEvidencePool) AddEvidence(types.Evidence) error { return nil }
|
||||
func (m MockEvidencePool) Update(*types.Block, State) {}
|
||||
|
||||
@ -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,
|
||||
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 {
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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),
|
||||
|
||||
@ -22,8 +22,7 @@ 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"`
|
||||
MaxBytes int `json:"max_txs_bytes"` // NOTE: must not be 0 nor greater than 100MB
|
||||
MaxGas int64 `json:"max_gas"`
|
||||
}
|
||||
|
||||
@ -57,7 +56,6 @@ func DefaultConsensusParams() *ConsensusParams {
|
||||
func DefaultBlockSize() BlockSize {
|
||||
return BlockSize{
|
||||
MaxBytes: 22020096, // 21MB
|
||||
MaxTxs: 10000,
|
||||
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
|
||||
}
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -115,9 +115,7 @@ 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,
|
||||
},
|
||||
TxSize: &abci.TxSize{
|
||||
@ -218,7 +216,6 @@ 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,
|
||||
},
|
||||
TxSize: TxSize{
|
||||
|
||||
@ -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(),
|
||||
|
||||
@ -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 ?
|
||||
|
||||
@ -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")
|
||||
|
||||
@ -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))
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user