Browse Source

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
pull/2184/head
Anton Kaliaev 6 years ago
parent
commit
d73c5cbdb1
No known key found for this signature in database GPG Key ID: 7B6881D965918214
33 changed files with 548 additions and 404 deletions
  1. +0
    -1
      Gopkg.lock
  2. +180
    -222
      abci/types/types.pb.go
  3. +1
    -2
      abci/types/types.proto
  4. +0
    -31
      abci/types/types_test.go
  5. +1
    -1
      consensus/mempool_test.go
  6. +3
    -2
      consensus/reactor_test.go
  7. +19
    -3
      consensus/state.go
  8. +72
    -0
      docs/architecture/adr-020-block-size.md
  9. +4
    -3
      evidence/pool.go
  10. +2
    -2
      evidence/reactor_test.go
  11. +14
    -6
      evidence/store.go
  12. +4
    -4
      evidence/store_test.go
  13. +55
    -13
      mempool/mempool.go
  14. +4
    -4
      mempool/mempool_test.go
  15. +1
    -1
      mempool/reactor_test.go
  16. +4
    -3
      node/node.go
  17. +1
    -1
      rpc/client/rpc_test.go
  18. +1
    -1
      rpc/core/mempool.go
  19. +3
    -2
      rpc/core/pipe.go
  20. +5
    -3
      state/execution.go
  21. +19
    -21
      state/services.go
  22. +9
    -12
      state/state_test.go
  23. +11
    -0
      types/block.go
  24. +41
    -5
      types/block_test.go
  25. +5
    -0
      types/evidence.go
  26. +27
    -6
      types/evidence_test.go
  27. +4
    -10
      types/params.go
  28. +24
    -32
      types/params_test.go
  29. +4
    -7
      types/protobuf.go
  30. +2
    -2
      types/protobuf_test.go
  31. +5
    -0
      types/tx.go
  32. +5
    -0
      types/vote.go
  33. +18
    -4
      types/vote_test.go

+ 0
- 1
Gopkg.lock View File

@ -525,7 +525,6 @@
"github.com/gogo/protobuf/gogoproto", "github.com/gogo/protobuf/gogoproto",
"github.com/gogo/protobuf/jsonpb", "github.com/gogo/protobuf/jsonpb",
"github.com/gogo/protobuf/proto", "github.com/gogo/protobuf/proto",
"github.com/gogo/protobuf/types",
"github.com/golang/protobuf/proto", "github.com/golang/protobuf/proto",
"github.com/golang/protobuf/ptypes/timestamp", "github.com/golang/protobuf/ptypes/timestamp",
"github.com/gorilla/websocket", "github.com/gorilla/websocket",


+ 180
- 222
abci/types/types.pb.go View File

@ -60,7 +60,7 @@ func (m *Request) Reset() { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) } func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage() {} func (*Request) ProtoMessage() {}
func (*Request) Descriptor() ([]byte, []int) { 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 { func (m *Request) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -482,7 +482,7 @@ func (m *RequestEcho) Reset() { *m = RequestEcho{} }
func (m *RequestEcho) String() string { return proto.CompactTextString(m) } func (m *RequestEcho) String() string { return proto.CompactTextString(m) }
func (*RequestEcho) ProtoMessage() {} func (*RequestEcho) ProtoMessage() {}
func (*RequestEcho) Descriptor() ([]byte, []int) { 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 { func (m *RequestEcho) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -528,7 +528,7 @@ func (m *RequestFlush) Reset() { *m = RequestFlush{} }
func (m *RequestFlush) String() string { return proto.CompactTextString(m) } func (m *RequestFlush) String() string { return proto.CompactTextString(m) }
func (*RequestFlush) ProtoMessage() {} func (*RequestFlush) ProtoMessage() {}
func (*RequestFlush) Descriptor() ([]byte, []int) { 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 { func (m *RequestFlush) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -568,7 +568,7 @@ func (m *RequestInfo) Reset() { *m = RequestInfo{} }
func (m *RequestInfo) String() string { return proto.CompactTextString(m) } func (m *RequestInfo) String() string { return proto.CompactTextString(m) }
func (*RequestInfo) ProtoMessage() {} func (*RequestInfo) ProtoMessage() {}
func (*RequestInfo) Descriptor() ([]byte, []int) { 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 { func (m *RequestInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -617,7 +617,7 @@ func (m *RequestSetOption) Reset() { *m = RequestSetOption{} }
func (m *RequestSetOption) String() string { return proto.CompactTextString(m) } func (m *RequestSetOption) String() string { return proto.CompactTextString(m) }
func (*RequestSetOption) ProtoMessage() {} func (*RequestSetOption) ProtoMessage() {}
func (*RequestSetOption) Descriptor() ([]byte, []int) { 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 { func (m *RequestSetOption) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -675,7 +675,7 @@ func (m *RequestInitChain) Reset() { *m = RequestInitChain{} }
func (m *RequestInitChain) String() string { return proto.CompactTextString(m) } func (m *RequestInitChain) String() string { return proto.CompactTextString(m) }
func (*RequestInitChain) ProtoMessage() {} func (*RequestInitChain) ProtoMessage() {}
func (*RequestInitChain) Descriptor() ([]byte, []int) { 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 { func (m *RequestInitChain) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -753,7 +753,7 @@ func (m *RequestQuery) Reset() { *m = RequestQuery{} }
func (m *RequestQuery) String() string { return proto.CompactTextString(m) } func (m *RequestQuery) String() string { return proto.CompactTextString(m) }
func (*RequestQuery) ProtoMessage() {} func (*RequestQuery) ProtoMessage() {}
func (*RequestQuery) Descriptor() ([]byte, []int) { 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 { func (m *RequestQuery) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -825,7 +825,7 @@ func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} }
func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) } func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) }
func (*RequestBeginBlock) ProtoMessage() {} func (*RequestBeginBlock) ProtoMessage() {}
func (*RequestBeginBlock) Descriptor() ([]byte, []int) { 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 { func (m *RequestBeginBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -893,7 +893,7 @@ func (m *RequestCheckTx) Reset() { *m = RequestCheckTx{} }
func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) } func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) }
func (*RequestCheckTx) ProtoMessage() {} func (*RequestCheckTx) ProtoMessage() {}
func (*RequestCheckTx) Descriptor() ([]byte, []int) { 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 { func (m *RequestCheckTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -940,7 +940,7 @@ func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} }
func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) } func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) }
func (*RequestDeliverTx) ProtoMessage() {} func (*RequestDeliverTx) ProtoMessage() {}
func (*RequestDeliverTx) Descriptor() ([]byte, []int) { 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 { func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -987,7 +987,7 @@ func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} }
func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) } func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) }
func (*RequestEndBlock) ProtoMessage() {} func (*RequestEndBlock) ProtoMessage() {}
func (*RequestEndBlock) Descriptor() ([]byte, []int) { 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 { func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1033,7 +1033,7 @@ func (m *RequestCommit) Reset() { *m = RequestCommit{} }
func (m *RequestCommit) String() string { return proto.CompactTextString(m) } func (m *RequestCommit) String() string { return proto.CompactTextString(m) }
func (*RequestCommit) ProtoMessage() {} func (*RequestCommit) ProtoMessage() {}
func (*RequestCommit) Descriptor() ([]byte, []int) { 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 { func (m *RequestCommit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1086,7 +1086,7 @@ func (m *Response) Reset() { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) } func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage() {} func (*Response) ProtoMessage() {}
func (*Response) Descriptor() ([]byte, []int) { 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 { func (m *Response) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1539,7 +1539,7 @@ func (m *ResponseException) Reset() { *m = ResponseException{} }
func (m *ResponseException) String() string { return proto.CompactTextString(m) } func (m *ResponseException) String() string { return proto.CompactTextString(m) }
func (*ResponseException) ProtoMessage() {} func (*ResponseException) ProtoMessage() {}
func (*ResponseException) Descriptor() ([]byte, []int) { 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 { func (m *ResponseException) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1586,7 +1586,7 @@ func (m *ResponseEcho) Reset() { *m = ResponseEcho{} }
func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } func (m *ResponseEcho) String() string { return proto.CompactTextString(m) }
func (*ResponseEcho) ProtoMessage() {} func (*ResponseEcho) ProtoMessage() {}
func (*ResponseEcho) Descriptor() ([]byte, []int) { 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 { func (m *ResponseEcho) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1632,7 +1632,7 @@ func (m *ResponseFlush) Reset() { *m = ResponseFlush{} }
func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } func (m *ResponseFlush) String() string { return proto.CompactTextString(m) }
func (*ResponseFlush) ProtoMessage() {} func (*ResponseFlush) ProtoMessage() {}
func (*ResponseFlush) Descriptor() ([]byte, []int) { 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 { func (m *ResponseFlush) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1675,7 +1675,7 @@ func (m *ResponseInfo) Reset() { *m = ResponseInfo{} }
func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } func (m *ResponseInfo) String() string { return proto.CompactTextString(m) }
func (*ResponseInfo) ProtoMessage() {} func (*ResponseInfo) ProtoMessage() {}
func (*ResponseInfo) Descriptor() ([]byte, []int) { 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 { func (m *ResponseInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1747,7 +1747,7 @@ func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} }
func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) } func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) }
func (*ResponseSetOption) ProtoMessage() {} func (*ResponseSetOption) ProtoMessage() {}
func (*ResponseSetOption) Descriptor() ([]byte, []int) { 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 { func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1809,7 +1809,7 @@ func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} }
func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) }
func (*ResponseInitChain) ProtoMessage() {} func (*ResponseInitChain) ProtoMessage() {}
func (*ResponseInitChain) Descriptor() ([]byte, []int) { 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 { func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1871,7 +1871,7 @@ func (m *ResponseQuery) Reset() { *m = ResponseQuery{} }
func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } func (m *ResponseQuery) String() string { return proto.CompactTextString(m) }
func (*ResponseQuery) ProtoMessage() {} func (*ResponseQuery) ProtoMessage() {}
func (*ResponseQuery) Descriptor() ([]byte, []int) { 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 { func (m *ResponseQuery) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -1967,7 +1967,7 @@ func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} }
func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) }
func (*ResponseBeginBlock) ProtoMessage() {} func (*ResponseBeginBlock) ProtoMessage() {}
func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { 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 { func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2020,7 +2020,7 @@ func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} }
func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) }
func (*ResponseCheckTx) ProtoMessage() {} func (*ResponseCheckTx) ProtoMessage() {}
func (*ResponseCheckTx) Descriptor() ([]byte, []int) { 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 { func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2115,7 +2115,7 @@ func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} }
func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) }
func (*ResponseDeliverTx) ProtoMessage() {} func (*ResponseDeliverTx) ProtoMessage() {}
func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { 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 { func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2206,7 +2206,7 @@ func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} }
func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) }
func (*ResponseEndBlock) ProtoMessage() {} func (*ResponseEndBlock) ProtoMessage() {}
func (*ResponseEndBlock) Descriptor() ([]byte, []int) { 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 { func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2268,7 +2268,7 @@ func (m *ResponseCommit) Reset() { *m = ResponseCommit{} }
func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } func (m *ResponseCommit) String() string { return proto.CompactTextString(m) }
func (*ResponseCommit) ProtoMessage() {} func (*ResponseCommit) ProtoMessage() {}
func (*ResponseCommit) Descriptor() ([]byte, []int) { 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 { func (m *ResponseCommit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2319,7 +2319,7 @@ func (m *ConsensusParams) Reset() { *m = ConsensusParams{} }
func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } func (m *ConsensusParams) String() string { return proto.CompactTextString(m) }
func (*ConsensusParams) ProtoMessage() {} func (*ConsensusParams) ProtoMessage() {}
func (*ConsensusParams) Descriptor() ([]byte, []int) { 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 { func (m *ConsensusParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2372,8 +2372,7 @@ func (m *ConsensusParams) GetBlockGossip() *BlockGossip {
// BlockSize contains limits on the block size. // BlockSize contains limits on the block size.
type BlockSize struct { type BlockSize struct {
MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"` 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_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `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 (m *BlockSize) String() string { return proto.CompactTextString(m) }
func (*BlockSize) ProtoMessage() {} func (*BlockSize) ProtoMessage() {}
func (*BlockSize) Descriptor() ([]byte, []int) { 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 { func (m *BlockSize) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2419,13 +2418,6 @@ func (m *BlockSize) GetMaxBytes() int32 {
return 0 return 0
} }
func (m *BlockSize) GetMaxTxs() int32 {
if m != nil {
return m.MaxTxs
}
return 0
}
func (m *BlockSize) GetMaxGas() int64 { func (m *BlockSize) GetMaxGas() int64 {
if m != nil { if m != nil {
return m.MaxGas return m.MaxGas
@ -2446,7 +2438,7 @@ func (m *TxSize) Reset() { *m = TxSize{} }
func (m *TxSize) String() string { return proto.CompactTextString(m) } func (m *TxSize) String() string { return proto.CompactTextString(m) }
func (*TxSize) ProtoMessage() {} func (*TxSize) ProtoMessage() {}
func (*TxSize) Descriptor() ([]byte, []int) { 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 { func (m *TxSize) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2503,7 +2495,7 @@ func (m *BlockGossip) Reset() { *m = BlockGossip{} }
func (m *BlockGossip) String() string { return proto.CompactTextString(m) } func (m *BlockGossip) String() string { return proto.CompactTextString(m) }
func (*BlockGossip) ProtoMessage() {} func (*BlockGossip) ProtoMessage() {}
func (*BlockGossip) Descriptor() ([]byte, []int) { 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 { func (m *BlockGossip) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2551,7 +2543,7 @@ func (m *LastCommitInfo) Reset() { *m = LastCommitInfo{} }
func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) } func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) }
func (*LastCommitInfo) ProtoMessage() {} func (*LastCommitInfo) ProtoMessage() {}
func (*LastCommitInfo) Descriptor() ([]byte, []int) { 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 { func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2624,7 +2616,7 @@ func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) } func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {} func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) { 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 { func (m *Header) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2770,7 +2762,7 @@ func (m *BlockID) Reset() { *m = BlockID{} }
func (m *BlockID) String() string { return proto.CompactTextString(m) } func (m *BlockID) String() string { return proto.CompactTextString(m) }
func (*BlockID) ProtoMessage() {} func (*BlockID) ProtoMessage() {}
func (*BlockID) Descriptor() ([]byte, []int) { 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 { func (m *BlockID) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2825,7 +2817,7 @@ func (m *PartSetHeader) Reset() { *m = PartSetHeader{} }
func (m *PartSetHeader) String() string { return proto.CompactTextString(m) } func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
func (*PartSetHeader) ProtoMessage() {} func (*PartSetHeader) ProtoMessage() {}
func (*PartSetHeader) Descriptor() ([]byte, []int) { 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 { func (m *PartSetHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2882,7 +2874,7 @@ func (m *Validator) Reset() { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) } func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage() {} func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) { 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 { func (m *Validator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2938,7 +2930,7 @@ func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} }
func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) } func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) }
func (*ValidatorUpdate) ProtoMessage() {} func (*ValidatorUpdate) ProtoMessage() {}
func (*ValidatorUpdate) Descriptor() ([]byte, []int) { 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 { func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -2994,7 +2986,7 @@ func (m *VoteInfo) Reset() { *m = VoteInfo{} }
func (m *VoteInfo) String() string { return proto.CompactTextString(m) } func (m *VoteInfo) String() string { return proto.CompactTextString(m) }
func (*VoteInfo) ProtoMessage() {} func (*VoteInfo) ProtoMessage() {}
func (*VoteInfo) Descriptor() ([]byte, []int) { 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 { func (m *VoteInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -3049,7 +3041,7 @@ func (m *PubKey) Reset() { *m = PubKey{} }
func (m *PubKey) String() string { return proto.CompactTextString(m) } func (m *PubKey) String() string { return proto.CompactTextString(m) }
func (*PubKey) ProtoMessage() {} func (*PubKey) ProtoMessage() {}
func (*PubKey) Descriptor() ([]byte, []int) { 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 { func (m *PubKey) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -3107,7 +3099,7 @@ func (m *Evidence) Reset() { *m = Evidence{} }
func (m *Evidence) String() string { return proto.CompactTextString(m) } func (m *Evidence) String() string { return proto.CompactTextString(m) }
func (*Evidence) ProtoMessage() {} func (*Evidence) ProtoMessage() {}
func (*Evidence) Descriptor() ([]byte, []int) { 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 { func (m *Evidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -4688,9 +4680,6 @@ func (this *BlockSize) Equal(that interface{}) bool {
if this.MaxBytes != that1.MaxBytes { if this.MaxBytes != that1.MaxBytes {
return false return false
} }
if this.MaxTxs != that1.MaxTxs {
return false
}
if this.MaxGas != that1.MaxGas { if this.MaxGas != that1.MaxGas {
return false return false
} }
@ -5212,7 +5201,8 @@ func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBloc
return out, nil return out, nil
} }
// ABCIApplicationServer is the server API for ABCIApplication service.
// Server API for ABCIApplication service
type ABCIApplicationServer interface { type ABCIApplicationServer interface {
Echo(context.Context, *RequestEcho) (*ResponseEcho, error) Echo(context.Context, *RequestEcho) (*ResponseEcho, error)
Flush(context.Context, *RequestFlush) (*ResponseFlush, error) Flush(context.Context, *RequestFlush) (*ResponseFlush, error)
@ -6821,13 +6811,8 @@ func (m *BlockSize) MarshalTo(dAtA []byte) (int, error) {
i++ i++
i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) 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 { if m.MaxGas != 0 {
dAtA[i] = 0x18
dAtA[i] = 0x10
i++ i++
i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas))
} }
@ -7899,16 +7884,12 @@ func NewPopulatedBlockSize(r randyTypes, easy bool) *BlockSize {
if r.Intn(2) == 0 { if r.Intn(2) == 0 {
this.MaxBytes *= -1 this.MaxBytes *= -1
} }
this.MaxTxs = int32(r.Int31())
if r.Intn(2) == 0 {
this.MaxTxs *= -1
}
this.MaxGas = int64(r.Int63()) this.MaxGas = int64(r.Int63())
if r.Intn(2) == 0 { if r.Intn(2) == 0 {
this.MaxGas *= -1 this.MaxGas *= -1
} }
if !easy && r.Intn(10) != 0 { if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedTypes(r, 4)
this.XXX_unrecognized = randUnrecognizedTypes(r, 3)
} }
return this return this
} }
@ -8905,9 +8886,6 @@ func (m *BlockSize) Size() (n int) {
if m.MaxBytes != 0 { if m.MaxBytes != 0 {
n += 1 + sovTypes(uint64(m.MaxBytes)) n += 1 + sovTypes(uint64(m.MaxBytes))
} }
if m.MaxTxs != 0 {
n += 1 + sovTypes(uint64(m.MaxTxs))
}
if m.MaxGas != 0 { if m.MaxGas != 0 {
n += 1 + sovTypes(uint64(m.MaxGas)) n += 1 + sovTypes(uint64(m.MaxGas))
} }
@ -12960,25 +12938,6 @@ func (m *BlockSize) Unmarshal(dAtA []byte) error {
} }
} }
case 2: 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 { if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MaxGas", wireType) return fmt.Errorf("proto: wrong wireType = %d for field MaxGas", wireType)
} }
@ -14664,144 +14623,143 @@ var (
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 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() { func init() {
golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_bafb6deff4c77e13)
}
var fileDescriptor_types_bafb6deff4c77e13 = []byte{
// 2115 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcf, 0x6e, 0x1b, 0xc9,
0xd1, 0xd7, 0x50, 0x14, 0xc9, 0x29, 0x4a, 0xa4, 0xdc, 0xb6, 0x25, 0x9a, 0xfb, 0x7d, 0x92, 0x31,
0x49, 0xbc, 0x52, 0x56, 0x2b, 0x6d, 0xb4, 0x71, 0x20, 0xaf, 0x37, 0x8b, 0x88, 0xb6, 0xb3, 0x12,
0x76, 0x93, 0x28, 0x63, 0x5b, 0x01, 0x82, 0x00, 0x83, 0x26, 0xa7, 0x45, 0x0e, 0x4c, 0xce, 0xcc,
0x4e, 0x37, 0xb5, 0x94, 0x9f, 0x61, 0x0f, 0x7b, 0x08, 0x90, 0x73, 0x6e, 0x79, 0x81, 0x00, 0x39,
0xe6, 0x14, 0xec, 0x31, 0x08, 0x12, 0xe4, 0xe6, 0x24, 0x0a, 0x72, 0x48, 0x9e, 0x20, 0xc7, 0xa0,
0xab, 0x7b, 0xfe, 0x6a, 0x68, 0xd8, 0xce, 0x2d, 0x17, 0x72, 0xba, 0xab, 0xaa, 0xbb, 0xab, 0xba,
0xaa, 0x7e, 0x55, 0x0d, 0x6b, 0xb4, 0x3f, 0xf0, 0xf6, 0xc4, 0x45, 0xc8, 0xb8, 0xfa, 0xdd, 0x0d,
0xa3, 0x40, 0x04, 0x64, 0x09, 0x07, 0xdd, 0x77, 0x87, 0x9e, 0x18, 0x4d, 0xfb, 0xbb, 0x83, 0x60,
0xb2, 0x37, 0x0c, 0x86, 0xc1, 0x1e, 0x52, 0xfb, 0xd3, 0x33, 0x1c, 0xe1, 0x00, 0xbf, 0x94, 0x54,
0x77, 0x73, 0x18, 0x04, 0xc3, 0x31, 0x4b, 0xb9, 0x84, 0x37, 0x61, 0x5c, 0xd0, 0x49, 0xa8, 0x19,
0x0e, 0x32, 0xeb, 0x09, 0xe6, 0xbb, 0x2c, 0x9a, 0x78, 0xbe, 0xc8, 0x7e, 0x8e, 0xbd, 0x3e, 0xdf,
0x1b, 0x04, 0x93, 0x49, 0xe0, 0x67, 0x0f, 0x64, 0xfd, 0xae, 0x0a, 0x75, 0x9b, 0x7d, 0x36, 0x65,
0x5c, 0x90, 0x2d, 0xa8, 0xb2, 0xc1, 0x28, 0xe8, 0x54, 0x6e, 0x1b, 0x5b, 0xcd, 0x7d, 0xb2, 0xab,
0xf8, 0x34, 0xf5, 0xd1, 0x60, 0x14, 0x1c, 0x2d, 0xd8, 0xc8, 0x41, 0xde, 0x81, 0xa5, 0xb3, 0xf1,
0x94, 0x8f, 0x3a, 0x8b, 0xc8, 0x7a, 0x3d, 0xcf, 0xfa, 0x7d, 0x49, 0x3a, 0x5a, 0xb0, 0x15, 0x8f,
0x5c, 0xd6, 0xf3, 0xcf, 0x82, 0x4e, 0xb5, 0x6c, 0xd9, 0x63, 0xff, 0x0c, 0x97, 0x95, 0x1c, 0xe4,
0x00, 0x80, 0x33, 0xe1, 0x04, 0xa1, 0xf0, 0x02, 0xbf, 0xb3, 0x84, 0xfc, 0xeb, 0x79, 0xfe, 0xc7,
0x4c, 0xfc, 0x08, 0xc9, 0x47, 0x0b, 0xb6, 0xc9, 0xe3, 0x81, 0x94, 0xf4, 0x7c, 0x4f, 0x38, 0x83,
0x11, 0xf5, 0xfc, 0x4e, 0xad, 0x4c, 0xf2, 0xd8, 0xf7, 0xc4, 0x03, 0x49, 0x96, 0x92, 0x5e, 0x3c,
0x90, 0xaa, 0x7c, 0x36, 0x65, 0xd1, 0x45, 0xa7, 0x5e, 0xa6, 0xca, 0x8f, 0x25, 0x49, 0xaa, 0x82,
0x3c, 0xe4, 0x3e, 0x34, 0xfb, 0x6c, 0xe8, 0xf9, 0x4e, 0x7f, 0x1c, 0x0c, 0x9e, 0x75, 0x1a, 0x28,
0xd2, 0xc9, 0x8b, 0xf4, 0x24, 0x43, 0x4f, 0xd2, 0x8f, 0x16, 0x6c, 0xe8, 0x27, 0x23, 0xb2, 0x0f,
0x8d, 0xc1, 0x88, 0x0d, 0x9e, 0x39, 0x62, 0xd6, 0x31, 0x51, 0xf2, 0x66, 0x5e, 0xf2, 0x81, 0xa4,
0x3e, 0x99, 0x1d, 0x2d, 0xd8, 0xf5, 0x81, 0xfa, 0x24, 0x77, 0xc1, 0x64, 0xbe, 0xab, 0xb7, 0x6b,
0xa2, 0xd0, 0x5a, 0xe1, 0x5e, 0x7c, 0x37, 0xde, 0xac, 0xc1, 0xf4, 0x37, 0xd9, 0x85, 0x9a, 0xbc,
0x6b, 0x4f, 0x74, 0x96, 0x51, 0xe6, 0x46, 0x61, 0x23, 0xa4, 0x1d, 0x2d, 0xd8, 0x9a, 0x4b, 0x9a,
0xcf, 0x65, 0x63, 0xef, 0x9c, 0x45, 0xf2, 0x70, 0xd7, 0xcb, 0xcc, 0xf7, 0x50, 0xd1, 0xf1, 0x78,
0xa6, 0x1b, 0x0f, 0x7a, 0x75, 0x58, 0x3a, 0xa7, 0xe3, 0x29, 0xb3, 0xde, 0x86, 0x66, 0xc6, 0x53,
0x48, 0x07, 0xea, 0x13, 0xc6, 0x39, 0x1d, 0xb2, 0x8e, 0x71, 0xdb, 0xd8, 0x32, 0xed, 0x78, 0x68,
0xb5, 0x60, 0x39, 0xeb, 0x27, 0x19, 0x41, 0xe9, 0x0b, 0x52, 0xf0, 0x9c, 0x45, 0x5c, 0x3a, 0x80,
0x16, 0xd4, 0x43, 0xeb, 0x03, 0x58, 0x2d, 0x3a, 0x01, 0x59, 0x85, 0xc5, 0x67, 0xec, 0x42, 0x73,
0xca, 0x4f, 0x72, 0x43, 0x1f, 0x08, 0xbd, 0xd8, 0xb4, 0xf5, 0xe9, 0xbe, 0xac, 0x24, 0xc2, 0x89,
0x1f, 0x90, 0x03, 0xa8, 0xca, 0x40, 0x42, 0xe9, 0xe6, 0x7e, 0x77, 0x57, 0x45, 0xd9, 0x6e, 0x1c,
0x65, 0xbb, 0x4f, 0xe2, 0x28, 0xeb, 0x35, 0xbe, 0x7a, 0xb1, 0xb9, 0xf0, 0xe5, 0x5f, 0x36, 0x0d,
0x1b, 0x25, 0xc8, 0x2d, 0x79, 0x95, 0xd4, 0xf3, 0x1d, 0xcf, 0xd5, 0xfb, 0xd4, 0x71, 0x7c, 0xec,
0x92, 0x43, 0x58, 0x1d, 0x04, 0x3e, 0x67, 0x3e, 0x9f, 0x72, 0x27, 0xa4, 0x11, 0x9d, 0x70, 0x1d,
0x25, 0xf1, 0xc5, 0x3d, 0x88, 0xc9, 0x27, 0x48, 0xb5, 0xdb, 0x83, 0xfc, 0x04, 0xf9, 0x10, 0xe0,
0x9c, 0x8e, 0x3d, 0x97, 0x8a, 0x20, 0xe2, 0x9d, 0xea, 0xed, 0xc5, 0x8c, 0xf0, 0x69, 0x4c, 0x78,
0x1a, 0xba, 0x54, 0xb0, 0x5e, 0x55, 0x9e, 0xcc, 0xce, 0xf0, 0x93, 0x3b, 0xd0, 0xa6, 0x61, 0xe8,
0x70, 0x41, 0x05, 0x73, 0xfa, 0x17, 0x82, 0x71, 0x8c, 0xa4, 0x65, 0x7b, 0x85, 0x86, 0xe1, 0x63,
0x39, 0xdb, 0x93, 0x93, 0x96, 0x9b, 0xdc, 0x03, 0x3a, 0x39, 0x21, 0x50, 0x75, 0xa9, 0xa0, 0x68,
0x8d, 0x65, 0x1b, 0xbf, 0xe5, 0x5c, 0x48, 0xc5, 0x48, 0xeb, 0x88, 0xdf, 0x64, 0x0d, 0x6a, 0x23,
0xe6, 0x0d, 0x47, 0x02, 0xd5, 0x5a, 0xb4, 0xf5, 0x48, 0x1a, 0x3e, 0x8c, 0x82, 0x73, 0x86, 0x71,
0xde, 0xb0, 0xd5, 0xc0, 0xfa, 0x87, 0x01, 0xd7, 0xae, 0x04, 0x86, 0x5c, 0x77, 0x44, 0xf9, 0x28,
0xde, 0x4b, 0x7e, 0x93, 0x77, 0xe4, 0xba, 0xd4, 0x65, 0x91, 0xce, 0x3f, 0x2b, 0x5a, 0xe3, 0x23,
0x9c, 0xd4, 0x8a, 0x6a, 0x16, 0xf2, 0x08, 0x56, 0xc7, 0x94, 0x0b, 0x47, 0xf9, 0xaf, 0x83, 0xf9,
0x65, 0x31, 0x17, 0x53, 0x9f, 0xd2, 0xd8, 0xcf, 0xa5, 0x5b, 0x69, 0xf1, 0xd6, 0x38, 0x37, 0x4b,
0x8e, 0xe0, 0x46, 0xff, 0xe2, 0x39, 0xf5, 0x85, 0xe7, 0x33, 0xe7, 0x8a, 0xcd, 0xdb, 0x7a, 0xa9,
0x47, 0xe7, 0x9e, 0xcb, 0xfc, 0x41, 0x6c, 0xec, 0xeb, 0x89, 0x48, 0x72, 0x19, 0xdc, 0xba, 0x0d,
0xad, 0x7c, 0x14, 0x93, 0x16, 0x54, 0xc4, 0x4c, 0x6b, 0x58, 0x11, 0x33, 0xcb, 0x4a, 0x3c, 0x30,
0x09, 0xa5, 0x2b, 0x3c, 0xdb, 0xd0, 0x2e, 0x84, 0x75, 0xc6, 0xdc, 0x46, 0xd6, 0xdc, 0x56, 0x1b,
0x56, 0x72, 0xd1, 0x6c, 0x7d, 0xb1, 0x04, 0x0d, 0x9b, 0xf1, 0x50, 0x3a, 0x13, 0x39, 0x00, 0x93,
0xcd, 0x06, 0x4c, 0x25, 0x52, 0xa3, 0x90, 0xa6, 0x14, 0xcf, 0xa3, 0x98, 0x2e, 0x03, 0x3a, 0x61,
0x26, 0xdb, 0x39, 0x10, 0xb8, 0x5e, 0x14, 0xca, 0xa2, 0xc0, 0x4e, 0x1e, 0x05, 0x6e, 0x14, 0x78,
0x0b, 0x30, 0xb0, 0x9d, 0x83, 0x81, 0xe2, 0xc2, 0x39, 0x1c, 0xb8, 0x57, 0x82, 0x03, 0xc5, 0xe3,
0xcf, 0x01, 0x82, 0x7b, 0x25, 0x40, 0xd0, 0xb9, 0xb2, 0x57, 0x29, 0x12, 0xec, 0xe4, 0x91, 0xa0,
0xa8, 0x4e, 0x01, 0x0a, 0x3e, 0x2c, 0x83, 0x82, 0x5b, 0x05, 0x99, 0xb9, 0x58, 0xf0, 0xfe, 0x15,
0x2c, 0x58, 0x2b, 0x88, 0x96, 0x80, 0xc1, 0xbd, 0x5c, 0x96, 0x86, 0x52, 0xdd, 0xca, 0xd3, 0x34,
0xf9, 0xce, 0x55, 0x1c, 0x59, 0x2f, 0x5e, 0x6d, 0x19, 0x90, 0xec, 0x15, 0x80, 0xe4, 0x66, 0xf1,
0x94, 0x05, 0x24, 0x49, 0xf1, 0x60, 0x5b, 0xc6, 0x7d, 0xc1, 0xd3, 0x64, 0x8e, 0x60, 0x51, 0x14,
0x44, 0x3a, 0x61, 0xab, 0x81, 0xb5, 0x25, 0x33, 0x51, 0xea, 0x5f, 0x2f, 0xc1, 0x0e, 0x74, 0xfa,
0x8c, 0x77, 0x59, 0xbf, 0x30, 0x52, 0x59, 0x8c, 0xe8, 0x6c, 0x16, 0x33, 0x75, 0x16, 0xcb, 0x40,
0x4a, 0x25, 0x07, 0x29, 0xe4, 0x9b, 0x70, 0x0d, 0xd3, 0x08, 0xda, 0xc5, 0xc9, 0xa5, 0xb5, 0xb6,
0x24, 0x28, 0x83, 0xa8, 0xfc, 0xf6, 0x2e, 0x5c, 0xcf, 0xf0, 0xca, 0x14, 0x8b, 0x29, 0xac, 0x8a,
0xc1, 0xbb, 0x9a, 0x70, 0x1f, 0x86, 0xe1, 0x11, 0xe5, 0x23, 0xeb, 0x07, 0xa9, 0xfe, 0x29, 0x5c,
0x11, 0xa8, 0x0e, 0x02, 0x57, 0xa9, 0xb5, 0x62, 0xe3, 0xb7, 0x84, 0xb0, 0x71, 0x30, 0xc4, 0x5d,
0x4d, 0x5b, 0x7e, 0x4a, 0xae, 0x24, 0x52, 0x4c, 0x15, 0x12, 0xd6, 0xcf, 0x8d, 0x74, 0xbd, 0x14,
0xc1, 0xca, 0xc0, 0xc6, 0xf8, 0x6f, 0xc0, 0xa6, 0xf2, 0x7a, 0x60, 0x63, 0xfd, 0xda, 0x48, 0x6f,
0x24, 0x81, 0x91, 0x37, 0x53, 0x51, 0x3a, 0x87, 0xe7, 0xbb, 0x6c, 0x86, 0x01, 0xbf, 0x68, 0xab,
0x41, 0x8c, 0xf0, 0x35, 0x34, 0x73, 0x1e, 0xe1, 0xeb, 0x38, 0xa7, 0x06, 0x1a, 0x7e, 0x82, 0x33,
0x8c, 0xc4, 0x65, 0x5b, 0x0d, 0x32, 0xd9, 0xd3, 0xcc, 0x65, 0xcf, 0x13, 0x20, 0x57, 0x63, 0x94,
0x7c, 0x00, 0x55, 0x41, 0x87, 0xd2, 0x84, 0xd2, 0x0a, 0xad, 0x5d, 0x55, 0x2f, 0xef, 0x7e, 0x72,
0x7a, 0x42, 0xbd, 0xa8, 0xb7, 0x26, 0xb5, 0xff, 0xd7, 0x8b, 0xcd, 0x96, 0xe4, 0xd9, 0x09, 0x26,
0x9e, 0x60, 0x93, 0x50, 0x5c, 0xd8, 0x28, 0x63, 0xfd, 0xc9, 0x90, 0xb9, 0x3b, 0x17, 0xbb, 0xa5,
0xb6, 0x88, 0x1d, 0xb4, 0x92, 0x81, 0xd9, 0x57, 0xb3, 0xcf, 0xff, 0x03, 0x0c, 0x29, 0x77, 0x3e,
0xa7, 0xbe, 0x60, 0xae, 0x36, 0x92, 0x39, 0xa4, 0xfc, 0x27, 0x38, 0x21, 0x6b, 0x12, 0x49, 0x9e,
0x72, 0xe6, 0xa2, 0xb5, 0x16, 0xed, 0xfa, 0x90, 0xf2, 0xa7, 0x9c, 0xb9, 0x89, 0x5e, 0xf5, 0x37,
0xd0, 0xeb, 0xcf, 0x19, 0xc7, 0x4b, 0x81, 0xeb, 0x7f, 0x41, 0xb3, 0x7f, 0x1a, 0x12, 0x91, 0xf3,
0xc9, 0x8f, 0x1c, 0xc3, 0xb5, 0xc4, 0xbd, 0x9d, 0x29, 0xba, 0x7d, 0xec, 0x0f, 0x2f, 0x8f, 0x8a,
0xd5, 0xf3, 0xfc, 0x34, 0x27, 0x3f, 0x84, 0xf5, 0x42, 0x70, 0x26, 0x0b, 0x56, 0x5e, 0x1a, 0xa3,
0x37, 0xf3, 0x31, 0x1a, 0xaf, 0x17, 0xeb, 0xba, 0xf8, 0x06, 0xba, 0x7e, 0x5d, 0x96, 0x27, 0xd9,
0x94, 0x5d, 0x76, 0x5b, 0xd6, 0x2f, 0x0d, 0x68, 0x17, 0x0e, 0x43, 0xf6, 0x00, 0x54, 0xc6, 0xe3,
0xde, 0xf3, 0xb8, 0x54, 0x5e, 0xd5, 0x07, 0x47, 0x93, 0x3d, 0xf6, 0x9e, 0x33, 0xdb, 0xec, 0xc7,
0x9f, 0xe4, 0x0e, 0xd4, 0xc5, 0x4c, 0x71, 0xe7, 0x0b, 0xb9, 0x27, 0x33, 0x64, 0xad, 0x09, 0xfc,
0x27, 0x77, 0x61, 0x59, 0x2d, 0x3c, 0x0c, 0x38, 0xf7, 0x42, 0x5d, 0x44, 0x90, 0xec, 0xd2, 0x1f,
0x23, 0xc5, 0x6e, 0xf6, 0xd3, 0x81, 0xf5, 0x53, 0x30, 0x93, 0x6d, 0xc9, 0x5b, 0x60, 0x4e, 0xe8,
0x4c, 0x57, 0xb9, 0xf2, 0x6c, 0x4b, 0x76, 0x63, 0x42, 0x67, 0x58, 0xe0, 0x92, 0x75, 0xa8, 0x4b,
0xa2, 0x98, 0x29, 0x7b, 0x2f, 0xd9, 0xb5, 0x09, 0x9d, 0x3d, 0x99, 0x25, 0x84, 0x21, 0xe5, 0x71,
0x09, 0x3b, 0xa1, 0xb3, 0x8f, 0x29, 0xb7, 0x3e, 0x82, 0x9a, 0x3a, 0xe4, 0x2b, 0x2d, 0x2c, 0xe5,
0x2b, 0x39, 0xf9, 0xef, 0x41, 0x33, 0x73, 0x6e, 0xf2, 0x2d, 0xb8, 0xa9, 0x34, 0x0c, 0x69, 0x24,
0xd0, 0x22, 0xb9, 0x05, 0x09, 0x12, 0x4f, 0x68, 0x24, 0xe4, 0x96, 0xaa, 0x28, 0x7f, 0x0c, 0xad,
0x7c, 0xe1, 0x2a, 0xf3, 0x5a, 0x14, 0x4c, 0x7d, 0x57, 0x0b, 0xa9, 0x81, 0xec, 0x5a, 0xcf, 0x03,
0xe5, 0x49, 0xd9, 0x4a, 0xf5, 0x34, 0x10, 0x2c, 0x53, 0xee, 0x2a, 0x1e, 0xeb, 0x0f, 0x55, 0xa8,
0xa9, 0x2a, 0x9a, 0xdc, 0xc9, 0x34, 0x2e, 0x08, 0x91, 0xbd, 0xe6, 0xe5, 0x8b, 0xcd, 0x3a, 0xa2,
0xc9, 0xf1, 0xc3, 0xb4, 0x8b, 0x49, 0xf3, 0x66, 0x25, 0x57, 0xe4, 0xc7, 0x2d, 0xd3, 0xe2, 0x6b,
0xb7, 0x4c, 0xeb, 0x50, 0xf7, 0xa7, 0x13, 0xbc, 0x8d, 0xaa, 0x5a, 0xd2, 0x9f, 0x4e, 0xe4, 0x6d,
0xbc, 0x05, 0xa6, 0x08, 0x04, 0x1d, 0x23, 0x49, 0xc5, 0x7e, 0x03, 0x27, 0x24, 0xf1, 0x00, 0x56,
0x32, 0xa0, 0xeb, 0xb9, 0xba, 0xa2, 0x6b, 0x65, 0xbd, 0xe4, 0xf8, 0xa1, 0x56, 0xb7, 0x99, 0x80,
0xf0, 0xb1, 0x4b, 0xb6, 0xf2, 0x1d, 0x02, 0x62, 0xb5, 0x02, 0x8c, 0x4c, 0x13, 0x20, 0x91, 0x5a,
0x1e, 0x40, 0x7a, 0xbf, 0x62, 0x51, 0xe8, 0xd1, 0x90, 0x13, 0x48, 0x7c, 0x1b, 0xda, 0x29, 0xdc,
0x29, 0x16, 0x53, 0xad, 0x92, 0x4e, 0x23, 0xe3, 0x7b, 0x70, 0xc3, 0x67, 0x33, 0xe1, 0x14, 0xb9,
0x01, 0xb9, 0x89, 0xa4, 0x9d, 0xe6, 0x25, 0xbe, 0x01, 0xad, 0x34, 0x3f, 0x20, 0x6f, 0x53, 0xf5,
0x69, 0xc9, 0x2c, 0xb2, 0xdd, 0x82, 0x46, 0x52, 0x6c, 0x2c, 0x23, 0x43, 0x9d, 0xaa, 0x1a, 0x23,
0x29, 0x5f, 0x22, 0xc6, 0xa7, 0x63, 0xa1, 0x17, 0x59, 0x41, 0x1e, 0x2c, 0x5f, 0x6c, 0x35, 0x8f,
0xbc, 0x5f, 0x83, 0x15, 0xa6, 0xfb, 0x18, 0xc5, 0xd7, 0x42, 0xbe, 0xe5, 0x78, 0x12, 0x99, 0xb6,
0x61, 0x35, 0x8c, 0x82, 0x30, 0xe0, 0x2c, 0x72, 0xa8, 0xeb, 0x46, 0x8c, 0xf3, 0x4e, 0x5b, 0xad,
0x17, 0xcf, 0x1f, 0xaa, 0x69, 0xeb, 0x67, 0x50, 0xd7, 0xd6, 0x2f, 0xed, 0xe6, 0xbe, 0x0b, 0xcb,
0xd2, 0xeb, 0xb9, 0x93, 0xeb, 0xe9, 0xe2, 0x9a, 0x1a, 0x9d, 0x9e, 0x89, 0x5c, 0x6b, 0xd7, 0x44,
0x7e, 0x35, 0x65, 0xdd, 0x83, 0x95, 0x1c, 0x8f, 0x0c, 0x03, 0x74, 0x8a, 0x38, 0x0c, 0x70, 0x90,
0xec, 0x5c, 0x49, 0x77, 0xb6, 0xee, 0x83, 0x99, 0x18, 0x5a, 0x96, 0x7e, 0xb1, 0x1e, 0x86, 0xb6,
0x9d, 0x1a, 0x62, 0xbd, 0x10, 0x7c, 0xce, 0x22, 0x9d, 0x02, 0xd4, 0xc0, 0x7a, 0x0a, 0xed, 0x42,
0x7a, 0x27, 0x3b, 0x50, 0x0f, 0xa7, 0x7d, 0x27, 0x7e, 0x66, 0x48, 0xf3, 0xd9, 0xc9, 0xb4, 0xff,
0x09, 0xbb, 0x88, 0x1b, 0xd3, 0x10, 0x47, 0xe9, 0xb2, 0x95, 0xec, 0xb2, 0x63, 0x68, 0xc4, 0xa1,
0x49, 0xbe, 0x0d, 0x66, 0xe2, 0x23, 0x85, 0x7c, 0x9a, 0x6c, 0xad, 0x17, 0x4d, 0x19, 0xe5, 0x55,
0x73, 0x6f, 0xe8, 0x33, 0xd7, 0x49, 0xe3, 0x01, 0xf7, 0x68, 0xd8, 0x6d, 0x45, 0xf8, 0x34, 0x76,
0x7e, 0xeb, 0x3d, 0xa8, 0xa9, 0xb3, 0x49, 0xfb, 0xc8, 0x95, 0xe3, 0x6a, 0x58, 0x7e, 0x97, 0x26,
0xfe, 0x3f, 0x1a, 0xd0, 0x88, 0xbb, 0xdc, 0x52, 0xa1, 0xdc, 0xa1, 0x2b, 0xaf, 0x7a, 0xe8, 0x79,
0x4f, 0x05, 0x71, 0x16, 0xa9, 0xbe, 0x76, 0x16, 0xd9, 0x01, 0xa2, 0x92, 0xc5, 0x79, 0x20, 0x3c,
0x7f, 0xe8, 0x28, 0x5b, 0xab, 0xac, 0xb1, 0x8a, 0x94, 0x53, 0x24, 0x9c, 0xc8, 0xf9, 0xfd, 0x2f,
0x96, 0xa0, 0x7d, 0xd8, 0x7b, 0x70, 0x7c, 0x18, 0x86, 0x63, 0x6f, 0x40, 0xb1, 0x04, 0xdf, 0x83,
0x2a, 0x36, 0x19, 0x25, 0xcf, 0x9b, 0xdd, 0xb2, 0x6e, 0x97, 0xec, 0xc3, 0x12, 0xf6, 0x1a, 0xa4,
0xec, 0x95, 0xb3, 0x5b, 0xda, 0xf4, 0xca, 0x4d, 0x54, 0x37, 0x72, 0xf5, 0xb1, 0xb3, 0x5b, 0xd6,
0xf9, 0x92, 0x8f, 0xc0, 0x4c, 0xbb, 0x84, 0x79, 0x4f, 0x9e, 0xdd, 0xb9, 0x3d, 0xb0, 0x94, 0x4f,
0x8b, 0xb3, 0x79, 0x2f, 0x77, 0xdd, 0xb9, 0xcd, 0x22, 0x39, 0x80, 0x7a, 0x5c, 0xb4, 0x96, 0x3f,
0x4a, 0x76, 0xe7, 0xf4, 0xa7, 0xd2, 0x3c, 0xaa, 0xf0, 0x2f, 0x7b, 0x39, 0xed, 0x96, 0x36, 0xd1,
0xe4, 0x2e, 0xd4, 0x74, 0x15, 0x52, 0xfa, 0x30, 0xd9, 0x2d, 0xef, 0x32, 0xa5, 0x92, 0x69, 0xeb,
0x33, 0xef, 0x75, 0xb7, 0x3b, 0xb7, 0xdb, 0x27, 0x87, 0x00, 0x99, 0x62, 0x7f, 0xee, 0xb3, 0x6d,
0x77, 0x7e, 0x17, 0x4f, 0xee, 0x43, 0x23, 0x7d, 0x99, 0x29, 0x7f, 0x88, 0xed, 0xce, 0x6b, 0xac,
0x7b, 0xff, 0xf7, 0xef, 0xbf, 0x6d, 0x18, 0xbf, 0xba, 0xdc, 0x30, 0x7e, 0x73, 0xb9, 0x61, 0x7c,
0x75, 0xb9, 0x61, 0xfc, 0xfe, 0x72, 0xc3, 0xf8, 0xeb, 0xe5, 0x86, 0xf1, 0xdb, 0xbf, 0x6f, 0x18,
0xfd, 0x1a, 0xba, 0xff, 0xfb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x32, 0xa1, 0x6a, 0x3b,
golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_c68d3007ea320b94)
}
var fileDescriptor_types_c68d3007ea320b94 = []byte{
// 2099 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4f, 0x73, 0x1b, 0x49,
0x15, 0xf7, 0x48, 0xb2, 0xfe, 0x3c, 0xd9, 0x92, 0xd3, 0x76, 0x6c, 0x45, 0x80, 0x9d, 0x1a, 0x20,
0x6b, 0xb3, 0x5e, 0x7b, 0xf1, 0x12, 0xca, 0xd9, 0x2c, 0x5b, 0x58, 0x49, 0x58, 0xbb, 0x76, 0x01,
0x33, 0x49, 0xcc, 0x85, 0xaa, 0xa9, 0x96, 0xa6, 0x2d, 0x4d, 0x45, 0x9a, 0x99, 0x9d, 0x6e, 0x79,
0xe5, 0x7c, 0x86, 0x3d, 0xec, 0x81, 0x2a, 0xce, 0xdc, 0xf8, 0x02, 0x54, 0x71, 0xe4, 0x44, 0xed,
0x91, 0xa2, 0xa0, 0xb8, 0x05, 0x30, 0xc5, 0x01, 0x3e, 0x01, 0x47, 0xaa, 0x5f, 0xf7, 0xfc, 0xf5,
0x28, 0x95, 0x84, 0xdb, 0x5e, 0xa4, 0xee, 0x7e, 0xef, 0x75, 0xf7, 0x7b, 0xf3, 0xde, 0xfb, 0xbd,
0xd7, 0xb0, 0x4e, 0xfb, 0x03, 0x77, 0x5f, 0x5c, 0x06, 0x8c, 0xab, 0xdf, 0xbd, 0x20, 0xf4, 0x85,
0x4f, 0x16, 0x71, 0xd2, 0x7d, 0x67, 0xe8, 0x8a, 0xd1, 0xb4, 0xbf, 0x37, 0xf0, 0x27, 0xfb, 0x43,
0x7f, 0xe8, 0xef, 0x23, 0xb5, 0x3f, 0x3d, 0xc7, 0x19, 0x4e, 0x70, 0xa4, 0xa4, 0xba, 0x5b, 0x43,
0xdf, 0x1f, 0x8e, 0x59, 0xc2, 0x25, 0xdc, 0x09, 0xe3, 0x82, 0x4e, 0x02, 0xcd, 0x70, 0x98, 0xda,
0x4f, 0x30, 0xcf, 0x61, 0xe1, 0xc4, 0xf5, 0x44, 0x7a, 0x38, 0x76, 0xfb, 0x7c, 0x7f, 0xe0, 0x4f,
0x26, 0xbe, 0x97, 0xbe, 0x90, 0xf9, 0x87, 0x0a, 0xd4, 0x2c, 0xf6, 0xe9, 0x94, 0x71, 0x41, 0xb6,
0xa1, 0xc2, 0x06, 0x23, 0xbf, 0x53, 0xba, 0x6d, 0x6c, 0x37, 0x0f, 0xc8, 0x9e, 0xe2, 0xd3, 0xd4,
0x47, 0x83, 0x91, 0x7f, 0xbc, 0x60, 0x21, 0x07, 0x79, 0x1b, 0x16, 0xcf, 0xc7, 0x53, 0x3e, 0xea,
0x94, 0x91, 0x75, 0x35, 0xcb, 0xfa, 0x23, 0x49, 0x3a, 0x5e, 0xb0, 0x14, 0x8f, 0xdc, 0xd6, 0xf5,
0xce, 0xfd, 0x4e, 0xa5, 0x68, 0xdb, 0x13, 0xef, 0x1c, 0xb7, 0x95, 0x1c, 0xe4, 0x10, 0x80, 0x33,
0x61, 0xfb, 0x81, 0x70, 0x7d, 0xaf, 0xb3, 0x88, 0xfc, 0x1b, 0x59, 0xfe, 0xc7, 0x4c, 0xfc, 0x14,
0xc9, 0xc7, 0x0b, 0x56, 0x83, 0x47, 0x13, 0x29, 0xe9, 0x7a, 0xae, 0xb0, 0x07, 0x23, 0xea, 0x7a,
0x9d, 0x6a, 0x91, 0xe4, 0x89, 0xe7, 0x8a, 0x07, 0x92, 0x2c, 0x25, 0xdd, 0x68, 0x22, 0x55, 0xf9,
0x74, 0xca, 0xc2, 0xcb, 0x4e, 0xad, 0x48, 0x95, 0x9f, 0x49, 0x92, 0x54, 0x05, 0x79, 0xc8, 0x7d,
0x68, 0xf6, 0xd9, 0xd0, 0xf5, 0xec, 0xfe, 0xd8, 0x1f, 0x3c, 0xeb, 0xd4, 0x51, 0xa4, 0x93, 0x15,
0xe9, 0x49, 0x86, 0x9e, 0xa4, 0x1f, 0x2f, 0x58, 0xd0, 0x8f, 0x67, 0xe4, 0x00, 0xea, 0x83, 0x11,
0x1b, 0x3c, 0xb3, 0xc5, 0xac, 0xd3, 0x40, 0xc9, 0x9b, 0x59, 0xc9, 0x07, 0x92, 0xfa, 0x64, 0x76,
0xbc, 0x60, 0xd5, 0x06, 0x6a, 0x48, 0xee, 0x42, 0x83, 0x79, 0x8e, 0x3e, 0xae, 0x89, 0x42, 0xeb,
0xb9, 0xef, 0xe2, 0x39, 0xd1, 0x61, 0x75, 0xa6, 0xc7, 0x64, 0x0f, 0xaa, 0xf2, 0x5b, 0xbb, 0xa2,
0xb3, 0x84, 0x32, 0x6b, 0xb9, 0x83, 0x90, 0x76, 0xbc, 0x60, 0x69, 0x2e, 0x69, 0x3e, 0x87, 0x8d,
0xdd, 0x0b, 0x16, 0xca, 0xcb, 0xad, 0x16, 0x99, 0xef, 0xa1, 0xa2, 0xe3, 0xf5, 0x1a, 0x4e, 0x34,
0xe9, 0xd5, 0x60, 0xf1, 0x82, 0x8e, 0xa7, 0xcc, 0x7c, 0x0b, 0x9a, 0x29, 0x4f, 0x21, 0x1d, 0xa8,
0x4d, 0x18, 0xe7, 0x74, 0xc8, 0x3a, 0xc6, 0x6d, 0x63, 0xbb, 0x61, 0x45, 0x53, 0xb3, 0x05, 0x4b,
0x69, 0x3f, 0x49, 0x09, 0x4a, 0x5f, 0x90, 0x82, 0x17, 0x2c, 0xe4, 0xd2, 0x01, 0xb4, 0xa0, 0x9e,
0x9a, 0xef, 0xc3, 0x4a, 0xde, 0x09, 0xc8, 0x0a, 0x94, 0x9f, 0xb1, 0x4b, 0xcd, 0x29, 0x87, 0x64,
0x4d, 0x5f, 0x08, 0xbd, 0xb8, 0x61, 0xe9, 0xdb, 0x7d, 0x51, 0x8a, 0x85, 0x63, 0x3f, 0x20, 0x87,
0x50, 0x91, 0x81, 0x84, 0xd2, 0xcd, 0x83, 0xee, 0x9e, 0x8a, 0xb2, 0xbd, 0x28, 0xca, 0xf6, 0x9e,
0x44, 0x51, 0xd6, 0xab, 0x7f, 0xf9, 0x62, 0x6b, 0xe1, 0x8b, 0xbf, 0x6d, 0x19, 0x16, 0x4a, 0x90,
0x5b, 0xf2, 0x53, 0x52, 0xd7, 0xb3, 0x5d, 0x47, 0x9f, 0x53, 0xc3, 0xf9, 0x89, 0x43, 0x8e, 0x60,
0x65, 0xe0, 0x7b, 0x9c, 0x79, 0x7c, 0xca, 0xed, 0x80, 0x86, 0x74, 0xc2, 0x75, 0x94, 0x44, 0x1f,
0xee, 0x41, 0x44, 0x3e, 0x45, 0xaa, 0xd5, 0x1e, 0x64, 0x17, 0xc8, 0x07, 0x00, 0x17, 0x74, 0xec,
0x3a, 0x54, 0xf8, 0x21, 0xef, 0x54, 0x6e, 0x97, 0x53, 0xc2, 0x67, 0x11, 0xe1, 0x69, 0xe0, 0x50,
0xc1, 0x7a, 0x15, 0x79, 0x33, 0x2b, 0xc5, 0x4f, 0xee, 0x40, 0x9b, 0x06, 0x81, 0xcd, 0x05, 0x15,
0xcc, 0xee, 0x5f, 0x0a, 0xc6, 0x31, 0x92, 0x96, 0xac, 0x65, 0x1a, 0x04, 0x8f, 0xe5, 0x6a, 0x4f,
0x2e, 0x9a, 0x4e, 0xfc, 0x1d, 0xd0, 0xc9, 0x09, 0x81, 0x8a, 0x43, 0x05, 0x45, 0x6b, 0x2c, 0x59,
0x38, 0x96, 0x6b, 0x01, 0x15, 0x23, 0xad, 0x23, 0x8e, 0xc9, 0x3a, 0x54, 0x47, 0xcc, 0x1d, 0x8e,
0x04, 0xaa, 0x55, 0xb6, 0xf4, 0x4c, 0x1a, 0x3e, 0x08, 0xfd, 0x0b, 0x86, 0x71, 0x5e, 0xb7, 0xd4,
0xc4, 0xfc, 0x97, 0x01, 0x37, 0xae, 0x05, 0x86, 0xdc, 0x77, 0x44, 0xf9, 0x28, 0x3a, 0x4b, 0x8e,
0xc9, 0xdb, 0x72, 0x5f, 0xea, 0xb0, 0x50, 0xe7, 0x9f, 0x65, 0xad, 0xf1, 0x31, 0x2e, 0x6a, 0x45,
0x35, 0x0b, 0x79, 0x04, 0x2b, 0x63, 0xca, 0x85, 0xad, 0xfc, 0xd7, 0xc6, 0xfc, 0x52, 0xce, 0xc4,
0xd4, 0x27, 0x34, 0xf2, 0x73, 0xe9, 0x56, 0x5a, 0xbc, 0x35, 0xce, 0xac, 0x92, 0x63, 0x58, 0xeb,
0x5f, 0x3e, 0xa7, 0x9e, 0x70, 0x3d, 0x66, 0x5f, 0xb3, 0x79, 0x5b, 0x6f, 0xf5, 0xe8, 0xc2, 0x75,
0x98, 0x37, 0x88, 0x8c, 0xbd, 0x1a, 0x8b, 0xc4, 0x1f, 0x83, 0x9b, 0xb7, 0xa1, 0x95, 0x8d, 0x62,
0xd2, 0x82, 0x92, 0x98, 0x69, 0x0d, 0x4b, 0x62, 0x66, 0x9a, 0xb1, 0x07, 0xc6, 0xa1, 0x74, 0x8d,
0x67, 0x07, 0xda, 0xb9, 0xb0, 0x4e, 0x99, 0xdb, 0x48, 0x9b, 0xdb, 0x6c, 0xc3, 0x72, 0x26, 0x9a,
0xcd, 0xcf, 0x17, 0xa1, 0x6e, 0x31, 0x1e, 0x48, 0x67, 0x22, 0x87, 0xd0, 0x60, 0xb3, 0x01, 0x53,
0x89, 0xd4, 0xc8, 0xa5, 0x29, 0xc5, 0xf3, 0x28, 0xa2, 0xcb, 0x80, 0x8e, 0x99, 0xc9, 0x4e, 0x06,
0x04, 0x56, 0xf3, 0x42, 0x69, 0x14, 0xd8, 0xcd, 0xa2, 0xc0, 0x5a, 0x8e, 0x37, 0x07, 0x03, 0x3b,
0x19, 0x18, 0xc8, 0x6f, 0x9c, 0xc1, 0x81, 0x7b, 0x05, 0x38, 0x90, 0xbf, 0xfe, 0x1c, 0x20, 0xb8,
0x57, 0x00, 0x04, 0x9d, 0x6b, 0x67, 0x15, 0x22, 0xc1, 0x6e, 0x16, 0x09, 0xf2, 0xea, 0xe4, 0xa0,
0xe0, 0x83, 0x22, 0x28, 0xb8, 0x95, 0x93, 0x99, 0x8b, 0x05, 0xef, 0x5d, 0xc3, 0x82, 0xf5, 0x9c,
0x68, 0x01, 0x18, 0xdc, 0xcb, 0x64, 0x69, 0x28, 0xd4, 0xad, 0x38, 0x4d, 0x93, 0xef, 0x5f, 0xc7,
0x91, 0x8d, 0xfc, 0xa7, 0x2d, 0x02, 0x92, 0xfd, 0x1c, 0x90, 0xdc, 0xcc, 0xdf, 0x32, 0x87, 0x24,
0x09, 0x1e, 0xec, 0xc8, 0xb8, 0xcf, 0x79, 0x9a, 0xcc, 0x11, 0x2c, 0x0c, 0xfd, 0x50, 0x27, 0x6c,
0x35, 0x31, 0xb7, 0x65, 0x26, 0x4a, 0xfc, 0xeb, 0x25, 0xd8, 0x81, 0x4e, 0x9f, 0xf2, 0x2e, 0xf3,
0x57, 0x46, 0x22, 0x8b, 0x11, 0x9d, 0xce, 0x62, 0x0d, 0x9d, 0xc5, 0x52, 0x90, 0x52, 0xca, 0x40,
0x0a, 0xf9, 0x0e, 0xdc, 0xc0, 0x34, 0x82, 0x76, 0xb1, 0x33, 0x69, 0xad, 0x2d, 0x09, 0xca, 0x20,
0x2a, 0xbf, 0xbd, 0x03, 0xab, 0x29, 0x5e, 0x99, 0x62, 0x31, 0x85, 0x55, 0x30, 0x78, 0x57, 0x62,
0xee, 0xa3, 0x20, 0x38, 0xa6, 0x7c, 0x64, 0xfe, 0x38, 0xd1, 0x3f, 0x81, 0x2b, 0x02, 0x95, 0x81,
0xef, 0x28, 0xb5, 0x96, 0x2d, 0x1c, 0x4b, 0x08, 0x1b, 0xfb, 0x43, 0x3c, 0xb5, 0x61, 0xc9, 0xa1,
0xe4, 0x8a, 0x23, 0xa5, 0xa1, 0x42, 0xc2, 0xfc, 0xa5, 0x91, 0xec, 0x97, 0x20, 0x58, 0x11, 0xd8,
0x18, 0xff, 0x0f, 0xd8, 0x94, 0x5e, 0x0f, 0x6c, 0xcc, 0xdf, 0x1a, 0xc9, 0x17, 0x89, 0x61, 0xe4,
0xcd, 0x54, 0x94, 0xce, 0xe1, 0x7a, 0x0e, 0x9b, 0x61, 0xc0, 0x97, 0x2d, 0x35, 0x89, 0x10, 0xbe,
0x8a, 0x66, 0xce, 0x22, 0x7c, 0x0d, 0xd7, 0xd4, 0x44, 0xc3, 0x8f, 0x7f, 0x8e, 0x91, 0xb8, 0x64,
0xa9, 0x49, 0x2a, 0x7b, 0x36, 0x32, 0xd9, 0xf3, 0x14, 0xc8, 0xf5, 0x18, 0x25, 0xef, 0x43, 0x45,
0xd0, 0xa1, 0x34, 0xa1, 0xb4, 0x42, 0x6b, 0x4f, 0xd5, 0xcb, 0x7b, 0x1f, 0x9f, 0x9d, 0x52, 0x37,
0xec, 0xad, 0x4b, 0xed, 0xff, 0xf3, 0x62, 0xab, 0x25, 0x79, 0x76, 0xfd, 0x89, 0x2b, 0xd8, 0x24,
0x10, 0x97, 0x16, 0xca, 0x98, 0x7f, 0x31, 0x64, 0xee, 0xce, 0xc4, 0x6e, 0xa1, 0x2d, 0x22, 0x07,
0x2d, 0xa5, 0x60, 0xf6, 0xd5, 0xec, 0xf3, 0x0d, 0x80, 0x21, 0xe5, 0xf6, 0x67, 0xd4, 0x13, 0xcc,
0xd1, 0x46, 0x6a, 0x0c, 0x29, 0xff, 0x39, 0x2e, 0xc8, 0x9a, 0x44, 0x92, 0xa7, 0x9c, 0x39, 0x68,
0xad, 0xb2, 0x55, 0x1b, 0x52, 0xfe, 0x94, 0x33, 0x27, 0xd6, 0xab, 0xf6, 0x06, 0x7a, 0xfd, 0x35,
0xe5, 0x78, 0x09, 0x70, 0x7d, 0x15, 0x34, 0xfb, 0xb7, 0x21, 0x11, 0x39, 0x9b, 0xfc, 0xc8, 0x09,
0xdc, 0x88, 0xdd, 0xdb, 0x9e, 0xa2, 0xdb, 0x47, 0xfe, 0xf0, 0xf2, 0xa8, 0x58, 0xb9, 0xc8, 0x2e,
0x73, 0xf2, 0x13, 0xd8, 0xc8, 0x05, 0x67, 0xbc, 0x61, 0xe9, 0xa5, 0x31, 0x7a, 0x33, 0x1b, 0xa3,
0xd1, 0x7e, 0x91, 0xae, 0xe5, 0x37, 0xd0, 0xf5, 0x5b, 0xb2, 0x3c, 0x49, 0xa7, 0xec, 0xa2, 0xaf,
0x65, 0xfe, 0xda, 0x80, 0x76, 0xee, 0x32, 0x64, 0x1f, 0x40, 0x65, 0x3c, 0xee, 0x3e, 0x8f, 0x4a,
0xe5, 0x15, 0x7d, 0x71, 0x34, 0xd9, 0x63, 0xf7, 0x39, 0xb3, 0x1a, 0xfd, 0x68, 0x48, 0xee, 0x40,
0x4d, 0xcc, 0x14, 0x77, 0xb6, 0x90, 0x7b, 0x32, 0x43, 0xd6, 0xaa, 0xc0, 0x7f, 0x72, 0x17, 0x96,
0xd4, 0xc6, 0x43, 0x9f, 0x73, 0x37, 0xd0, 0x45, 0x04, 0x49, 0x6f, 0xfd, 0x11, 0x52, 0xac, 0x66,
0x3f, 0x99, 0x98, 0x47, 0xd0, 0x88, 0x8f, 0x25, 0x5f, 0x83, 0xc6, 0x84, 0xce, 0x74, 0x95, 0x2b,
0xef, 0xb6, 0x68, 0xd5, 0x27, 0x74, 0x86, 0x05, 0x2e, 0xd9, 0x80, 0x9a, 0x24, 0x0e, 0xa9, 0xb2,
0x77, 0xd9, 0xaa, 0x4e, 0xe8, 0xec, 0x23, 0xca, 0xcd, 0x0f, 0xa1, 0xaa, 0xee, 0xf2, 0x86, 0xf2,
0x3f, 0x84, 0x66, 0xea, 0x7a, 0xe4, 0xbb, 0x70, 0x53, 0x29, 0x12, 0xd0, 0x50, 0xa0, 0xe2, 0x99,
0x0d, 0x09, 0x12, 0x4f, 0x69, 0x28, 0xe4, 0x91, 0xaa, 0xf6, 0x7e, 0x0c, 0xad, 0x6c, 0x7d, 0x2a,
0xd3, 0x57, 0xe8, 0x4f, 0x3d, 0x47, 0x0b, 0xa9, 0x89, 0x6c, 0x4e, 0x2f, 0x7c, 0xe5, 0x30, 0xe9,
0x82, 0xf4, 0xcc, 0x17, 0x2c, 0x55, 0xd5, 0x2a, 0x1e, 0xf3, 0x4f, 0x15, 0xa8, 0xaa, 0x62, 0x99,
0xdc, 0x49, 0xf5, 0x27, 0x88, 0x84, 0xbd, 0xe6, 0xd5, 0x8b, 0xad, 0x1a, 0x82, 0xc6, 0xc9, 0xc3,
0xa4, 0x59, 0x49, 0xd2, 0x63, 0x29, 0x53, 0xcb, 0x47, 0x9d, 0x51, 0xf9, 0xb5, 0x3b, 0xa3, 0x0d,
0xa8, 0x79, 0xd3, 0x89, 0x2d, 0x66, 0x1c, 0x23, 0xbc, 0x6c, 0x55, 0xbd, 0xe9, 0xe4, 0xc9, 0x8c,
0x4b, 0x53, 0x0b, 0x5f, 0xd0, 0x31, 0x92, 0x54, 0x88, 0xd7, 0x71, 0x41, 0x12, 0x0f, 0x61, 0x39,
0x85, 0xad, 0xae, 0xa3, 0x0b, 0xb7, 0x56, 0xda, 0x19, 0x4e, 0x1e, 0x6a, 0x75, 0x9b, 0x31, 0xd6,
0x9e, 0x38, 0x64, 0x3b, 0xdb, 0x08, 0x20, 0x24, 0x2b, 0x5c, 0x48, 0xd5, 0xfa, 0x12, 0x90, 0xe5,
0x05, 0xa4, 0x93, 0x2b, 0x16, 0x05, 0x12, 0x75, 0xb9, 0x80, 0xc4, 0xb7, 0xa0, 0x9d, 0xa0, 0x9a,
0x62, 0x69, 0xa8, 0x5d, 0x92, 0x65, 0x64, 0x7c, 0x17, 0xd6, 0x3c, 0x36, 0x13, 0x76, 0x9e, 0x1b,
0x90, 0x9b, 0x48, 0xda, 0x59, 0x56, 0xe2, 0xdb, 0xd0, 0x4a, 0xd2, 0x00, 0xf2, 0x36, 0x55, 0x3b,
0x16, 0xaf, 0x22, 0xdb, 0x2d, 0xa8, 0xc7, 0x35, 0xc5, 0x12, 0x32, 0xd4, 0xa8, 0x2a, 0x25, 0xe2,
0x2a, 0x25, 0x64, 0x7c, 0x3a, 0x16, 0x7a, 0x93, 0x65, 0xe4, 0xc1, 0x2a, 0xc5, 0x52, 0xeb, 0xc8,
0xfb, 0x4d, 0x58, 0x66, 0xba, 0x5d, 0x51, 0x7c, 0x2d, 0xe4, 0x5b, 0x8a, 0x16, 0x91, 0x69, 0x07,
0x56, 0x82, 0xd0, 0x0f, 0x7c, 0xce, 0x42, 0x9b, 0x3a, 0x4e, 0xc8, 0x38, 0xef, 0xb4, 0xd5, 0x7e,
0xd1, 0xfa, 0x91, 0x5a, 0x36, 0x7f, 0x01, 0x35, 0x6d, 0xfd, 0xc2, 0xa6, 0xed, 0x07, 0xb0, 0x24,
0xbd, 0x9e, 0xdb, 0x99, 0xd6, 0x2d, 0x2a, 0x9d, 0xd1, 0xe9, 0x99, 0xc8, 0x74, 0x70, 0x4d, 0xe4,
0x57, 0x4b, 0xe6, 0x3d, 0x58, 0xce, 0xf0, 0xc8, 0x30, 0x40, 0xa7, 0x88, 0xc2, 0x00, 0x27, 0xf1,
0xc9, 0xa5, 0xe4, 0x64, 0xf3, 0x3e, 0x34, 0x62, 0x43, 0xcb, 0x0a, 0x2f, 0xd2, 0xc3, 0xd0, 0xb6,
0x53, 0x53, 0x2c, 0x0b, 0xfc, 0xcf, 0x58, 0xa8, 0xab, 0x3a, 0x35, 0x31, 0x9f, 0x42, 0x3b, 0x97,
0xc5, 0xc9, 0x2e, 0xd4, 0x82, 0x69, 0xdf, 0x8e, 0x5e, 0x13, 0x92, 0xb4, 0x75, 0x3a, 0xed, 0x7f,
0xcc, 0x2e, 0xa3, 0xfe, 0x33, 0xc0, 0x59, 0xb2, 0x6d, 0x29, 0xbd, 0xed, 0x18, 0xea, 0x51, 0x68,
0x92, 0xef, 0x41, 0x23, 0xf6, 0x91, 0x5c, 0xda, 0x8c, 0x8f, 0xd6, 0x9b, 0x26, 0x8c, 0xf2, 0x53,
0x73, 0x77, 0xe8, 0x31, 0xc7, 0x4e, 0xe2, 0x01, 0xcf, 0xa8, 0x5b, 0x6d, 0x45, 0xf8, 0x24, 0x72,
0x7e, 0xf3, 0x5d, 0xa8, 0xaa, 0xbb, 0x49, 0xfb, 0xc8, 0x9d, 0xa3, 0xa2, 0x57, 0x8e, 0x0b, 0xf3,
0xfb, 0x9f, 0x0d, 0xa8, 0x47, 0xcd, 0x6c, 0xa1, 0x50, 0xe6, 0xd2, 0xa5, 0x57, 0xbd, 0xf4, 0xbc,
0x17, 0x81, 0x28, 0x8b, 0x54, 0x5e, 0x3b, 0x8b, 0xec, 0x02, 0x51, 0xc9, 0xe2, 0xc2, 0x17, 0xae,
0x37, 0xb4, 0x95, 0xad, 0x55, 0xd6, 0x58, 0x41, 0xca, 0x19, 0x12, 0x4e, 0xe5, 0xfa, 0xc1, 0xe7,
0x8b, 0xd0, 0x3e, 0xea, 0x3d, 0x38, 0x39, 0x0a, 0x82, 0xb1, 0x3b, 0xa0, 0x58, 0x69, 0xef, 0x43,
0x05, 0x7b, 0x89, 0x82, 0x57, 0xcc, 0x6e, 0x51, 0x53, 0x4b, 0x0e, 0x60, 0x11, 0x5b, 0x0a, 0x52,
0xf4, 0x98, 0xd9, 0x2d, 0xec, 0x6d, 0xe5, 0x21, 0xaa, 0xe9, 0xb8, 0xfe, 0xa6, 0xd9, 0x2d, 0x6a,
0x70, 0xc9, 0x87, 0xd0, 0x48, 0x9a, 0x81, 0x79, 0x2f, 0x9b, 0xdd, 0xb9, 0xad, 0xae, 0x94, 0x4f,
0x6a, 0xb0, 0x79, 0x0f, 0x74, 0xdd, 0xb9, 0x3d, 0x21, 0x39, 0x84, 0x5a, 0x54, 0x9b, 0x16, 0xbf,
0x3d, 0x76, 0xe7, 0xb4, 0xa1, 0xd2, 0x3c, 0xaa, 0xbe, 0x2f, 0x7a, 0x20, 0xed, 0x16, 0xf6, 0xca,
0xe4, 0x2e, 0x54, 0x75, 0xb1, 0x51, 0xf8, 0xfe, 0xd8, 0x2d, 0x6e, 0x26, 0xa5, 0x92, 0x49, 0x87,
0x33, 0xef, 0x11, 0xb7, 0x3b, 0xb7, 0xa9, 0x27, 0x47, 0x00, 0xa9, 0x9a, 0x7e, 0xee, 0xeb, 0x6c,
0x77, 0x7e, 0xb3, 0x4e, 0xee, 0x43, 0x3d, 0x79, 0x80, 0x29, 0x7e, 0x6f, 0xed, 0xce, 0xeb, 0x9f,
0x7b, 0x5f, 0xff, 0xef, 0x3f, 0x36, 0x8d, 0xdf, 0x5c, 0x6d, 0x1a, 0xbf, 0xbb, 0xda, 0x34, 0xbe,
0xbc, 0xda, 0x34, 0xfe, 0x78, 0xb5, 0x69, 0xfc, 0xfd, 0x6a, 0xd3, 0xf8, 0xfd, 0x3f, 0x37, 0x8d,
0x7e, 0x15, 0xdd, 0xff, 0xbd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x48, 0x26, 0x13, 0xca, 0x22,
0x18, 0x00, 0x00, 0x18, 0x00, 0x00,
} }

+ 1
- 2
abci/types/types.proto View File

@ -207,8 +207,7 @@ message ConsensusParams {
// BlockSize contains limits on the block size. // BlockSize contains limits on the block size.
message BlockSize { message BlockSize {
int32 max_bytes = 1; int32 max_bytes = 1;
int32 max_txs = 2;
int64 max_gas = 3;
int64 max_gas = 2;
} }
// TxSize contains limits on the tx size. // TxSize contains limits on the tx size.


+ 0
- 31
abci/types/types_test.go View File

@ -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)
}

+ 1
- 1
consensus/mempool_test.go View File

@ -148,7 +148,7 @@ func TestMempoolRmBadTx(t *testing.T) {
// check for the tx // check for the tx
for { for {
txs := cs.mempool.Reap(1)
txs := cs.mempool.ReapMaxBytes(len(txBytes))
if len(txs) == 0 { if len(txs) == 0 {
emptyMempoolCh <- struct{}{} emptyMempoolCh <- struct{}{}
return return


+ 3
- 2
consensus/reactor_test.go View File

@ -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 { if m.height > 0 {
return m.ev return m.ev
} }
@ -207,7 +208,7 @@ func (m *mockEvidencePool) Update(block *types.Block, state sm.State) {
panic("block has no evidence") panic("block has no evidence")
} }
} }
m.height += 1
m.height++
} }
//------------------------------------ //------------------------------------


+ 19
- 3
consensus/state.go View File

@ -153,6 +153,7 @@ func NewConsensusState(
cs.setProposal = cs.defaultSetProposal cs.setProposal = cs.defaultSetProposal
cs.updateToState(state) cs.updateToState(state)
// Don't call scheduleRound0 yet. // Don't call scheduleRound0 yet.
// We do that upon Start(). // We do that upon Start().
cs.reconstructLastCommit(state) cs.reconstructLastCommit(state)
@ -946,14 +947,25 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
return return
} }
maxBytes := cs.state.ConsensusParams.BlockSize.MaxBytes
// bound evidence to 1/10th of the block
evidence := cs.evpool.PendingEvidence(maxBytes / 10)
// Mempool validated transactions // 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() proposerAddr := cs.privValidator.GetAddress()
block, parts := cs.state.MakeBlock(cs.Height, txs, commit, evidence, proposerAddr) block, parts := cs.state.MakeBlock(cs.Height, txs, commit, evidence, proposerAddr)
return block, parts 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: `timeoutPropose` after entering Propose.
// Enter: proposal block and POL is ready. // Enter: proposal block and POL is ready.
// Enter: any +2/3 prevotes for future round. // 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() { if added && cs.ProposalBlockParts.IsComplete() {
// Added and completed! // 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 { if err != nil {
return true, err return true, err
} }


+ 72
- 0
docs/architecture/adr-020-block-size.md View 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

+ 4
- 3
evidence/pool.go View File

@ -57,9 +57,10 @@ func (evpool *EvidencePool) PriorityEvidence() []types.Evidence {
return evpool.evidenceStore.PriorityEvidence() 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. // State returns the current state of the evpool.


+ 2
- 2
evidence/reactor_test.go View File

@ -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) { func _waitForEvidence(t *testing.T, wg *sync.WaitGroup, evs types.EvidenceList, reactorIdx int, reactors []*EvidenceReactor) {
evpool := reactors[reactorIdx].evpool evpool := reactors[reactorIdx].evpool
for len(evpool.PendingEvidence()) != len(evs) {
for len(evpool.PendingEvidence(-1)) != len(evs) {
time.Sleep(time.Millisecond * 100) 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 // put the reaped evidence in a map so we can quickly check we got everything
evMap := make(map[string]types.Evidence) evMap := make(map[string]types.Evidence)
for _, e := range reapedEv { for _, e := range reapedEv {


+ 14
- 6
evidence/store.go View File

@ -78,7 +78,7 @@ func NewEvidenceStore(db dbm.DB) *EvidenceStore {
// PriorityEvidence returns the evidence from the outqueue, sorted by highest priority. // PriorityEvidence returns the evidence from the outqueue, sorted by highest priority.
func (store *EvidenceStore) PriorityEvidence() (evidence []types.Evidence) { func (store *EvidenceStore) PriorityEvidence() (evidence []types.Evidence) {
// reverse the order so highest priority is first // reverse the order so highest priority is first
l := store.ListEvidence(baseKeyOutqueue)
l := store.listEvidence(baseKeyOutqueue, -1)
l2 := make([]types.Evidence, len(l)) l2 := make([]types.Evidence, len(l))
for i := range l { for i := range l {
l2[i] = l[len(l)-1-i] l2[i] = l[len(l)-1-i]
@ -86,18 +86,26 @@ func (store *EvidenceStore) PriorityEvidence() (evidence []types.Evidence) {
return l2 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. // 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)) iter := dbm.IteratePrefix(store.db, []byte(prefixKey))
for ; iter.Valid(); iter.Next() { for ; iter.Valid(); iter.Next() {
val := iter.Value() val := iter.Value()
if maxBytes > 0 && bytes+len(val) > maxBytes {
return evidence
}
bytes += len(val)
var ei EvidenceInfo var ei EvidenceInfo
err := cdc.UnmarshalBinaryBare(val, &ei) err := cdc.UnmarshalBinaryBare(val, &ei)
if err != nil { if err != nil {


+ 4
- 4
evidence/store_test.go View File

@ -35,7 +35,7 @@ func TestStoreMark(t *testing.T) {
// before we do anything, priority/pending are empty // before we do anything, priority/pending are empty
priorityEv := store.PriorityEvidence() priorityEv := store.PriorityEvidence()
pendingEv := store.PendingEvidence()
pendingEv := store.PendingEvidence(-1)
assert.Equal(0, len(priorityEv)) assert.Equal(0, len(priorityEv))
assert.Equal(0, len(pendingEv)) assert.Equal(0, len(pendingEv))
@ -53,21 +53,21 @@ func TestStoreMark(t *testing.T) {
// new evidence should be returns in priority/pending // new evidence should be returns in priority/pending
priorityEv = store.PriorityEvidence() priorityEv = store.PriorityEvidence()
pendingEv = store.PendingEvidence()
pendingEv = store.PendingEvidence(-1)
assert.Equal(1, len(priorityEv)) assert.Equal(1, len(priorityEv))
assert.Equal(1, len(pendingEv)) assert.Equal(1, len(pendingEv))
// priority is now empty // priority is now empty
store.MarkEvidenceAsBroadcasted(ev) store.MarkEvidenceAsBroadcasted(ev)
priorityEv = store.PriorityEvidence() priorityEv = store.PriorityEvidence()
pendingEv = store.PendingEvidence()
pendingEv = store.PendingEvidence(-1)
assert.Equal(0, len(priorityEv)) assert.Equal(0, len(priorityEv))
assert.Equal(1, len(pendingEv)) assert.Equal(1, len(pendingEv))
// priority and pending are now empty // priority and pending are now empty
store.MarkEvidenceAsCommitted(ev) store.MarkEvidenceAsCommitted(ev)
priorityEv = store.PriorityEvidence() priorityEv = store.PriorityEvidence()
pendingEv = store.PendingEvidence()
pendingEv = store.PendingEvidence(-1)
assert.Equal(0, len(priorityEv)) assert.Equal(0, len(priorityEv))
assert.Equal(0, len(pendingEv)) assert.Equal(0, len(pendingEv))


+ 55
- 13
mempool/mempool.go View File

@ -80,6 +80,8 @@ type Mempool struct {
recheckEnd *clist.CElement // re-checking stops here recheckEnd *clist.CElement // re-checking stops here
notifiedTxsAvailable bool notifiedTxsAvailable bool
txsAvailable chan struct{} // fires once for each height, when the mempool is not empty 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. // Keep a cache of already-seen txs.
// This reduces the pressure on the proxyApp. // This reduces the pressure on the proxyApp.
@ -139,6 +141,14 @@ func (mem *Mempool) SetLogger(l log.Logger) {
mem.logger = l 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. // WithMetrics sets the metrics.
func WithMetrics(metrics *Metrics) MempoolOption { func WithMetrics(metrics *Metrics) MempoolOption {
return func(mem *Mempool) { mem.metrics = metrics } 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 return ErrMempoolIsFull
} }
if mem.filter != nil && !mem.filter(tx) {
return
}
// CACHE // CACHE
if !mem.cache.Push(tx) { if !mem.cache.Push(tx) {
return ErrTxInCache 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() mem.proxyMtx.Lock()
defer mem.proxyMtx.Unlock() defer mem.proxyMtx.Unlock()
@ -378,19 +393,39 @@ func (mem *Mempool) Reap(maxTxs int) types.Txs {
time.Sleep(time.Millisecond * 10) 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 return txs
} }
// maxTxs: -1 means uncapped, 0 means none
func (mem *Mempool) collectTxs(maxTxs int) types.Txs {
if maxTxs == 0 {
return []types.Tx{}
} else if maxTxs < 0 {
maxTxs = mem.txs.Len()
// ReapMaxTxs reaps up to max transactions from the mempool.
// If max is negative, function panics.
func (mem *Mempool) ReapMaxTxs(max int) types.Txs {
mem.proxyMtx.Lock()
defer mem.proxyMtx.Unlock()
if max < 0 {
panic("Called ReapMaxTxs with negative max")
}
for atomic.LoadInt32(&mem.rechecking) > 0 {
// TODO: Something better?
time.Sleep(time.Millisecond * 10)
} }
txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), maxTxs))
for e := mem.txs.Front(); e != nil && len(txs) < maxTxs; e = e.Next() {
txs := make([]types.Tx, 0, cmn.MinInt(mem.txs.Len(), max))
for e := mem.txs.Front(); e != nil && len(txs) <= max; e = e.Next() {
memTx := e.Value.(*mempoolTx) memTx := e.Value.(*mempoolTx)
txs = append(txs, memTx.tx) 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. // 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: this should be called *after* block is committed by consensus.
// NOTE: unsafe; Lock/Unlock must be managed by caller // 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. // First, create a lookup map of txns in new txs.
txsMap := make(map[string]struct{}, len(txs)) txsMap := make(map[string]struct{}, len(txs))
for _, tx := range txs { for _, tx := range txs {
@ -411,6 +446,10 @@ func (mem *Mempool) Update(height int64, txs types.Txs) error {
mem.height = height mem.height = height
mem.notifiedTxsAvailable = false mem.notifiedTxsAvailable = false
if filter != nil {
mem.filter = filter
}
// Remove transactions that are already in txs. // Remove transactions that are already in txs.
goodTxs := mem.filterTxs(txsMap) goodTxs := mem.filterTxs(txsMap)
// Recheck mempool txs if any txs were committed in the block // 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. // mem.recheckCursor re-scans mem.txs and possibly removes some txs.
// Before mem.Reap(), we should wait for mem.recheckCursor to be nil. // Before mem.Reap(), we should wait for mem.recheckCursor to be nil.
} }
// Update metrics
mem.metrics.Size.Set(float64(mem.Size())) mem.metrics.Size.Set(float64(mem.Size()))
return nil return nil
} }


+ 4
- 4
mempool/mempool_test.go View File

@ -91,7 +91,7 @@ func TestTxsAvailable(t *testing.T) {
// it should fire once now for the new height // it should fire once now for the new height
// since there are still txs left // since there are still txs left
committedTxs, txs := txs[:50], txs[50:] 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) t.Error(err)
} }
ensureFire(t, mempool.TxsAvailable(), timeoutMS) 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 // now call update with all the txs. it should not fire as there are no txs left
committedTxs = append(txs, moreTxs...) committedTxs = append(txs, moreTxs...)
if err := mempool.Update(2, committedTxs); err != nil {
if err := mempool.Update(2, committedTxs, nil); err != nil {
t.Error(err) t.Error(err)
} }
ensureNoFire(t, mempool.TxsAvailable(), timeoutMS) ensureNoFire(t, mempool.TxsAvailable(), timeoutMS)
@ -149,7 +149,7 @@ func TestSerialReap(t *testing.T) {
} }
reapCheck := func(exp int) { 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))) 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)) binary.BigEndian.PutUint64(txBytes, uint64(i))
txs = append(txs, txBytes) txs = append(txs, txBytes)
} }
if err := mempool.Update(0, txs); err != nil {
if err := mempool.Update(0, txs, nil); err != nil {
t.Error(err) t.Error(err)
} }
} }


+ 1
- 1
mempool/reactor_test.go View File

@ -86,7 +86,7 @@ func _waitForTxs(t *testing.T, wg *sync.WaitGroup, txs types.Txs, reactorIdx int
time.Sleep(time.Millisecond * 100) time.Sleep(time.Millisecond * 100)
} }
reapedTxs := mempool.Reap(len(txs))
reapedTxs := mempool.ReapMaxTxs(len(txs))
for i, tx := range 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])) 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]))
} }


+ 4
- 3
node/node.go View File

@ -83,7 +83,7 @@ func DefaultNewNode(config *cfg.Config, logger log.Logger) (*Node, error) {
// Generate node PrivKey // Generate node PrivKey
nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile()) nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile())
if err != nil { if err != nil {
return nil,err
return nil, err
} }
return NewNode(config, return NewNode(config,
privval.LoadOrGenFilePV(config.PrivValidatorFile()), privval.LoadOrGenFilePV(config.PrivValidatorFile()),
@ -248,6 +248,8 @@ func NewNode(config *cfg.Config,
mempl.WithMetrics(memplMetrics), mempl.WithMetrics(memplMetrics),
) )
mempool.SetLogger(mempoolLogger) 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 mempool.InitWAL() // no need to have the mempool wal during tests
mempoolReactor := mempl.NewMempoolReactor(config.Mempool, mempool) mempoolReactor := mempl.NewMempoolReactor(config.Mempool, mempool)
mempoolReactor.SetLogger(mempoolLogger) mempoolReactor.SetLogger(mempoolLogger)
@ -401,7 +403,7 @@ func NewNode(config *cfg.Config,
sw: sw, sw: sw,
addrBook: addrBook, addrBook: addrBook,
nodeKey: nodeKey,
nodeKey: nodeKey,
stateDB: stateDB, stateDB: stateDB,
blockStore: blockStore, blockStore: blockStore,
@ -434,7 +436,6 @@ func (n *Node) OnStart() error {
n.Logger.With("module", "p2p")) n.Logger.With("module", "p2p"))
n.sw.AddListener(l) n.sw.AddListener(l)
nodeInfo := n.makeNodeInfo(n.nodeKey.ID()) nodeInfo := n.makeNodeInfo(n.nodeKey.ID())
n.sw.SetNodeInfo(nodeInfo) n.sw.SetNodeInfo(nodeInfo)
n.sw.SetNodeKey(n.nodeKey) n.sw.SetNodeKey(n.nodeKey)


+ 1
- 1
rpc/client/rpc_test.go View File

@ -242,7 +242,7 @@ func TestBroadcastTxSync(t *testing.T) {
require.Equal(initMempoolSize+1, mempool.Size()) require.Equal(initMempoolSize+1, mempool.Size())
txs := mempool.Reap(1)
txs := mempool.ReapMaxTxs(len(tx))
require.EqualValues(tx, txs[0]) require.EqualValues(tx, txs[0])
mempool.Flush() mempool.Flush()
} }


+ 1
- 1
rpc/core/mempool.go View File

@ -243,7 +243,7 @@ func UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error) {
// reuse per_page validator // reuse per_page validator
limit = validatePerPage(limit) limit = validatePerPage(limit)
txs := mempool.Reap(limit)
txs := mempool.ReapMaxTxs(limit)
return &ctypes.ResultUnconfirmedTxs{len(txs), txs}, nil return &ctypes.ResultUnconfirmedTxs{len(txs), txs}, nil
} }


+ 3
- 2
rpc/core/pipe.go View File

@ -7,6 +7,7 @@ import (
crypto "github.com/tendermint/tendermint/crypto" crypto "github.com/tendermint/tendermint/crypto"
dbm "github.com/tendermint/tendermint/libs/db" dbm "github.com/tendermint/tendermint/libs/db"
"github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/log"
mempl "github.com/tendermint/tendermint/mempool"
"github.com/tendermint/tendermint/p2p" "github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/proxy" "github.com/tendermint/tendermint/proxy"
sm "github.com/tendermint/tendermint/state" sm "github.com/tendermint/tendermint/state"
@ -53,7 +54,6 @@ var (
// interfaces defined in types and above // interfaces defined in types and above
stateDB dbm.DB stateDB dbm.DB
blockStore sm.BlockStore blockStore sm.BlockStore
mempool sm.Mempool
evidencePool sm.EvidencePool evidencePool sm.EvidencePool
consensusState Consensus consensusState Consensus
p2pSwitch P2P p2pSwitch P2P
@ -65,6 +65,7 @@ var (
txIndexer txindex.TxIndexer txIndexer txindex.TxIndexer
consensusReactor *consensus.ConsensusReactor consensusReactor *consensus.ConsensusReactor
eventBus *types.EventBus // thread safe eventBus *types.EventBus // thread safe
mempool *mempl.Mempool
logger log.Logger logger log.Logger
) )
@ -77,7 +78,7 @@ func SetBlockStore(bs sm.BlockStore) {
blockStore = bs blockStore = bs
} }
func SetMempool(mem sm.Mempool) {
func SetMempool(mem *mempl.Mempool) {
mempool = mem mempool = mem
} }


+ 5
- 3
state/execution.go View File

@ -92,7 +92,7 @@ func (blockExec *BlockExecutor) ApplyBlock(state State, blockID types.BlockID, b
} }
// Lock mempool, commit app state, update mempoool. // Lock mempool, commit app state, update mempoool.
appHash, err := blockExec.Commit(block)
appHash, err := blockExec.Commit(state, block)
if err != nil { if err != nil {
return state, fmt.Errorf("Commit failed for application: %v", err) 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. // 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 // 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. // 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() blockExec.mempool.Lock()
defer blockExec.mempool.Unlock() defer blockExec.mempool.Unlock()
@ -145,7 +145,9 @@ func (blockExec *BlockExecutor) Commit(block *types.Block) ([]byte, error) {
"appHash", fmt.Sprintf("%X", res.Data)) "appHash", fmt.Sprintf("%X", res.Data))
// Update mempool. // 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 return nil, err
} }


+ 19
- 21
state/services.go View File

@ -22,8 +22,8 @@ type Mempool interface {
Size() int Size() int
CheckTx(types.Tx, func(*abci.Response)) error 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() Flush()
FlushAppConn() error FlushAppConn() error
@ -32,19 +32,18 @@ type Mempool interface {
} }
// MockMempool is an empty implementation of a Mempool, useful for testing. // MockMempool is an empty implementation of a Mempool, useful for testing.
type MockMempool struct {
}
func (m MockMempool) Lock() {}
func (m MockMempool) Unlock() {}
func (m MockMempool) Size() int { return 0 }
func (m MockMempool) CheckTx(tx types.Tx, cb func(*abci.Response)) error { return nil }
func (m MockMempool) Reap(n int) types.Txs { return types.Txs{} }
func (m MockMempool) Update(height int64, txs types.Txs) error { return nil }
func (m MockMempool) Flush() {}
func (m MockMempool) FlushAppConn() error { return nil }
func (m MockMempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) }
func (m MockMempool) EnableTxsAvailable() {}
type MockMempool struct{}
func (MockMempool) Lock() {}
func (MockMempool) Unlock() {}
func (MockMempool) Size() int { return 0 }
func (MockMempool) CheckTx(tx types.Tx, cb func(*abci.Response)) error { return nil }
func (MockMempool) ReapMaxBytes(max int) types.Txs { return types.Txs{} }
func (MockMempool) Update(height int64, txs types.Txs, filter func(types.Tx) bool) error { return nil }
func (MockMempool) Flush() {}
func (MockMempool) FlushAppConn() error { return nil }
func (MockMempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) }
func (MockMempool) EnableTxsAvailable() {}
//------------------------------------------------------ //------------------------------------------------------
// blockstore // blockstore
@ -72,15 +71,14 @@ type BlockStore interface {
// EvidencePool defines the EvidencePool interface used by the ConsensusState. // EvidencePool defines the EvidencePool interface used by the ConsensusState.
type EvidencePool interface { type EvidencePool interface {
PendingEvidence() []types.Evidence
PendingEvidence(int) []types.Evidence
AddEvidence(types.Evidence) error AddEvidence(types.Evidence) error
Update(*types.Block, State) Update(*types.Block, State)
} }
// MockMempool is an empty implementation of a Mempool, useful for testing. // MockMempool is an empty implementation of a Mempool, useful for testing.
type MockEvidencePool struct {
}
type MockEvidencePool struct{}
func (m MockEvidencePool) PendingEvidence() []types.Evidence { return nil }
func (m MockEvidencePool) AddEvidence(types.Evidence) error { return nil }
func (m MockEvidencePool) Update(*types.Block, State) {}
func (m MockEvidencePool) PendingEvidence(int) []types.Evidence { return nil }
func (m MockEvidencePool) AddEvidence(types.Evidence) error { return nil }
func (m MockEvidencePool) Update(*types.Block, State) {}

+ 9
- 12
state/state_test.go View File

@ -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{ return types.ConsensusParams{
BlockSize: types.BlockSize{ BlockSize: types.BlockSize{
MaxBytes: blockBytes,
MaxTxs: blockTx,
MaxBytes: txsBytes,
MaxGas: int64(blockGas), MaxGas: int64(blockGas),
}, },
TxSize: types.TxSize{ TxSize: types.TxSize{
@ -397,7 +394,7 @@ func pk() []byte {
} }
func TestApplyUpdates(t *testing.T) { func TestApplyUpdates(t *testing.T) {
initParams := makeParams(1, 2, 3, 4, 5, 6)
initParams := makeParams(1, 2, 3, 4, 5)
cases := [...]struct { cases := [...]struct {
init types.ConsensusParams init types.ConsensusParams
@ -412,19 +409,19 @@ func TestApplyUpdates(t *testing.T) {
MaxBytes: 123, MaxBytes: 123,
}, },
}, },
makeParams(1, 2, 3, 123, 5, 6)},
makeParams(1, 2, 123, 4, 5)},
3: {initParams, 3: {initParams,
abci.ConsensusParams{ abci.ConsensusParams{
BlockSize: &abci.BlockSize{ BlockSize: &abci.BlockSize{
MaxTxs: 44,
MaxGas: 55,
MaxBytes: 1,
MaxGas: 55,
}, },
}, },
makeParams(1, 44, 55, 4, 5, 6)},
makeParams(1, 55, 3, 4, 5)},
4: {initParams, 4: {initParams,
abci.ConsensusParams{ abci.ConsensusParams{
BlockSize: &abci.BlockSize{ BlockSize: &abci.BlockSize{
MaxTxs: 789,
MaxBytes: 1,
}, },
TxSize: &abci.TxSize{ TxSize: &abci.TxSize{
MaxGas: 888, MaxGas: 888,
@ -433,7 +430,7 @@ func TestApplyUpdates(t *testing.T) {
BlockPartSizeBytes: 2002, BlockPartSizeBytes: 2002,
}, },
}, },
makeParams(1, 789, 3, 4, 888, 2002)},
makeParams(1, 2, 3, 888, 2002)},
} }
for i, tc := range cases { for i, tc := range cases {


+ 11
- 0
types/block.go View File

@ -13,6 +13,17 @@ import (
cmn "github.com/tendermint/tendermint/libs/common" 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. // Block defines the atomic unit of a Tendermint blockchain.
// TODO: add Version byte // TODO: add Version byte
type Block struct { type Block struct {


+ 41
- 5
types/block_test.go View File

@ -2,11 +2,13 @@ package types
import ( import (
"testing" "testing"
"time"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/tmhash"
cmn "github.com/tendermint/tendermint/libs/common" cmn "github.com/tendermint/tendermint/libs/common"
) )
@ -118,7 +120,7 @@ func TestBlockMakePartSetWithEvidence(t *testing.T) {
partSet := MakeBlock(h, txs, commit, evList).MakePartSet(1024) partSet := MakeBlock(h, txs, commit, evList).MakePartSet(1024)
assert.NotNil(t, partSet) assert.NotNil(t, partSet)
assert.Equal(t, 3, partSet.Total())
assert.Equal(t, 2, partSet.Total())
} }
func TestBlockHashesTo(t *testing.T) { func TestBlockHashesTo(t *testing.T) {
@ -159,16 +161,16 @@ func TestBlockString(t *testing.T) {
} }
func makeBlockIDRandom() BlockID { 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} return BlockID{blockHash, blockPartsHeader}
} }
func makeBlockID(hash string, partSetSize int, partSetHash string) BlockID {
func makeBlockID(hash []byte, partSetSize int, partSetHash []byte) BlockID {
return BlockID{ return BlockID{
Hash: []byte(hash),
Hash: hash,
PartsHeader: PartSetHeader{ PartsHeader: PartSetHeader{
Total: partSetSize, Total: partSetSize,
Hash: []byte(partSetHash),
Hash: partSetHash,
}, },
} }
@ -233,6 +235,40 @@ func TestCommitValidateBasic(t *testing.T) {
assert.Error(t, commit.ValidateBasic()) 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 { func randCommit() *Commit {
lastID := makeBlockIDRandom() lastID := makeBlockIDRandom()
h := int64(3) h := int64(3)


+ 5
- 0
types/evidence.go View File

@ -10,6 +10,11 @@ import (
"github.com/tendermint/tendermint/crypto/merkle" "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. // ErrEvidenceInvalid wraps a piece of evidence and the error denoting how or why it is invalid.
type ErrEvidenceInvalid struct { type ErrEvidenceInvalid struct {
Evidence Evidence Evidence Evidence


+ 27
- 6
types/evidence_test.go View File

@ -4,6 +4,9 @@ import (
"testing" "testing"
"github.com/stretchr/testify/assert" "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 { type voteData struct {
@ -31,10 +34,11 @@ func makeVote(val PrivValidator, chainID string, valIndex int, height int64, rou
func TestEvidence(t *testing.T) { func TestEvidence(t *testing.T) {
val := NewMockPV() val := NewMockPV()
val2 := 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" const chainID = "mychain"
@ -89,10 +93,27 @@ func TestEvidenceList(t *testing.T) {
assert.False(t, evl.Has(&DuplicateVoteEvidence{})) 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 { func randomDuplicatedVoteEvidence() *DuplicateVoteEvidence {
val := NewMockPV() 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" const chainID = "mychain"
return &DuplicateVoteEvidence{ return &DuplicateVoteEvidence{
VoteA: makeVote(val, chainID, 0, 10, 2, 1, blockID), VoteA: makeVote(val, chainID, 0, 10, 2, 1, blockID),


+ 4
- 10
types/params.go View File

@ -22,9 +22,8 @@ type ConsensusParams struct {
// BlockSize contain limits on the block size. // BlockSize contain limits on the block size.
type BlockSize struct { type BlockSize struct {
MaxBytes int `json:"max_bytes"` // NOTE: must not be 0 nor greater than 100MB
MaxTxs int `json:"max_txs"`
MaxGas int64 `json:"max_gas"`
MaxBytes int `json:"max_txs_bytes"` // NOTE: must not be 0 nor greater than 100MB
MaxGas int64 `json:"max_gas"`
} }
// TxSize contain limits on the tx size. // TxSize contain limits on the tx size.
@ -56,9 +55,8 @@ func DefaultConsensusParams() *ConsensusParams {
// DefaultBlockSize returns a default BlockSize. // DefaultBlockSize returns a default BlockSize.
func DefaultBlockSize() BlockSize { func DefaultBlockSize() BlockSize {
return BlockSize{ return BlockSize{
MaxBytes: 22020096, // 21MB
MaxTxs: 10000,
MaxGas: -1,
MaxBytes: 22020096, // 21MB
MaxGas: -1,
} }
} }
@ -110,7 +108,6 @@ func (params *ConsensusParams) Hash() []byte {
"block_gossip_part_size_bytes": aminoHasher(params.BlockGossip.BlockPartSizeBytes), "block_gossip_part_size_bytes": aminoHasher(params.BlockGossip.BlockPartSizeBytes),
"block_size_max_bytes": aminoHasher(params.BlockSize.MaxBytes), "block_size_max_bytes": aminoHasher(params.BlockSize.MaxBytes),
"block_size_max_gas": aminoHasher(params.BlockSize.MaxGas), "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_bytes": aminoHasher(params.TxSize.MaxBytes),
"tx_size_max_gas": aminoHasher(params.TxSize.MaxGas), "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 { if params2.BlockSize.MaxBytes > 0 {
res.BlockSize.MaxBytes = int(params2.BlockSize.MaxBytes) res.BlockSize.MaxBytes = int(params2.BlockSize.MaxBytes)
} }
if params2.BlockSize.MaxTxs > 0 {
res.BlockSize.MaxTxs = int(params2.BlockSize.MaxTxs)
}
if params2.BlockSize.MaxGas > 0 { if params2.BlockSize.MaxGas > 0 {
res.BlockSize.MaxGas = params2.BlockSize.MaxGas res.BlockSize.MaxGas = params2.BlockSize.MaxGas
} }


+ 24
- 32
types/params_test.go View File

@ -9,9 +9,9 @@ import (
abci "github.com/tendermint/tendermint/abci/types" abci "github.com/tendermint/tendermint/abci/types"
) )
func newConsensusParams(blockSize, partSize int) ConsensusParams {
func newConsensusParams(txsBytes, partSize int) ConsensusParams {
return ConsensusParams{ return ConsensusParams{
BlockSize: BlockSize{MaxBytes: blockSize},
BlockSize: BlockSize{MaxBytes: txsBytes},
BlockGossip: BlockGossip{BlockPartSizeBytes: partSize}, BlockGossip: BlockGossip{BlockPartSizeBytes: partSize},
} }
} }
@ -33,22 +33,19 @@ func TestConsensusParamsValidation(t *testing.T) {
{newConsensusParams(101*1024*1024, 400), false}, {newConsensusParams(101*1024*1024, 400), false},
{newConsensusParams(1024*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 { } 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{ return ConsensusParams{
BlockSize: BlockSize{ BlockSize: BlockSize{
MaxBytes: blockBytes,
MaxTxs: blockTx,
MaxBytes: txsBytes,
MaxGas: int64(blockGas), MaxGas: int64(blockGas),
}, },
TxSize: TxSize{ TxSize: TxSize{
@ -63,14 +60,11 @@ func makeParams(blockBytes, blockTx, blockGas, txBytes,
func TestConsensusParamsHash(t *testing.T) { func TestConsensusParamsHash(t *testing.T) {
params := []ConsensusParams{ 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)) hashes := make([][]byte, len(params))
@ -96,18 +90,17 @@ func TestConsensusParamsUpdate(t *testing.T) {
}{ }{
// empty updates // empty updates
{ {
makeParams(1, 2, 3, 4, 5, 6),
makeParams(1, 2, 3, 4, 5),
&abci.ConsensusParams{}, &abci.ConsensusParams{},
makeParams(1, 2, 3, 4, 5, 6),
makeParams(1, 2, 3, 4, 5),
}, },
// negative BlockPartSizeBytes // negative BlockPartSizeBytes
{ {
makeParams(1, 2, 3, 4, 5, 6),
makeParams(1, 2, 3, 4, 5),
&abci.ConsensusParams{ &abci.ConsensusParams{
BlockSize: &abci.BlockSize{ BlockSize: &abci.BlockSize{
MaxBytes: -100, MaxBytes: -100,
MaxTxs: -200,
MaxGas: -300,
MaxGas: -200,
}, },
TxSize: &abci.TxSize{ TxSize: &abci.TxSize{
MaxBytes: -400, MaxBytes: -400,
@ -117,26 +110,25 @@ func TestConsensusParamsUpdate(t *testing.T) {
BlockPartSizeBytes: -600, BlockPartSizeBytes: -600,
}, },
}, },
makeParams(1, 2, 3, 4, 5, 6),
makeParams(1, 2, 3, 4, 5),
}, },
// fine updates // fine updates
{ {
makeParams(1, 2, 3, 4, 5, 6),
makeParams(1, 2, 3, 4, 5),
&abci.ConsensusParams{ &abci.ConsensusParams{
BlockSize: &abci.BlockSize{ BlockSize: &abci.BlockSize{
MaxBytes: 100, MaxBytes: 100,
MaxTxs: 200,
MaxGas: 300,
MaxGas: 200,
}, },
TxSize: &abci.TxSize{ TxSize: &abci.TxSize{
MaxBytes: 400,
MaxGas: 500,
MaxBytes: 300,
MaxGas: 400,
}, },
BlockGossip: &abci.BlockGossip{ BlockGossip: &abci.BlockGossip{
BlockPartSizeBytes: 600,
BlockPartSizeBytes: 500,
}, },
}, },
makeParams(100, 200, 300, 400, 500, 600),
makeParams(100, 200, 300, 400, 500),
}, },
} }
for _, tc := range testCases { for _, tc := range testCases {


+ 4
- 7
types/protobuf.go View File

@ -115,10 +115,8 @@ func (tm2pb) ValidatorUpdates(vals *ValidatorSet) []abci.ValidatorUpdate {
func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams { func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams {
return &abci.ConsensusParams{ return &abci.ConsensusParams{
BlockSize: &abci.BlockSize{ BlockSize: &abci.BlockSize{
MaxBytes: int32(params.BlockSize.MaxBytes),
MaxTxs: int32(params.BlockSize.MaxTxs),
MaxGas: params.BlockSize.MaxGas,
MaxBytes: int32(params.BlockSize.MaxBytes),
MaxGas: params.BlockSize.MaxGas,
}, },
TxSize: &abci.TxSize{ TxSize: &abci.TxSize{
MaxBytes: int32(params.TxSize.MaxBytes), MaxBytes: int32(params.TxSize.MaxBytes),
@ -217,9 +215,8 @@ func (pb2tm) ValidatorUpdates(vals []abci.ValidatorUpdate) ([]*Validator, error)
func (pb2tm) ConsensusParams(csp *abci.ConsensusParams) ConsensusParams { func (pb2tm) ConsensusParams(csp *abci.ConsensusParams) ConsensusParams {
return ConsensusParams{ return ConsensusParams{
BlockSize: BlockSize{ BlockSize: BlockSize{
MaxBytes: int(csp.BlockSize.MaxBytes), // XXX
MaxTxs: int(csp.BlockSize.MaxTxs), // XXX
MaxGas: csp.BlockSize.MaxGas,
MaxBytes: int(csp.BlockSize.MaxBytes), // XXX
MaxGas: csp.BlockSize.MaxGas,
}, },
TxSize: TxSize{ TxSize: TxSize{
MaxBytes: int(csp.TxSize.MaxBytes), // XXX MaxBytes: int(csp.TxSize.MaxBytes), // XXX


+ 2
- 2
types/protobuf_test.go View File

@ -89,8 +89,8 @@ func TestABCIHeader(t *testing.T) {
func TestABCIEvidence(t *testing.T) { func TestABCIEvidence(t *testing.T) {
val := NewMockPV() 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" const chainID = "mychain"
ev := &DuplicateVoteEvidence{ ev := &DuplicateVoteEvidence{
PubKey: val.GetPubKey(), PubKey: val.GetPubKey(),


+ 5
- 0
types/tx.go View File

@ -11,6 +11,11 @@ import (
cmn "github.com/tendermint/tendermint/libs/common" cmn "github.com/tendermint/tendermint/libs/common"
) )
const (
// MaxAminoOverheadForTx - amino overhead to encode a transaction.
MaxAminoOverheadForTx = 4
)
// Tx is an arbitrary byte array. // Tx is an arbitrary byte array.
// NOTE: Tx has no types at this level, so when wire encoded it's just length-prefixed. // NOTE: Tx has no types at this level, so when wire encoded it's just length-prefixed.
// Might we want types here ? // Might we want types here ?


+ 5
- 0
types/vote.go View File

@ -10,6 +10,11 @@ import (
cmn "github.com/tendermint/tendermint/libs/common" cmn "github.com/tendermint/tendermint/libs/common"
) )
const (
// MaxVoteBytes is a maximum vote size (including amino overhead).
MaxVoteBytes = 170
)
var ( var (
ErrVoteUnexpectedStep = errors.New("Unexpected step") ErrVoteUnexpectedStep = errors.New("Unexpected step")
ErrVoteInvalidValidatorIndex = errors.New("Invalid validator index") ErrVoteInvalidValidatorIndex = errors.New("Invalid validator index")


+ 18
- 4
types/vote_test.go View File

@ -7,6 +7,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/crypto/ed25519"
"github.com/tendermint/tendermint/crypto/tmhash"
) )
func examplePrevote() *Vote { func examplePrevote() *Vote {
@ -24,17 +25,17 @@ func exampleVote(t byte) *Vote {
} }
return &Vote{ return &Vote{
ValidatorAddress: []byte("addr"),
ValidatorAddress: tmhash.Sum([]byte("validator_address")),
ValidatorIndex: 56789, ValidatorIndex: 56789,
Height: 12345, Height: 12345,
Round: 2, Round: 2,
Timestamp: stamp, Timestamp: stamp,
Type: t, Type: t,
BlockID: BlockID{ BlockID: BlockID{
Hash: []byte("hash"),
Hash: tmhash.Sum([]byte("blockID_hash")),
PartsHeader: PartSetHeader{ PartsHeader: PartSetHeader{
Total: 1000000, 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") signBytes := vote.SignBytes("test_chain_id")
signStr := string(signBytes) 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 { if signStr != expected {
// NOTE: when this fails, you probably want to fix up consensus/replay_test too // 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) 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) 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…
Cancel
Save