Merge latest changes from master and resolve conflicts

Signed-off-by: Thane Thomson <connect@thanethomson.com>

.github/workflows/docker.yml

@@ -49,7 +49,7 @@ jobs:
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Publish to Docker Hub
-        uses: docker/build-push-action@v2.9.0
+        uses: docker/build-push-action@v2.10.0
         with:
           context: .
           file: ./DOCKER/Dockerfile

.github/workflows/linkchecker.yml

@@ -7,6 +7,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.13
+      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.14
         with:
           folder-path: "docs"

abci/example/kvstore/kvstore.go

@@ -284,16 +284,19 @@ func (app *Application) PrepareProposal(req types.RequestPrepareProposal) types.
 	app.mu.Lock()
 	defer app.mu.Unlock()
 
-	return types.ResponsePrepareProposal{TxRecords: app.substPrepareTx(req.Txs)}
+	return types.ResponsePrepareProposal{
+		ModifiedTxStatus: types.ResponsePrepareProposal_MODIFIED,
+		TxRecords:        app.substPrepareTx(req.Txs),
+	}
 }
 
 func (*Application) ProcessProposal(req types.RequestProcessProposal) types.ResponseProcessProposal {
 	for _, tx := range req.Txs {
 		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Accept: false}
+			return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}
 		}
 	}
-	return types.ResponseProcessProposal{Accept: true}
+	return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}
 }
 
 //---------------------------------------------

abci/types/application.go

@@ -66,7 +66,7 @@ func (BaseApplication) ExtendVote(req RequestExtendVote) ResponseExtendVote {
 
 func (BaseApplication) VerifyVoteExtension(req RequestVerifyVoteExtension) ResponseVerifyVoteExtension {
 	return ResponseVerifyVoteExtension{
-		Accept: true,
+		Status: ResponseVerifyVoteExtension_ACCEPT,
 	}
 }
 
@@ -95,11 +95,11 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
 }
 
 func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
-	return ResponsePrepareProposal{}
+	return ResponsePrepareProposal{ModifiedTxStatus: ResponsePrepareProposal_UNMODIFIED}
 }
 
 func (BaseApplication) ProcessProposal(req RequestProcessProposal) ResponseProcessProposal {
-	return ResponseProcessProposal{}
+	return ResponseProcessProposal{Status: ResponseProcessProposal_ACCEPT}
 }
 
 func (BaseApplication) FinalizeBlock(req RequestFinalizeBlock) ResponseFinalizeBlock {

abci/types/mocks/base.go

@@ -25,8 +25,7 @@ func NewBaseMock() BaseMock {
 
 // Info/Query Connection
 // Return application info
-func (m BaseMock) Info(input types.RequestInfo) types.ResponseInfo {
-	var ret types.ResponseInfo
+func (m BaseMock) Info(input types.RequestInfo) (ret types.ResponseInfo) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.Info(input)
@@ -36,8 +35,7 @@ func (m BaseMock) Info(input types.RequestInfo) types.ResponseInfo {
 	return ret
 }
 
-func (m BaseMock) Query(input types.RequestQuery) types.ResponseQuery {
-	var ret types.ResponseQuery
+func (m BaseMock) Query(input types.RequestQuery) (ret types.ResponseQuery) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.Query(input)
@@ -49,8 +47,7 @@ func (m BaseMock) Query(input types.RequestQuery) types.ResponseQuery {
 
 // Mempool Connection
 // Validate a tx for the mempool
-func (m BaseMock) CheckTx(input types.RequestCheckTx) types.ResponseCheckTx {
-	var ret types.ResponseCheckTx
+func (m BaseMock) CheckTx(input types.RequestCheckTx) (ret types.ResponseCheckTx) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.CheckTx(input)
@@ -62,8 +59,7 @@ func (m BaseMock) CheckTx(input types.RequestCheckTx) types.ResponseCheckTx {
 
 // Consensus Connection
 // Initialize blockchain w validators/other info from TendermintCore
-func (m BaseMock) InitChain(input types.RequestInitChain) types.ResponseInitChain {
-	var ret types.ResponseInitChain
+func (m BaseMock) InitChain(input types.RequestInitChain) (ret types.ResponseInitChain) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.InitChain(input)
@@ -73,8 +69,7 @@ func (m BaseMock) InitChain(input types.RequestInitChain) types.ResponseInitChai
 	return ret
 }
 
-func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	var ret types.ResponsePrepareProposal
+func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) (ret types.ResponsePrepareProposal) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.PrepareProposal(input)
@@ -84,8 +79,7 @@ func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) types.Resp
 	return ret
 }
 
-func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) types.ResponseProcessProposal {
-	var ret types.ResponseProcessProposal
+func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) (ret types.ResponseProcessProposal) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.ProcessProposal(input)
@@ -96,8 +90,7 @@ func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) types.Resp
 }
 
 // Commit the state and return the application Merkle root hash
-func (m BaseMock) Commit() types.ResponseCommit {
-	var ret types.ResponseCommit
+func (m BaseMock) Commit() (ret types.ResponseCommit) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.Commit()
@@ -108,8 +101,7 @@ func (m BaseMock) Commit() types.ResponseCommit {
 }
 
 // Create application specific vote extension
-func (m BaseMock) ExtendVote(input types.RequestExtendVote) types.ResponseExtendVote {
-	var ret types.ResponseExtendVote
+func (m BaseMock) ExtendVote(input types.RequestExtendVote) (ret types.ResponseExtendVote) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.ExtendVote(input)
@@ -120,8 +112,7 @@ func (m BaseMock) ExtendVote(input types.RequestExtendVote) types.ResponseExtend
 }
 
 // Verify application's vote extension data
-func (m BaseMock) VerifyVoteExtension(input types.RequestVerifyVoteExtension) types.ResponseVerifyVoteExtension {
-	var ret types.ResponseVerifyVoteExtension
+func (m BaseMock) VerifyVoteExtension(input types.RequestVerifyVoteExtension) (ret types.ResponseVerifyVoteExtension) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.VerifyVoteExtension(input)
@@ -133,8 +124,7 @@ func (m BaseMock) VerifyVoteExtension(input types.RequestVerifyVoteExtension) ty
 
 // State Sync Connection
 // List available snapshots
-func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) types.ResponseListSnapshots {
-	var ret types.ResponseListSnapshots
+func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) (ret types.ResponseListSnapshots) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.ListSnapshots(input)
@@ -144,8 +134,7 @@ func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) types.Response
 	return ret
 }
 
-func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
-	var ret types.ResponseOfferSnapshot
+func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) (ret types.ResponseOfferSnapshot) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.OfferSnapshot(input)
@@ -155,8 +144,7 @@ func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) types.Response
 	return ret
 }
 
-func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk {
-	var ret types.ResponseLoadSnapshotChunk
+func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) (ret types.ResponseLoadSnapshotChunk) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.LoadSnapshotChunk(input)
@@ -166,8 +154,7 @@ func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) types.
 	return ret
 }
 
-func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
-	var ret types.ResponseApplySnapshotChunk
+func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) (ret types.ResponseApplySnapshotChunk) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.ApplySnapshotChunk(input)
@@ -177,8 +164,7 @@ func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) type
 	return ret
 }
 
-func (m BaseMock) FinalizeBlock(input types.RequestFinalizeBlock) types.ResponseFinalizeBlock {
-	var ret types.ResponseFinalizeBlock
+func (m BaseMock) FinalizeBlock(input types.RequestFinalizeBlock) (ret types.ResponseFinalizeBlock) {
 	defer func() {
 		if r := recover(); r != nil {
 			ret = m.base.FinalizeBlock(input)

abci/types/types.go

@@ -51,6 +51,37 @@ func (r ResponseQuery) IsErr() bool {
 	return r.Code != CodeTypeOK
 }
 
+func (r ResponsePrepareProposal) IsTxStatusUnknown() bool {
+	return r.ModifiedTxStatus == ResponsePrepareProposal_UNKNOWN
+}
+
+func (r ResponsePrepareProposal) IsTxStatusModified() bool {
+	return r.ModifiedTxStatus == ResponsePrepareProposal_MODIFIED
+}
+
+func (r ResponseProcessProposal) IsAccepted() bool {
+	return r.Status == ResponseProcessProposal_ACCEPT
+}
+
+func (r ResponseProcessProposal) IsStatusUnknown() bool {
+	return r.Status == ResponseProcessProposal_UNKNOWN
+}
+
+// IsStatusUnknown returns true if Code is Unknown
+func (r ResponseVerifyVoteExtension) IsStatusUnknown() bool {
+	return r.Status == ResponseVerifyVoteExtension_UNKNOWN
+}
+
+// IsOK returns true if Code is OK
+func (r ResponseVerifyVoteExtension) IsOK() bool {
+	return r.Status == ResponseVerifyVoteExtension_ACCEPT
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResponseVerifyVoteExtension) IsErr() bool {
+	return r.Status != ResponseVerifyVoteExtension_ACCEPT
+}
+
 //---------------------------------------------------------------------------
 // override JSON marshaling so we emit defaults (ie. disable omitempty)
 
@@ -132,6 +163,16 @@ var _ jsonRoundTripper = (*EventAttribute)(nil)
 // -----------------------------------------------
 // construct Result data
 
+func RespondVerifyVoteExtension(ok bool) ResponseVerifyVoteExtension {
+	status := ResponseVerifyVoteExtension_REJECT
+	if ok {
+		status = ResponseVerifyVoteExtension_ACCEPT
+	}
+	return ResponseVerifyVoteExtension{
+		Status: status,
+	}
+}
+
 // deterministicExecTxResult constructs a copy of response that omits
 // non-deterministic fields. The input response is not modified.
 func deterministicExecTxResult(response *ExecTxResult) *ExecTxResult {

abci/types/types.pb.go

@@ -160,6 +160,90 @@ func (ResponseApplySnapshotChunk_Result) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_252557cfdd89a31a, []int{35, 0}
 }
 
+type ResponsePrepareProposal_ModifiedTxStatus int32
+
+const (
+	ResponsePrepareProposal_UNKNOWN    ResponsePrepareProposal_ModifiedTxStatus = 0
+	ResponsePrepareProposal_UNMODIFIED ResponsePrepareProposal_ModifiedTxStatus = 1
+	ResponsePrepareProposal_MODIFIED   ResponsePrepareProposal_ModifiedTxStatus = 2
+)
+
+var ResponsePrepareProposal_ModifiedTxStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "UNMODIFIED",
+	2: "MODIFIED",
+}
+
+var ResponsePrepareProposal_ModifiedTxStatus_value = map[string]int32{
+	"UNKNOWN":    0,
+	"UNMODIFIED": 1,
+	"MODIFIED":   2,
+}
+
+func (x ResponsePrepareProposal_ModifiedTxStatus) String() string {
+	return proto.EnumName(ResponsePrepareProposal_ModifiedTxStatus_name, int32(x))
+}
+
+func (ResponsePrepareProposal_ModifiedTxStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_252557cfdd89a31a, []int{36, 0}
+}
+
+type ResponseProcessProposal_ProposalStatus int32
+
+const (
+	ResponseProcessProposal_UNKNOWN ResponseProcessProposal_ProposalStatus = 0
+	ResponseProcessProposal_ACCEPT  ResponseProcessProposal_ProposalStatus = 1
+	ResponseProcessProposal_REJECT  ResponseProcessProposal_ProposalStatus = 2
+)
+
+var ResponseProcessProposal_ProposalStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "ACCEPT",
+	2: "REJECT",
+}
+
+var ResponseProcessProposal_ProposalStatus_value = map[string]int32{
+	"UNKNOWN": 0,
+	"ACCEPT":  1,
+	"REJECT":  2,
+}
+
+func (x ResponseProcessProposal_ProposalStatus) String() string {
+	return proto.EnumName(ResponseProcessProposal_ProposalStatus_name, int32(x))
+}
+
+func (ResponseProcessProposal_ProposalStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_252557cfdd89a31a, []int{37, 0}
+}
+
+type ResponseVerifyVoteExtension_VerifyStatus int32
+
+const (
+	ResponseVerifyVoteExtension_UNKNOWN ResponseVerifyVoteExtension_VerifyStatus = 0
+	ResponseVerifyVoteExtension_ACCEPT  ResponseVerifyVoteExtension_VerifyStatus = 1
+	ResponseVerifyVoteExtension_REJECT  ResponseVerifyVoteExtension_VerifyStatus = 2
+)
+
+var ResponseVerifyVoteExtension_VerifyStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "ACCEPT",
+	2: "REJECT",
+}
+
+var ResponseVerifyVoteExtension_VerifyStatus_value = map[string]int32{
+	"UNKNOWN": 0,
+	"ACCEPT":  1,
+	"REJECT":  2,
+}
+
+func (x ResponseVerifyVoteExtension_VerifyStatus) String() string {
+	return proto.EnumName(ResponseVerifyVoteExtension_VerifyStatus_name, int32(x))
+}
+
+func (ResponseVerifyVoteExtension_VerifyStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_252557cfdd89a31a, []int{39, 0}
+}
+
 // TxAction contains App-provided information on what to do with a transaction that is part of a raw proposal
 type TxRecord_TxAction int32
 
@@ -2886,12 +2970,12 @@ func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string {
 }
 
 type ResponsePrepareProposal struct {
-	ModifiedTx            bool                    `protobuf:"varint,1,opt,name=modified_tx,json=modifiedTx,proto3" json:"modified_tx,omitempty"`
-	TxRecords             []*TxRecord             `protobuf:"bytes,2,rep,name=tx_records,json=txRecords,proto3" json:"tx_records,omitempty"`
-	AppHash               []byte                  `protobuf:"bytes,3,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
-	TxResults             []*ExecTxResult         `protobuf:"bytes,4,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
-	ValidatorUpdates      []*ValidatorUpdate      `protobuf:"bytes,5,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
-	ConsensusParamUpdates *types1.ConsensusParams `protobuf:"bytes,6,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
+	ModifiedTxStatus      ResponsePrepareProposal_ModifiedTxStatus `protobuf:"varint,1,opt,name=modified_tx_status,json=modifiedTxStatus,proto3,enum=tendermint.abci.ResponsePrepareProposal_ModifiedTxStatus" json:"modified_tx_status,omitempty"`
+	TxRecords             []*TxRecord                              `protobuf:"bytes,2,rep,name=tx_records,json=txRecords,proto3" json:"tx_records,omitempty"`
+	AppHash               []byte                                   `protobuf:"bytes,3,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
+	TxResults             []*ExecTxResult                          `protobuf:"bytes,4,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
+	ValidatorUpdates      []*ValidatorUpdate                       `protobuf:"bytes,5,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
+	ConsensusParamUpdates *types1.ConsensusParams                  `protobuf:"bytes,6,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
 }
 
 func (m *ResponsePrepareProposal) Reset()         { *m = ResponsePrepareProposal{} }
@@ -2927,11 +3011,11 @@ func (m *ResponsePrepareProposal) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResponsePrepareProposal proto.InternalMessageInfo
 
-func (m *ResponsePrepareProposal) GetModifiedTx() bool {
+func (m *ResponsePrepareProposal) GetModifiedTxStatus() ResponsePrepareProposal_ModifiedTxStatus {
 	if m != nil {
-		return m.ModifiedTx
+		return m.ModifiedTxStatus
 	}
-	return false
+	return ResponsePrepareProposal_UNKNOWN
 }
 
 func (m *ResponsePrepareProposal) GetTxRecords() []*TxRecord {
@@ -2970,11 +3054,11 @@ func (m *ResponsePrepareProposal) GetConsensusParamUpdates() *types1.ConsensusPa
 }
 
 type ResponseProcessProposal struct {
-	Accept                bool                    `protobuf:"varint,1,opt,name=accept,proto3" json:"accept,omitempty"`
-	AppHash               []byte                  `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
-	TxResults             []*ExecTxResult         `protobuf:"bytes,3,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
-	ValidatorUpdates      []*ValidatorUpdate      `protobuf:"bytes,4,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
-	ConsensusParamUpdates *types1.ConsensusParams `protobuf:"bytes,5,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
+	Status                ResponseProcessProposal_ProposalStatus `protobuf:"varint,1,opt,name=status,proto3,enum=tendermint.abci.ResponseProcessProposal_ProposalStatus" json:"status,omitempty"`
+	AppHash               []byte                                 `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
+	TxResults             []*ExecTxResult                        `protobuf:"bytes,3,rep,name=tx_results,json=txResults,proto3" json:"tx_results,omitempty"`
+	ValidatorUpdates      []*ValidatorUpdate                     `protobuf:"bytes,4,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates,omitempty"`
+	ConsensusParamUpdates *types1.ConsensusParams                `protobuf:"bytes,5,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"`
 }
 
 func (m *ResponseProcessProposal) Reset()         { *m = ResponseProcessProposal{} }
@@ -3010,11 +3094,11 @@ func (m *ResponseProcessProposal) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResponseProcessProposal proto.InternalMessageInfo
 
-func (m *ResponseProcessProposal) GetAccept() bool {
+func (m *ResponseProcessProposal) GetStatus() ResponseProcessProposal_ProposalStatus {
 	if m != nil {
-		return m.Accept
+		return m.Status
 	}
-	return false
+	return ResponseProcessProposal_UNKNOWN
 }
 
 func (m *ResponseProcessProposal) GetAppHash() []byte {
@@ -3090,7 +3174,7 @@ func (m *ResponseExtendVote) GetVoteExtension() []byte {
 }
 
 type ResponseVerifyVoteExtension struct {
-	Accept bool `protobuf:"varint,1,opt,name=accept,proto3" json:"accept,omitempty"`
+	Status ResponseVerifyVoteExtension_VerifyStatus `protobuf:"varint,1,opt,name=status,proto3,enum=tendermint.abci.ResponseVerifyVoteExtension_VerifyStatus" json:"status,omitempty"`
 }
 
 func (m *ResponseVerifyVoteExtension) Reset()         { *m = ResponseVerifyVoteExtension{} }
@@ -3126,11 +3210,11 @@ func (m *ResponseVerifyVoteExtension) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResponseVerifyVoteExtension proto.InternalMessageInfo
 
-func (m *ResponseVerifyVoteExtension) GetAccept() bool {
+func (m *ResponseVerifyVoteExtension) GetStatus() ResponseVerifyVoteExtension_VerifyStatus {
 	if m != nil {
-		return m.Accept
+		return m.Status
 	}
-	return false
+	return ResponseVerifyVoteExtension_UNKNOWN
 }
 
 type ResponseFinalizeBlock struct {
@@ -3269,6 +3353,9 @@ func (m *CommitInfo) GetVotes() []VoteInfo {
 	return nil
 }
 
+// ExtendedCommitInfo is similar to CommitInfo except that it is only used in
+// the PrepareProposal request such that Tendermint can provide vote extensions
+// to the application.
 type ExtendedCommitInfo struct {
 	// The round at which the block proposer decided in the previous height.
 	Round int32 `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"`
@@ -4053,6 +4140,9 @@ func init() {
 	proto.RegisterEnum("tendermint.abci.EvidenceType", EvidenceType_name, EvidenceType_value)
 	proto.RegisterEnum("tendermint.abci.ResponseOfferSnapshot_Result", ResponseOfferSnapshot_Result_name, ResponseOfferSnapshot_Result_value)
 	proto.RegisterEnum("tendermint.abci.ResponseApplySnapshotChunk_Result", ResponseApplySnapshotChunk_Result_name, ResponseApplySnapshotChunk_Result_value)
+	proto.RegisterEnum("tendermint.abci.ResponsePrepareProposal_ModifiedTxStatus", ResponsePrepareProposal_ModifiedTxStatus_name, ResponsePrepareProposal_ModifiedTxStatus_value)
+	proto.RegisterEnum("tendermint.abci.ResponseProcessProposal_ProposalStatus", ResponseProcessProposal_ProposalStatus_name, ResponseProcessProposal_ProposalStatus_value)
+	proto.RegisterEnum("tendermint.abci.ResponseVerifyVoteExtension_VerifyStatus", ResponseVerifyVoteExtension_VerifyStatus_name, ResponseVerifyVoteExtension_VerifyStatus_value)
 	proto.RegisterEnum("tendermint.abci.TxRecord_TxAction", TxRecord_TxAction_name, TxRecord_TxAction_value)
 	proto.RegisterType((*Request)(nil), "tendermint.abci.Request")
 	proto.RegisterType((*RequestEcho)(nil), "tendermint.abci.RequestEcho")
@@ -4113,218 +4203,223 @@ func init() {
 func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
 
 var fileDescriptor_252557cfdd89a31a = []byte{
-	// 3372 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5b, 0xcd, 0x73, 0x23, 0xd5,
-	0x11, 0xd7, 0xf7, 0x47, 0xcb, 0xfa, 0xf0, 0xb3, 0x59, 0xb4, 0x62, 0xd7, 0x5e, 0x66, 0x0b, 0x58,
-	0x16, 0xf0, 0x86, 0xa5, 0x96, 0x2c, 0x59, 0x08, 0x65, 0xcb, 0x5a, 0x64, 0xd6, 0x6b, 0x9b, 0xb1,
-	0x6c, 0x8a, 0x7c, 0xec, 0x30, 0x9e, 0x79, 0x96, 0x86, 0x95, 0x66, 0x86, 0x99, 0x91, 0x91, 0x39,
-	0xa5, 0x52, 0xc5, 0x85, 0x4a, 0x55, 0xb8, 0x25, 0x55, 0x09, 0x95, 0x53, 0xaa, 0xf2, 0x07, 0xe4,
-	0x90, 0x53, 0x2e, 0xc9, 0x81, 0x43, 0x0e, 0xdc, 0x92, 0xca, 0x81, 0xa4, 0xe0, 0x96, 0x7f, 0x80,
-	0x53, 0x3e, 0xea, 0x7d, 0xcc, 0x97, 0x34, 0x23, 0xc9, 0xec, 0x2e, 0x97, 0xdc, 0xf4, 0x7a, 0xba,
-	0x7b, 0xe6, 0xf5, 0x7b, 0xaf, 0xbb, 0x7f, 0xdd, 0x4f, 0xf0, 0x84, 0x83, 0x75, 0x15, 0x5b, 0x03,
-	0x4d, 0x77, 0xae, 0xc9, 0x47, 0x8a, 0x76, 0xcd, 0x39, 0x35, 0xb1, 0xbd, 0x66, 0x5a, 0x86, 0x63,
-	0xa0, 0xaa, 0xff, 0x70, 0x8d, 0x3c, 0x6c, 0x5c, 0x0c, 0x70, 0x2b, 0xd6, 0xa9, 0xe9, 0x18, 0xd7,
-	0x4c, 0xcb, 0x30, 0x8e, 0x19, 0x7f, 0xe3, 0x42, 0xe0, 0x31, 0xd5, 0x13, 0xd4, 0x16, 0x7a, 0xca,
-	0x85, 0xef, 0xe3, 0x53, 0xf7, 0xe9, 0xc5, 0x09, 0x59, 0x53, 0xb6, 0xe4, 0x81, 0xfb, 0x78, 0xb5,
-	0x6b, 0x18, 0xdd, 0x3e, 0xbe, 0x46, 0x47, 0x47, 0xc3, 0xe3, 0x6b, 0x8e, 0x36, 0xc0, 0xb6, 0x23,
-	0x0f, 0x4c, 0xce, 0xb0, 0xdc, 0x35, 0xba, 0x06, 0xfd, 0x79, 0x8d, 0xfc, 0x62, 0x54, 0xe1, 0xbf,
-	0x00, 0x79, 0x11, 0xbf, 0x3f, 0xc4, 0xb6, 0x83, 0xae, 0x43, 0x06, 0x2b, 0x3d, 0xa3, 0x9e, 0xbc,
-	0x94, 0xbc, 0x52, 0xba, 0x7e, 0x61, 0x6d, 0x6c, 0x72, 0x6b, 0x9c, 0xaf, 0xa5, 0xf4, 0x8c, 0x76,
-	0x42, 0xa4, 0xbc, 0xe8, 0x06, 0x64, 0x8f, 0xfb, 0x43, 0xbb, 0x57, 0x4f, 0x51, 0xa1, 0x8b, 0x71,
-	0x42, 0xb7, 0x09, 0x53, 0x3b, 0x21, 0x32, 0x6e, 0xf2, 0x2a, 0x4d, 0x3f, 0x36, 0xea, 0xe9, 0xe9,
-	0xaf, 0xda, 0xd2, 0x8f, 0xe9, 0xab, 0x08, 0x2f, 0xda, 0x00, 0xd0, 0x74, 0xcd, 0x91, 0x94, 0x9e,
-	0xac, 0xe9, 0xf5, 0x0c, 0x95, 0x7c, 0x32, 0x5e, 0x52, 0x73, 0x9a, 0x84, 0xb1, 0x9d, 0x10, 0x8b,
-	0x9a, 0x3b, 0x20, 0x9f, 0xfb, 0xfe, 0x10, 0x5b, 0xa7, 0xf5, 0xec, 0xf4, 0xcf, 0x7d, 0x8b, 0x30,
-	0x91, 0xcf, 0xa5, 0xdc, 0x68, 0x0b, 0x4a, 0x47, 0xb8, 0xab, 0xe9, 0xd2, 0x51, 0xdf, 0x50, 0xee,
-	0xd7, 0x73, 0x54, 0x58, 0x88, 0x13, 0xde, 0x20, 0xac, 0x1b, 0x84, 0x73, 0x23, 0x55, 0x4f, 0xb6,
-	0x13, 0x22, 0x1c, 0x79, 0x14, 0xf4, 0x2a, 0x14, 0x94, 0x1e, 0x56, 0xee, 0x4b, 0xce, 0xa8, 0x9e,
-	0xa7, 0x7a, 0x56, 0xe3, 0xf4, 0x34, 0x09, 0x5f, 0x67, 0xd4, 0x4e, 0x88, 0x79, 0x85, 0xfd, 0x44,
-	0xb7, 0x01, 0x54, 0xdc, 0xd7, 0x4e, 0xb0, 0x45, 0xe4, 0x0b, 0xd3, 0x6d, 0xb0, 0xc9, 0x38, 0x3b,
-	0x23, 0xfe, 0x19, 0x45, 0xd5, 0x25, 0xa0, 0x26, 0x14, 0xb1, 0xae, 0xf2, 0xe9, 0x14, 0xa9, 0x9a,
-	0x4b, 0xb1, 0xeb, 0xad, 0xab, 0xc1, 0xc9, 0x14, 0x30, 0x1f, 0xa3, 0x9b, 0x90, 0x53, 0x8c, 0xc1,
-	0x40, 0x73, 0xea, 0x40, 0x35, 0xac, 0xc4, 0x4e, 0x84, 0x72, 0xb5, 0x13, 0x22, 0xe7, 0x47, 0x3b,
-	0x50, 0xe9, 0x6b, 0xb6, 0x23, 0xd9, 0xba, 0x6c, 0xda, 0x3d, 0xc3, 0xb1, 0xeb, 0x25, 0xaa, 0xe1,
-	0xa9, 0x38, 0x0d, 0xdb, 0x9a, 0xed, 0xec, 0xbb, 0xcc, 0xed, 0x84, 0x58, 0xee, 0x07, 0x09, 0x44,
-	0x9f, 0x71, 0x7c, 0x8c, 0x2d, 0x4f, 0x61, 0x7d, 0x61, 0xba, 0xbe, 0x5d, 0xc2, 0xed, 0xca, 0x13,
-	0x7d, 0x46, 0x90, 0x80, 0x7e, 0x08, 0x4b, 0x7d, 0x43, 0x56, 0x3d, 0x75, 0x92, 0xd2, 0x1b, 0xea,
-	0xf7, 0xeb, 0x65, 0xaa, 0xf4, 0xd9, 0xd8, 0x8f, 0x34, 0x64, 0xd5, 0x55, 0xd1, 0x24, 0x02, 0xed,
-	0x84, 0xb8, 0xd8, 0x1f, 0x27, 0xa2, 0x7b, 0xb0, 0x2c, 0x9b, 0x66, 0xff, 0x74, 0x5c, 0x7b, 0x85,
-	0x6a, 0xbf, 0x1a, 0xa7, 0x7d, 0x9d, 0xc8, 0x8c, 0xab, 0x47, 0xf2, 0x04, 0x15, 0x75, 0xa0, 0x66,
-	0x5a, 0xd8, 0x94, 0x2d, 0x2c, 0x99, 0x96, 0x61, 0x1a, 0xb6, 0xdc, 0xaf, 0x57, 0xa9, 0xee, 0x67,
-	0xe2, 0x74, 0xef, 0x31, 0xfe, 0x3d, 0xce, 0xde, 0x4e, 0x88, 0x55, 0x33, 0x4c, 0x62, 0x5a, 0x0d,
-	0x05, 0xdb, 0xb6, 0xaf, 0xb5, 0x36, 0x4b, 0x2b, 0xe5, 0x0f, 0x6b, 0x0d, 0x91, 0x50, 0x0b, 0x4a,
-	0x78, 0x44, 0xc4, 0xa5, 0x13, 0xc3, 0xc1, 0xf5, 0xc5, 0xe9, 0x07, 0xab, 0x45, 0x59, 0x0f, 0x0d,
-	0x07, 0x93, 0x43, 0x85, 0xbd, 0x11, 0x92, 0xe1, 0xb1, 0x13, 0x6c, 0x69, 0xc7, 0xa7, 0x54, 0x8d,
-	0x44, 0x9f, 0xd8, 0x9a, 0xa1, 0xd7, 0x11, 0x55, 0xf8, 0x5c, 0x9c, 0xc2, 0x43, 0x2a, 0x44, 0x54,
-	0xb4, 0x5c, 0x91, 0x76, 0x42, 0x5c, 0x3a, 0x99, 0x24, 0x93, 0x2d, 0x76, 0xac, 0xe9, 0x72, 0x5f,
-	0xfb, 0x10, 0xf3, 0x63, 0xb3, 0x34, 0x7d, 0x8b, 0xdd, 0xe6, 0xdc, 0xf4, 0xac, 0x90, 0x2d, 0x76,
-	0x1c, 0x24, 0x6c, 0xe4, 0x21, 0x7b, 0x22, 0xf7, 0x87, 0x58, 0x78, 0x06, 0x4a, 0x01, 0xc7, 0x8a,
-	0xea, 0x90, 0x1f, 0x60, 0xdb, 0x96, 0xbb, 0x98, 0xfa, 0xe1, 0xa2, 0xe8, 0x0e, 0x85, 0x0a, 0x2c,
-	0x04, 0x9d, 0xa9, 0xf0, 0x49, 0xd2, 0x93, 0x24, 0x7e, 0x92, 0x48, 0x9e, 0x60, 0x8b, 0x4e, 0x9b,
-	0x4b, 0xf2, 0x21, 0xba, 0x0c, 0x65, 0xfa, 0xc9, 0x92, 0xfb, 0x9c, 0x38, 0xeb, 0x8c, 0xb8, 0x40,
-	0x89, 0x87, 0x9c, 0x69, 0x15, 0x4a, 0xe6, 0x75, 0xd3, 0x63, 0x49, 0x53, 0x16, 0x30, 0xaf, 0x9b,
-	0x2e, 0xc3, 0x93, 0xb0, 0x40, 0xe6, 0xe7, 0x71, 0x64, 0xe8, 0x4b, 0x4a, 0x84, 0xc6, 0x59, 0x84,
-	0xbf, 0xa4, 0xa0, 0x36, 0xee, 0x80, 0xd1, 0x4d, 0xc8, 0x90, 0x58, 0xc4, 0xc3, 0x4a, 0x63, 0x8d,
-	0x05, 0xaa, 0x35, 0x37, 0x50, 0xad, 0x75, 0xdc, 0x40, 0xb5, 0x51, 0xf8, 0xec, 0x8b, 0xd5, 0xc4,
-	0x27, 0xff, 0x58, 0x4d, 0x8a, 0x54, 0x02, 0x9d, 0x27, 0xbe, 0x52, 0xd6, 0x74, 0x49, 0x53, 0xe9,
-	0x27, 0x17, 0x89, 0x23, 0x94, 0x35, 0x7d, 0x4b, 0x45, 0xdb, 0x50, 0x53, 0x0c, 0xdd, 0xc6, 0xba,
-	0x3d, 0xb4, 0x25, 0x16, 0x08, 0x79, 0x30, 0x09, 0xb9, 0x43, 0x16, 0x5e, 0x9b, 0x2e, 0xe7, 0x1e,
-	0x65, 0x14, 0xab, 0x4a, 0x98, 0x40, 0xdc, 0xea, 0x89, 0xdc, 0xd7, 0x54, 0xd9, 0x31, 0x2c, 0xbb,
-	0x9e, 0xb9, 0x94, 0x8e, 0xf4, 0x87, 0x87, 0x2e, 0xcb, 0x81, 0xa9, 0xca, 0x0e, 0xde, 0xc8, 0x90,
-	0xcf, 0x15, 0x03, 0x92, 0xe8, 0x69, 0xa8, 0xca, 0xa6, 0x29, 0xd9, 0x8e, 0xec, 0x60, 0xe9, 0xe8,
-	0xd4, 0xc1, 0x36, 0x0d, 0x34, 0x0b, 0x62, 0x59, 0x36, 0xcd, 0x7d, 0x42, 0xdd, 0x20, 0x44, 0xf4,
-	0x14, 0x54, 0x48, 0x4c, 0xd2, 0xe4, 0xbe, 0xd4, 0xc3, 0x5a, 0xb7, 0xe7, 0xd0, 0x90, 0x92, 0x16,
-	0xcb, 0x9c, 0xda, 0xa6, 0x44, 0x41, 0xf5, 0x56, 0x9c, 0xc6, 0x23, 0x84, 0x20, 0xa3, 0xca, 0x8e,
-	0x4c, 0x2d, 0xb9, 0x20, 0xd2, 0xdf, 0x84, 0x66, 0xca, 0x4e, 0x8f, 0xdb, 0x87, 0xfe, 0x46, 0xe7,
-	0x20, 0xc7, 0xd5, 0xa6, 0xa9, 0x5a, 0x3e, 0x42, 0xcb, 0x90, 0x35, 0x2d, 0xe3, 0x04, 0xd3, 0xa5,
-	0x2b, 0x88, 0x6c, 0x20, 0xfc, 0x24, 0x05, 0x8b, 0x13, 0x91, 0x8b, 0xe8, 0xed, 0xc9, 0x76, 0xcf,
-	0x7d, 0x17, 0xf9, 0x8d, 0x5e, 0x26, 0x7a, 0x65, 0x15, 0x5b, 0x3c, 0xda, 0xd7, 0x27, 0x4d, 0xdd,
-	0xa6, 0xcf, 0xb9, 0x69, 0x38, 0x37, 0xba, 0x03, 0xb5, 0xbe, 0x6c, 0x3b, 0x12, 0xf3, 0xfe, 0x52,
-	0x20, 0xf2, 0x3f, 0x31, 0x61, 0x64, 0x16, 0x2b, 0xc8, 0x86, 0xe6, 0x4a, 0x2a, 0x44, 0xd4, 0xa7,
-	0x22, 0x11, 0x96, 0x8f, 0x4e, 0x3f, 0x94, 0x75, 0x47, 0xd3, 0xb1, 0x34, 0xb1, 0x6a, 0xe7, 0x27,
-	0x14, 0xb6, 0x4e, 0x34, 0x15, 0xeb, 0x8a, 0xbb, 0x5c, 0x4b, 0x9e, 0xb0, 0xb7, 0x9c, 0xb6, 0x20,
-	0x42, 0x25, 0x1c, 0x73, 0x51, 0x05, 0x52, 0xce, 0x88, 0x4f, 0x3e, 0xe5, 0x8c, 0xd0, 0x77, 0x20,
-	0x43, 0x26, 0x48, 0x27, 0x5e, 0x89, 0x48, 0x58, 0xb8, 0x5c, 0xe7, 0xd4, 0xc4, 0x22, 0xe5, 0x14,
-	0x04, 0xef, 0x28, 0x78, 0x71, 0x78, 0x5c, 0xab, 0xf0, 0x2c, 0x54, 0xc7, 0x82, 0x6c, 0x60, 0xed,
-	0x92, 0xc1, 0xb5, 0x13, 0xaa, 0x50, 0x0e, 0x45, 0x53, 0xe1, 0x1c, 0x2c, 0x47, 0x05, 0x47, 0xa1,
-	0xe7, 0xd1, 0x43, 0x41, 0x0e, 0xdd, 0x80, 0x82, 0x17, 0x1d, 0xd9, 0x51, 0x9c, 0xb4, 0x95, 0xcb,
-	0x2c, 0x7a, 0xac, 0xe4, 0x0c, 0x92, 0x2d, 0x4d, 0xf7, 0x42, 0x8a, 0x7e, 0x78, 0x5e, 0x36, 0xcd,
-	0xb6, 0x6c, 0xf7, 0x84, 0x77, 0xa1, 0x1e, 0x17, 0xf9, 0xc6, 0xa6, 0x91, 0xf1, 0xb6, 0xe0, 0x39,
-	0xc8, 0x1d, 0x1b, 0xd6, 0x40, 0x76, 0xa8, 0xb2, 0xb2, 0xc8, 0x47, 0x64, 0x6b, 0xb2, 0x28, 0x98,
-	0xa6, 0x64, 0x36, 0x10, 0x24, 0x38, 0x1f, 0x1b, 0xfd, 0x88, 0x88, 0xa6, 0xab, 0x98, 0xd9, 0xb3,
-	0x2c, 0xb2, 0x81, 0xaf, 0x88, 0x7d, 0x2c, 0x1b, 0x90, 0xd7, 0xda, 0x74, 0xae, 0x54, 0x7f, 0x51,
-	0xe4, 0x23, 0xe1, 0x4f, 0x29, 0x38, 0x17, 0x1d, 0x03, 0x1f, 0xea, 0x01, 0xa8, 0x41, 0xda, 0x19,
-	0x11, 0x07, 0x95, 0xbe, 0xb2, 0x20, 0x92, 0x9f, 0xe8, 0x00, 0x16, 0xfb, 0x86, 0x22, 0xf7, 0xa5,
-	0xc0, 0xc1, 0xe0, 0x39, 0xed, 0xe5, 0xc9, 0x2d, 0x4c, 0x23, 0x1d, 0x56, 0x27, 0xce, 0x46, 0x95,
-	0xea, 0xd8, 0xf6, 0x0e, 0x48, 0xec, 0xe1, 0xc8, 0x7e, 0xf3, 0xc3, 0x81, 0x2e, 0xc1, 0xc2, 0x40,
-	0x1e, 0x49, 0xce, 0x88, 0x7b, 0x34, 0xe6, 0xaa, 0x60, 0x20, 0x8f, 0x3a, 0x23, 0xea, 0xce, 0x84,
-	0xdf, 0x04, 0xad, 0x18, 0x0e, 0xf0, 0x8f, 0xd6, 0x8a, 0xfb, 0xb0, 0xcc, 0x92, 0x11, 0xac, 0x46,
-	0x18, 0x72, 0x0e, 0xe7, 0x82, 0x5c, 0xf1, 0x47, 0x6b, 0x43, 0xe1, 0x75, 0xcf, 0xc5, 0xfa, 0x39,
-	0x4c, 0xa4, 0x6d, 0xfc, 0x73, 0x93, 0x0a, 0x1d, 0xff, 0x5f, 0x27, 0xa1, 0x11, 0x9f, 0xb4, 0x44,
-	0xaa, 0x7a, 0x0e, 0x16, 0xbd, 0xaf, 0x97, 0x64, 0x55, 0xb5, 0xb0, 0x6d, 0xf3, 0x53, 0x51, 0xf3,
-	0x1e, 0xac, 0x33, 0x7a, 0x6c, 0xc8, 0x78, 0x0a, 0x2a, 0x63, 0x29, 0x55, 0x86, 0x05, 0xb4, 0x93,
-	0xe0, 0xfb, 0x85, 0x5f, 0xa5, 0x3c, 0xaf, 0x13, 0xca, 0x7b, 0x1e, 0xf1, 0xfa, 0xbf, 0x05, 0x4b,
-	0x2a, 0x56, 0x34, 0xf5, 0x9b, 0x2e, 0xff, 0x22, 0x97, 0x7e, 0xc4, 0xab, 0xff, 0xd7, 0x12, 0x14,
-	0x44, 0x6c, 0x9b, 0x24, 0xeb, 0x40, 0x1b, 0x50, 0xc4, 0x23, 0x05, 0x9b, 0x8e, 0x9b, 0xa8, 0x45,
-	0x27, 0xbc, 0x8c, 0xbb, 0xe5, 0x72, 0x12, 0xf8, 0xe6, 0x89, 0xa1, 0x97, 0x38, 0x52, 0x8f, 0x07,
-	0xdd, 0x5c, 0x3c, 0x08, 0xd5, 0x5f, 0x76, 0xa1, 0x7a, 0x3a, 0x16, 0xad, 0x31, 0xa9, 0x31, 0xac,
-	0xfe, 0x12, 0xc7, 0xea, 0x99, 0x19, 0x2f, 0x0b, 0x81, 0xf5, 0x66, 0x08, 0xac, 0x67, 0x67, 0x4c,
-	0x33, 0x06, 0xad, 0xbf, 0xec, 0xa2, 0xf5, 0xdc, 0x8c, 0x2f, 0x1e, 0x83, 0xeb, 0x6f, 0x86, 0xe1,
-	0x7a, 0x3e, 0xc6, 0xad, 0xba, 0xd2, 0x53, 0xf1, 0xfa, 0x6b, 0x01, 0xbc, 0x5e, 0x88, 0x05, 0xca,
-	0x4c, 0x51, 0x04, 0x60, 0x7f, 0x23, 0x04, 0xd8, 0x8b, 0x33, 0xec, 0x30, 0x05, 0xb1, 0x6f, 0x06,
-	0x11, 0x3b, 0xc4, 0x02, 0x7f, 0xbe, 0xee, 0x71, 0x90, 0xfd, 0x15, 0x0f, 0xb2, 0x97, 0x62, 0x6b,
-	0x0f, 0x7c, 0x2e, 0xe3, 0x98, 0x7d, 0x77, 0x02, 0xb3, 0x33, 0x8c, 0xfd, 0x74, 0xac, 0x8a, 0x19,
-	0xa0, 0x7d, 0x77, 0x02, 0xb4, 0x97, 0x67, 0x28, 0x9c, 0x81, 0xda, 0x7f, 0x14, 0x8d, 0xda, 0xe3,
-	0x71, 0x35, 0xff, 0xcc, 0xf9, 0x60, 0xbb, 0x14, 0x03, 0xdb, 0xab, 0xb1, 0x10, 0x93, 0xa9, 0x9f,
-	0x1b, 0xb7, 0x1f, 0x44, 0xe0, 0x76, 0x86, 0xb0, 0xaf, 0xc4, 0x2a, 0x9f, 0x03, 0xb8, 0x1f, 0x44,
-	0x00, 0xf7, 0xc5, 0x99, 0x6a, 0x67, 0x22, 0xf7, 0xdb, 0x61, 0xe4, 0x8e, 0x66, 0x9c, 0xb1, 0x58,
-	0xe8, 0x7e, 0x14, 0x07, 0xdd, 0x19, 0xbc, 0x7e, 0x3e, 0x56, 0xe3, 0x19, 0xb0, 0xfb, 0xee, 0x04,
-	0x76, 0x5f, 0x9e, 0xb1, 0xd3, 0xe6, 0x05, 0xef, 0xcf, 0x92, 0xb8, 0x3e, 0xe6, 0xaa, 0x49, 0x0a,
-	0x8a, 0x2d, 0xcb, 0xb0, 0x38, 0x0c, 0x67, 0x03, 0xe1, 0x0a, 0x01, 0x73, 0xbe, 0x5b, 0x9e, 0x02,
-	0xf4, 0x69, 0xaa, 0x1f, 0x70, 0xc5, 0xc2, 0x1f, 0x92, 0xbe, 0x2c, 0xc5, 0x40, 0x41, 0x20, 0x58,
-	0xe4, 0x40, 0x30, 0x00, 0xff, 0x53, 0x61, 0xf8, 0xbf, 0x0a, 0x25, 0x92, 0xc2, 0x8f, 0x21, 0x7b,
-	0xd9, 0xf4, 0x90, 0xfd, 0x55, 0x58, 0xa4, 0xe1, 0x93, 0x15, 0x09, 0x78, 0x1e, 0x90, 0xa1, 0x79,
-	0x40, 0x95, 0x3c, 0x60, 0x56, 0x60, 0x09, 0xc1, 0x0b, 0xb0, 0x14, 0xe0, 0xf5, 0xa0, 0x01, 0x83,
-	0xb9, 0x35, 0x8f, 0x7b, 0x9d, 0x63, 0x84, 0x3f, 0x27, 0x7d, 0x0b, 0xf9, 0x25, 0x81, 0x28, 0xf4,
-	0x9e, 0x7c, 0x48, 0xe8, 0x3d, 0xf5, 0x8d, 0xd1, 0x7b, 0x10, 0xea, 0xa4, 0xc3, 0x50, 0xe7, 0xeb,
-	0xa4, 0xbf, 0x26, 0x1e, 0x16, 0x57, 0x0c, 0x15, 0x73, 0xf0, 0x41, 0x7f, 0x93, 0x04, 0xa5, 0x6f,
-	0x74, 0x39, 0xc4, 0x20, 0x3f, 0x09, 0x97, 0x17, 0x3b, 0x8b, 0x3c, 0x34, 0x7a, 0xb8, 0x25, 0x4b,
-	0x2d, 0xcc, 0x71, 0x4b, 0x0d, 0xd2, 0xf7, 0x31, 0x8b, 0x74, 0x0b, 0x22, 0xf9, 0x49, 0xf8, 0xe8,
-	0x26, 0xa3, 0xf1, 0x6b, 0x41, 0x64, 0x03, 0x74, 0x13, 0x8a, 0xb4, 0xa3, 0x20, 0x19, 0xa6, 0xcd,
-	0x03, 0x52, 0x28, 0xd1, 0x61, 0x8d, 0x83, 0xb5, 0x3d, 0xc2, 0xb3, 0x6b, 0xda, 0x62, 0xc1, 0xe4,
-	0xbf, 0x02, 0x29, 0x5e, 0x31, 0x94, 0xe2, 0x5d, 0x80, 0x22, 0xf9, 0x7a, 0xdb, 0x94, 0x15, 0x4c,
-	0x23, 0x4b, 0x51, 0xf4, 0x09, 0xc2, 0x3d, 0x40, 0x93, 0x71, 0x12, 0xb5, 0x21, 0x87, 0x4f, 0xb0,
-	0xee, 0x90, 0x65, 0x23, 0xe6, 0x3e, 0x17, 0x91, 0x17, 0x61, 0xdd, 0xd9, 0xa8, 0x13, 0x23, 0xff,
-	0xeb, 0x8b, 0xd5, 0x1a, 0xe3, 0x7e, 0xde, 0x18, 0x68, 0x0e, 0x1e, 0x98, 0xce, 0xa9, 0xc8, 0xe5,
-	0x85, 0xbf, 0xa7, 0x08, 0x06, 0x0e, 0xc5, 0xcf, 0x48, 0xdb, 0xba, 0x5b, 0x3e, 0x15, 0xa8, 0x7d,
-	0xcc, 0x67, 0xef, 0x8b, 0x00, 0x5d, 0xd9, 0x96, 0x3e, 0x90, 0x75, 0x07, 0xab, 0xdc, 0xe8, 0xc5,
-	0xae, 0x6c, 0xbf, 0x4d, 0x09, 0x64, 0xd5, 0xc9, 0xe3, 0xa1, 0x8d, 0x55, 0x0e, 0x6d, 0xf2, 0x5d,
-	0xd9, 0x3e, 0xb0, 0xb1, 0x1a, 0x98, 0x65, 0xfe, 0xc1, 0x66, 0x19, 0xb6, 0x71, 0x61, 0xcc, 0xc6,
-	0x01, 0x74, 0x5a, 0x0c, 0xa2, 0x53, 0xd4, 0x80, 0x82, 0x69, 0x69, 0x86, 0xa5, 0x39, 0xa7, 0x74,
-	0x61, 0xd2, 0xa2, 0x37, 0x46, 0x97, 0xa1, 0x3c, 0xc0, 0x03, 0xd3, 0x30, 0xfa, 0x12, 0x73, 0x36,
-	0x25, 0x2a, 0xba, 0xc0, 0x89, 0x2d, 0xea, 0x73, 0x3e, 0x4a, 0xf9, 0xa7, 0xcf, 0xaf, 0x42, 0x3c,
-	0x5c, 0xf3, 0xae, 0x44, 0x98, 0x37, 0x40, 0x21, 0x93, 0x18, 0xb3, 0xaf, 0x37, 0xfe, 0xb6, 0x0c,
-	0x2c, 0xfc, 0x8c, 0xd6, 0x25, 0xc3, 0xb9, 0x11, 0xda, 0x0f, 0xe2, 0xa3, 0x21, 0x75, 0x0a, 0xee,
-	0x76, 0x9e, 0xd7, 0x7b, 0xf8, 0x38, 0x8a, 0x91, 0x6d, 0xf4, 0x0e, 0x3c, 0x3e, 0xe6, 0xd9, 0x3c,
-	0xd5, 0xa9, 0x79, 0x1d, 0xdc, 0x63, 0x61, 0x07, 0xe7, 0xaa, 0xf6, 0x8d, 0x95, 0x7e, 0xc0, 0x33,
-	0xb7, 0x05, 0x95, 0x70, 0x9a, 0x17, 0xb9, 0xfc, 0x97, 0xa1, 0x6c, 0x61, 0x47, 0xd6, 0x74, 0x29,
-	0x84, 0x0c, 0x17, 0x18, 0x91, 0x97, 0x28, 0xf7, 0xe0, 0xb1, 0xc8, 0x74, 0x0f, 0x7d, 0x17, 0x8a,
-	0x7e, 0xa6, 0x98, 0x8c, 0x01, 0x4f, 0x5e, 0xbd, 0xc9, 0xe7, 0x15, 0xfe, 0x98, 0xf4, 0x55, 0x86,
-	0x2b, 0x58, 0x2d, 0xc8, 0x59, 0xd8, 0x1e, 0xf6, 0x59, 0x4d, 0xa9, 0x72, 0xfd, 0x85, 0xf9, 0x12,
-	0x45, 0x42, 0x1d, 0xf6, 0x1d, 0x91, 0x0b, 0x0b, 0xf7, 0x20, 0xc7, 0x28, 0xa8, 0x04, 0xf9, 0x83,
-	0x9d, 0x3b, 0x3b, 0xbb, 0x6f, 0xef, 0xd4, 0x12, 0x08, 0x20, 0xb7, 0xde, 0x6c, 0xb6, 0xf6, 0x3a,
-	0xb5, 0x24, 0x2a, 0x42, 0x76, 0x7d, 0x63, 0x57, 0xec, 0xd4, 0x52, 0x84, 0x2c, 0xb6, 0xde, 0x6c,
-	0x35, 0x3b, 0xb5, 0x34, 0x5a, 0x84, 0x32, 0xfb, 0x2d, 0xdd, 0xde, 0x15, 0xef, 0xae, 0x77, 0x6a,
-	0x99, 0x00, 0x69, 0xbf, 0xb5, 0xb3, 0xd9, 0x12, 0x6b, 0x59, 0xe1, 0x45, 0x38, 0x1f, 0x9b, 0x5a,
-	0xfa, 0xe5, 0xa9, 0x64, 0xa0, 0x3c, 0x25, 0xfc, 0x32, 0x45, 0xd0, 0x7d, 0x5c, 0xbe, 0x88, 0xde,
-	0x1c, 0x9b, 0xf8, 0xf5, 0x33, 0x24, 0x9b, 0x63, 0xb3, 0x27, 0x80, 0xde, 0xc2, 0xc7, 0xd8, 0x51,
-	0x7a, 0x2c, 0x7f, 0x65, 0x01, 0xb3, 0x2c, 0x96, 0x39, 0x95, 0x0a, 0xd9, 0x8c, 0xed, 0x3d, 0xac,
-	0x38, 0x12, 0xf3, 0x45, 0x6c, 0xd3, 0x15, 0x09, 0x1b, 0xa1, 0xee, 0x33, 0xa2, 0xf0, 0xee, 0x99,
-	0x6c, 0x59, 0x84, 0xac, 0xd8, 0xea, 0x88, 0xef, 0xd4, 0xd2, 0x08, 0x41, 0x85, 0xfe, 0x94, 0xf6,
-	0x77, 0xd6, 0xf7, 0xf6, 0xdb, 0xbb, 0xc4, 0x96, 0x4b, 0x50, 0x75, 0x6d, 0xe9, 0x12, 0xb3, 0xc2,
-	0xd7, 0x29, 0x78, 0x3c, 0x26, 0xdb, 0x25, 0x89, 0xcd, 0xc0, 0x50, 0xb5, 0x63, 0x0d, 0xab, 0x12,
-	0xaf, 0xab, 0x16, 0x44, 0x70, 0x49, 0x9d, 0x11, 0xba, 0x09, 0xe0, 0x8c, 0x24, 0x0b, 0x2b, 0x86,
-	0xa5, 0xba, 0x99, 0xc1, 0xe4, 0x2e, 0xec, 0x8c, 0x44, 0xca, 0x21, 0x16, 0x1d, 0xfe, 0x6b, 0x5a,
-	0x2e, 0x80, 0x5e, 0xe5, 0x4a, 0xc9, 0xb4, 0xdd, 0xb2, 0xf3, 0xc5, 0x88, 0x9a, 0x1d, 0x56, 0x88,
-	0x62, 0x6a, 0x7c, 0xaa, 0x98, 0xf2, 0xa3, 0xbb, 0x51, 0x5e, 0x27, 0x3b, 0x9f, 0xd7, 0x39, 0x9b,
-	0xbf, 0xc9, 0x3d, 0x98, 0xbf, 0x11, 0x7e, 0x1f, 0xb2, 0x7c, 0x38, 0xfb, 0x3f, 0x07, 0x39, 0x59,
-	0x21, 0xf9, 0x2e, 0x37, 0x3a, 0x1f, 0x4d, 0xa9, 0x16, 0x8f, 0x99, 0x2d, 0xfd, 0x30, 0xcc, 0x96,
-	0x79, 0x14, 0x66, 0xcb, 0x3e, 0xa0, 0xd9, 0x6e, 0xf9, 0x09, 0x53, 0xa0, 0xd6, 0x37, 0x59, 0x47,
-	0x4b, 0x46, 0xd5, 0xd1, 0x6e, 0xc0, 0x13, 0x53, 0xf0, 0x4d, 0x9c, 0xd9, 0x85, 0x9f, 0xa7, 0x7d,
-	0x9f, 0x19, 0xae, 0xbf, 0x3d, 0xb4, 0x44, 0x6d, 0x6c, 0xfd, 0x52, 0x67, 0x5c, 0xbf, 0xc8, 0x60,
-	0x9b, 0x7e, 0x74, 0xc1, 0x36, 0xf3, 0x80, 0xc1, 0x36, 0xb8, 0x91, 0xb3, 0xe1, 0x8d, 0x3c, 0x11,
-	0x17, 0x73, 0x11, 0x71, 0xf1, 0x1d, 0x80, 0x40, 0xcf, 0x6a, 0x19, 0xb2, 0x96, 0x31, 0xd4, 0x55,
-	0xba, 0x6c, 0x59, 0x91, 0x0d, 0xd0, 0x0d, 0xc8, 0x92, 0xd5, 0x8f, 0x77, 0x4c, 0x64, 0xf1, 0x03,
-	0xd5, 0x4a, 0xc6, 0x2d, 0x68, 0x80, 0x26, 0x1b, 0x02, 0x31, 0xaf, 0x78, 0x2d, 0xfc, 0x8a, 0x27,
-	0x63, 0x5b, 0x0b, 0xd1, 0xaf, 0xfa, 0x10, 0xb2, 0x74, 0x7b, 0x90, 0xfc, 0x80, 0xb6, 0xbf, 0x38,
-	0xe0, 0x24, 0xbf, 0xd1, 0x8f, 0x01, 0x64, 0xc7, 0xb1, 0xb4, 0xa3, 0xa1, 0xff, 0x82, 0xd5, 0xe8,
-	0xed, 0xb5, 0xee, 0xf2, 0x6d, 0x5c, 0xe0, 0xfb, 0x6c, 0xd9, 0x17, 0x0d, 0xec, 0xb5, 0x80, 0x42,
-	0x61, 0x07, 0x2a, 0x61, 0x59, 0x17, 0x22, 0xb1, 0x6f, 0x08, 0x43, 0x24, 0x86, 0x78, 0x39, 0x44,
-	0xf2, 0x00, 0x56, 0x9a, 0xb5, 0x39, 0xe9, 0x40, 0xf8, 0x4f, 0x12, 0x16, 0x82, 0xbb, 0xf3, 0xff,
-	0x0d, 0x65, 0x08, 0x1f, 0x25, 0xa1, 0xe0, 0x4d, 0x3e, 0xa6, 0xcd, 0xe8, 0xdb, 0x2e, 0x15, 0x6c,
-	0xaa, 0xb1, 0xbe, 0x65, 0xda, 0xeb, 0x86, 0xde, 0xf2, 0x12, 0x92, 0xb8, 0xa2, 0x70, 0xd0, 0xd2,
-	0x6e, 0x19, 0x9f, 0xe7, 0x5f, 0xbf, 0xe0, 0xdf, 0x41, 0x02, 0x2d, 0xfa, 0x1e, 0xf1, 0x68, 0x5e,
-	0x29, 0xbc, 0x12, 0x51, 0x1b, 0x75, 0x59, 0xd7, 0x3a, 0xa3, 0x75, 0xca, 0x29, 0x72, 0x09, 0xfe,
-	0x55, 0x29, 0xaf, 0x9b, 0xfa, 0x3a, 0xd1, 0xcb, 0x78, 0xc2, 0xe9, 0x48, 0x05, 0xe0, 0x60, 0xe7,
-	0xee, 0xee, 0xe6, 0xd6, 0xed, 0xad, 0xd6, 0x26, 0x4f, 0x49, 0x36, 0x37, 0x5b, 0x9b, 0xb5, 0x14,
-	0xe1, 0x13, 0x5b, 0x77, 0x77, 0x0f, 0x5b, 0x9b, 0xb5, 0xb4, 0x70, 0x0b, 0x8a, 0x9e, 0xeb, 0x41,
-	0x75, 0xc8, 0xbb, 0x4d, 0x93, 0x24, 0x77, 0x00, 0xbc, 0x57, 0xb2, 0x0c, 0x59, 0xd3, 0xf8, 0x80,
-	0xf7, 0x12, 0xd3, 0x22, 0x1b, 0x08, 0x2a, 0x54, 0xc7, 0xfc, 0x16, 0xba, 0x05, 0x79, 0x73, 0x78,
-	0x24, 0xb9, 0x9b, 0x76, 0xec, 0xa2, 0x9b, 0x8b, 0xd4, 0x87, 0x47, 0x7d, 0x4d, 0xb9, 0x83, 0x4f,
-	0x5d, 0x33, 0x99, 0xc3, 0xa3, 0x3b, 0x6c, 0x6f, 0xb3, 0xb7, 0xa4, 0x82, 0x6f, 0x39, 0x81, 0x82,
-	0x7b, 0x54, 0xd1, 0xf7, 0xa1, 0xe8, 0xb9, 0x44, 0xef, 0x76, 0x45, 0xac, 0x2f, 0xe5, 0xea, 0x7d,
-	0x11, 0x74, 0x15, 0x16, 0x6d, 0xad, 0xab, 0xbb, 0xcd, 0x13, 0x56, 0x19, 0x4b, 0xd1, 0x33, 0x53,
-	0x65, 0x0f, 0xb6, 0xdd, 0x72, 0x8e, 0xf0, 0xdb, 0x24, 0xd4, 0xc6, 0x7d, 0xc5, 0xb7, 0xf9, 0x01,
-	0x11, 0x01, 0x34, 0x1d, 0x15, 0x40, 0xff, 0x9d, 0x84, 0x82, 0xdb, 0x92, 0x41, 0x2f, 0x06, 0xbc,
-	0x56, 0x25, 0x6a, 0x93, 0x72, 0x46, 0xbf, 0x6b, 0x1f, 0x9e, 0x52, 0xea, 0xec, 0x53, 0x8a, 0xeb,
-	0xa3, 0xb9, 0x97, 0x60, 0x32, 0x67, 0xbe, 0x04, 0xf3, 0x3c, 0x20, 0xc7, 0x70, 0xe4, 0xbe, 0x74,
-	0x62, 0x38, 0x9a, 0xde, 0x95, 0xd8, 0xa6, 0x60, 0x0e, 0xa6, 0x46, 0x9f, 0x1c, 0xd2, 0x07, 0x7b,
-	0x74, 0x7f, 0xfc, 0x34, 0x09, 0x05, 0x0f, 0x30, 0x9d, 0xb5, 0x09, 0x7f, 0x0e, 0x72, 0x1c, 0x13,
-	0xb0, 0x2e, 0x3c, 0x1f, 0x79, 0x4d, 0xbc, 0x4c, 0xa0, 0x89, 0xd7, 0x80, 0xc2, 0x00, 0x3b, 0x32,
-	0xf5, 0x96, 0x2c, 0x40, 0x7a, 0xe3, 0xab, 0xaf, 0x40, 0x29, 0x70, 0x1f, 0x82, 0x38, 0xd0, 0x9d,
-	0xd6, 0xdb, 0xb5, 0x44, 0x23, 0xff, 0xf1, 0xa7, 0x97, 0xd2, 0x3b, 0xf8, 0x03, 0x72, 0xb6, 0xc4,
-	0x56, 0xb3, 0xdd, 0x6a, 0xde, 0xa9, 0x25, 0x1b, 0xa5, 0x8f, 0x3f, 0xbd, 0x94, 0x17, 0x31, 0xed,
-	0x98, 0x5c, 0x6d, 0xc3, 0x42, 0x70, 0x55, 0xc2, 0xe7, 0x18, 0x41, 0x65, 0xf3, 0x60, 0x6f, 0x7b,
-	0xab, 0xb9, 0xde, 0x69, 0x49, 0x87, 0xbb, 0x9d, 0x56, 0x2d, 0x89, 0x1e, 0x87, 0xa5, 0xed, 0xad,
-	0x37, 0xda, 0x1d, 0xa9, 0xb9, 0xbd, 0xd5, 0xda, 0xe9, 0x48, 0xeb, 0x9d, 0xce, 0x7a, 0xf3, 0x4e,
-	0x2d, 0x75, 0xfd, 0x77, 0x25, 0xa8, 0xae, 0x6f, 0x34, 0xb7, 0x08, 0x24, 0xd2, 0x14, 0x99, 0x7a,
-	0x85, 0x26, 0x64, 0x68, 0xed, 0x75, 0xea, 0xdd, 0xd6, 0xc6, 0xf4, 0x7e, 0x1a, 0xba, 0x0d, 0x59,
-	0x5a, 0x96, 0x45, 0xd3, 0x2f, 0xbb, 0x36, 0x66, 0x34, 0xd8, 0xc8, 0xc7, 0xd0, 0x53, 0x34, 0xf5,
-	0xf6, 0x6b, 0x63, 0x7a, 0xbf, 0x0d, 0x6d, 0x43, 0xde, 0xad, 0x9a, 0xcd, 0xba, 0x47, 0xda, 0x98,
-	0xd9, 0xb8, 0x22, 0x53, 0x63, 0xd5, 0xcd, 0xe9, 0x17, 0x63, 0x1b, 0x33, 0x3a, 0x71, 0x68, 0x0b,
-	0x72, 0xbc, 0xb0, 0x30, 0xe3, 0x4e, 0x68, 0x63, 0x56, 0x03, 0x0a, 0x89, 0x50, 0xf4, 0xeb, 0xc6,
-	0xb3, 0xaf, 0xfb, 0x36, 0xe6, 0x68, 0x32, 0xa2, 0x7b, 0x50, 0x0e, 0x17, 0x2b, 0xe6, 0xbb, 0x77,
-	0xda, 0x98, 0xb3, 0xd5, 0x45, 0xf4, 0x87, 0x2b, 0x17, 0xf3, 0xdd, 0x43, 0x6d, 0xcc, 0xd9, 0xf9,
-	0x42, 0xef, 0xc1, 0xe2, 0x64, 0x65, 0x61, 0xfe, 0x6b, 0xa9, 0x8d, 0x33, 0xf4, 0xc2, 0xd0, 0x00,
-	0x50, 0x44, 0x45, 0xe2, 0x0c, 0xb7, 0x54, 0x1b, 0x67, 0x69, 0x8d, 0x21, 0x15, 0xaa, 0xe3, 0x28,
-	0x7f, 0xde, 0x5b, 0xab, 0x8d, 0xb9, 0xdb, 0x64, 0xec, 0x2d, 0x61, 0x44, 0x3b, 0xef, 0x2d, 0xd6,
-	0xc6, 0xdc, 0x5d, 0x33, 0x74, 0x00, 0x10, 0x40, 0x80, 0x73, 0xdc, 0x6a, 0x6d, 0xcc, 0xd3, 0x3f,
-	0x43, 0x26, 0x2c, 0x45, 0x61, 0xc3, 0xb3, 0x5c, 0x72, 0x6d, 0x9c, 0xa9, 0xad, 0x46, 0xf6, 0x73,
-	0x18, 0x55, 0xce, 0x77, 0xe9, 0xb5, 0x31, 0x67, 0x7f, 0x6d, 0xa3, 0xf5, 0xd9, 0x97, 0x2b, 0xc9,
-	0xcf, 0xbf, 0x5c, 0x49, 0xfe, 0xf3, 0xcb, 0x95, 0xe4, 0x27, 0x5f, 0xad, 0x24, 0x3e, 0xff, 0x6a,
-	0x25, 0xf1, 0xb7, 0xaf, 0x56, 0x12, 0x3f, 0x78, 0xae, 0xab, 0x39, 0xbd, 0xe1, 0xd1, 0x9a, 0x62,
-	0x0c, 0xae, 0x05, 0xff, 0xff, 0x10, 0xf5, 0x9f, 0x8c, 0xa3, 0x1c, 0x8d, 0xa6, 0x2f, 0xfd, 0x2f,
-	0x00, 0x00, 0xff, 0xff, 0xe8, 0x59, 0xbe, 0x94, 0xb3, 0x31, 0x00, 0x00,
+	// 3453 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5b, 0xcb, 0x73, 0x1b, 0xc7,
+	0xd1, 0xc7, 0xfb, 0xd1, 0x78, 0x2d, 0x87, 0xb4, 0x0c, 0xc1, 0x12, 0x29, 0xaf, 0xca, 0xb6, 0x2c,
+	0xdb, 0xd4, 0x67, 0xa9, 0x64, 0x4b, 0x9f, 0xec, 0xcf, 0x45, 0x82, 0x90, 0x41, 0x89, 0x22, 0xe9,
+	0x25, 0x28, 0x97, 0xbf, 0xef, 0x8b, 0xd6, 0x4b, 0xec, 0x10, 0x58, 0x0b, 0xc0, 0xae, 0x77, 0x17,
+	0x34, 0xe8, 0x53, 0x2a, 0x55, 0xbe, 0xb8, 0x52, 0x15, 0xdf, 0x92, 0xaa, 0xc4, 0x95, 0x4b, 0x52,
+	0x95, 0x3f, 0x21, 0xa7, 0x5c, 0x92, 0x83, 0x0f, 0x39, 0xf8, 0x96, 0x54, 0x0e, 0x4e, 0xca, 0xbe,
+	0xe5, 0x1f, 0xc8, 0x29, 0x4e, 0x6a, 0x1e, 0xfb, 0x02, 0x76, 0xf1, 0xb0, 0x24, 0x5f, 0x72, 0xdb,
+	0x69, 0x74, 0xf7, 0xee, 0xf4, 0xcc, 0x74, 0xf7, 0xaf, 0x7b, 0x00, 0xcf, 0xd8, 0x78, 0xa0, 0x62,
+	0xb3, 0xaf, 0x0d, 0xec, 0x2b, 0xca, 0x51, 0x5b, 0xbb, 0x62, 0x9f, 0x1a, 0xd8, 0x5a, 0x37, 0x4c,
+	0xdd, 0xd6, 0x51, 0xc5, 0xfb, 0x71, 0x9d, 0xfc, 0x58, 0x3b, 0xef, 0xe3, 0x6e, 0x9b, 0xa7, 0x86,
+	0xad, 0x5f, 0x31, 0x4c, 0x5d, 0x3f, 0x66, 0xfc, 0xb5, 0x73, 0xbe, 0x9f, 0xa9, 0x1e, 0xbf, 0xb6,
+	0xc0, 0xaf, 0x5c, 0xf8, 0x21, 0x3e, 0x75, 0x7e, 0x3d, 0x3f, 0x21, 0x6b, 0x28, 0xa6, 0xd2, 0x77,
+	0x7e, 0x5e, 0xeb, 0xe8, 0x7a, 0xa7, 0x87, 0xaf, 0xd0, 0xd1, 0xd1, 0xf0, 0xf8, 0x8a, 0xad, 0xf5,
+	0xb1, 0x65, 0x2b, 0x7d, 0x83, 0x33, 0xac, 0x74, 0xf4, 0x8e, 0x4e, 0x1f, 0xaf, 0x90, 0x27, 0x46,
+	0x15, 0xff, 0x05, 0x90, 0x95, 0xf0, 0x87, 0x43, 0x6c, 0xd9, 0xe8, 0x2a, 0xa4, 0x70, 0xbb, 0xab,
+	0x57, 0xe3, 0x17, 0xe2, 0x97, 0x0a, 0x57, 0xcf, 0xad, 0x8f, 0x4d, 0x6e, 0x9d, 0xf3, 0x35, 0xda,
+	0x5d, 0xbd, 0x19, 0x93, 0x28, 0x2f, 0xba, 0x0e, 0xe9, 0xe3, 0xde, 0xd0, 0xea, 0x56, 0x13, 0x54,
+	0xe8, 0x7c, 0x94, 0xd0, 0x6d, 0xc2, 0xd4, 0x8c, 0x49, 0x8c, 0x9b, 0xbc, 0x4a, 0x1b, 0x1c, 0xeb,
+	0xd5, 0xe4, 0xf4, 0x57, 0x6d, 0x0f, 0x8e, 0xe9, 0xab, 0x08, 0x2f, 0xda, 0x04, 0xd0, 0x06, 0x9a,
+	0x2d, 0xb7, 0xbb, 0x8a, 0x36, 0xa8, 0xa6, 0xa8, 0xe4, 0xb3, 0xd1, 0x92, 0x9a, 0x5d, 0x27, 0x8c,
+	0xcd, 0x98, 0x94, 0xd7, 0x9c, 0x01, 0xf9, 0xdc, 0x0f, 0x87, 0xd8, 0x3c, 0xad, 0xa6, 0xa7, 0x7f,
+	0xee, 0x3b, 0x84, 0x89, 0x7c, 0x2e, 0xe5, 0x46, 0xdb, 0x50, 0x38, 0xc2, 0x1d, 0x6d, 0x20, 0x1f,
+	0xf5, 0xf4, 0xf6, 0xc3, 0x6a, 0x86, 0x0a, 0x8b, 0x51, 0xc2, 0x9b, 0x84, 0x75, 0x93, 0x70, 0x6e,
+	0x26, 0xaa, 0xf1, 0x66, 0x4c, 0x82, 0x23, 0x97, 0x82, 0xde, 0x80, 0x5c, 0xbb, 0x8b, 0xdb, 0x0f,
+	0x65, 0x7b, 0x54, 0xcd, 0x52, 0x3d, 0x6b, 0x51, 0x7a, 0xea, 0x84, 0xaf, 0x35, 0x6a, 0xc6, 0xa4,
+	0x6c, 0x9b, 0x3d, 0xa2, 0xdb, 0x00, 0x2a, 0xee, 0x69, 0x27, 0xd8, 0x24, 0xf2, 0xb9, 0xe9, 0x36,
+	0xd8, 0x62, 0x9c, 0xad, 0x11, 0xff, 0x8c, 0xbc, 0xea, 0x10, 0x50, 0x1d, 0xf2, 0x78, 0xa0, 0xf2,
+	0xe9, 0xe4, 0xa9, 0x9a, 0x0b, 0x91, 0xeb, 0x3d, 0x50, 0xfd, 0x93, 0xc9, 0x61, 0x3e, 0x46, 0x37,
+	0x20, 0xd3, 0xd6, 0xfb, 0x7d, 0xcd, 0xae, 0x02, 0xd5, 0xb0, 0x1a, 0x39, 0x11, 0xca, 0xd5, 0x8c,
+	0x49, 0x9c, 0x1f, 0xed, 0x42, 0xb9, 0xa7, 0x59, 0xb6, 0x6c, 0x0d, 0x14, 0xc3, 0xea, 0xea, 0xb6,
+	0x55, 0x2d, 0x50, 0x0d, 0xcf, 0x45, 0x69, 0xd8, 0xd1, 0x2c, 0xfb, 0xc0, 0x61, 0x6e, 0xc6, 0xa4,
+	0x52, 0xcf, 0x4f, 0x20, 0xfa, 0xf4, 0xe3, 0x63, 0x6c, 0xba, 0x0a, 0xab, 0xc5, 0xe9, 0xfa, 0xf6,
+	0x08, 0xb7, 0x23, 0x4f, 0xf4, 0xe9, 0x7e, 0x02, 0xfa, 0x3f, 0x58, 0xee, 0xe9, 0x8a, 0xea, 0xaa,
+	0x93, 0xdb, 0xdd, 0xe1, 0xe0, 0x61, 0xb5, 0x44, 0x95, 0xbe, 0x18, 0xf9, 0x91, 0xba, 0xa2, 0x3a,
+	0x2a, 0xea, 0x44, 0xa0, 0x19, 0x93, 0x96, 0x7a, 0xe3, 0x44, 0xf4, 0x00, 0x56, 0x14, 0xc3, 0xe8,
+	0x9d, 0x8e, 0x6b, 0x2f, 0x53, 0xed, 0x97, 0xa3, 0xb4, 0x6f, 0x10, 0x99, 0x71, 0xf5, 0x48, 0x99,
+	0xa0, 0xa2, 0x16, 0x08, 0x86, 0x89, 0x0d, 0xc5, 0xc4, 0xb2, 0x61, 0xea, 0x86, 0x6e, 0x29, 0xbd,
+	0x6a, 0x85, 0xea, 0x7e, 0x21, 0x4a, 0xf7, 0x3e, 0xe3, 0xdf, 0xe7, 0xec, 0xcd, 0x98, 0x54, 0x31,
+	0x82, 0x24, 0xa6, 0x55, 0x6f, 0x63, 0xcb, 0xf2, 0xb4, 0x0a, 0xb3, 0xb4, 0x52, 0xfe, 0xa0, 0xd6,
+	0x00, 0x09, 0x35, 0xa0, 0x80, 0x47, 0x44, 0x5c, 0x3e, 0xd1, 0x6d, 0x5c, 0x5d, 0x9a, 0x7e, 0xb0,
+	0x1a, 0x94, 0xf5, 0xbe, 0x6e, 0x63, 0x72, 0xa8, 0xb0, 0x3b, 0x42, 0x0a, 0x3c, 0x75, 0x82, 0x4d,
+	0xed, 0xf8, 0x94, 0xaa, 0x91, 0xe9, 0x2f, 0x96, 0xa6, 0x0f, 0xaa, 0x88, 0x2a, 0x7c, 0x29, 0x4a,
+	0xe1, 0x7d, 0x2a, 0x44, 0x54, 0x34, 0x1c, 0x91, 0x66, 0x4c, 0x5a, 0x3e, 0x99, 0x24, 0x93, 0x2d,
+	0x76, 0xac, 0x0d, 0x94, 0x9e, 0xf6, 0x31, 0xe6, 0xc7, 0x66, 0x79, 0xfa, 0x16, 0xbb, 0xcd, 0xb9,
+	0xe9, 0x59, 0x21, 0x5b, 0xec, 0xd8, 0x4f, 0xd8, 0xcc, 0x42, 0xfa, 0x44, 0xe9, 0x0d, 0xb1, 0xf8,
+	0x02, 0x14, 0x7c, 0x8e, 0x15, 0x55, 0x21, 0xdb, 0xc7, 0x96, 0xa5, 0x74, 0x30, 0xf5, 0xc3, 0x79,
+	0xc9, 0x19, 0x8a, 0x65, 0x28, 0xfa, 0x9d, 0xa9, 0xf8, 0x59, 0xdc, 0x95, 0x24, 0x7e, 0x92, 0x48,
+	0x9e, 0x60, 0x93, 0x4e, 0x9b, 0x4b, 0xf2, 0x21, 0xba, 0x08, 0x25, 0xfa, 0xc9, 0xb2, 0xf3, 0x3b,
+	0x71, 0xd6, 0x29, 0xa9, 0x48, 0x89, 0xf7, 0x39, 0xd3, 0x1a, 0x14, 0x8c, 0xab, 0x86, 0xcb, 0x92,
+	0xa4, 0x2c, 0x60, 0x5c, 0x35, 0x1c, 0x86, 0x67, 0xa1, 0x48, 0xe6, 0xe7, 0x72, 0xa4, 0xe8, 0x4b,
+	0x0a, 0x84, 0xc6, 0x59, 0xc4, 0x3f, 0x26, 0x40, 0x18, 0x77, 0xc0, 0xe8, 0x06, 0xa4, 0x48, 0x2c,
+	0xe2, 0x61, 0xa5, 0xb6, 0xce, 0x02, 0xd5, 0xba, 0x13, 0xa8, 0xd6, 0x5b, 0x4e, 0xa0, 0xda, 0xcc,
+	0x7d, 0xf1, 0xd5, 0x5a, 0xec, 0xb3, 0xbf, 0xae, 0xc5, 0x25, 0x2a, 0x81, 0xce, 0x12, 0x5f, 0xa9,
+	0x68, 0x03, 0x59, 0x53, 0xe9, 0x27, 0xe7, 0x89, 0x23, 0x54, 0xb4, 0xc1, 0xb6, 0x8a, 0x76, 0x40,
+	0x68, 0xeb, 0x03, 0x0b, 0x0f, 0xac, 0xa1, 0x25, 0xb3, 0x40, 0xc8, 0x83, 0x49, 0xc0, 0x1d, 0xb2,
+	0xf0, 0x5a, 0x77, 0x38, 0xf7, 0x29, 0xa3, 0x54, 0x69, 0x07, 0x09, 0xc4, 0xad, 0x9e, 0x28, 0x3d,
+	0x4d, 0x55, 0x6c, 0xdd, 0xb4, 0xaa, 0xa9, 0x0b, 0xc9, 0x50, 0x7f, 0x78, 0xdf, 0x61, 0x39, 0x34,
+	0x54, 0xc5, 0xc6, 0x9b, 0x29, 0xf2, 0xb9, 0x92, 0x4f, 0x12, 0x3d, 0x0f, 0x15, 0xc5, 0x30, 0x64,
+	0xcb, 0x56, 0x6c, 0x2c, 0x1f, 0x9d, 0xda, 0xd8, 0xa2, 0x81, 0xa6, 0x28, 0x95, 0x14, 0xc3, 0x38,
+	0x20, 0xd4, 0x4d, 0x42, 0x44, 0xcf, 0x41, 0x99, 0xc4, 0x24, 0x4d, 0xe9, 0xc9, 0x5d, 0xac, 0x75,
+	0xba, 0x36, 0x0d, 0x29, 0x49, 0xa9, 0xc4, 0xa9, 0x4d, 0x4a, 0x14, 0x55, 0x77, 0xc5, 0x69, 0x3c,
+	0x42, 0x08, 0x52, 0xaa, 0x62, 0x2b, 0xd4, 0x92, 0x45, 0x89, 0x3e, 0x13, 0x9a, 0xa1, 0xd8, 0x5d,
+	0x6e, 0x1f, 0xfa, 0x8c, 0xce, 0x40, 0x86, 0xab, 0x4d, 0x52, 0xb5, 0x7c, 0x84, 0x56, 0x20, 0x6d,
+	0x98, 0xfa, 0x09, 0xa6, 0x4b, 0x97, 0x93, 0xd8, 0x40, 0xfc, 0x61, 0x02, 0x96, 0x26, 0x22, 0x17,
+	0xd1, 0xdb, 0x55, 0xac, 0xae, 0xf3, 0x2e, 0xf2, 0x8c, 0x5e, 0x23, 0x7a, 0x15, 0x15, 0x9b, 0x3c,
+	0xda, 0x57, 0x27, 0x4d, 0xdd, 0xa4, 0xbf, 0x73, 0xd3, 0x70, 0x6e, 0x74, 0x17, 0x84, 0x9e, 0x62,
+	0xd9, 0x32, 0xf3, 0xfe, 0xb2, 0x2f, 0xf2, 0x3f, 0x33, 0x61, 0x64, 0x16, 0x2b, 0xc8, 0x86, 0xe6,
+	0x4a, 0xca, 0x44, 0xd4, 0xa3, 0x22, 0x09, 0x56, 0x8e, 0x4e, 0x3f, 0x56, 0x06, 0xb6, 0x36, 0xc0,
+	0xf2, 0xc4, 0xaa, 0x9d, 0x9d, 0x50, 0xd8, 0x38, 0xd1, 0x54, 0x3c, 0x68, 0x3b, 0xcb, 0xb5, 0xec,
+	0x0a, 0xbb, 0xcb, 0x69, 0x89, 0x12, 0x94, 0x83, 0x31, 0x17, 0x95, 0x21, 0x61, 0x8f, 0xf8, 0xe4,
+	0x13, 0xf6, 0x08, 0xfd, 0x17, 0xa4, 0xc8, 0x04, 0xe9, 0xc4, 0xcb, 0x21, 0x09, 0x0b, 0x97, 0x6b,
+	0x9d, 0x1a, 0x58, 0xa2, 0x9c, 0xa2, 0xe8, 0x1e, 0x05, 0x37, 0x0e, 0x8f, 0x6b, 0x15, 0x5f, 0x84,
+	0xca, 0x58, 0x90, 0xf5, 0xad, 0x5d, 0xdc, 0xbf, 0x76, 0x62, 0x05, 0x4a, 0x81, 0x68, 0x2a, 0x9e,
+	0x81, 0x95, 0xb0, 0xe0, 0x28, 0x76, 0x5d, 0x7a, 0x20, 0xc8, 0xa1, 0xeb, 0x90, 0x73, 0xa3, 0x23,
+	0x3b, 0x8a, 0x93, 0xb6, 0x72, 0x98, 0x25, 0x97, 0x95, 0x9c, 0x41, 0xb2, 0xa5, 0xe9, 0x5e, 0x48,
+	0xd0, 0x0f, 0xcf, 0x2a, 0x86, 0xd1, 0x54, 0xac, 0xae, 0xf8, 0x3e, 0x54, 0xa3, 0x22, 0xdf, 0xd8,
+	0x34, 0x52, 0xee, 0x16, 0x3c, 0x03, 0x99, 0x63, 0xdd, 0xec, 0x2b, 0x36, 0x55, 0x56, 0x92, 0xf8,
+	0x88, 0x6c, 0x4d, 0x16, 0x05, 0x93, 0x94, 0xcc, 0x06, 0xa2, 0x0c, 0x67, 0x23, 0xa3, 0x1f, 0x11,
+	0xd1, 0x06, 0x2a, 0x66, 0xf6, 0x2c, 0x49, 0x6c, 0xe0, 0x29, 0x62, 0x1f, 0xcb, 0x06, 0xe4, 0xb5,
+	0x16, 0x9d, 0x2b, 0xd5, 0x9f, 0x97, 0xf8, 0x48, 0xfc, 0x7d, 0x02, 0xce, 0x84, 0xc7, 0xc0, 0xc7,
+	0x7a, 0x00, 0x04, 0x48, 0xda, 0x23, 0xe2, 0xa0, 0x92, 0x97, 0x8a, 0x12, 0x79, 0x44, 0x87, 0xb0,
+	0xd4, 0xd3, 0xdb, 0x4a, 0x4f, 0xf6, 0x1d, 0x0c, 0x9e, 0xd3, 0x5e, 0x9c, 0xdc, 0xc2, 0x34, 0xd2,
+	0x61, 0x75, 0xe2, 0x6c, 0x54, 0xa8, 0x8e, 0x1d, 0xf7, 0x80, 0x44, 0x1e, 0x8e, 0xf4, 0x77, 0x3f,
+	0x1c, 0xe8, 0x02, 0x14, 0xfb, 0xca, 0x48, 0xb6, 0x47, 0xdc, 0xa3, 0x31, 0x57, 0x05, 0x7d, 0x65,
+	0xd4, 0x1a, 0x51, 0x77, 0x26, 0xfe, 0xd2, 0x6f, 0xc5, 0x60, 0x80, 0x7f, 0xb2, 0x56, 0x3c, 0x80,
+	0x15, 0x96, 0x8c, 0x60, 0x35, 0xc4, 0x90, 0x73, 0x38, 0x17, 0xe4, 0x88, 0x3f, 0x59, 0x1b, 0x8a,
+	0x6f, 0xb9, 0x2e, 0xd6, 0xcb, 0x61, 0x42, 0x6d, 0xe3, 0x9d, 0x9b, 0x44, 0xe0, 0xf8, 0xff, 0x22,
+	0x0e, 0xb5, 0xe8, 0xa4, 0x25, 0x54, 0xd5, 0x4b, 0xb0, 0xe4, 0x7e, 0xbd, 0xac, 0xa8, 0xaa, 0x89,
+	0x2d, 0x8b, 0x9f, 0x0a, 0xc1, 0xfd, 0x61, 0x83, 0xd1, 0x23, 0x43, 0xc6, 0x73, 0x50, 0x1e, 0x4b,
+	0xa9, 0x52, 0x2c, 0xa0, 0x9d, 0xf8, 0xdf, 0x2f, 0xfe, 0x3c, 0xe1, 0x7a, 0x9d, 0x40, 0xde, 0xf3,
+	0x84, 0xd7, 0xff, 0x1d, 0x58, 0x56, 0x71, 0x5b, 0x53, 0xbf, 0xeb, 0xf2, 0x2f, 0x71, 0xe9, 0x27,
+	0xbc, 0xfa, 0x7f, 0x2a, 0x40, 0x4e, 0xc2, 0x96, 0x41, 0xb2, 0x0e, 0xb4, 0x09, 0x79, 0x3c, 0x6a,
+	0x63, 0xc3, 0x76, 0x12, 0xb5, 0xf0, 0x84, 0x97, 0x71, 0x37, 0x1c, 0x4e, 0x02, 0xdf, 0x5c, 0x31,
+	0x74, 0x8d, 0x23, 0xf5, 0x68, 0xd0, 0xcd, 0xc5, 0xfd, 0x50, 0xfd, 0x35, 0x07, 0xaa, 0x27, 0x23,
+	0xd1, 0x1a, 0x93, 0x1a, 0xc3, 0xea, 0xd7, 0x38, 0x56, 0x4f, 0xcd, 0x78, 0x59, 0x00, 0xac, 0xd7,
+	0x03, 0x60, 0x3d, 0x3d, 0x63, 0x9a, 0x11, 0x68, 0xfd, 0x35, 0x07, 0xad, 0x67, 0x66, 0x7c, 0xf1,
+	0x18, 0x5c, 0xbf, 0x13, 0x84, 0xeb, 0xd9, 0x08, 0xb7, 0xea, 0x48, 0x4f, 0xc5, 0xeb, 0x6f, 0xfa,
+	0xf0, 0x7a, 0x2e, 0x12, 0x28, 0x33, 0x45, 0x21, 0x80, 0xfd, 0xed, 0x00, 0x60, 0xcf, 0xcf, 0xb0,
+	0xc3, 0x14, 0xc4, 0xbe, 0xe5, 0x47, 0xec, 0x10, 0x09, 0xfc, 0xf9, 0xba, 0x47, 0x41, 0xf6, 0x9b,
+	0x2e, 0x64, 0x2f, 0x44, 0xd6, 0x1e, 0xf8, 0x5c, 0xc6, 0x31, 0xfb, 0xde, 0x04, 0x66, 0x67, 0x18,
+	0xfb, 0xf9, 0x48, 0x15, 0x33, 0x40, 0xfb, 0xde, 0x04, 0x68, 0x2f, 0xcd, 0x50, 0x38, 0x03, 0xb5,
+	0xff, 0x7f, 0x38, 0x6a, 0x8f, 0xc6, 0xd5, 0xfc, 0x33, 0xe7, 0x83, 0xed, 0x72, 0x04, 0x6c, 0xaf,
+	0x44, 0x42, 0x4c, 0xa6, 0x7e, 0x6e, 0xdc, 0x7e, 0x18, 0x82, 0xdb, 0x19, 0xc2, 0xbe, 0x14, 0xa9,
+	0x7c, 0x0e, 0xe0, 0x7e, 0x18, 0x02, 0xdc, 0x97, 0x66, 0xaa, 0x9d, 0x89, 0xdc, 0x6f, 0x07, 0x91,
+	0x3b, 0x9a, 0x71, 0xc6, 0x22, 0xa1, 0xfb, 0x51, 0x14, 0x74, 0x67, 0xf0, 0xfa, 0xe5, 0x48, 0x8d,
+	0x0b, 0x60, 0xf7, 0xbd, 0x09, 0xec, 0xbe, 0x32, 0x63, 0xa7, 0xcd, 0x0b, 0xde, 0x5f, 0x24, 0x71,
+	0x7d, 0xcc, 0x55, 0x93, 0x14, 0x14, 0x9b, 0xa6, 0x6e, 0x72, 0x18, 0xce, 0x06, 0xe2, 0x25, 0x02,
+	0xe6, 0x3c, 0xb7, 0x3c, 0x05, 0xe8, 0xd3, 0x54, 0xdf, 0xe7, 0x8a, 0xc5, 0xdf, 0xc6, 0x3d, 0x59,
+	0x8a, 0x81, 0xfc, 0x40, 0x30, 0xcf, 0x81, 0xa0, 0x0f, 0xfe, 0x27, 0x82, 0xf0, 0x7f, 0x0d, 0x0a,
+	0x24, 0x85, 0x1f, 0x43, 0xf6, 0x8a, 0xe1, 0x22, 0xfb, 0xcb, 0xb0, 0x44, 0xc3, 0x27, 0x2b, 0x12,
+	0xf0, 0x3c, 0x20, 0x45, 0xf3, 0x80, 0x0a, 0xf9, 0x81, 0x59, 0x81, 0x25, 0x04, 0xaf, 0xc0, 0xb2,
+	0x8f, 0xd7, 0x85, 0x06, 0x0c, 0xe6, 0x0a, 0x2e, 0xf7, 0x06, 0xc7, 0x08, 0x7f, 0x88, 0x7b, 0x16,
+	0xf2, 0x4a, 0x02, 0x61, 0xe8, 0x3d, 0xfe, 0x98, 0xd0, 0x7b, 0xe2, 0x3b, 0xa3, 0x77, 0x3f, 0xd4,
+	0x49, 0x06, 0xa1, 0xce, 0x3f, 0xe2, 0xde, 0x9a, 0xb8, 0x58, 0xbc, 0xad, 0xab, 0x98, 0x83, 0x0f,
+	0xfa, 0x4c, 0x12, 0x94, 0x9e, 0xde, 0xe1, 0x10, 0x83, 0x3c, 0x12, 0x2e, 0x37, 0x76, 0xe6, 0x79,
+	0x68, 0x74, 0x71, 0x4b, 0x9a, 0x5a, 0x98, 0xe3, 0x16, 0x01, 0x92, 0x0f, 0x31, 0x8b, 0x74, 0x45,
+	0x89, 0x3c, 0x12, 0x3e, 0xba, 0xc9, 0x68, 0xfc, 0x2a, 0x4a, 0x6c, 0x80, 0x6e, 0x40, 0x9e, 0x76,
+	0x14, 0x64, 0xdd, 0xb0, 0x78, 0x40, 0x0a, 0x24, 0x3a, 0xac, 0x71, 0xb0, 0xbe, 0x4f, 0x78, 0xf6,
+	0x0c, 0x4b, 0xca, 0x19, 0xfc, 0xc9, 0x97, 0xe2, 0xe5, 0x03, 0x29, 0xde, 0x39, 0xc8, 0x93, 0xaf,
+	0xb7, 0x0c, 0xa5, 0x8d, 0x69, 0x64, 0xc9, 0x4b, 0x1e, 0x41, 0x7c, 0x00, 0x68, 0x32, 0x4e, 0xa2,
+	0x26, 0x64, 0xf0, 0x09, 0x1e, 0xd8, 0x64, 0xd9, 0x88, 0xb9, 0xcf, 0x84, 0xe4, 0x45, 0x78, 0x60,
+	0x6f, 0x56, 0x89, 0x91, 0xff, 0xfe, 0xd5, 0x9a, 0xc0, 0xb8, 0x5f, 0xd6, 0xfb, 0x9a, 0x8d, 0xfb,
+	0x86, 0x7d, 0x2a, 0x71, 0x79, 0xf1, 0x2f, 0x09, 0x82, 0x81, 0x03, 0xf1, 0x33, 0xd4, 0xb6, 0xce,
+	0x96, 0x4f, 0xf8, 0x6a, 0x1f, 0xf3, 0xd9, 0xfb, 0x3c, 0x40, 0x47, 0xb1, 0xe4, 0x8f, 0x94, 0x81,
+	0x8d, 0x55, 0x6e, 0xf4, 0x7c, 0x47, 0xb1, 0xde, 0xa5, 0x04, 0xb2, 0xea, 0xe4, 0xe7, 0xa1, 0x85,
+	0x55, 0x0e, 0x6d, 0xb2, 0x1d, 0xc5, 0x3a, 0xb4, 0xb0, 0xea, 0x9b, 0x65, 0xf6, 0xd1, 0x66, 0x19,
+	0xb4, 0x71, 0x6e, 0xcc, 0xc6, 0x3e, 0x74, 0x9a, 0xf7, 0xa3, 0x53, 0x54, 0x83, 0x9c, 0x61, 0x6a,
+	0xba, 0xa9, 0xd9, 0xa7, 0x74, 0x61, 0x92, 0x92, 0x3b, 0x46, 0x17, 0xa1, 0xd4, 0xc7, 0x7d, 0x43,
+	0xd7, 0x7b, 0x32, 0x73, 0x36, 0x05, 0x2a, 0x5a, 0xe4, 0xc4, 0x06, 0xf5, 0x39, 0x9f, 0x24, 0xbc,
+	0xd3, 0xe7, 0x55, 0x21, 0x1e, 0xaf, 0x79, 0x57, 0x43, 0xcc, 0xeb, 0xa3, 0x90, 0x49, 0x8c, 0xd9,
+	0xd7, 0x1d, 0x7f, 0x5f, 0x06, 0x16, 0x7f, 0x4c, 0xeb, 0x92, 0xc1, 0xdc, 0x08, 0x1d, 0xf8, 0xf1,
+	0xd1, 0x90, 0x3a, 0x05, 0x67, 0x3b, 0xcf, 0xeb, 0x3d, 0x3c, 0x1c, 0xc5, 0xc8, 0x16, 0x7a, 0x0f,
+	0x9e, 0x1e, 0xf3, 0x6c, 0xae, 0xea, 0xc4, 0xbc, 0x0e, 0xee, 0xa9, 0xa0, 0x83, 0x73, 0x54, 0x7b,
+	0xc6, 0x4a, 0x3e, 0xe2, 0x99, 0xdb, 0x86, 0x72, 0x30, 0xcd, 0x0b, 0x5d, 0xfe, 0x8b, 0x50, 0x32,
+	0xb1, 0xad, 0x68, 0x03, 0x39, 0x80, 0x0c, 0x8b, 0x8c, 0xc8, 0x4b, 0x94, 0xfb, 0xf0, 0x54, 0x68,
+	0xba, 0x87, 0x5e, 0x87, 0xbc, 0x97, 0x29, 0xc6, 0x23, 0xc0, 0x93, 0x5b, 0x6f, 0xf2, 0x78, 0xc5,
+	0xdf, 0xc5, 0x3d, 0x95, 0xc1, 0x0a, 0x56, 0x03, 0x32, 0x26, 0xb6, 0x86, 0x3d, 0x56, 0x53, 0x2a,
+	0x5f, 0x7d, 0x65, 0xbe, 0x44, 0x91, 0x50, 0x87, 0x3d, 0x5b, 0xe2, 0xc2, 0xe2, 0x03, 0xc8, 0x30,
+	0x0a, 0x2a, 0x40, 0xf6, 0x70, 0xf7, 0xee, 0xee, 0xde, 0xbb, 0xbb, 0x42, 0x0c, 0x01, 0x64, 0x36,
+	0xea, 0xf5, 0xc6, 0x7e, 0x4b, 0x88, 0xa3, 0x3c, 0xa4, 0x37, 0x36, 0xf7, 0xa4, 0x96, 0x90, 0x20,
+	0x64, 0xa9, 0x71, 0xa7, 0x51, 0x6f, 0x09, 0x49, 0xb4, 0x04, 0x25, 0xf6, 0x2c, 0xdf, 0xde, 0x93,
+	0xee, 0x6d, 0xb4, 0x84, 0x94, 0x8f, 0x74, 0xd0, 0xd8, 0xdd, 0x6a, 0x48, 0x42, 0x5a, 0x7c, 0x15,
+	0xce, 0x46, 0xa6, 0x96, 0x5e, 0x79, 0x2a, 0xee, 0x2b, 0x4f, 0x89, 0x3f, 0x4b, 0x10, 0x74, 0x1f,
+	0x95, 0x2f, 0xa2, 0x3b, 0x63, 0x13, 0xbf, 0xba, 0x40, 0xb2, 0x39, 0x36, 0x7b, 0x02, 0xe8, 0x4d,
+	0x7c, 0x8c, 0xed, 0x76, 0x97, 0xe5, 0xaf, 0x2c, 0x60, 0x96, 0xa4, 0x12, 0xa7, 0x52, 0x21, 0x8b,
+	0xb1, 0x7d, 0x80, 0xdb, 0xb6, 0xcc, 0x7c, 0x11, 0xdb, 0x74, 0x79, 0xc2, 0x46, 0xa8, 0x07, 0x8c,
+	0x28, 0xbe, 0xbf, 0x90, 0x2d, 0xf3, 0x90, 0x96, 0x1a, 0x2d, 0xe9, 0x3d, 0x21, 0x89, 0x10, 0x94,
+	0xe9, 0xa3, 0x7c, 0xb0, 0xbb, 0xb1, 0x7f, 0xd0, 0xdc, 0x23, 0xb6, 0x5c, 0x86, 0x8a, 0x63, 0x4b,
+	0x87, 0x98, 0x16, 0xbf, 0x4d, 0xc2, 0xd3, 0x11, 0xd9, 0x2e, 0xea, 0x00, 0xea, 0xeb, 0xaa, 0x76,
+	0xac, 0x61, 0x55, 0xb6, 0x47, 0xb4, 0xec, 0x3e, 0xb4, 0xb8, 0x8d, 0x6e, 0xce, 0x9b, 0x33, 0xaf,
+	0xdf, 0xe3, 0x2a, 0x5a, 0xa3, 0x03, 0xaa, 0x40, 0x12, 0xfa, 0x63, 0x14, 0x74, 0x03, 0xc0, 0x1e,
+	0xc9, 0x26, 0x6e, 0xeb, 0xa6, 0xea, 0x64, 0x18, 0x93, 0xbb, 0xb9, 0x35, 0x92, 0x28, 0x87, 0x94,
+	0xb7, 0xf9, 0xd3, 0xb4, 0x9c, 0x02, 0xbd, 0xc1, 0x95, 0x12, 0xf3, 0x39, 0xe5, 0xeb, 0xf3, 0x21,
+	0xb5, 0x3f, 0xdc, 0x26, 0x8a, 0xe9, 0x22, 0x52, 0xc5, 0x94, 0x1f, 0xdd, 0x0b, 0xf3, 0x5e, 0xe9,
+	0xf9, 0xbc, 0xd7, 0x62, 0x7e, 0x2b, 0xf3, 0x68, 0x7e, 0x4b, 0x7c, 0x13, 0x84, 0x71, 0x13, 0x07,
+	0x77, 0x4b, 0x19, 0xe0, 0x70, 0xf7, 0xde, 0xde, 0xd6, 0xf6, 0xed, 0xed, 0xc6, 0x96, 0x10, 0x47,
+	0x45, 0xc8, 0xb9, 0xa3, 0x84, 0xf8, 0xab, 0xc0, 0x06, 0x08, 0x82, 0x90, 0x3d, 0xc8, 0x04, 0x16,
+	0xfd, 0xf5, 0x79, 0x11, 0xcd, 0xba, 0xf3, 0xc0, 0x97, 0x9c, 0xab, 0x99, 0x52, 0xed, 0x1e, 0x5b,
+	0xae, 0xe4, 0xe3, 0x58, 0xae, 0xd4, 0x93, 0x58, 0xae, 0xf4, 0x23, 0x2e, 0xd7, 0x75, 0x28, 0x07,
+	0x8d, 0x13, 0x7d, 0xb4, 0x3d, 0xdf, 0x98, 0x10, 0x6f, 0x79, 0x79, 0xa2, 0xaf, 0xc4, 0x39, 0x59,
+	0x3e, 0x8c, 0x87, 0x95, 0x0f, 0x7f, 0x1d, 0x87, 0x67, 0xa6, 0xe0, 0x3a, 0xf4, 0xce, 0xd8, 0x3a,
+	0xdf, 0x5c, 0x04, 0x15, 0xae, 0x33, 0x5a, 0x70, 0xa5, 0xc5, 0x6b, 0x50, 0xf4, 0xd3, 0xe7, 0x9b,
+	0xe4, 0x4f, 0x92, 0x5e, 0x6c, 0x0a, 0xd6, 0x39, 0x1f, 0x5b, 0x42, 0x3c, 0xb6, 0xcf, 0x12, 0x0b,
+	0xee, 0xb3, 0xd0, 0xa4, 0x26, 0xf9, 0xe4, 0x92, 0x9a, 0xd4, 0x23, 0x26, 0x35, 0xfe, 0x03, 0x97,
+	0x0e, 0x1e, 0xb8, 0x89, 0xfc, 0x23, 0x13, 0x92, 0x7f, 0xbc, 0x07, 0xe0, 0xeb, 0x0d, 0xae, 0x40,
+	0xda, 0xd4, 0x87, 0x03, 0x95, 0x6e, 0x93, 0xb4, 0xc4, 0x06, 0xe8, 0x3a, 0xa4, 0xc9, 0x76, 0x8b,
+	0x76, 0xdc, 0x64, 0xbb, 0xf8, 0xaa, 0xc2, 0x8c, 0x5b, 0xd4, 0x00, 0x4d, 0x36, 0x5e, 0x22, 0x5e,
+	0xf1, 0x66, 0xf0, 0x15, 0xcf, 0x46, 0xb6, 0x70, 0xc2, 0x5f, 0xf5, 0x31, 0xa4, 0xe9, 0xf6, 0x20,
+	0x79, 0x18, 0x6d, 0x33, 0x72, 0x60, 0x4f, 0x9e, 0xd1, 0x0f, 0x00, 0x14, 0xdb, 0x36, 0xb5, 0xa3,
+	0xa1, 0xf7, 0x82, 0xb5, 0xf0, 0xed, 0xb5, 0xe1, 0xf0, 0x6d, 0x9e, 0xe3, 0xfb, 0x6c, 0xc5, 0x13,
+	0xf5, 0xed, 0x35, 0x9f, 0x42, 0x71, 0x17, 0xca, 0x41, 0x59, 0x07, 0x8a, 0xb2, 0x6f, 0x08, 0x42,
+	0x51, 0x56, 0x59, 0xe0, 0x50, 0xd4, 0x05, 0xb2, 0x49, 0xd6, 0x4e, 0xa6, 0x03, 0xf1, 0xdb, 0x38,
+	0x14, 0xfd, 0xbb, 0xf3, 0x3f, 0x0d, 0xcd, 0x89, 0x9f, 0xc4, 0x21, 0xe7, 0x4e, 0x3e, 0xa2, 0x9d,
+	0xeb, 0xd9, 0x2e, 0xe1, 0x6f, 0x5e, 0xb2, 0xfe, 0x70, 0xd2, 0xed, 0x3a, 0xdf, 0x72, 0x13, 0xbf,
+	0xa8, 0xe2, 0xbb, 0xdf, 0xd2, 0x4e, 0xbb, 0x84, 0xe7, 0xb9, 0x3f, 0xe5, 0xdf, 0x41, 0x12, 0x11,
+	0xf4, 0xdf, 0x90, 0x51, 0xda, 0x6e, 0xcb, 0xa1, 0x1c, 0x52, 0x83, 0x76, 0x58, 0xd7, 0x5b, 0xa3,
+	0x0d, 0xca, 0x29, 0x71, 0x09, 0xfe, 0x55, 0x09, 0xb7, 0x6b, 0xfd, 0x16, 0xd1, 0xcb, 0x78, 0xa6,
+	0x07, 0x72, 0x92, 0xfa, 0x6d, 0x6d, 0x91, 0x28, 0x4e, 0xf8, 0xa4, 0xc6, 0xbd, 0xbd, 0xfb, 0x8d,
+	0x2d, 0x21, 0x29, 0xde, 0x82, 0xbc, 0xeb, 0x7a, 0x50, 0x15, 0xb2, 0x4e, 0x73, 0x2a, 0xce, 0x1d,
+	0x00, 0xef, 0x49, 0xad, 0x40, 0xda, 0xd0, 0x3f, 0xe2, 0x3d, 0xdb, 0xa4, 0xc4, 0x06, 0xa2, 0x0a,
+	0x95, 0x31, 0xbf, 0x85, 0x6e, 0x41, 0xd6, 0x18, 0x1e, 0xc9, 0xce, 0xa6, 0x1d, 0xbb, 0x50, 0xe8,
+	0x54, 0x44, 0x86, 0x47, 0x3d, 0xad, 0x7d, 0x17, 0x9f, 0x3a, 0x66, 0x32, 0x86, 0x47, 0x77, 0xd9,
+	0xde, 0x66, 0x6f, 0x49, 0xf8, 0xdf, 0xf2, 0xa3, 0x38, 0xe4, 0x9c, 0xb3, 0x8a, 0xfe, 0x07, 0xf2,
+	0xae, 0x4f, 0x74, 0xaf, 0xb1, 0x44, 0x3a, 0x53, 0xae, 0xdf, 0x13, 0x41, 0x97, 0x61, 0xc9, 0xd2,
+	0x3a, 0x03, 0xa7, 0x4b, 0xc5, 0x4a, 0x90, 0x09, 0x7a, 0x68, 0x2a, 0xec, 0x87, 0x1d, 0xa7, 0x6e,
+	0x76, 0x27, 0x95, 0x4b, 0x0a, 0xa9, 0x3b, 0xa9, 0x5c, 0x4a, 0x48, 0x93, 0xb0, 0x28, 0x8c, 0x3b,
+	0x8e, 0xef, 0xf3, 0x63, 0x42, 0xc2, 0x77, 0x32, 0x2c, 0x7c, 0xff, 0x33, 0x0e, 0x39, 0xa7, 0x0f,
+	0x86, 0x5e, 0xf5, 0xb9, 0xb0, 0x72, 0xd8, 0x8e, 0xe5, 0x8c, 0xde, 0x55, 0x89, 0xe0, 0x94, 0x12,
+	0x8b, 0x4f, 0x29, 0xaa, 0x79, 0xe9, 0xdc, 0x3c, 0x4a, 0x2d, 0x7c, 0xf3, 0xe8, 0x65, 0x40, 0xb6,
+	0x6e, 0x2b, 0x3d, 0xf9, 0x44, 0xb7, 0xb5, 0x41, 0x47, 0x66, 0x3b, 0x84, 0x79, 0x1b, 0x81, 0xfe,
+	0x72, 0x9f, 0xfe, 0xb0, 0xef, 0x6e, 0x16, 0x17, 0xa5, 0x2e, 0x7a, 0xf3, 0xe1, 0x0c, 0x64, 0x38,
+	0x10, 0x63, 0x57, 0x1f, 0xf8, 0xc8, 0xed, 0x9c, 0xa6, 0x7c, 0x9d, 0xd3, 0x1a, 0xe4, 0xfa, 0xd8,
+	0x56, 0xa8, 0xeb, 0x64, 0xd1, 0xd2, 0x1d, 0x5f, 0xbe, 0x09, 0x05, 0xdf, 0x25, 0x14, 0xe2, 0x4d,
+	0x77, 0x1b, 0xef, 0x0a, 0xb1, 0x5a, 0xf6, 0xd3, 0xcf, 0x2f, 0x24, 0x77, 0xf1, 0x47, 0xe4, 0xa0,
+	0x49, 0x8d, 0x7a, 0xb3, 0x51, 0xbf, 0x2b, 0xc4, 0x6b, 0x85, 0x4f, 0x3f, 0xbf, 0x90, 0x95, 0x30,
+	0x6d, 0x53, 0x5d, 0x6e, 0x42, 0xd1, 0xbf, 0x2a, 0xc1, 0x43, 0x8d, 0xa0, 0xbc, 0x75, 0xb8, 0xbf,
+	0xb3, 0x5d, 0xdf, 0x68, 0x35, 0xe4, 0xfb, 0x7b, 0xad, 0x86, 0x10, 0x47, 0x4f, 0xc3, 0xf2, 0xce,
+	0xf6, 0xdb, 0xcd, 0x96, 0x5c, 0xdf, 0xd9, 0x6e, 0xec, 0xb6, 0xe4, 0x8d, 0x56, 0x6b, 0xa3, 0x7e,
+	0x57, 0x48, 0x5c, 0xfd, 0x4d, 0x01, 0x2a, 0x1b, 0x9b, 0xf5, 0x6d, 0x82, 0x43, 0xb5, 0xb6, 0x42,
+	0x5d, 0x44, 0x1d, 0x52, 0xb4, 0xe0, 0x3d, 0xf5, 0x42, 0x71, 0x6d, 0x7a, 0x13, 0x13, 0xdd, 0x86,
+	0x34, 0xad, 0x85, 0xa3, 0xe9, 0x37, 0x8c, 0x6b, 0x33, 0xba, 0x9a, 0xe4, 0x63, 0xe8, 0x29, 0x9a,
+	0x7a, 0xe5, 0xb8, 0x36, 0xbd, 0xc9, 0x89, 0x76, 0x20, 0xeb, 0x94, 0x2a, 0x67, 0x5d, 0xde, 0xad,
+	0xcd, 0xec, 0x16, 0x92, 0xa9, 0xb1, 0x92, 0xf2, 0xf4, 0xdb, 0xc8, 0xb5, 0x19, 0xed, 0x4f, 0xb4,
+	0x0d, 0x19, 0x5e, 0xcd, 0x99, 0x71, 0x11, 0xb7, 0x36, 0xab, 0xeb, 0x87, 0x24, 0xc8, 0x7b, 0xc5,
+	0xfa, 0xd9, 0x77, 0xac, 0x6b, 0x73, 0x74, 0x76, 0xd1, 0x03, 0x28, 0x05, 0x2b, 0x44, 0xf3, 0x5d,
+	0xf6, 0xad, 0xcd, 0xd9, 0x5f, 0x24, 0xfa, 0x83, 0xe5, 0xa2, 0xf9, 0x2e, 0xff, 0xd6, 0xe6, 0x6c,
+	0x37, 0xa2, 0x0f, 0x60, 0x69, 0xb2, 0x9c, 0x33, 0xff, 0x5d, 0xe0, 0xda, 0x02, 0x0d, 0x48, 0xd4,
+	0x07, 0x14, 0x52, 0x06, 0x5a, 0xe0, 0x6a, 0x70, 0x6d, 0x91, 0x7e, 0x24, 0x52, 0xa1, 0x32, 0x5e,
+	0x5a, 0x99, 0xf7, 0xaa, 0x70, 0x6d, 0xee, 0xde, 0x24, 0x7b, 0x4b, 0x10, 0xbf, 0xcf, 0x7b, 0x75,
+	0xb8, 0x36, 0x77, 0xab, 0x12, 0x1d, 0x02, 0xf8, 0xf0, 0xe7, 0x1c, 0x57, 0x89, 0x6b, 0xf3, 0x34,
+	0x2d, 0x91, 0x01, 0xcb, 0x61, 0xc0, 0x74, 0x91, 0x9b, 0xc5, 0xb5, 0x85, 0x7a, 0x99, 0x64, 0x3f,
+	0x07, 0x21, 0xe6, 0x7c, 0x37, 0x8d, 0x6b, 0x73, 0x36, 0x35, 0x37, 0x1b, 0x5f, 0x7c, 0xbd, 0x1a,
+	0xff, 0xf2, 0xeb, 0xd5, 0xf8, 0xdf, 0xbe, 0x5e, 0x8d, 0x7f, 0xf6, 0xcd, 0x6a, 0xec, 0xcb, 0x6f,
+	0x56, 0x63, 0x7f, 0xfe, 0x66, 0x35, 0xf6, 0xbf, 0x2f, 0x75, 0x34, 0xbb, 0x3b, 0x3c, 0x5a, 0x6f,
+	0xeb, 0xfd, 0x2b, 0xfe, 0x3f, 0x9d, 0x84, 0xfd, 0x11, 0xe6, 0x28, 0x43, 0xa3, 0xe9, 0xb5, 0x7f,
+	0x07, 0x00, 0x00, 0xff, 0xff, 0x0b, 0xa0, 0x3a, 0x89, 0x28, 0x33, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -7532,13 +7627,8 @@ func (m *ResponsePrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
 			dAtA[i] = 0x12
 		}
 	}
-	if m.ModifiedTx {
-		i--
-		if m.ModifiedTx {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if m.ModifiedTxStatus != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.ModifiedTxStatus))
 		i--
 		dAtA[i] = 0x8
 	}
@@ -7612,13 +7702,8 @@ func (m *ResponseProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i--
 		dAtA[i] = 0x12
 	}
-	if m.Accept {
-		i--
-		if m.Accept {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if m.Status != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
 		i--
 		dAtA[i] = 0x8
 	}
@@ -7675,13 +7760,8 @@ func (m *ResponseVerifyVoteExtension) MarshalToSizedBuffer(dAtA []byte) (int, er
 	_ = i
 	var l int
 	_ = l
-	if m.Accept {
-		i--
-		if m.Accept {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if m.Status != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
 		i--
 		dAtA[i] = 0x8
 	}
@@ -9606,8 +9686,8 @@ func (m *ResponsePrepareProposal) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.ModifiedTx {
-		n += 2
+	if m.ModifiedTxStatus != 0 {
+		n += 1 + sovTypes(uint64(m.ModifiedTxStatus))
 	}
 	if len(m.TxRecords) > 0 {
 		for _, e := range m.TxRecords {
@@ -9644,8 +9724,8 @@ func (m *ResponseProcessProposal) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.Accept {
-		n += 2
+	if m.Status != 0 {
+		n += 1 + sovTypes(uint64(m.Status))
 	}
 	l = len(m.AppHash)
 	if l > 0 {
@@ -9689,8 +9769,8 @@ func (m *ResponseVerifyVoteExtension) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.Accept {
-		n += 2
+	if m.Status != 0 {
+		n += 1 + sovTypes(uint64(m.Status))
 	}
 	return n
 }
@@ -16258,9 +16338,9 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedTx", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedTxStatus", wireType)
 			}
-			var v int
+			m.ModifiedTxStatus = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -16270,12 +16350,11 @@ func (m *ResponsePrepareProposal) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.ModifiedTxStatus |= ResponsePrepareProposal_ModifiedTxStatus(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.ModifiedTx = bool(v != 0)
 		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field TxRecords", wireType)
@@ -16500,9 +16579,9 @@ func (m *ResponseProcessProposal) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Accept", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 			}
-			var v int
+			m.Status = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -16512,12 +16591,11 @@ func (m *ResponseProcessProposal) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Status |= ResponseProcessProposal_ProposalStatus(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Accept = bool(v != 0)
 		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType)
@@ -16792,9 +16870,9 @@ func (m *ResponseVerifyVoteExtension) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Accept", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 			}
-			var v int
+			m.Status = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -16804,12 +16882,11 @@ func (m *ResponseVerifyVoteExtension) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Status |= ResponseVerifyVoteExtension_VerifyStatus(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Accept = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])

cmd/tendermint/commands/rollback_test.go

@@ -53,6 +53,7 @@ func TestRollbackIntegration(t *testing.T) {
 		defer cancel()
 		node2, _, err2 := rpctest.StartTendermint(ctx, cfg, app, rpctest.SuppressStdout)
 		require.NoError(t, err2)
+		t.Cleanup(node2.Wait)
 
 		logger := log.NewNopLogger()
 

config/config.go

@@ -1030,33 +1030,6 @@ func (cfg *ConsensusConfig) WaitForTxs() bool {
 	return !cfg.CreateEmptyBlocks || cfg.CreateEmptyBlocksInterval > 0
 }
 
-// Propose returns the amount of time to wait for a proposal
-func (cfg *ConsensusConfig) Propose(round int32) time.Duration {
-	return time.Duration(
-		cfg.TimeoutPropose.Nanoseconds()+cfg.TimeoutProposeDelta.Nanoseconds()*int64(round),
-	) * time.Nanosecond
-}
-
-// Prevote returns the amount of time to wait for straggler votes after receiving any +2/3 prevotes
-func (cfg *ConsensusConfig) Prevote(round int32) time.Duration {
-	return time.Duration(
-		cfg.TimeoutPrevote.Nanoseconds()+cfg.TimeoutPrevoteDelta.Nanoseconds()*int64(round),
-	) * time.Nanosecond
-}
-
-// Precommit returns the amount of time to wait for straggler votes after receiving any +2/3 precommits
-func (cfg *ConsensusConfig) Precommit(round int32) time.Duration {
-	return time.Duration(
-		cfg.TimeoutPrecommit.Nanoseconds()+cfg.TimeoutPrecommitDelta.Nanoseconds()*int64(round),
-	) * time.Nanosecond
-}
-
-// Commit returns the amount of time to wait for straggler votes after receiving +2/3 precommits
-// for a single block (ie. a commit).
-func (cfg *ConsensusConfig) Commit(t time.Time) time.Time {
-	return t.Add(cfg.TimeoutCommit)
-}
-
 // WalFile returns the full path to the write-ahead log file
 func (cfg *ConsensusConfig) WalFile() string {
 	if cfg.walFile != "" {

config/toml.go

@@ -602,6 +602,14 @@ var testGenesisFmt = `{
 			"message_delay": "500000000",
 			"precision": "10000000"
 		},
+		"timeout": {
+			"propose": "30000000",
+			"propose_delta": "50000",
+			"vote": "30000000",
+			"vote_delta": "50000",
+			"commit": "10000000",
+			"bypass_timeout_commit": true
+		},
 		"evidence": {
 			"max_age_num_blocks": "100000",
 			"max_age_duration": "172800000000000",

docs/architecture/adr-074-timeout-params.md

@@ -67,7 +67,7 @@ The 8 timeout parameters will be consolidated down to 6. These will be as follow
 	 parameters.
 * `TimeoutCommit`
 	* Same as current `TimeoutCommit`.
-* `EnableTimeoutCommitBypass`
+* `BypassCommitTimeout`
 	* Same as current `SkipTimeoutCommit`, renamed for clarity.
 
 A safe default will be provided by Tendermint for each of these parameters and
@@ -149,7 +149,7 @@ message TimeoutParams {
  google.protobuf.Duration vote = 3;
  google.protobuf.Duration vote_delta = 4;
  google.protobuf.Duration commit = 5;
- bool enable_commit_timeout_bypass = 6;
+ bool bypass_commit_timeout = 6;
 }
 ```
 

go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/go-kit/kit v0.12.0
 	github.com/gogo/protobuf v1.3.2
 	github.com/golang/protobuf v1.5.2
-	github.com/golangci/golangci-lint v1.44.2
+	github.com/golangci/golangci-lint v1.45.0
 	github.com/google/orderedcode v0.0.1
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/websocket v1.5.0
@@ -31,7 +31,7 @@ require (
 	github.com/stretchr/testify v1.7.1
 	github.com/tendermint/tm-db v0.6.6
 	github.com/vektra/mockery/v2 v2.10.0
-	golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce
+	golang.org/x/crypto v0.0.0-20220214200702-86341886e292
 	golang.org/x/net v0.0.0-20211208012354-db4efeb81f4b
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	google.golang.org/grpc v1.45.0
@@ -58,7 +58,7 @@ require (
 	github.com/OpenPeeDeeP/depguard v1.1.0 // indirect
 	github.com/alexkohler/prealloc v1.0.0 // indirect
 	github.com/ashanbrown/forbidigo v1.3.0 // indirect
-	github.com/ashanbrown/makezero v1.1.0 // indirect
+	github.com/ashanbrown/makezero v1.1.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bkielbasa/cyclop v1.2.0 // indirect
 	github.com/blizzy78/varnamelen v0.6.0 // indirect
@@ -72,9 +72,9 @@ require (
 	github.com/charithe/durationcheck v0.0.9 // indirect
 	github.com/chavacava/garif v0.0.0-20210405164556-e8a0a408d6af // indirect
 	github.com/containerd/continuity v0.2.1 // indirect
-	github.com/daixiang0/gci v0.3.1-0.20220208004058-76d765e3ab48 // indirect
+	github.com/daixiang0/gci v0.3.3 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/denis-tingajkin/go-header v0.4.2 // indirect
+	github.com/denis-tingaikin/go-header v0.4.3 // indirect
 	github.com/dgraph-io/badger/v2 v2.2007.2 // indirect
 	github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de // indirect
 	github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect
@@ -119,6 +119,7 @@ require (
 	github.com/gostaticanalysis/nilerr v0.1.1 // indirect
 	github.com/hashicorp/errwrap v1.0.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/go-version v1.2.1 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/hexops/gotextdiff v1.0.3 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
@@ -143,7 +144,6 @@ require (
 	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/mbilski/exhaustivestruct v1.2.0 // indirect
-	github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect
 	github.com/mgechev/revive v1.1.4 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.4.3 // indirect
@@ -170,10 +170,10 @@ require (
 	github.com/ryancurrah/gomodguard v1.2.3 // indirect
 	github.com/ryanrolds/sqlclosecheck v0.3.0 // indirect
 	github.com/sanposhiho/wastedassign/v2 v2.0.6 // indirect
-	github.com/securego/gosec/v2 v2.9.6 // indirect
+	github.com/securego/gosec/v2 v2.10.0 // indirect
 	github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
-	github.com/sivchari/containedctx v1.0.1 // indirect
+	github.com/sivchari/containedctx v1.0.2 // indirect
 	github.com/sivchari/tenv v1.4.7 // indirect
 	github.com/sonatard/noctx v0.0.1 // indirect
 	github.com/sourcegraph/go-diff v0.6.1 // indirect
@@ -190,7 +190,7 @@ require (
 	github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect
 	github.com/tetafro/godot v1.4.11 // indirect
 	github.com/timakin/bodyclose v0.0.0-20210704033933-f49887972144 // indirect
-	github.com/tomarrell/wrapcheck/v2 v2.4.0 // indirect
+	github.com/tomarrell/wrapcheck/v2 v2.5.0 // indirect
 	github.com/tommy-muehle/go-mnd/v2 v2.5.0 // indirect
 	github.com/ultraware/funlen v0.0.3 // indirect
 	github.com/ultraware/whitespace v0.0.5 // indirect
@@ -199,11 +199,11 @@ require (
 	github.com/yeya24/promlinter v0.1.1-0.20210918184747-d757024714a1 // indirect
 	gitlab.com/bosi/decorder v0.2.1 // indirect
 	go.etcd.io/bbolt v1.3.6 // indirect
-	golang.org/x/mod v0.5.1 // indirect
-	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 // indirect
+	golang.org/x/sys v0.0.0-20220209214540-3681064d5158 // indirect
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
 	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/tools v0.1.9 // indirect
+	golang.org/x/tools v0.1.10 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
@@ -211,7 +211,7 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 	honnef.co/go/tools v0.2.2 // indirect
-	mvdan.cc/gofumpt v0.2.1 // indirect
+	mvdan.cc/gofumpt v0.3.0 // indirect
 	mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed // indirect
 	mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b // indirect
 	mvdan.cc/unparam v0.0.0-20211214103731-d0ef000c54e5 // indirect

go.sum

@@ -122,8 +122,8 @@ github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj
 github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/ashanbrown/forbidigo v1.3.0 h1:VkYIwb/xxdireGAdJNZoo24O4lmnEWkactplBlWTShc=
 github.com/ashanbrown/forbidigo v1.3.0/go.mod h1:vVW7PEdqEFqapJe95xHkTfB1+XvZXBFg8t0sG2FIxmI=
-github.com/ashanbrown/makezero v1.1.0 h1:b2FVq4dTlBpy9f6qxhbyWH+6zy56IETE9cFbBGtDqs8=
-github.com/ashanbrown/makezero v1.1.0/go.mod h1:oG9Dnez7/ESBqc4EdrdNlryeo7d0KcW1ftXHm7nU/UU=
+github.com/ashanbrown/makezero v1.1.1 h1:iCQ87C0V0vSyO+M9E/FZYbu65auqH0lnsOkf5FcB28s=
+github.com/ashanbrown/makezero v1.1.1/go.mod h1:i1bJLCRSCHOcOa9Y6MyF2FTfMZMFdHvxKHxgO5Z1axI=
 github.com/aws/aws-sdk-go v1.23.20/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.25.37/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.36.30/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro=
@@ -222,16 +222,16 @@ github.com/creachadair/atomicfile v0.2.4/go.mod h1:BRq8Une6ckFneYXZQ+kO7p1ZZP3I2
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4=
-github.com/daixiang0/gci v0.3.1-0.20220208004058-76d765e3ab48 h1:9rJGqaC5do9zkvKrtRdx0HJoxj7Jd6vDa0O2eBU0AbU=
-github.com/daixiang0/gci v0.3.1-0.20220208004058-76d765e3ab48/go.mod h1:jaASoJmv/ykO9dAAPy31iJnreV19248qKDdVWf3QgC4=
+github.com/daixiang0/gci v0.3.3 h1:55xJKH7Gl9Vk6oQ1cMkwrDWjAkT1D+D1G9kNmRcAIY4=
+github.com/daixiang0/gci v0.3.3/go.mod h1:1Xr2bxnQbDxCqqulUOv8qpGqkgRw9RSCGGjEC2LjF8o=
 github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
-github.com/denis-tingajkin/go-header v0.4.2 h1:jEeSF4sdv8/3cT/WY8AgDHUoItNSoEZ7qg9dX7pc218=
-github.com/denis-tingajkin/go-header v0.4.2/go.mod h1:eLRHAVXzE5atsKAnNRDB90WHCFFnBUn4RN0nRcs1LJA=
+github.com/denis-tingaikin/go-header v0.4.3 h1:tEaZKAlqql6SKCY++utLmkPLd6K8IBM20Ha7UVm+mtU=
+github.com/denis-tingaikin/go-header v0.4.3/go.mod h1:0wOCWuN71D5qIgE2nz9KrKmuYBAC2Mra5RassOIQ2/c=
 github.com/dgraph-io/badger/v2 v2.2007.2 h1:EjjK0KqwaFMlPin1ajhP943VPENHJdEz1KLIegjaI3k=
 github.com/dgraph-io/badger/v2 v2.2007.2/go.mod h1:26P/7fbL4kUZVEVKLAKXkBXKOydDmM2p1e+NhhnBCAE=
 github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de h1:t0UHb5vdojIDUqktM6+xJAfScFBsVpXZmqC9dsgJmeA=
@@ -287,8 +287,8 @@ github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHqu
 github.com/franela/goblin v0.0.0-20210519012713-85d372ac71e2/go.mod h1:VzmDKDJVZI3aJmnRI9VjAn9nJ8qPPsN1fqzr9dqInIo=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
 github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
-github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
-github.com/frankban/quicktest v1.14.0/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og=
+github.com/frankban/quicktest v1.14.2 h1:SPb1KFFmM+ybpEjPUhCCkZOM5xlovT5UbrMvWnXyBns=
+github.com/frankban/quicktest v1.14.2/go.mod h1:mgiwOwqx65TmIk1wJ6Q7wvnVMocbUorkibMOrVTHZps=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI=
@@ -400,8 +400,8 @@ github.com/golangci/go-misc v0.0.0-20180628070357-927a3d87b613 h1:9kfjN3AdxcbsZB
 github.com/golangci/go-misc v0.0.0-20180628070357-927a3d87b613/go.mod h1:SyvUF2NxV+sN8upjjeVYr5W7tyxaT1JVtvhKhOn2ii8=
 github.com/golangci/gofmt v0.0.0-20190930125516-244bba706f1a h1:iR3fYXUjHCR97qWS8ch1y9zPNsgXThGwjKPrYfqMPks=
 github.com/golangci/gofmt v0.0.0-20190930125516-244bba706f1a/go.mod h1:9qCChq59u/eW8im404Q2WWTrnBUQKjpNYKMbU4M7EFU=
-github.com/golangci/golangci-lint v1.44.2 h1:MzvkDt1j1OHkv42/feNJVNNXRFACPp7aAWBWDo5aYQw=
-github.com/golangci/golangci-lint v1.44.2/go.mod h1:KjBgkLvsTWDkhfu12iCrv0gwL1kON5KNhbyjQ6qN7Jo=
+github.com/golangci/golangci-lint v1.45.0 h1:T2oCVkYoeckBxcNS6DTYiSXN2QcTNuAWaHyLGfqzMlU=
+github.com/golangci/golangci-lint v1.45.0/go.mod h1:Y6grRO3drH/7kGP88i9jSl9fGWwCrbA5u7i++jOXll4=
 github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0 h1:MfyDlzVjl1hoaPzPD4Gpb/QgoRfSBR0jdhwGyAWwMSA=
 github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg=
 github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca h1:kNY3/svz5T29MYHubXix4aDDuE3RWHkPvopM/EDv/MA=
@@ -687,7 +687,6 @@ github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0j
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mbilski/exhaustivestruct v1.2.0 h1:wCBmUnSYufAHO6J4AVWY6ff+oxWxsVFrwgOdMUQePUo=
 github.com/mbilski/exhaustivestruct v1.2.0/go.mod h1:OeTBVxQWoEmB2J2JCHmXWPJ0aksxSUOUy+nvtVEfzXc=
-github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0=
 github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg=
 github.com/mgechev/revive v1.1.4 h1:sZOjY6GU35Kr9jKa/wsKSHgrFz8eASIB5i3tqWZMp0A=
 github.com/mgechev/revive v1.1.4/go.mod h1:ZZq2bmyssGh8MSPz3VVziqRNIMYTJXzP8MUKG90vZ9A=
@@ -768,15 +767,17 @@ github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9k
 github.com/onsi/ginkgo v1.16.2/go.mod h1:CObGmKUOKaSC0RjmoAK7tKyn4Azo5P2IWuoMnvwxz1E=
 github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc=
 github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
-github.com/onsi/ginkgo/v2 v2.0.0 h1:CcuG/HvWNkkaqCUpJifQY8z7qEMBJya6aLPx6ftGyjQ=
 github.com/onsi/ginkgo/v2 v2.0.0/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
+github.com/onsi/ginkgo/v2 v2.1.3 h1:e/3Cwtogj0HA+25nMP1jCMDIf8RtRYbGwGGuBIFztkc=
+github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.13.0/go.mod h1:lRk9szgn8TxENtWd0Tp4c3wjlRfMTMH27I+3Je41yGY=
-github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
+github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
@@ -897,12 +898,12 @@ github.com/sanposhiho/wastedassign/v2 v2.0.6 h1:+6/hQIHKNJAUixEj6EmOngGIisyeI+T3
 github.com/sanposhiho/wastedassign/v2 v2.0.6/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dmsbF2ud9pAAGfoLfjhtI=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo=
-github.com/securego/gosec/v2 v2.9.6 h1:ysfvgQBp2zmTgXQl65UkqEkYlQGbnVSRUGpCrJiiR4c=
-github.com/securego/gosec/v2 v2.9.6/go.mod h1:EESY9Ywxo/Zc5NyF/qIj6Cop+4PSWM0F0OfGD7FdIXc=
+github.com/securego/gosec/v2 v2.10.0 h1:l6BET4EzWtyUXCpY2v7N92v0DDCas0L7ngg3bpqbr8g=
+github.com/securego/gosec/v2 v2.10.0/go.mod h1:PVq8Ewh/nCN8l/kKC6zrGXSr7m2NmEK6ITIAWMtIaA0=
 github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c h1:W65qqJCIOVP4jpqPQ0YvHYKwcMEMVWIzWC5iNQQfBTU=
 github.com/shazow/go-diff v0.0.0-20160112020656-b6b7b6733b8c/go.mod h1:/PevMnwAxekIXwN8qQyfc5gl2NlkB3CQlkizAbOkeBs=
-github.com/shirou/gopsutil/v3 v3.22.1/go.mod h1:WapW1AOOPlHyXr+yOyw3uYx36enocrtSoSBy0L5vUHY=
+github.com/shirou/gopsutil/v3 v3.22.2/go.mod h1:WapW1AOOPlHyXr+yOyw3uYx36enocrtSoSBy0L5vUHY=
 github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
 github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
@@ -912,8 +913,8 @@ github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrf
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
 github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/sivchari/containedctx v1.0.1 h1:fJq44cX+tD+uT5xGrsg25GwiaY61NGybQk9WWKij3Uo=
-github.com/sivchari/containedctx v1.0.1/go.mod h1:PwZOeqm4/DLoJOqMSIJs3aKqXRX4YO+uXww087KZ7Bw=
+github.com/sivchari/containedctx v1.0.2 h1:0hLQKpgC53OVF1VT7CeoFHk9YKstur1XOgfYIc1yrHI=
+github.com/sivchari/containedctx v1.0.2/go.mod h1:PwZOeqm4/DLoJOqMSIJs3aKqXRX4YO+uXww087KZ7Bw=
 github.com/sivchari/tenv v1.4.7 h1:FdTpgRlTue5eb5nXIYgS/lyVXSjugU8UUVDwhP1NLU8=
 github.com/sivchari/tenv v1.4.7/go.mod h1:5nF+bITvkebQVanjU6IuMbvIot/7ReNsUV7I5NbprB0=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
@@ -1000,8 +1001,8 @@ github.com/tklauser/numcpus v0.3.0/go.mod h1:yFGUr7TUHQRAhyqBcEg0Ge34zDBAsIvJJcy
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20200427203606-3cfed13b9966/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
-github.com/tomarrell/wrapcheck/v2 v2.4.0 h1:mU4H9KsqqPZUALOUbVOpjy8qNQbWLoLI9fV68/1tq30=
-github.com/tomarrell/wrapcheck/v2 v2.4.0/go.mod h1:68bQ/eJg55BROaRTbMjC7vuhL2OgfoG8bLp9ZyoBfyY=
+github.com/tomarrell/wrapcheck/v2 v2.5.0 h1:g27SGGHNoQdvHz4KZA9o4v09RcWzylR+b1yueE5ECiw=
+github.com/tomarrell/wrapcheck/v2 v2.5.0/go.mod h1:68bQ/eJg55BROaRTbMjC7vuhL2OgfoG8bLp9ZyoBfyY=
 github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce/go.mod h1:o8v6yHRoik09Xen7gje4m9ERNah1d1PPsVq1VEx9vE4=
 github.com/tommy-muehle/go-mnd/v2 v2.5.0 h1:iAj0a8e6+dXSL7Liq0aXPox36FiN1dBbjA6lt9fl65s=
 github.com/tommy-muehle/go-mnd/v2 v2.5.0/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw=
@@ -1106,10 +1107,12 @@ golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210915214749-c084706c2272/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211215165025-cf75a172585e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce h1:Roh6XWxHFKrPgC/EQhVubSAGQ6Ozk6IdxHSzt1mR0EI=
 golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20220214200702-86341886e292 h1:f+lwQ+GtmgoY+A2YaQxlSOnDjXcQ7ZRLWOHbC6HtRqE=
+golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -1151,8 +1154,9 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 h1:kQgndtyPBW/JIYERgdxfwMYh3AVStj88WQTlNDi2a+o=
+golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1347,8 +1351,9 @@ golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211213223007-03aa0b5f6827/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220111092808-5a964db01320/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220209214540-3681064d5158 h1:rm+CHSpPEEW2IsXUib1ThaHIjuBVZjxNgSKmBLFfD4c=
+golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
@@ -1468,8 +1473,9 @@ golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
 golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 golang.org/x/tools v0.1.9-0.20211228192929-ee1ca4ffc4da/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
-golang.org/x/tools v0.1.9 h1:j9KsMiaP1c3B0OTQGth0/k+miLGTgLsAFUCrF2vLcF8=
 golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.1.10 h1:QjFRCZxdOhBJ/UNgnBZLbNV13DlbnK0quyivTnXJM20=
+golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1689,8 +1695,8 @@ honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.2.2 h1:MNh1AVMyVX23VUHE2O27jm6lNj3vjO5DexS4A1xvnzk=
 honnef.co/go/tools v0.2.2/go.mod h1:lPVVZ2BS5TfnjLyizF7o7hv7j9/L+8cZY2hLyjP9cGY=
-mvdan.cc/gofumpt v0.2.1 h1:7jakRGkQcLAJdT+C8Bwc9d0BANkVPSkHZkzNv07pJAs=
-mvdan.cc/gofumpt v0.2.1/go.mod h1:a/rvZPhsNaedOJBzqRD9omnwVwHZsBdJirXHa9Gh9Ig=
+mvdan.cc/gofumpt v0.3.0 h1:kTojdZo9AcEYbQYhGuLf/zszYthRdhDNDUi2JKTxas4=
+mvdan.cc/gofumpt v0.3.0/go.mod h1:0+VyGZWleeIj5oostkOex+nDBA0eyavuDnDusAJ8ylo=
 mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed h1:WX1yoOaKQfddO/mLzdV4wptyWgoH/6hwLs7QHTixo0I=
 mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc=
 mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b h1:DxJ5nJdkhDlLok9K6qO+5290kphDJbHOQO1DFFFTeBo=

internal/blocksync/reactor_test.go

@@ -226,7 +226,7 @@ func TestReactor_AbruptDisconnect(t *testing.T) {
 	defer os.RemoveAll(cfg.RootDir)
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, 1, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	maxBlockHeight := int64(64)
 
 	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
@@ -266,7 +266,7 @@ func TestReactor_SyncTime(t *testing.T) {
 	defer os.RemoveAll(cfg.RootDir)
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, 1, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	maxBlockHeight := int64(101)
 
 	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
@@ -294,7 +294,7 @@ func TestReactor_NoBlockResponse(t *testing.T) {
 	defer os.RemoveAll(cfg.RootDir)
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, 1, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	maxBlockHeight := int64(65)
 
 	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
@@ -347,7 +347,7 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) {
 
 	maxBlockHeight := int64(48)
 	valSet, privVals := factory.ValidatorSet(ctx, t, 1, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 
 	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0, 0, 0, 0}, 1000)
 
@@ -382,7 +382,7 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) {
 	// XXX: This causes a potential race condition.
 	// See: https://github.com/tendermint/tendermint/issues/6005
 	valSet, otherPrivVals := factory.ValidatorSet(ctx, t, 1, 30)
-	otherGenDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	otherGenDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	newNode := rts.network.MakeNode(ctx, t, p2ptest.NodeOptions{
 		MaxPeers:     uint16(len(rts.nodes) + 1),
 		MaxConnected: uint16(len(rts.nodes) + 1),

internal/consensus/byzantine_test.go

@@ -48,7 +48,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 	tickerFunc := newMockTickerFunc(true)
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, nValidators, 30)
-	genDoc := factory.GenesisDoc(config, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(config, time.Now(), valSet.Validators, factory.ConsensusParams())
 	states := make([]*State, nValidators)
 
 	for i := 0; i < nValidators; i++ {

internal/consensus/common_test.go

@@ -546,6 +546,7 @@ func makeState(ctx context.Context, t *testing.T, args makeStateArgs) (*State, [
 	}
 
 	state, privVals := makeGenesisState(ctx, t, args.config, genesisStateArgs{
+		Params:     factory.ConsensusParams(),
 		Validators: validators,
 	})
 
@@ -791,7 +792,7 @@ func makeConsensusState(
 	tempDir := t.TempDir()
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, nValidators, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	css := make([]*State, nValidators)
 	logger := consensusLogger()
 
@@ -850,7 +851,7 @@ func randConsensusNetWithPeers(
 	t.Helper()
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, nValidators, testMinPower)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	css := make([]*State, nPeers)
 	t.Helper()
 	logger := consensusLogger()

internal/consensus/invalid_test.go

@@ -26,13 +26,13 @@ func TestReactorInvalidPrecommit(t *testing.T) {
 
 	config := configSetup(t)
 
-	n := 4
+	const n = 2
 	states, cleanup := makeConsensusState(ctx, t,
 		config, n, "consensus_reactor_test",
 		newMockTickerFunc(true))
 	t.Cleanup(cleanup)
 
-	for i := 0; i < 4; i++ {
+	for i := 0; i < n; i++ {
 		ticker := NewTimeoutTicker(states[i].logger)
 		states[i].SetTimeoutTicker(ticker)
 	}

internal/consensus/mempool_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/tendermint/tendermint/internal/mempool"
 	sm "github.com/tendermint/tendermint/internal/state"
 	"github.com/tendermint/tendermint/internal/store"
+	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/types"
 )
@@ -42,7 +43,8 @@ func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
 	config.Consensus.CreateEmptyBlocks = false
 	state, privVals := makeGenesisState(ctx, t, baseConfig, genesisStateArgs{
 		Validators: 1,
-		Power:      10})
+		Power:      10,
+		Params:     factory.ConsensusParams()})
 	cs := newStateWithConfig(ctx, t, log.NewNopLogger(), config, state, privVals[0], NewCounterApplication())
 	assertMempool(t, cs.txNotifier).EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
@@ -69,7 +71,8 @@ func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
 	config.Consensus.CreateEmptyBlocksInterval = ensureTimeout
 	state, privVals := makeGenesisState(ctx, t, baseConfig, genesisStateArgs{
 		Validators: 1,
-		Power:      10})
+		Power:      10,
+		Params:     factory.ConsensusParams()})
 	cs := newStateWithConfig(ctx, t, log.NewNopLogger(), config, state, privVals[0], NewCounterApplication())
 
 	assertMempool(t, cs.txNotifier).EnableTxsAvailable()
@@ -94,7 +97,8 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 	config.Consensus.CreateEmptyBlocks = false
 	state, privVals := makeGenesisState(ctx, t, baseConfig, genesisStateArgs{
 		Validators: 1,
-		Power:      10})
+		Power:      10,
+		Params:     factory.ConsensusParams()})
 	cs := newStateWithConfig(ctx, t, log.NewNopLogger(), config, state, privVals[0], NewCounterApplication())
 	assertMempool(t, cs.txNotifier).EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
@@ -119,7 +123,7 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 
 	ensureNewRound(t, newRoundCh, height, round) // first round at next height
 	checkTxsRange(ctx, t, cs, 0, 1)              // we deliver txs, but don't set a proposal so we get the next round
-	ensureNewTimeout(t, timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())
+	ensureNewTimeout(t, timeoutCh, height, round, cs.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	round++                                      // moving to the next round
 	ensureNewRound(t, newRoundCh, height, round) // wait for the next round
@@ -145,7 +149,9 @@ func TestMempoolTxConcurrentWithCommit(t *testing.T) {
 	logger := log.NewNopLogger()
 	state, privVals := makeGenesisState(ctx, t, config, genesisStateArgs{
 		Validators: 1,
-		Power:      10})
+		Power:      10,
+		Params:     factory.ConsensusParams(),
+	})
 	stateStore := sm.NewStore(dbm.NewMemDB())
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 
@@ -180,7 +186,8 @@ func TestMempoolRmBadTx(t *testing.T) {
 
 	state, privVals := makeGenesisState(ctx, t, config, genesisStateArgs{
 		Validators: 1,
-		Power:      10})
+		Power:      10,
+		Params:     factory.ConsensusParams()})
 	app := NewCounterApplication()
 	stateStore := sm.NewStore(dbm.NewMemDB())
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
@@ -310,10 +317,12 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {
 
 func (app *CounterApplication) PrepareProposal(
 	req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
-	return abci.ResponsePrepareProposal{}
+	return abci.ResponsePrepareProposal{
+		ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
+	}
 }
 
 func (app *CounterApplication) ProcessProposal(
 	req abci.RequestProcessProposal) abci.ResponseProcessProposal {
-	return abci.ResponseProcessProposal{Accept: true}
+	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
 }

internal/consensus/pbts_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/internal/eventbus"
 	tmpubsub "github.com/tendermint/tendermint/internal/pubsub"
+	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	tmtimemocks "github.com/tendermint/tendermint/libs/time/mocks"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
@@ -105,8 +106,8 @@ func newPBTSTestHarness(ctx context.Context, t *testing.T, tc pbtsTestConfigurat
 		// height 4 therefore occurs 2*blockTimeIota after height 2.
 		tc.height4ProposedBlockOffset = tc.height2ProposalTimeDeliveryOffset + 2*blockTimeIota
 	}
-	cfg.Consensus.TimeoutPropose = tc.timeoutPropose
-	consensusParams := types.DefaultConsensusParams()
+	consensusParams := factory.ConsensusParams()
+	consensusParams.Timeout.Propose = tc.timeoutPropose
 	consensusParams.Synchrony = tc.synchronyParams
 
 	state, privVals := makeGenesisState(ctx, t, cfg, genesisStateArgs{

internal/consensus/reactor_test.go

@@ -355,7 +355,7 @@ func TestReactorBasic(t *testing.T) {
 
 	cfg := configSetup(t)
 
-	n := 4
+	n := 2
 	states, cleanup := makeConsensusState(ctx, t,
 		cfg, n, "consensus_reactor_test",
 		newMockTickerFunc(true))
@@ -445,12 +445,12 @@ func TestReactorWithEvidence(t *testing.T) {
 
 	cfg := configSetup(t)
 
-	n := 4
+	n := 2
 	testName := "consensus_reactor_test"
 	tickerFunc := newMockTickerFunc(true)
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, n, 30)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 	states := make([]*State, n)
 	logger := consensusLogger()
 
@@ -551,7 +551,7 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 
 	cfg := configSetup(t)
 
-	n := 4
+	n := 2
 	states, cleanup := makeConsensusState(ctx,
 		t,
 		cfg,
@@ -574,7 +574,7 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 	// send a tx
 	require.NoError(
 		t,
-		assertMempool(t, states[3].txNotifier).CheckTx(
+		assertMempool(t, states[1].txNotifier).CheckTx(
 			ctx,
 			[]byte{1, 2, 3},
 			nil,
@@ -605,7 +605,7 @@ func TestReactorRecordsVotesAndBlockParts(t *testing.T) {
 
 	cfg := configSetup(t)
 
-	n := 4
+	n := 2
 	states, cleanup := makeConsensusState(ctx, t,
 		cfg, n, "consensus_reactor_test",
 		newMockTickerFunc(true))
@@ -670,7 +670,7 @@ func TestReactorVotingPowerChange(t *testing.T) {
 
 	cfg := configSetup(t)
 
-	n := 4
+	n := 2
 	states, cleanup := makeConsensusState(ctx,
 		t,
 		cfg,

internal/consensus/replay_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/fortytw2/leaktest"
 	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -594,6 +595,8 @@ func TestHandshakeReplayAll(t *testing.T) {
 
 	sim := setupSimulator(ctx, t)
 
+	t.Cleanup(leaktest.Check(t))
+
 	for _, m := range modes {
 		testHandshakeReplay(ctx, t, sim, 0, m, false)
 	}
@@ -609,6 +612,8 @@ func TestHandshakeReplaySome(t *testing.T) {
 
 	sim := setupSimulator(ctx, t)
 
+	t.Cleanup(leaktest.Check(t))
+
 	for _, m := range modes {
 		testHandshakeReplay(ctx, t, sim, 2, m, false)
 	}
@@ -639,6 +644,8 @@ func TestHandshakeReplayNone(t *testing.T) {
 
 	sim := setupSimulator(ctx, t)
 
+	t.Cleanup(leaktest.Check(t))
+
 	for _, m := range modes {
 		testHandshakeReplay(ctx, t, sim, numBlocks, m, false)
 	}
@@ -652,12 +659,12 @@ func tempWALWithData(t *testing.T, data []byte) string {
 
 	walFile, err := os.CreateTemp(t.TempDir(), "wal")
 	require.NoError(t, err, "failed to create temp WAL file")
+	t.Cleanup(func() { _ = os.RemoveAll(walFile.Name()) })
 
 	_, err = walFile.Write(data)
 	require.NoError(t, err, "failed to  write to temp WAL file")
 
 	require.NoError(t, walFile.Close(), "failed to close temp WAL file")
-
 	return walFile.Name()
 }
 

internal/consensus/state.go

@@ -506,8 +506,8 @@ func (cs *State) OnStop() {
 	if cs.GetRoundState().Step == cstypes.RoundStepCommit {
 		select {
 		case <-cs.getOnStopCh():
-		case <-time.After(cs.config.TimeoutCommit):
-			cs.logger.Error("OnStop: timeout waiting for commit to finish", "time", cs.config.TimeoutCommit)
+		case <-time.After(cs.state.ConsensusParams.Timeout.Commit):
+			cs.logger.Error("OnStop: timeout waiting for commit to finish", "time", cs.state.ConsensusParams.Timeout.Commit)
 		}
 	}
 
@@ -787,9 +787,9 @@ func (cs *State) updateToState(ctx context.Context, state sm.State) {
 		// to be gathered for the first block.
 		// And alternative solution that relies on clocks:
 		// cs.StartTime = state.LastBlockTime.Add(timeoutCommit)
-		cs.StartTime = cs.config.Commit(tmtime.Now())
+		cs.StartTime = cs.state.ConsensusParams.Timeout.CommitTime(tmtime.Now())
 	} else {
-		cs.StartTime = cs.config.Commit(cs.CommitTime)
+		cs.StartTime = cs.state.ConsensusParams.Timeout.CommitTime(cs.CommitTime)
 	}
 
 	cs.Validators = validators
@@ -861,19 +861,35 @@ func (cs *State) receiveRoutine(ctx context.Context, maxSteps int) {
 			// complicate diagnosing and recovering from the failure.
 			onExit(cs)
 
+			// There are a couple of cases where the we
+			// panic with an error from deeper within the
+			// state machine and in these cases, typically
+			// during a normal shutdown, we can continue
+			// with normal shutdown with safety. These
+			// cases are:
+			if err, ok := r.(error); ok {
+				// TODO(creachadair): In ordinary operation, the WAL autofile should
+				// never be closed. This only happens during shutdown and production
+				// nodes usually halt by panicking. Many existing tests, however,
+				// assume a clean shutdown is possible. Prior to #8111, we were
+				// swallowing the panic in receiveRoutine, making that appear to
+				// work. Filtering this specific error is slightly risky, but should
+				// affect only unit tests. In any case, not re-panicking here only
+				// preserves the pre-existing behavior for this one error type.
+				if errors.Is(err, autofile.ErrAutoFileClosed) {
+					return
+				}
+
+				// don't re-panic if the panic is just an
+				// error and we're already trying to shut down
+				if ctx.Err() != nil {
+					return
+
+				}
+			}
+
 			// Re-panic to ensure the node terminates.
 			//
-			// TODO(creachadair): In ordinary operation, the WAL autofile should
-			// never be closed. This only happens during shutdown and production
-			// nodes usually halt by panicking. Many existing tests, however,
-			// assume a clean shutdown is possible. Prior to #8111, we were
-			// swallowing the panic in receiveRoutine, making that appear to
-			// work. Filtering this specific error is slightly risky, but should
-			// affect only unit tests. In any case, not re-panicking here only
-			// preserves the pre-existing behavior for this one error type.
-			if err, ok := r.(error); ok && errors.Is(err, autofile.ErrAutoFileClosed) {
-				return
-			}
 			panic(r)
 		}
 	}()
@@ -1246,7 +1262,7 @@ func (cs *State) enterPropose(ctx context.Context, height int64, round int32) {
 	}()
 
 	// If we don't get the proposal and all block parts quick enough, enterPrevote
-	cs.scheduleTimeout(cs.config.Propose(round), height, round, cstypes.RoundStepPropose)
+	cs.scheduleTimeout(cs.state.ConsensusParams.Timeout.ProposeTimeout(round), height, round, cstypes.RoundStepPropose)
 
 	// Nothing more to do if we're not a validator
 	if cs.privValidator == nil {
@@ -1327,7 +1343,7 @@ func (cs *State) defaultDecideProposal(ctx context.Context, height int64, round
 	p := proposal.ToProto()
 
 	// wait the max amount we would wait for a proposal
-	ctxto, cancel := context.WithTimeout(ctx, cs.config.TimeoutPropose)
+	ctxto, cancel := context.WithTimeout(ctx, cs.state.ConsensusParams.Timeout.Propose)
 	defer cancel()
 	if err := cs.privValidator.SignProposal(ctxto, cs.state.ChainID, p); err == nil {
 		proposal.Signature = p.Signature
@@ -1606,7 +1622,7 @@ func (cs *State) enterPrevoteWait(ctx context.Context, height int64, round int32
 	}()
 
 	// Wait for some more prevotes; enterPrecommit
-	cs.scheduleTimeout(cs.config.Prevote(round), height, round, cstypes.RoundStepPrevoteWait)
+	cs.scheduleTimeout(cs.state.ConsensusParams.Timeout.VoteTimeout(round), height, round, cstypes.RoundStepPrevoteWait)
 }
 
 // Enter: `timeoutPrevote` after any +2/3 prevotes.
@@ -1759,7 +1775,7 @@ func (cs *State) enterPrecommitWait(ctx context.Context, height int64, round int
 	}()
 
 	// wait for some more precommits; enterNewRound
-	cs.scheduleTimeout(cs.config.Precommit(round), height, round, cstypes.RoundStepPrecommitWait)
+	cs.scheduleTimeout(cs.state.ConsensusParams.Timeout.VoteTimeout(round), height, round, cstypes.RoundStepPrecommitWait)
 }
 
 // Enter: +2/3 precommits for block
@@ -2295,7 +2311,7 @@ func (cs *State) addVote(
 		cs.evsw.FireEvent(ctx, types.EventVoteValue, vote)
 
 		// if we can skip timeoutCommit and have all the votes now,
-		if cs.config.SkipTimeoutCommit && cs.LastCommit.HasAll() {
+		if cs.state.ConsensusParams.Timeout.BypassCommitTimeout && cs.LastCommit.HasAll() {
 			// go straight to new round (skip timeout commit)
 			// cs.scheduleTimeout(time.Duration(0), cs.Height, 0, cstypes.RoundStepNewHeight)
 			cs.enterNewRound(ctx, cs.Height, 0)
@@ -2408,7 +2424,7 @@ func (cs *State) addVote(
 
 			if !blockID.IsNil() {
 				cs.enterCommit(ctx, height, vote.Round)
-				if cs.config.SkipTimeoutCommit && precommits.HasAll() {
+				if cs.state.ConsensusParams.Timeout.BypassCommitTimeout && precommits.HasAll() {
 					cs.enterNewRound(ctx, cs.Height, 0)
 				}
 			} else {
@@ -2458,19 +2474,16 @@ func (cs *State) signVote(
 
 	// If the signedMessageType is for precommit,
 	// use our local precommit Timeout as the max wait time for getting a singed commit. The same goes for prevote.
-	var timeout time.Duration
+	timeout := cs.state.ConsensusParams.Timeout.VoteTimeout(cs.Round)
 
 	switch msgType {
 	case tmproto.PrecommitType:
-		timeout = cs.config.TimeoutPrecommit
 		// if the signedMessage type is for a precommit, add VoteExtension
 		ext, err := cs.blockExec.ExtendVote(ctx, vote)
 		if err != nil {
 			return nil, err
 		}
 		vote.Extension = ext
-	case tmproto.PrevoteType:
-		timeout = cs.config.TimeoutPrevote
 	default:
 		timeout = time.Second
 	}
@@ -2530,12 +2543,7 @@ func (cs *State) updatePrivValidatorPubKey(rctx context.Context) error {
 		return nil
 	}
 
-	var timeout time.Duration
-	if cs.config.TimeoutPrecommit > cs.config.TimeoutPrevote {
-		timeout = cs.config.TimeoutPrecommit
-	} else {
-		timeout = cs.config.TimeoutPrevote
-	}
+	timeout := cs.state.ConsensusParams.Timeout.VoteTimeout(cs.Round)
 
 	// no GetPubKey retry beyond the proposal/voting in RetrySignerClient
 	if cs.Step >= cstypes.RoundStepPrecommit && cs.privValidatorType == types.RetrySignerClient {

internal/consensus/state_test.go

@@ -3,7 +3,6 @@ package consensus
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
@@ -12,7 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/tendermint/tendermint/abci/example/kvstore"
-	abcitypes "github.com/tendermint/tendermint/abci/types"
+	abci "github.com/tendermint/tendermint/abci/types"
 	abcimocks "github.com/tendermint/tendermint/abci/types/mocks"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	cstypes "github.com/tendermint/tendermint/internal/consensus/types"
@@ -164,7 +163,7 @@ func TestStateEnterProposeNoPrivValidator(t *testing.T) {
 	startTestRound(ctx, cs, height, round)
 
 	// if we're not a validator, EnterPropose should timeout
-	ensureNewTimeout(t, timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())
+	ensureNewTimeout(t, timeoutCh, height, round, cs.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	if cs.GetRoundState().Proposal != nil {
 		t.Error("Expected to make no proposal, since no privValidator")
@@ -203,7 +202,7 @@ func TestStateEnterProposeYesPrivValidator(t *testing.T) {
 	}
 
 	// if we're a validator, enterPropose should not timeout
-	ensureNoNewTimeout(t, timeoutCh, cs.config.TimeoutPropose.Nanoseconds())
+	ensureNoNewTimeout(t, timeoutCh, cs.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 }
 
 func TestStateBadProposal(t *testing.T) {
@@ -312,11 +311,9 @@ func TestStateOversizedBlock(t *testing.T) {
 	// start the machine
 	startTestRound(ctx, cs1, height, round)
 
-	t.Log("Block Sizes", "Limit", cs1.state.ConsensusParams.Block.MaxBytes, "Current", totalBytes)
-
 	// c1 should log an error with the block part message as it exceeds the consensus params. The
 	// block is not added to cs.ProposalBlock so the node timeouts.
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	// and then should send nil prevote and precommit regardless of whether other validators prevote and
 	// precommit on it
@@ -484,13 +481,12 @@ func TestStateLock_NoPOL(t *testing.T) {
 
 	// (note we're entering precommit for a second time this round)
 	// but with invalid args. then we enterPrecommitWait, and the timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	///
 
 	round++ // moving to the next round
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("#### ONTO ROUND 1")
 	/*
 		Round2 (cs1, B) // B B2
 	*/
@@ -498,7 +494,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 	incrementRound(vs2)
 
 	// now we're on a new round and not the proposer, so wait for timeout
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	rs := cs1.GetRoundState()
 
@@ -517,7 +513,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 
 	// now we're going to enter prevote again, but with invalid args
 	// and then prevote wait, which should timeout. then wait for precommit
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 	// the proposed block should still be locked block.
 	// we should precommit nil and be locked on the proposal.
 	ensurePrecommit(t, voteCh, height, round)
@@ -529,11 +525,10 @@ func TestStateLock_NoPOL(t *testing.T) {
 
 	// (note we're entering precommit for a second time this round, but with invalid args
 	// then we enterPrecommitWait and timeout into NewRound
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	round++ // entering new round
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("#### ONTO ROUND 2")
 	/*
 		Round3 (vs2, _) // B, B2
 	*/
@@ -557,7 +552,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrevoteType, config.ChainID(), newBlockID, vs2)
 	ensurePrevote(t, voteCh, height, round)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 	ensurePrecommit(t, voteCh, height, round) // precommit
 
 	validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, initialBlockID.Hash) // precommit nil but be locked on proposal
@@ -572,7 +567,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 		vs2) // NOTE: conflicting precommits at same height
 	ensurePrecommit(t, voteCh, height, round)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	// cs1 is locked on a block at this point, so we must generate a new consensus
 	// state to force a new proposal block to be generated.
@@ -590,7 +585,6 @@ func TestStateLock_NoPOL(t *testing.T) {
 
 	round++ // entering new round
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("#### ONTO ROUND 3")
 	/*
 		Round4 (vs2, C) // B C // B C
 	*/
@@ -612,7 +606,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrevoteType, config.ChainID(), propBlockID, vs2)
 	ensurePrevote(t, voteCh, height, round)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 	ensurePrecommit(t, voteCh, height, round)
 	validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, initialBlockID.Hash) // precommit nil but locked on proposal
 
@@ -662,7 +656,6 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 
 	// start round and wait for propose and prevote
 	startTestRound(ctx, cs1, height, round)
@@ -690,7 +683,7 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -700,7 +693,6 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 
 		Check that cs1 is now locked on the new block, D and no longer on the old block.
 	*/
-	t.Log("### Starting Round 1")
 	incrementRound(vs2, vs3, vs4)
 	round++
 
@@ -769,7 +761,6 @@ func TestStateLock_POLRelock(t *testing.T) {
 		Send a precommit for nil from all of the validators to cs1.
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 
 	startTestRound(ctx, cs1, height, round)
 
@@ -798,7 +789,7 @@ func TestStateLock_POLRelock(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -808,7 +799,6 @@ func TestStateLock_POLRelock(t *testing.T) {
 
 		Check that cs1 updates its 'locked round' value to the current round.
 	*/
-	t.Log("### Starting Round 1")
 	incrementRound(vs2, vs3, vs4)
 	round++
 	propR1 := types.NewProposal(height, round, cs1.ValidRound, blockID, theBlock.Header.Time)
@@ -868,7 +858,6 @@ func TestStateLock_PrevoteNilWhenLockedAndMissProposal(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 
 	startTestRound(ctx, cs1, height, round)
 
@@ -895,7 +884,7 @@ func TestStateLock_PrevoteNilWhenLockedAndMissProposal(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -905,7 +894,6 @@ func TestStateLock_PrevoteNilWhenLockedAndMissProposal(t *testing.T) {
 		Check that cs1 prevotes nil instead of its locked block, but ensure
 		that it maintains its locked block.
 	*/
-	t.Log("### Starting Round 1")
 	incrementRound(vs2, vs3, vs4)
 	round++
 
@@ -957,7 +945,6 @@ func TestStateLock_PrevoteNilWhenLockedAndDifferentProposal(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 	startTestRound(ctx, cs1, height, round)
 
 	ensureNewRound(t, newRoundCh, height, round)
@@ -983,7 +970,7 @@ func TestStateLock_PrevoteNilWhenLockedAndDifferentProposal(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -994,7 +981,6 @@ func TestStateLock_PrevoteNilWhenLockedAndDifferentProposal(t *testing.T) {
 		Check that cs1 prevotes nil instead of its locked block, but ensure
 		that it maintains its locked block.
 	*/
-	t.Log("### Starting Round 1")
 	incrementRound(vs2, vs3, vs4)
 	round++
 	cs2 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
@@ -1059,7 +1045,6 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round.
 	*/
-	t.Log("#### ONTO ROUND 0")
 
 	// start round and wait for propose and prevote
 	startTestRound(ctx, cs1, height, round)
@@ -1093,7 +1078,7 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), blockID, vs3)
 
 	// timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -1101,7 +1086,6 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 		Check that cs1 maintains its lock on B but precommits nil.
 		Send a precommit for nil from >2/3 of the validators to `cs1`.
 	*/
-	t.Log("#### ONTO ROUND 1")
 	round++
 	incrementRound(vs2, vs3, vs4)
 	cs2 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
@@ -1128,7 +1112,7 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 	validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, blockID.Hash)
 
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 2:
@@ -1136,7 +1120,6 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 		Send the validator >2/3 prevotes for nil and ensure that it did not
 		unlock its block at the end of the previous round.
 	*/
-	t.Log("#### ONTO ROUND 2")
 	round++
 	incrementRound(vs2, vs3, vs4)
 	cs3 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
@@ -1193,7 +1176,6 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 	startTestRound(ctx, cs1, height, round)
 
 	ensureNewRound(t, newRoundCh, height, round)
@@ -1216,7 +1198,7 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -1225,7 +1207,6 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 
 		Check that cs1 does not update its locked block to this missed block D.
 	*/
-	t.Log("### Starting Round 1")
 	incrementRound(vs2, vs3, vs4)
 	round++
 	cs2 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
@@ -1281,7 +1262,6 @@ func TestStateLock_DoesNotLockOnOldProposal(t *testing.T) {
 
 		This ensures that cs1 will not lock on B.
 	*/
-	t.Log("### Starting Round 0")
 	startTestRound(ctx, cs1, height, round)
 
 	ensureNewRound(t, newRoundCh, height, round)
@@ -1305,7 +1285,7 @@ func TestStateLock_DoesNotLockOnOldProposal(t *testing.T) {
 	incrementRound(vs2, vs3, vs4)
 
 	// timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -1315,7 +1295,6 @@ func TestStateLock_DoesNotLockOnOldProposal(t *testing.T) {
 		cs1 saw a POL for the block it saw in round 0. We ensure that it does not
 		lock on this block, since it did not see a proposal for it in this round.
 	*/
-	t.Log("### Starting Round 1")
 	round++
 	ensureNewRound(t, newRoundCh, height, round)
 
@@ -1377,9 +1356,8 @@ func TestStateLock_POLSafety1(t *testing.T) {
 
 	// cs1 precommit nil
 	ensurePrecommit(t, voteCh, height, round)
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
-	t.Log("### ONTO ROUND 1")
 	incrementRound(vs2, vs3, vs4)
 	round++ // moving to the next round
 	cs2 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
@@ -1407,8 +1385,6 @@ func TestStateLock_POLSafety1(t *testing.T) {
 
 	require.Nil(t, rs.LockedBlock, "we should not be locked!")
 
-	t.Logf("new prop hash %v", fmt.Sprintf("%X", propBlock.Hash()))
-
 	// go to prevote, prevote for proposal block
 	ensurePrevoteMatch(t, voteCh, height, round, r2BlockID.Hash)
 
@@ -1421,20 +1397,19 @@ func TestStateLock_POLSafety1(t *testing.T) {
 
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	incrementRound(vs2, vs3, vs4)
 	round++ // moving to the next round
 
 	ensureNewRound(t, newRoundCh, height, round)
 
-	t.Log("### ONTO ROUND 2")
 	/*Round3
 	we see the polka from round 1 but we shouldn't unlock!
 	*/
 
 	// timeout of propose
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	// finish prevote
 	ensurePrevoteMatch(t, voteCh, height, round, nil)
@@ -1494,7 +1469,7 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	incrementRound(vs2, vs3, vs4)
 
 	round++ // moving to the next round
-	t.Log("### ONTO Round 1")
+
 	// jump in at round 1
 	startTestRound(ctx, cs1, height, round)
 	ensureNewRound(t, newRoundCh, height, round)
@@ -1518,7 +1493,7 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	incrementRound(vs2, vs3, vs4)
 
 	// timeout of precommit wait to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	round++ // moving to the next round
 	// in round 2 we see the polkad block from round 0
@@ -1536,7 +1511,7 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	addVotes(cs1, prevotes...)
 
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("### ONTO Round 2")
+
 	/*Round2
 	// now we see the polka from round 1, but we shouldnt unlock
 	*/
@@ -1579,7 +1554,6 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 
 		This ensures that cs1 will lock on B in this round but not precommit it.
 	*/
-	t.Log("### Starting Round 0")
 
 	startTestRound(ctx, cs1, height, round)
 
@@ -1606,7 +1580,7 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Round 1:
@@ -1617,14 +1591,16 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 		cs1 has now seen greater than 2/3 of the voting power prevote D in this round
 		but cs1 did not see the proposal for D in this round so it will not prevote or precommit it.
 	*/
-	t.Log("### Starting Round 1")
+
 	incrementRound(vs2, vs3, vs4)
 	round++
 	// Generate a new proposal block.
 	cs2 := newState(ctx, t, logger, cs1.state, vs2, kvstore.NewApplication())
 	cs2.ValidRound = 1
 	propR1, propBlockR1 := decideProposal(ctx, t, cs2, vs2, vs2.Height, round)
-	t.Log(propR1.POLRound)
+
+	assert.EqualValues(t, 1, propR1.POLRound)
+
 	propBlockR1Parts, err := propBlockR1.MakePartSet(partSize)
 	require.NoError(t, err)
 	r1BlockID := types.BlockID{
@@ -1645,7 +1621,7 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 	ensurePrecommit(t, voteCh, height, round)
 
 	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	/*
 		Create a new proposal for D, the same block from Round 1.
@@ -1658,7 +1634,6 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 		Send cs1 prevotes for nil and check that it still prevotes its locked block
 		and not the block that it prevoted.
 	*/
-	t.Log("### Starting Round 2")
 	incrementRound(vs2, vs3, vs4)
 	round++
 	propR2 := types.NewProposal(height, round, 1, r1BlockID, propBlockR1.Header.Time)
@@ -1739,16 +1714,15 @@ func TestProposeValidBlock(t *testing.T) {
 
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	incrementRound(vs2, vs3, vs4)
 	round++ // moving to the next round
 
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("### ONTO ROUND 1")
 
 	// timeout of propose
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	// We did not see a valid proposal within this round, so prevote nil.
 	ensurePrevoteMatch(t, voteCh, height, round, nil)
@@ -1768,9 +1742,8 @@ func TestProposeValidBlock(t *testing.T) {
 	round += 2 // increment by multiple rounds
 
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("### ONTO ROUND 3")
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	round++ // moving to the next round
 
@@ -1829,7 +1802,7 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 	// vs3 send prevote nil
 	signAddVotes(ctx, t, cs1, tmproto.PrevoteType, config.ChainID(), types.BlockID{}, vs3)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	ensurePrecommit(t, voteCh, height, round)
 	// we should have precommitted
@@ -1883,7 +1856,7 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	startTestRound(ctx, cs1, cs1.Height, round)
 	ensureNewRound(t, newRoundCh, height, round)
 
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	ensurePrevoteMatch(t, voteCh, height, round, nil)
 
@@ -1899,7 +1872,7 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrevoteType, config.ChainID(), blockID, vs2, vs3, vs4)
 	ensureNewValidBlock(t, validBlockCh, height, round)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	ensurePrecommit(t, voteCh, height, round)
 	validatePrecommit(ctx, t, cs1, round, -1, vss[0], nil, nil)
@@ -1940,7 +1913,11 @@ func TestProcessProposalAccept(t *testing.T) {
 			defer cancel()
 
 			m := abcimocks.NewBaseMock()
-			m.On("ProcessProposal", mock.Anything).Return(abcitypes.ResponseProcessProposal{Accept: testCase.accept})
+			status := abci.ResponseProcessProposal_REJECT
+			if testCase.accept {
+				status = abci.ResponseProcessProposal_ACCEPT
+			}
+			m.On("ProcessProposal", mock.Anything).Return(abci.ResponseProcessProposal{Status: status})
 			cs1, _ := makeState(ctx, t, makeStateArgs{config: config, application: m})
 			height, round := cs1.Height, cs1.Round
 
@@ -1988,11 +1965,11 @@ func TestFinalizeBlockCalled(t *testing.T) {
 			defer cancel()
 
 			m := abcimocks.NewBaseMock()
-			m.On("ProcessProposal", mock.Anything).Return(abcitypes.ResponseProcessProposal{Accept: true})
-			m.On("VerifyVoteExtension", mock.Anything).Return(abcitypes.ResponseVerifyVoteExtension{
-				Accept: true,
+			m.On("ProcessProposal", mock.Anything).Return(abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT})
+			m.On("VerifyVoteExtension", mock.Anything).Return(abci.ResponseVerifyVoteExtension{
+				Status: abci.ResponseVerifyVoteExtension_ACCEPT,
 			})
-			m.On("FinalizeBlock", mock.Anything).Return(abcitypes.ResponseFinalizeBlock{}).Maybe()
+			m.On("FinalizeBlock", mock.Anything).Return(abci.ResponseFinalizeBlock{}).Maybe()
 			cs1, vss := makeState(ctx, t, makeStateArgs{config: config, application: m})
 			height, round := cs1.Height, cs1.Round
 
@@ -2059,7 +2036,7 @@ func TestWaitingTimeoutOnNilPolka(t *testing.T) {
 
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 	ensureNewRound(t, newRoundCh, height, round+1)
 }
 
@@ -2097,7 +2074,7 @@ func TestWaitingTimeoutProposeOnNewRound(t *testing.T) {
 	rs := cs1.GetRoundState()
 	assert.True(t, rs.Step == cstypes.RoundStepPropose) // P0 does not prevote before timeoutPropose expires
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	ensurePrevoteMatch(t, voteCh, height, round, nil)
 }
@@ -2136,7 +2113,7 @@ func TestRoundSkipOnNilPolkaFromHigherRound(t *testing.T) {
 	ensurePrecommit(t, voteCh, height, round)
 	validatePrecommit(ctx, t, cs1, round, -1, vss[0], nil, nil)
 
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	round++ // moving to the next round
 	ensureNewRound(t, newRoundCh, height, round)
@@ -2168,7 +2145,7 @@ func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) {
 	incrementRound(vss[1:]...)
 	signAddVotes(ctx, t, cs1, tmproto.PrevoteType, config.ChainID(), types.BlockID{}, vs2, vs3, vs4)
 
-	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 
 	ensurePrevoteMatch(t, voteCh, height, round, nil)
 }
@@ -2283,8 +2260,8 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	config.Consensus.SkipTimeoutCommit = false
 	cs1, vss := makeState(ctx, t, makeStateArgs{config: config})
+	cs1.state.ConsensusParams.Timeout.BypassCommitTimeout = false
 	cs1.txNotifier = &fakeTxNotifier{ch: make(chan struct{})}
 
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@@ -2325,7 +2302,7 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 	signAddVotes(ctx, t, cs1, tmproto.PrecommitType, config.ChainID(), blockID, vs3)
 
 	// wait till timeout occurs
-	ensureNewTimeout(t, precommitTimeoutCh, height, round, cs1.config.TimeoutPrecommit.Nanoseconds())
+	ensureNewTimeout(t, precommitTimeoutCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	ensureNewRound(t, newRoundCh, height, round+1)
 
@@ -2336,7 +2313,7 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 
 	cs1.txNotifier.(*fakeTxNotifier).Notify()
 
-	ensureNewTimeout(t, timeoutProposeCh, height+1, round, cs1.config.Propose(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutProposeCh, height+1, round, cs1.state.ConsensusParams.Timeout.ProposeTimeout(round).Nanoseconds())
 	rs = cs1.GetRoundState()
 	assert.False(
 		t,
@@ -2349,8 +2326,8 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	config.Consensus.SkipTimeoutCommit = false
 	cs1, vss := makeState(ctx, t, makeStateArgs{config: config})
+	cs1.state.ConsensusParams.Timeout.BypassCommitTimeout = false
 
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -2464,13 +2441,12 @@ func TestStateHalt1(t *testing.T) {
 	incrementRound(vs2, vs3, vs4)
 
 	// timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.state.ConsensusParams.Timeout.VoteTimeout(round).Nanoseconds())
 
 	round++ // moving to the next round
 
 	ensureNewRound(t, newRoundCh, height, round)
 
-	t.Log("### ONTO ROUND 1")
 	/*Round2
 	// we timeout and prevote
 	// a polka happened but we didn't see it!

internal/state/errors.go

@@ -39,6 +39,7 @@ type (
 
 	ErrNoValSetForHeight struct {
 		Height int64
+		Err    error
 	}
 
 	ErrNoConsensusParamsForHeight struct {
@@ -89,9 +90,14 @@ func (e ErrStateMismatch) Error() string {
 }
 
 func (e ErrNoValSetForHeight) Error() string {
-	return fmt.Sprintf("could not find validator set for height #%d", e.Height)
+	if e.Err == nil {
+		return fmt.Sprintf("could not find validator set for height #%d", e.Height)
+	}
+	return fmt.Sprintf("could not find validator set for height #%d: %s", e.Height, e.Err.Error())
 }
 
+func (e ErrNoValSetForHeight) Unwrap() error { return e.Err }
+
 func (e ErrNoConsensusParamsForHeight) Error() string {
 	return fmt.Sprintf("could not find consensus params for height #%d", e.Height)
 }

internal/state/execution.go

@@ -140,8 +140,11 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 		// purpose for now.
 		panic(err)
 	}
+	if rpp.IsTxStatusUnknown() {
+		panic(fmt.Sprintf("PrepareProposal responded with ModifiedTxStatus %s", rpp.ModifiedTxStatus.String()))
+	}
 
-	if !rpp.ModifiedTx {
+	if !rpp.IsTxStatusModified() {
 		return block, nil
 	}
 	txrSet := types.NewTxRecordSet(rpp.TxRecords)
@@ -155,11 +158,6 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 			blockExec.logger.Debug("error removing transaction from the mempool", "error", err, "tx hash", rtx.Hash())
 		}
 	}
-	for _, atx := range txrSet.AddedTxs() {
-		if err := blockExec.mempool.CheckTx(ctx, atx, nil, mempool.TxInfo{}); err != nil {
-			blockExec.logger.Error("error adding tx to the mempool", "error", err, "tx hash", atx.Hash())
-		}
-	}
 	itxs := txrSet.IncludedTxs()
 	return state.MakeBlock(height, itxs, commit, evidence, proposerAddr), nil
 }
@@ -181,8 +179,11 @@ func (blockExec *BlockExecutor) ProcessProposal(
 	if err != nil {
 		return false, ErrInvalidBlock(err)
 	}
+	if resp.IsStatusUnknown() {
+		panic(fmt.Sprintf("ProcessProposal responded with status %s", resp.Status.String()))
+	}
 
-	return resp.Accept, nil
+	return resp.IsAccepted(), nil
 }
 
 // ValidateBlock validates the given block against the given state.
@@ -336,7 +337,7 @@ func (blockExec *BlockExecutor) VerifyVoteExtension(ctx context.Context, vote *t
 		return err
 	}
 
-	if !resp.Accept {
+	if !resp.IsOK() {
 		return types.ErrVoteInvalidExtension
 	}
 

internal/state/execution_test.go

@@ -338,7 +338,7 @@ func TestProcessProposal(t *testing.T) {
 		},
 	}
 
-	app.On("ProcessProposal", mock.Anything).Return(abci.ResponseProcessProposal{Accept: true})
+	app.On("ProcessProposal", mock.Anything).Return(abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT})
 	acceptBlock, err := blockExec.ProcessProposal(ctx, block1, state)
 	require.NoError(t, err)
 	require.True(t, acceptBlock)
@@ -615,6 +615,9 @@ func TestEmptyPrepareProposal(t *testing.T) {
 	require.NoError(t, eventBus.Start(ctx))
 
 	app := abcimocks.NewBaseMock()
+	app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
+		ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
+	}, nil)
 	cc := abciclient.NewLocalClient(logger, app)
 	proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
 	err := proxyApp.Start(ctx)
@@ -674,7 +677,7 @@ func TestPrepareProposalPanicOnInvalid(t *testing.T) {
 
 	// create an invalid ResponsePrepareProposal
 	rpp := abci.ResponsePrepareProposal{
-		ModifiedTx: true,
+		ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
 		TxRecords: []*abci.TxRecord{
 			{
 				Action: abci.TxRecord_REMOVED,
@@ -737,8 +740,8 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
 
 	app := abcimocks.NewBaseMock()
 	app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
-		ModifiedTx: true,
-		TxRecords:  trs,
+		ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
+		TxRecords:        trs,
 	}, nil)
 
 	cc := abciclient.NewLocalClient(logger, app)
@@ -770,8 +773,7 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
 }
 
 // TestPrepareProposalAddedTxsIncluded tests that any transactions marked as ADDED
-// in the prepare proposal response are included in the block. The test also
-// ensures that any transactions added are also checked into the mempool.
+// in the prepare proposal response are included in the block.
 func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 	const height = 2
 	ctx, cancel := context.WithCancel(context.Background())
@@ -790,7 +792,6 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 	txs := factory.MakeTenTxs(height)
 	mp := &mpmocks.Mempool{}
 	mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs[2:]))
-	mp.On("CheckTx", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Twice()
 
 	trs := txsToTxRecords(types.Txs(txs))
 	trs[0].Action = abci.TxRecord_ADDED
@@ -798,8 +799,8 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 
 	app := abcimocks.NewBaseMock()
 	app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
-		ModifiedTx: true,
-		TxRecords:  trs,
+		ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
+		TxRecords:        trs,
 	}, nil)
 
 	cc := abciclient.NewLocalClient(logger, app)
@@ -825,8 +826,6 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 	require.Equal(t, txs[1], block.Data.Txs[1])
 
 	mp.AssertExpectations(t)
-	mp.AssertCalled(t, "CheckTx", mock.Anything, types.Tx(trs[0].Tx), mock.Anything, mock.Anything)
-	mp.AssertCalled(t, "CheckTx", mock.Anything, types.Tx(trs[1].Tx), mock.Anything, mock.Anything)
 }
 
 // TestPrepareProposalReorderTxs tests that CreateBlock produces a block with transactions
@@ -856,8 +855,8 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 
 	app := abcimocks.NewBaseMock()
 	app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
-		ModifiedTx: true,
-		TxRecords:  trs,
+		ModifiedTxStatus: abci.ResponsePrepareProposal_MODIFIED,
+		TxRecords:        trs,
 	}, nil)
 
 	cc := abciclient.NewLocalClient(logger, app)
@@ -886,10 +885,10 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 
 }
 
-// TestPrepareProposalModifiedTxFalse tests that CreateBlock correctly ignores
+// TestPrepareProposalModifiedTxStatusFalse tests that CreateBlock correctly ignores
 // the ResponsePrepareProposal TxRecords if ResponsePrepareProposal does not
-// set ModifiedTx to true.
-func TestPrepareProposalModifiedTxFalse(t *testing.T) {
+// set ModifiedTxStatus to true.
+func TestPrepareProposalModifiedTxStatusFalse(t *testing.T) {
 	const height = 2
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -919,8 +918,8 @@ func TestPrepareProposalModifiedTxFalse(t *testing.T) {
 
 	app := abcimocks.NewBaseMock()
 	app.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{
-		ModifiedTx: false,
-		TxRecords:  trs,
+		ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED,
+		TxRecords:        trs,
 	}, nil)
 
 	cc := abciclient.NewLocalClient(logger, app)

internal/state/helpers_test.go

@@ -322,8 +322,8 @@ func (app *testApp) Query(reqQuery abci.RequestQuery) (resQuery abci.ResponseQue
 func (app *testApp) ProcessProposal(req abci.RequestProcessProposal) abci.ResponseProcessProposal {
 	for _, tx := range req.Txs {
 		if len(tx) == 0 {
-			return abci.ResponseProcessProposal{Accept: false}
+			return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}
 		}
 	}
-	return abci.ResponseProcessProposal{Accept: true}
+	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
 }

internal/state/store.go

@@ -488,7 +488,7 @@ func (store dbStore) LoadValidators(height int64) (*types.ValidatorSet, error) {
 
 	valInfo, err := loadValidatorsInfo(store.db, height)
 	if err != nil {
-		return nil, ErrNoValSetForHeight{height}
+		return nil, ErrNoValSetForHeight{Height: height, Err: err}
 	}
 	if valInfo.ValidatorSet == nil {
 		lastStoredHeight := lastStoredHeightFor(height, valInfo.LastHeightChanged)

internal/test/factory/params.go

@@ -0,0 +1,22 @@
+package factory
+
+import (
+	"time"
+
+	"github.com/tendermint/tendermint/types"
+)
+
+// ConsensusParams returns a default set of ConsensusParams that are suitable
+// for use in testing
+func ConsensusParams() *types.ConsensusParams {
+	c := types.DefaultConsensusParams()
+	c.Timeout = types.TimeoutParams{
+		Commit:              10 * time.Millisecond,
+		Propose:             40 * time.Millisecond,
+		ProposeDelta:        1 * time.Millisecond,
+		Vote:                10 * time.Millisecond,
+		VoteDelta:           1 * time.Millisecond,
+		BypassCommitTimeout: true,
+	}
+	return c
+}

node/node_test.go

@@ -754,7 +754,7 @@ func loadStatefromGenesis(ctx context.Context, t *testing.T) sm.State {
 	require.True(t, loadedState.IsEmpty())
 
 	valSet, _ := factory.ValidatorSet(ctx, t, 0, 10)
-	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams())
 
 	state, err := loadStateFromDBOrGenesisDocProvider(
 		stateStore,

proto/tendermint/abci/types.proto

@@ -316,20 +316,32 @@ message ResponseApplySnapshotChunk {
 }
 
 message ResponsePrepareProposal {
-  bool                             modified_tx             = 1;
+  ModifiedTxStatus                 modified_tx_status      = 1;
   repeated TxRecord                tx_records              = 2;
   bytes                            app_hash                = 3;
   repeated ExecTxResult            tx_results              = 4;
   repeated ValidatorUpdate         validator_updates       = 5;
   tendermint.types.ConsensusParams consensus_param_updates = 6;
+
+  enum ModifiedTxStatus {
+    UNKNOWN    = 0;
+    UNMODIFIED = 1;
+    MODIFIED   = 2;
+  }
 }
 
 message ResponseProcessProposal {
-  bool                             accept                  = 1;
+  ProposalStatus                   status                  = 1;
   bytes                            app_hash                = 2;
   repeated ExecTxResult            tx_results              = 3;
   repeated ValidatorUpdate         validator_updates       = 4;
   tendermint.types.ConsensusParams consensus_param_updates = 5;
+
+  enum ProposalStatus {
+    UNKNOWN = 0;
+    ACCEPT  = 1;
+    REJECT  = 2;
+  }
 }
 
 message ResponseExtendVote {
@@ -337,7 +349,13 @@ message ResponseExtendVote {
 }
 
 message ResponseVerifyVoteExtension {
-  bool accept = 1;
+  VerifyStatus status = 1;
+
+  enum VerifyStatus {
+    UNKNOWN = 0;
+    ACCEPT  = 1;
+    REJECT  = 2;
+  }
 }
 
 message ResponseFinalizeBlock {

proto/tendermint/abci/types.proto.intermediate

@@ -123,16 +123,6 @@ message RequestApplySnapshotChunk {
   string sender = 3;
 }
 
-// Extends a vote with application-side injection
-message RequestExtendVote {
-  types.Vote vote = 1;
-}
-
-// Verify the vote extension
-message RequestVerifyVoteExtension {
-  types.Vote vote = 1;
-}
-
 message RequestPrepareProposal {
   bytes                   hash   = 1;
   tendermint.types.Header header = 2 [(gogoproto.nullable) = false];
@@ -153,6 +143,16 @@ message RequestProcessProposal {
   repeated Evidence       byzantine_validators = 5 [(gogoproto.nullable) = false];
 }
 
+// Extends a vote with application-side injection
+message RequestExtendVote {
+  types.Vote vote = 1;
+}
+
+// Verify the vote extension
+message RequestVerifyVoteExtension {
+  types.Vote vote = 1;
+}
+
 message RequestFinalizeBlock {
   bytes                   hash                 = 1;
   tendermint.types.Header header               = 2 [(gogoproto.nullable) = false];
@@ -312,36 +312,47 @@ message ResponseApplySnapshotChunk {
   }
 }
 
-message ResponseExtendVote {
-  tendermint.types.VoteExtension vote_extension = 1;
-}
-
-message ResponseVerifyVoteExtension {
-  Result result = 1;
-
-  enum Result {
-    UNKNOWN = 0;  // Unknown result, reject vote extension
-    ACCEPT  = 1;  // Vote extension verified, include the vote
-    SLASH   = 2;  // Vote extension verification aborted, continue but slash validator
-    REJECT  = 3;  // Vote extension invalidated
-  }
-}
-
 message ResponsePrepareProposal {
-  bool                             modified_tx             = 1;
+  ModifiedTxStatus                 modified_tx_status      = 1;
   repeated TxRecord                tx_records              = 2;
   bytes                            app_hash                = 3;
   repeated ExecTxResult            tx_results              = 4;
   repeated ValidatorUpdate         validator_updates       = 5;
   tendermint.types.ConsensusParams consensus_param_updates = 6;
+
+  enum ModifiedTxStatus {
+    UNKNOWN    = 0;
+    UNMODIFIED = 1;
+    MODIFIED   = 2;
+  }
 }
 
 message ResponseProcessProposal {
-  bool                             accept                  = 1;
+  ProposalStatus                   status                  = 1;
   bytes                            app_hash                = 2;
   repeated ExecTxResult            tx_results              = 3;
   repeated ValidatorUpdate         validator_updates       = 4;
   tendermint.types.ConsensusParams consensus_param_updates = 5;
+
+  enum ProposalStatus {
+    UNKNOWN = 0;
+    ACCEPT  = 1;
+    REJECT  = 2;
+  }
+}
+
+message ResponseExtendVote {
+  tendermint.types.VoteExtension vote_extension = 1;
+}
+
+message ResponseVerifyVoteExtension {
+  VerifyStatus status = 1;
+
+  enum VerifyStatus {
+    UNKNOWN = 0;
+    ACCEPT  = 1;
+    REJECT  = 2;
+  }
 }
 
 message ResponseFinalizeBlock {

proto/tendermint/types/params.pb.go

@@ -483,12 +483,12 @@ type TimeoutParams struct {
 	// precommits before beginning consensus for the next height. This can be
 	// used to allow slow precommits to arrive for inclusion in the next height before progressing.
 	Commit *time.Duration `protobuf:"bytes,5,opt,name=commit,proto3,stdduration" json:"commit,omitempty"`
-	// enable_commit_timeout_bypass configures the node to proceed immediately to
+	// bypass_commit_timeout configures the node to proceed immediately to
 	// the next height once the node has received all precommits for a block, forgoing
 	// the remaining commit timeout.
-	// Setting enable_commit_timeout_bypass false (the default) causes Tendermint to wait
-	// for the full commit.
-	EnableCommitTimeoutBypass bool `protobuf:"varint,6,opt,name=enable_commit_timeout_bypass,json=enableCommitTimeoutBypass,proto3" json:"enable_commit_timeout_bypass,omitempty"`
+	// Setting bypass_commit_timeout false (the default) causes Tendermint to wait
+	// for the full commit timeout.
+	BypassCommitTimeout bool `protobuf:"varint,6,opt,name=bypass_commit_timeout,json=bypassCommitTimeout,proto3" json:"bypass_commit_timeout,omitempty"`
 }
 
 func (m *TimeoutParams) Reset()         { *m = TimeoutParams{} }
@@ -559,9 +559,9 @@ func (m *TimeoutParams) GetCommit() *time.Duration {
 	return nil
 }
 
-func (m *TimeoutParams) GetEnableCommitTimeoutBypass() bool {
+func (m *TimeoutParams) GetBypassCommitTimeout() bool {
 	if m != nil {
-		return m.EnableCommitTimeoutBypass
+		return m.BypassCommitTimeout
 	}
 	return false
 }
@@ -580,50 +580,50 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }
 
 var fileDescriptor_e12598271a686f57 = []byte{
-	// 687 bytes of a gzipped FileDescriptorProto
+	// 680 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x6e, 0xd3, 0x4a,
-	0x14, 0xc6, 0xe3, 0x26, 0x4d, 0x93, 0x93, 0xa6, 0xa9, 0x46, 0x57, 0xba, 0x6e, 0xef, 0xad, 0xd3,
-	0xeb, 0xc5, 0x55, 0x25, 0x24, 0x07, 0x51, 0xa1, 0x0a, 0x09, 0xa8, 0x48, 0x83, 0x40, 0x42, 0x45,
-	0xc8, 0x14, 0x16, 0xdd, 0x58, 0xe3, 0x64, 0x70, 0xad, 0xc6, 0x1e, 0xcb, 0x63, 0x47, 0xf1, 0x5b,
-	0xb0, 0x42, 0x3c, 0x02, 0xbc, 0x49, 0x97, 0x5d, 0xb2, 0x02, 0x94, 0xbe, 0x06, 0x12, 0x68, 0xfe,
-	0x35, 0x4d, 0x4a, 0x69, 0x56, 0x71, 0xe6, 0xfc, 0x3e, 0x7f, 0x9e, 0xef, 0x9c, 0x19, 0xd8, 0xca,
-	0x48, 0x3c, 0x20, 0x69, 0x14, 0xc6, 0x59, 0x27, 0x2b, 0x12, 0xc2, 0x3a, 0x09, 0x4e, 0x71, 0xc4,
-	0x9c, 0x24, 0xa5, 0x19, 0x45, 0xeb, 0xd3, 0xb2, 0x23, 0xca, 0x9b, 0x7f, 0x05, 0x34, 0xa0, 0xa2,
-	0xd8, 0xe1, 0x4f, 0x92, 0xdb, 0xb4, 0x02, 0x4a, 0x83, 0x21, 0xe9, 0x88, 0x7f, 0x7e, 0xfe, 0xae,
-	0x33, 0xc8, 0x53, 0x9c, 0x85, 0x34, 0x96, 0x75, 0xfb, 0xc7, 0x12, 0xb4, 0x0e, 0x68, 0xcc, 0x48,
-	0xcc, 0x72, 0xf6, 0x4a, 0x38, 0xa0, 0x5d, 0x58, 0xf6, 0x87, 0xb4, 0x7f, 0x6a, 0x1a, 0xdb, 0xc6,
-	0x4e, 0xe3, 0xde, 0x96, 0x33, 0xef, 0xe5, 0x74, 0x79, 0x59, 0xd2, 0xae, 0x64, 0xd1, 0x43, 0xa8,
-	0x91, 0x51, 0x38, 0x20, 0x71, 0x9f, 0x98, 0x4b, 0x42, 0xb7, 0x7d, 0x5d, 0xf7, 0x54, 0x11, 0x4a,
-	0x7a, 0xa9, 0x40, 0xfb, 0x50, 0x1f, 0xe1, 0x61, 0x38, 0xc0, 0x19, 0x4d, 0xcd, 0xb2, 0x90, 0xff,
-	0x77, 0x5d, 0xfe, 0x56, 0x23, 0x4a, 0x3f, 0xd5, 0xa0, 0x07, 0xb0, 0x32, 0x22, 0x29, 0x0b, 0x69,
-	0x6c, 0x56, 0x84, 0xbc, 0xfd, 0x1b, 0xb9, 0x04, 0x94, 0x58, 0xf3, 0xdc, 0x9b, 0x15, 0x71, 0xff,
-	0x24, 0xa5, 0x71, 0x61, 0x2e, 0xdf, 0xe4, 0xfd, 0x5a, 0x23, 0xda, 0xfb, 0x52, 0xc3, 0xbd, 0xb3,
-	0x30, 0x22, 0x34, 0xcf, 0xcc, 0xea, 0x4d, 0xde, 0x47, 0x12, 0xd0, 0xde, 0x8a, 0xb7, 0x0f, 0xa0,
-	0x71, 0x25, 0x4b, 0xf4, 0x0f, 0xd4, 0x23, 0x3c, 0xf6, 0xfc, 0x22, 0x23, 0x4c, 0xa4, 0x5f, 0x76,
-	0x6b, 0x11, 0x1e, 0x77, 0xf9, 0x7f, 0xf4, 0x37, 0xac, 0xf0, 0x62, 0x80, 0x99, 0x08, 0xb8, 0xec,
-	0x56, 0x23, 0x3c, 0x7e, 0x86, 0x99, 0xfd, 0xd9, 0x80, 0xb5, 0xd9, 0x64, 0xd1, 0x1d, 0x40, 0x9c,
-	0xc5, 0x01, 0xf1, 0xe2, 0x3c, 0xf2, 0x44, 0x8b, 0xf4, 0x1b, 0x5b, 0x11, 0x1e, 0x3f, 0x09, 0xc8,
-	0xcb, 0x3c, 0x12, 0xd6, 0x0c, 0x1d, 0xc2, 0xba, 0x86, 0xf5, 0x74, 0xa8, 0x16, 0x6e, 0x38, 0x72,
-	0x7c, 0x1c, 0x3d, 0x3e, 0x4e, 0x4f, 0x01, 0xdd, 0xda, 0xd9, 0xd7, 0x76, 0xe9, 0xe3, 0xb7, 0xb6,
-	0xe1, 0xae, 0xc9, 0xf7, 0xe9, 0xca, 0xec, 0x26, 0xca, 0xb3, 0x9b, 0xb0, 0xef, 0x43, 0x6b, 0xae,
-	0x8b, 0xc8, 0x86, 0x66, 0x92, 0xfb, 0xde, 0x29, 0x29, 0x3c, 0x91, 0x95, 0x69, 0x6c, 0x97, 0x77,
-	0xea, 0x6e, 0x23, 0xc9, 0xfd, 0x17, 0xa4, 0x38, 0xe2, 0x4b, 0xf6, 0x5d, 0x68, 0xce, 0x74, 0x0f,
-	0xb5, 0xa1, 0x81, 0x93, 0xc4, 0xd3, 0x3d, 0xe7, 0x3b, 0xab, 0xb8, 0x80, 0x93, 0x44, 0x61, 0xf6,
-	0x31, 0xac, 0x3e, 0xc7, 0xec, 0x84, 0x0c, 0x94, 0xe0, 0x7f, 0x68, 0x89, 0x14, 0xbc, 0xf9, 0x80,
-	0x9b, 0x62, 0xf9, 0x50, 0xa7, 0x6c, 0x43, 0x73, 0xca, 0x4d, 0xb3, 0x6e, 0x68, 0x8a, 0x07, 0xfe,
-	0xc1, 0x80, 0xd6, 0xdc, 0x3c, 0xa0, 0x1e, 0x34, 0x23, 0xc2, 0x98, 0x08, 0x91, 0x0c, 0x71, 0xa1,
-	0x0e, 0xcf, 0x1f, 0x12, 0xac, 0x88, 0xf4, 0x56, 0x95, 0xaa, 0xc7, 0x45, 0xe8, 0x11, 0xd4, 0x93,
-	0x94, 0xf4, 0x43, 0xb6, 0x50, 0x0f, 0xe4, 0x1b, 0xa6, 0x0a, 0xfb, 0xe7, 0x12, 0x34, 0x67, 0x26,
-	0x8d, 0xcf, 0x66, 0x92, 0xd2, 0x84, 0x32, 0xb2, 0xe8, 0x07, 0x69, 0x9e, 0xef, 0x48, 0x3d, 0xf2,
-	0x1d, 0x65, 0x78, 0xd1, 0xef, 0x59, 0x55, 0xaa, 0x1e, 0x17, 0xa1, 0x5d, 0xa8, 0x8c, 0x68, 0x46,
-	0xd4, 0xa1, 0xbe, 0x55, 0x2c, 0x60, 0xf4, 0x18, 0x80, 0xff, 0x2a, 0xdf, 0xca, 0x82, 0x39, 0x70,
-	0x89, 0x34, 0xdd, 0x83, 0x6a, 0x9f, 0x46, 0x51, 0x98, 0xa9, 0xf3, 0x7c, 0xab, 0x56, 0xe1, 0x68,
-	0x1f, 0xfe, 0x25, 0x31, 0xf6, 0x87, 0xc4, 0x93, 0x0b, 0x9e, 0x3a, 0xa8, 0x9e, 0x5f, 0x24, 0x98,
-	0x31, 0x71, 0xbe, 0x6b, 0xee, 0x86, 0x64, 0x0e, 0x04, 0xa2, 0xf2, 0xee, 0x0a, 0xa0, 0xfb, 0xe6,
-	0xd3, 0xc4, 0x32, 0xce, 0x26, 0x96, 0x71, 0x3e, 0xb1, 0x8c, 0xef, 0x13, 0xcb, 0x78, 0x7f, 0x61,
-	0x95, 0xce, 0x2f, 0xac, 0xd2, 0x97, 0x0b, 0xab, 0x74, 0xbc, 0x17, 0x84, 0xd9, 0x49, 0xee, 0x3b,
-	0x7d, 0x1a, 0x75, 0xae, 0xde, 0xef, 0xd3, 0x47, 0x79, 0x81, 0xcf, 0xdf, 0xfd, 0x7e, 0x55, 0xac,
-	0xef, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xc1, 0xad, 0x03, 0x4c, 0x16, 0x06, 0x00, 0x00,
+	0x14, 0xc6, 0xe3, 0x26, 0x4d, 0x93, 0x93, 0xa6, 0xa9, 0xe6, 0xde, 0xab, 0xeb, 0xdb, 0xab, 0x3a,
+	0xc5, 0x0b, 0x54, 0x09, 0xc9, 0x41, 0xad, 0x50, 0x85, 0xc4, 0x1f, 0x91, 0x06, 0x81, 0x84, 0x8a,
+	0x90, 0x29, 0x2c, 0xba, 0xb1, 0xc6, 0xc9, 0xe0, 0x5a, 0x8d, 0x3d, 0x96, 0xc7, 0x8e, 0xe2, 0xb7,
+	0x60, 0x85, 0x78, 0x04, 0x78, 0x93, 0x2e, 0xbb, 0x64, 0x05, 0x28, 0x7d, 0x03, 0xd6, 0x2c, 0xd0,
+	0xfc, 0x6b, 0x9a, 0x94, 0xd2, 0xac, 0xe2, 0xcc, 0xf9, 0x7e, 0xfe, 0x3c, 0xdf, 0x39, 0x33, 0xb0,
+	0x99, 0x91, 0x78, 0x40, 0xd2, 0x28, 0x8c, 0xb3, 0x4e, 0x56, 0x24, 0x84, 0x75, 0x12, 0x9c, 0xe2,
+	0x88, 0x39, 0x49, 0x4a, 0x33, 0x8a, 0xd6, 0xa7, 0x65, 0x47, 0x94, 0x37, 0xfe, 0x0e, 0x68, 0x40,
+	0x45, 0xb1, 0xc3, 0x9f, 0xa4, 0x6e, 0xc3, 0x0a, 0x28, 0x0d, 0x86, 0xa4, 0x23, 0xfe, 0xf9, 0xf9,
+	0xbb, 0xce, 0x20, 0x4f, 0x71, 0x16, 0xd2, 0x58, 0xd6, 0xed, 0x9f, 0x4b, 0xd0, 0xda, 0xa7, 0x31,
+	0x23, 0x31, 0xcb, 0xd9, 0x2b, 0xe1, 0x80, 0x76, 0x61, 0xd9, 0x1f, 0xd2, 0xfe, 0x89, 0x69, 0x6c,
+	0x19, 0xdb, 0x8d, 0x9d, 0x4d, 0x67, 0xde, 0xcb, 0xe9, 0xf2, 0xb2, 0x54, 0xbb, 0x52, 0x8b, 0x1e,
+	0x40, 0x8d, 0x8c, 0xc2, 0x01, 0x89, 0xfb, 0xc4, 0x5c, 0x12, 0xdc, 0xd6, 0x55, 0xee, 0xa9, 0x52,
+	0x28, 0xf4, 0x82, 0x40, 0x8f, 0xa1, 0x3e, 0xc2, 0xc3, 0x70, 0x80, 0x33, 0x9a, 0x9a, 0x65, 0x81,
+	0xdf, 0xba, 0x8a, 0xbf, 0xd5, 0x12, 0xc5, 0x4f, 0x19, 0x74, 0x1f, 0x56, 0x46, 0x24, 0x65, 0x21,
+	0x8d, 0xcd, 0x8a, 0xc0, 0xdb, 0xbf, 0xc1, 0xa5, 0x40, 0xc1, 0x5a, 0xcf, 0xbd, 0x59, 0x11, 0xf7,
+	0x8f, 0x53, 0x1a, 0x17, 0xe6, 0xf2, 0x75, 0xde, 0xaf, 0xb5, 0x44, 0x7b, 0x5f, 0x30, 0xdc, 0x3b,
+	0x0b, 0x23, 0x42, 0xf3, 0xcc, 0xac, 0x5e, 0xe7, 0x7d, 0x28, 0x05, 0xda, 0x5b, 0xe9, 0xed, 0x7d,
+	0x68, 0x5c, 0xca, 0x12, 0xfd, 0x0f, 0xf5, 0x08, 0x8f, 0x3d, 0xbf, 0xc8, 0x08, 0x13, 0xe9, 0x97,
+	0xdd, 0x5a, 0x84, 0xc7, 0x5d, 0xfe, 0x1f, 0xfd, 0x0b, 0x2b, 0xbc, 0x18, 0x60, 0x26, 0x02, 0x2e,
+	0xbb, 0xd5, 0x08, 0x8f, 0x9f, 0x61, 0x66, 0x7f, 0x36, 0x60, 0x6d, 0x36, 0x59, 0x74, 0x07, 0x10,
+	0xd7, 0xe2, 0x80, 0x78, 0x71, 0x1e, 0x79, 0xa2, 0x45, 0xfa, 0x8d, 0xad, 0x08, 0x8f, 0x9f, 0x04,
+	0xe4, 0x65, 0x1e, 0x09, 0x6b, 0x86, 0x0e, 0x60, 0x5d, 0x8b, 0xf5, 0x74, 0xa8, 0x16, 0xfe, 0xe7,
+	0xc8, 0xf1, 0x71, 0xf4, 0xf8, 0x38, 0x3d, 0x25, 0xe8, 0xd6, 0x4e, 0xbf, 0xb6, 0x4b, 0x1f, 0xbf,
+	0xb5, 0x0d, 0x77, 0x4d, 0xbe, 0x4f, 0x57, 0x66, 0x37, 0x51, 0x9e, 0xdd, 0x84, 0x7d, 0x0f, 0x5a,
+	0x73, 0x5d, 0x44, 0x36, 0x34, 0x93, 0xdc, 0xf7, 0x4e, 0x48, 0xe1, 0x89, 0xac, 0x4c, 0x63, 0xab,
+	0xbc, 0x5d, 0x77, 0x1b, 0x49, 0xee, 0xbf, 0x20, 0xc5, 0x21, 0x5f, 0xb2, 0xef, 0x42, 0x73, 0xa6,
+	0x7b, 0xa8, 0x0d, 0x0d, 0x9c, 0x24, 0x9e, 0xee, 0x39, 0xdf, 0x59, 0xc5, 0x05, 0x9c, 0x24, 0x4a,
+	0x66, 0x1f, 0xc1, 0xea, 0x73, 0xcc, 0x8e, 0xc9, 0x40, 0x01, 0xb7, 0xa1, 0x25, 0x52, 0xf0, 0xe6,
+	0x03, 0x6e, 0x8a, 0xe5, 0x03, 0x9d, 0xb2, 0x0d, 0xcd, 0xa9, 0x6e, 0x9a, 0x75, 0x43, 0xab, 0x78,
+	0xe0, 0x1f, 0x0c, 0x68, 0xcd, 0xcd, 0x03, 0xea, 0x41, 0x33, 0x22, 0x8c, 0x89, 0x10, 0xc9, 0x10,
+	0x17, 0xea, 0xf0, 0xfc, 0x21, 0xc1, 0x8a, 0x48, 0x6f, 0x55, 0x51, 0x3d, 0x0e, 0xa1, 0x87, 0x50,
+	0x4f, 0x52, 0xd2, 0x0f, 0xd9, 0x42, 0x3d, 0x90, 0x6f, 0x98, 0x12, 0xf6, 0x8f, 0x25, 0x68, 0xce,
+	0x4c, 0x1a, 0x9f, 0xcd, 0x24, 0xa5, 0x09, 0x65, 0x64, 0xd1, 0x0f, 0xd2, 0x7a, 0xbe, 0x23, 0xf5,
+	0xc8, 0x77, 0x94, 0xe1, 0x45, 0xbf, 0x67, 0x55, 0x51, 0x3d, 0x0e, 0xa1, 0x5d, 0xa8, 0x8c, 0x68,
+	0x46, 0xd4, 0xa1, 0xbe, 0x11, 0x16, 0x62, 0xf4, 0x08, 0x80, 0xff, 0x2a, 0xdf, 0xca, 0x82, 0x39,
+	0x70, 0x44, 0x9a, 0xee, 0x41, 0xb5, 0x4f, 0xa3, 0x28, 0xcc, 0xd4, 0x79, 0xbe, 0x91, 0x55, 0x72,
+	0xb4, 0x03, 0xff, 0xf8, 0x45, 0x82, 0x19, 0xf3, 0xe4, 0x82, 0x77, 0xf9, 0x60, 0xd7, 0xdc, 0xbf,
+	0x64, 0x71, 0x5f, 0xd4, 0x54, 0xd0, 0xdd, 0x37, 0x9f, 0x26, 0x96, 0x71, 0x3a, 0xb1, 0x8c, 0xb3,
+	0x89, 0x65, 0x7c, 0x9f, 0x58, 0xc6, 0xfb, 0x73, 0xab, 0x74, 0x76, 0x6e, 0x95, 0xbe, 0x9c, 0x5b,
+	0xa5, 0xa3, 0xbd, 0x20, 0xcc, 0x8e, 0x73, 0xdf, 0xe9, 0xd3, 0xa8, 0x73, 0xf9, 0x4a, 0x9f, 0x3e,
+	0xca, 0x3b, 0x7b, 0xfe, 0xba, 0xf7, 0xab, 0x62, 0x7d, 0xf7, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0xfc, 0x06, 0xae, 0x9f, 0x09, 0x06, 0x00, 0x00,
 }
 
 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -905,7 +905,7 @@ func (this *TimeoutParams) Equal(that interface{}) bool {
 	} else if that1.Commit != nil {
 		return false
 	}
-	if this.EnableCommitTimeoutBypass != that1.EnableCommitTimeoutBypass {
+	if this.BypassCommitTimeout != that1.BypassCommitTimeout {
 		return false
 	}
 	return true
@@ -1235,9 +1235,9 @@ func (m *TimeoutParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.EnableCommitTimeoutBypass {
+	if m.BypassCommitTimeout {
 		i--
-		if m.EnableCommitTimeoutBypass {
+		if m.BypassCommitTimeout {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
@@ -1459,7 +1459,7 @@ func (m *TimeoutParams) Size() (n int) {
 		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Commit)
 		n += 1 + l + sovParams(uint64(l))
 	}
-	if m.EnableCommitTimeoutBypass {
+	if m.BypassCommitTimeout {
 		n += 2
 	}
 	return n
@@ -2518,7 +2518,7 @@ func (m *TimeoutParams) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 6:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EnableCommitTimeoutBypass", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BypassCommitTimeout", wireType)
 			}
 			var v int
 			for shift := uint(0); ; shift += 7 {
@@ -2535,7 +2535,7 @@ func (m *TimeoutParams) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-			m.EnableCommitTimeoutBypass = bool(v != 0)
+			m.BypassCommitTimeout = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])

proto/tendermint/types/params.proto

@@ -120,10 +120,10 @@ message TimeoutParams {
   // used to allow slow precommits to arrive for inclusion in the next height before progressing.
   google.protobuf.Duration commit = 5 [(gogoproto.stdduration) = true];
 
-  // enable_commit_timeout_bypass configures the node to proceed immediately to
+  // bypass_commit_timeout configures the node to proceed immediately to
   // the next height once the node has received all precommits for a block, forgoing
   // the remaining commit timeout.
-  // Setting enable_commit_timeout_bypass false (the default) causes Tendermint to wait
-  // for the full commit.
-  bool enable_commit_timeout_bypass = 6;
+  // Setting bypass_commit_timeout false (the default) causes Tendermint to wait
+  // for the full commit timeout.
+  bool bypass_commit_timeout = 6;
 }

scripts/abci-gen.sh

@@ -18,8 +18,6 @@ sh ./scripts/protopackage.sh ./proto/tendermint/abci/types.proto $MODNAME "abci/
 
 make proto-gen
 
-mv ./proto/tendermint/abci/types.pb.go ./abci/types
-
 echo "proto files have been compiled"
 
 echo "checking out copied files"

spec/abci++/abci++_methods_002_draft.md

@@ -298,7 +298,7 @@ title: Methods
 
     | Name                    | Type                                             | Description                                                                                 | Field Number |
     |-------------------------|--------------------------------------------------|---------------------------------------------------------------------------------------------|--------------|
-    | modified_tx             | bool                                             | The Application sets it to true to denote it made changes to transactions                   | 1            |
+    | modified_tx_status      | [TxModifiedStatus](#TxModifiedStatus)            | `enum` signaling if the application has made changes to the list of transactions.           | 1            |
     | tx_records              | repeated [TxRecord](#txrecord)                   | Possibly modified list of transactions that have been picked as part of the proposed block. | 2            |
     | app_hash                | bytes                                            | The Merkle root hash of the application state.                                              | 3            |
     | tx_results              | repeated [ExecTxResult](#txresult)               | List of structures containing the data resulting from executing the transactions            | 4            |
@@ -311,15 +311,15 @@ title: Methods
     * The header contains the height, timestamp, and more - it exactly matches the
       Tendermint block header.
     * `RequestPrepareProposal` contains a preliminary set of transactions `txs` that Tendermint considers to be a good block proposal, called _raw proposal_. The Application can modify this set via `ResponsePrepareProposal.tx_records` (see [TxRecord](#txrecord)).
-        * In this case, the Application should set `ResponsePrepareProposal.modified_tx` to true.
+        * In this case, the Application should set `ResponsePrepareProposal.modified_tx_status` to `MODIFIED`.
         * The Application _can_ reorder, remove or add transactions to the raw proposal. Let `tx` be a transaction in `txs`:
             * If the Application considers that `tx` should not be proposed in this block, e.g., there are other transactions with higher priority, then it should not include it in `tx_records`. In this case, Tendermint won't remove `tx` from the mempool. The Application should be extra-careful, as abusing this feature may cause transactions to stay forever in the mempool.
-            * If the Application considers that a `tx` should not be included in the proposal and removed from the mempool, then the Application should include it in `tx_records` and _mark_ it as "REMOVE". In this case, Tendermint will remove `tx` from the mempool.
-            * If the Application wants to add a new transaction, then the Application should include it in `tx_records` and _mark_ it as "ADD". In this case, Tendermint will add it to the mempool.
+            * If the Application considers that a `tx` should not be included in the proposal and removed from the mempool, then the Application should include it in `tx_records` and _mark_ it as `REMOVE`. In this case, Tendermint will remove `tx` from the mempool.
+            * If the Application wants to add a new transaction, then the Application should include it in `tx_records` and _mark_ it as `ADD`. In this case, Tendermint will add it to the mempool.
         * The Application should be aware that removing and adding transactions may compromise _traceability_.
           > Consider the following example: the Application transforms a client-submitted transaction `t1` into a second transaction `t2`, i.e., the Application asks Tendermint to remove `t1` and add `t2` to the mempool. If a client wants to eventually check what happened to `t1`, it will discover that `t_1` is not in the mempool or in a committed block, getting the wrong idea that `t_1` did not make it into a block. Note that `t_2` _will be_ in a committed block, but unless the Application tracks this information, no component will be aware of it. Thus, if the Application wants traceability, it is its responsability to support it. For instance, the Application could attach to a transformed transaction a list with the hashes of the transactions it derives from. 
         * If the Application modifies the set of transactions, the modified transactions MUST NOT exceed the configured maximum size `RequestPrepareProposal.max_tx_bytes`.
-    * If the Application does not modify the preliminary set of transactions `txs`, then it sets `ResponsePrepareProposal.modified_tx` to false. In this case, Tendermint will ignore the contents of `ResponsePrepareProposal.tx_records`.
+    * If the Application does not modify the preliminary set of transactions `txs`, then it sets `ResponsePrepareProposal.modified_tx_status` to `UNMODIFIED`. In this case, Tendermint will ignore the contents of `ResponsePrepareProposal.tx_records`.
     * In same-block execution mode, the Application must provide values for `ResponsePrepareProposal.app_hash`,
       `ResponsePrepareProposal.tx_results`, `ResponsePrepareProposal.validator_updates`, and
       `ResponsePrepareProposal.consensus_param_updates`, as a result of fully executing the block.
@@ -348,12 +348,10 @@ title: Methods
     * As a sanity check, Tendermint will check the returned parameters for validity if the Application modified them.
       In particular, `ResponsePrepareProposal.tx_records` will be deemed invalid if
         * There is a duplicate transaction in the list.
-        * A new or modified transaction is marked as "TXUNMODIFIED" or "TXREMOVED".
-        * An unmodified transaction is marked as "TXADDED".
-        * A transaction is marked as "TXUNKNOWN".
-    * If Tendermint's sanity checks on the parameters of `ResponsePrepareProposal` fails, then it will drop the proposal
-      and proceed to the next round (thus simulating a network loss/delay of the proposal).
-        * **TODO**: [From discussion with William] Another possibility here is to panic. What do folks think we should do here?
+        * A new or modified transaction is marked as `UNMODIFIED` or `REMOVED`.
+        * An unmodified transaction is marked as `ADDED`.
+        * A transaction is marked as `UNKNOWN`.
+    * If Tendermint fails to validate the `ResponsePrepareProposal`, Tendermint will assume the application is faulty and crash.
     * The implementation of `PrepareProposal` can be non-deterministic.
 
 #### When does Tendermint call it?
@@ -380,7 +378,7 @@ and _p_'s _validValue_ is `nil`:
       `ResponsePrepareProposal.validator_updates`, and `ResponsePrepareProposal.consensus_param_updates`.
     * in both modes, the Application can manipulate transactions
         * leave transactions untouched - `TxAction = UNMODIFIED`
-        * add new transactions (not previously in the mempool) - `TxAction = ADDED`
+        * add new transactions directly to the proposal - `TxAction = ADDED`
         * remove transactions (invalid) from the proposal and from the mempool - `TxAction = REMOVED`
         * remove transactions from the proposal but not from the mempool (effectively _delaying_ them) - the
           Application removes the transaction from the list
@@ -411,7 +409,7 @@ Note that, if _p_ has a non-`nil` _validValue_, Tendermint will use it as propos
 
     | Name                    | Type                                             | Description                                                                       | Field Number |
     |-------------------------|--------------------------------------------------|-----------------------------------------------------------------------------------|--------------|
-    | accept                  | bool                                             | If false, the received block failed verification.                                 | 1            |
+    | status                  | [ProposalStatus](#ProposalStatus)                | `enum` that signals if the application finds the proposal valid.                  | 1            |
     | app_hash                | bytes                                            | The Merkle root hash of the application state.                                    | 2            |
     | tx_results              | repeated [ExecTxResult](#txresult)               | List of structures containing the data resulting from executing the transactions. | 3            |
     | validator_updates       | repeated [ValidatorUpdate](#validatorupdate)     | Changes to validator set (set voting power to 0 to remove).                       | 4            |
@@ -432,25 +430,23 @@ Note that, if _p_ has a non-`nil` _validValue_, Tendermint will use it as propos
           and _ConsensusHash_ refer to the **same** block being passed in the `Request*` call to this
           method (data was provided by the call to `ResponsePrepareProposal` at the current height that
           resulted in the block being passed in the `Request*` call to this method)
-    * If `ResponseProcessProposal.accept` is _false_, Tendermint assumes the proposal received
+    * If `ResponseProcessProposal.status` is `REJECT`, Tendermint assumes the proposal received
       is not valid.
     * In same-block execution mode, the Application is required to fully execute the block and provide values
       for parameters `ResponseProcessProposal.app_hash`, `ResponseProcessProposal.tx_results`,
       `ResponseProcessProposal.validator_updates`, and `ResponseProcessProposal.consensus_param_updates`,
       so that Tendermint can then verify the hashes in the block's header are correct.
-      If the hashes mismatch, Tendermint will reject the block even if `ResponseProcessProposal.accept`
-      was set to _true_.
+      If the hashes mismatch, Tendermint will reject the block even if `ResponseProcessProposal.status`
+      was set to `ACCEPT`.
     * In next-block execution mode, the Application should *not* provide values for parameters
       `ResponseProcessProposal.app_hash`, `ResponseProcessProposal.tx_results`,
       `ResponseProcessProposal.validator_updates`, and `ResponseProcessProposal.consensus_param_updates`.
     * The implementation of `ProcessProposal` MUST be deterministic. Moreover, the value of
-      `ResponseProcessProposal.accept` MUST **exclusively** depend on the parameters passed in
+      `ResponseProcessProposal.status` MUST **exclusively** depend on the parameters passed in
       the call to `RequestProcessProposal`, and the last committed Application state
       (see [Requirements](abci++_app_requirements_002_draft.md) section).
-    * Moreover, application implementors SHOULD always set `ResponseProcessProposal.accept` to _true_,
-      unless they _really_ know what the potential liveness implications of returning _false_ are.
-
->**TODO**: should `ResponseProcessProposal.accept` be of type `Result` rather than `bool`? (so we are able to extend the possible values in the future?)
+    * Moreover, application implementors SHOULD always set `ResponseProcessProposal.status` to `ACCEPT`,
+      unless they _really_ know what the potential liveness implications of returning `REJECT` are.
 
 #### When does Tendermint call it?
 
@@ -537,20 +533,20 @@ a [CanonicalVoteExtension](#canonicalvoteextension) field in the `precommit nil`
 
 * **Response**:
 
-    | Name   | Type | Description                                           | Field Number |
-    |--------|------|-------------------------------------------------------|--------------|
-    | accept | bool | If false, Application is rejecting the vote extension | 1            |
+    | Name   | Type                          | Description                                                    | Field Number |
+    |--------|-------------------------------|----------------------------------------------------------------|--------------|
+    | status | [VerifyStatus](#VerifyStatus) | `enum` signaling if the application accepts the vote extension | 1            |
 
 * **Usage**:
-    * If `ResponseVerifyVoteExtension.accept` is _false_, Tendermint will reject the whole received vote.
+    * If `ResponseVerifyVoteExtension.status` is `REJECT`, Tendermint will reject the whole received vote.
       See the [Requirements](abci++_app_requirements_002_draft.md) section to understand the potential
       liveness implications of this.
     * The implementation of `VerifyVoteExtension` MUST be deterministic. Moreover, the value of
-      `ResponseVerifyVoteExtension.accept` MUST **exclusively** depend on the parameters passed in
+      `ResponseVerifyVoteExtension.status` MUST **exclusively** depend on the parameters passed in
       the call to `RequestVerifyVoteExtension`, and the last committed Application state
       (see [Requirements](abci++_app_requirements_002_draft.md) section).
-    * Moreover, application implementors SHOULD always set `ResponseVerifyVoteExtension.accept` to _true_,
-      unless they _really_ know what the potential liveness implications of returning _false_ are.
+    * Moreover, application implementers SHOULD always set `ResponseVerifyVoteExtension.status` to `ACCEPT`,
+      unless they _really_ know what the potential liveness implications of returning `REJECT` are.
 
 #### When does Tendermint call it?
 
@@ -558,7 +554,7 @@ When a validator _p_ is in Tendermint consensus round _r_, height _h_, state _pr
 from this condition, but not sure), and _p_ receives a Precommit message for round _r_, height _h_ from _q_:
 
 1. _p_'s Tendermint calls `RequestVerifyVoteExtension`.
-2. The Application returns _accept_ or _reject_ via `ResponseVerifyVoteExtension.accept`.
+2. The Application returns _accept_ or _reject_ via `ResponseVerifyVoteExtension.status`.
 3. If the Application returns
    * _accept_, _p_'s Tendermint will keep the received vote, together with its corresponding
      vote extension in its internal data structures. It will be used to populate the [ExtendedCommitInfo](#extendedcommitinfo)
@@ -832,20 +828,20 @@ Most of the data structures used in ABCI are shared [common data structures](../
 
 ### TxAction
 
-```protobuf
-  enum TxAction {
-    TXUNKNOWN    = 0;  // Unknown action
-    TXUNMODIFIED = 1;  // The Application did not modify this transaction.
-    TXADDED      = 2;  // The Application added this transaction.
-    TXREMOVED    = 3;  // The Application wants this transaction removed from the proposal and the mempool.
-  }
+```proto
+enum TxAction {
+  UNKNOWN    = 0;  // Unknown action
+  UNMODIFIED = 1;  // The Application did not modify this transaction.
+  ADDED      = 2;  // The Application added this transaction.
+  REMOVED    = 3;  // The Application wants this transaction removed from the proposal and the mempool.
+}
 ```
 
 * **Usage**:
-    * If `Action` is TXUNKNOWN, a problem happened in the Application. Tendermint will ignore this transaction. **TODO** should we panic?
-    * If `Action` is TXUNMODIFIED, Tendermint includes the transaction in the proposal. Nothing to do on the mempool.
-    * If `Action` is TXADDED, Tendermint includes the transaction in the proposal. The transaction is also added to the mempool and gossipped.
-    * If `Action` is TXREMOVED, Tendermint excludes the transaction from the proposal. The transaction is also removed from the mempool if it exists,
+    * If `Action` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
+    * If `Action` is `UNMODIFIED`, Tendermint includes the transaction in the proposal. Nothing to do on the mempool.
+    * If `Action` is `ADDED`, Tendermint includes the transaction in the proposal. The transaction is _not_ added to the mempool.
+    * If `Action` is `REMOVED`, Tendermint excludes the transaction from the proposal. The transaction is also removed from the mempool if it exists,
       similar to `CheckTx` returning _false_.
 ### TxRecord
 
@@ -856,6 +852,55 @@ Most of the data structures used in ABCI are shared [common data structures](../
     | action     | [TxAction](#txaction) | What should Tendermint do with this transaction?                 | 1            |
     | tx         | bytes                 | Transaction contents                                             | 2            |
 
+### ProposalStatus
+
+```proto
+enum ProposalStatus {
+  UNKNOWN = 0; // Unknown status. Returning this from the application is always an error. 
+  ACCEPT  = 1; // Status that signals that the application finds the proposal valid.
+  REJECT  = 2; // Status that signals that the application finds the proposal invalid.
+}
+```
+
+* **Usage**:
+	* Used within the [ProcessProposal](#ProcessProposal) response.
+    * If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
+    * If `Status` is `ACCEPT`, Tendermint accepts the proposal and will issue a Prevote message for it.
+    * If `Status` is `REJECT`, Tendermint rejects the proposal and will issue a Prevote for `nil` instead.
+
+### TxModifiedStatus
+
+```proto
+enum ModifiedTxStatus {
+  UNKNOWN    = 0; // Unknown status. Returning this from the application is always an error.
+  UNMODIFIED = 1; // Status that signals the application has modified the returned list of transactions.
+  MODIFIED   = 2; // Status that signals that the application has not modified the list of transactions.
+}
+```
+
+* **Usage**:
+	* Used within the [PrepareProposal](#PrepareProposal) response.
+    * If `TxModifiedStatus` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
+    * If `TxModifiedStatus` is `UNMODIFIED`, Tendermint will ignore the contents of the `PrepareProposal` response and use the transactions originally passed to the application during `PrepareProposal`.
+    * If `TxModifiedStatus` is `MODIFIED`, Tendermint will update the block proposal using the contents of the `PrepareProposal` response returned by the application.
+
+### VerifyStatus
+
+```proto
+enum VerifyStatus {
+  UNKNOWN = 0; // Unknown status. Returning this from the application is always an error.
+  ACCEPT  = 1; // Status that signals that the application finds the vote extension valid.
+  REJECT  = 2; // Status that signals that the application finds the vote extension invalid.
+}
+```
+
+* **Usage**:
+	* Used within the [VerifyVoteExtension](#VerifyVoteExtension) response.
+    * If `Status` is `UNKNOWN`, a problem happened in the Application. Tendermint will assume the application is faulty and crash.
+    * If `Status` is `ACCEPT`, Tendermint will accept the vote as valid.
+    * If `Status` is `REJECT`, Tendermint will reject the vote as invalid.
+
+
 ### CanonicalVoteExtension
 
 >**TODO**: This protobuf message definition is not part of the ABCI++ interface, but rather belongs to the

spec/core/data_structures.md

@@ -466,7 +466,7 @@ func SumTruncated(bz []byte) []byte {
 | vote | [google.protobuf.Duration](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration)| Parameter that, along with vote_delta, configures the timeout for the prevote and precommit step of the consensus algorithm. | 3 |
 | vote_delta | [google.protobuf.Duration](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration)| Parameter that, along with vote, configures the timeout for the prevote and precommit step of the consensus algorithm. | 4 |
 | commit | [google.protobuf.Duration](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration) | Parameter that configures how long Tendermint will wait after receiving a quorum of precommits before beginning consensus for the next height.| 5 |
-| enable_commit_timeout_bypass | bool | Parameter that, if enabled, configures the node to proceed immediately to the next height once the node has received all precommits for a block, forgoing the commit timeout. |  6  |
+| bypass_commit_timeout | bool | Parameter that, if enabled, configures the node to proceed immediately to the next height once the node has received all precommits for a block, forgoing the commit timeout. |  6  |
 
 ## Proof
 

test/e2e/app/app.go

@@ -306,7 +306,7 @@ func (app *Application) ApplySnapshotChunk(req abci.RequestApplySnapshotChunk) a
 
 func (app *Application) PrepareProposal(req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
 	// None of the transactions are modified by this application.
-	return abci.ResponsePrepareProposal{ModifiedTx: false}
+	return abci.ResponsePrepareProposal{ModifiedTxStatus: abci.ResponsePrepareProposal_UNMODIFIED}
 }
 
 // ProcessProposal implements part of the Application interface.
@@ -315,10 +315,10 @@ func (app *Application) ProcessProposal(req abci.RequestProcessProposal) abci.Re
 	for _, tx := range req.Txs {
 		_, _, err := parseTx(tx)
 		if err != nil {
-			return abci.ResponseProcessProposal{Accept: false}
+			return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}
 		}
 	}
-	return abci.ResponseProcessProposal{Accept: true}
+	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
 }
 
 func (app *Application) Rollback() error {

types/genesis_test.go

@@ -72,6 +72,14 @@ func TestBasicGenesisDoc(t *testing.T) {
 			"app_state":{"account_owner": "Bob"},
 			"consensus_params": {
 				"synchrony":  {"precision": "1", "message_delay": "10"},
+				"timeout": {
+					"propose": "30000000000",
+					"propose_delta": "50000000",
+					"vote": "30000000000",
+					"vote_delta": "50000000",
+					"commit": "10000000000",
+					"bypass_commit_timeout": false
+				},
 				"validator": {"pub_key_types":["ed25519"]},
 				"block": {"max_bytes": "100"},
 				"evidence": {"max_age_num_blocks": "100", "max_age_duration": "10"}

types/params.go

@@ -42,6 +42,7 @@ type ConsensusParams struct {
 	Validator ValidatorParams `json:"validator"`
 	Version   VersionParams   `json:"version"`
 	Synchrony SynchronyParams `json:"synchrony"`
+	Timeout   TimeoutParams   `json:"timeout"`
 }
 
 // HashedParams is a subset of ConsensusParams.
@@ -85,6 +86,16 @@ type SynchronyParams struct {
 	MessageDelay time.Duration `json:"message_delay,string"`
 }
 
+// TimeoutParams configure the timings of the steps of the Tendermint consensus algorithm.
+type TimeoutParams struct {
+	Propose             time.Duration `json:"propose,string"`
+	ProposeDelta        time.Duration `json:"propose_delta,string"`
+	Vote                time.Duration `json:"vote,string"`
+	VoteDelta           time.Duration `json:"vote_delta,string"`
+	Commit              time.Duration `json:"commit,string"`
+	BypassCommitTimeout bool          `json:"bypass_commit_timeout"`
+}
+
 // DefaultConsensusParams returns a default ConsensusParams.
 func DefaultConsensusParams() *ConsensusParams {
 	return &ConsensusParams{
@@ -93,6 +104,7 @@ func DefaultConsensusParams() *ConsensusParams {
 		Validator: DefaultValidatorParams(),
 		Version:   DefaultVersionParams(),
 		Synchrony: DefaultSynchronyParams(),
+		Timeout:   DefaultTimeoutParams(),
 	}
 }
 
@@ -135,6 +147,39 @@ func DefaultSynchronyParams() SynchronyParams {
 		Precision:    505 * time.Millisecond,
 		MessageDelay: 12 * time.Second,
 	}
+
+}
+
+func DefaultTimeoutParams() TimeoutParams {
+	return TimeoutParams{
+		Propose:             3000 * time.Millisecond,
+		ProposeDelta:        500 * time.Millisecond,
+		Vote:                1000 * time.Millisecond,
+		VoteDelta:           500 * time.Millisecond,
+		Commit:              1000 * time.Millisecond,
+		BypassCommitTimeout: false,
+	}
+}
+
+// ProposeTimeout returns the amount of time to wait for a proposal.
+func (t TimeoutParams) ProposeTimeout(round int32) time.Duration {
+	return time.Duration(
+		t.Propose.Nanoseconds()+t.ProposeDelta.Nanoseconds()*int64(round),
+	) * time.Nanosecond
+}
+
+// VoteTimeout returns the amount of time to wait for remaining votes after receiving any +2/3 votes.
+func (t TimeoutParams) VoteTimeout(round int32) time.Duration {
+	return time.Duration(
+		t.Vote.Nanoseconds()+t.VoteDelta.Nanoseconds()*int64(round),
+	) * time.Nanosecond
+}
+
+// CommitTime accepts ti, the time at which the consensus engine received +2/3
+// precommits for a block and returns the point in time at which the consensus
+// engine should begin consensus on the next block.
+func (t TimeoutParams) CommitTime(ti time.Time) time.Time {
+	return ti.Add(t.Commit)
 }
 
 func (val *ValidatorParams) IsValidPubkeyType(pubkeyType string) bool {
@@ -150,6 +195,9 @@ func (params *ConsensusParams) Complete() {
 	if params.Synchrony == (SynchronyParams{}) {
 		params.Synchrony = DefaultSynchronyParams()
 	}
+	if params.Timeout == (TimeoutParams{}) {
+		params.Timeout = DefaultTimeoutParams()
+	}
 }
 
 // Validate validates the ConsensusParams to ensure all values are within their
@@ -199,6 +247,26 @@ func (params ConsensusParams) ValidateConsensusParams() error {
 			params.Synchrony.Precision)
 	}
 
+	if params.Timeout.Propose < 0 {
+		return fmt.Errorf("timeout.ProposeDelta must not be negative. Got: %d", params.Timeout.Propose)
+	}
+
+	if params.Timeout.ProposeDelta < 0 {
+		return fmt.Errorf("timeout.ProposeDelta must not be negative. Got: %d", params.Timeout.ProposeDelta)
+	}
+
+	if params.Timeout.Vote < 0 {
+		return fmt.Errorf("timeout.Vote must not be negative. Got: %d", params.Timeout.Vote)
+	}
+
+	if params.Timeout.VoteDelta < 0 {
+		return fmt.Errorf("timeout.VoteDelta must not be negative. Got: %d", params.Timeout.VoteDelta)
+	}
+
+	if params.Timeout.Commit < 0 {
+		return fmt.Errorf("timeout.Commit must not be negative. Got: %d", params.Timeout.Commit)
+	}
+
 	if len(params.Validator.PubKeyTypes) == 0 {
 		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
 	}
@@ -244,6 +312,7 @@ func (params *ConsensusParams) Equals(params2 *ConsensusParams) bool {
 		params.Evidence == params2.Evidence &&
 		params.Version == params2.Version &&
 		params.Synchrony == params2.Synchrony &&
+		params.Timeout == params2.Timeout &&
 		tmstrings.StringSliceEqual(params.Validator.PubKeyTypes, params2.Validator.PubKeyTypes)
 }
 
@@ -282,6 +351,24 @@ func (params ConsensusParams) UpdateConsensusParams(params2 *tmproto.ConsensusPa
 			res.Synchrony.Precision = *params2.Synchrony.GetPrecision()
 		}
 	}
+	if params2.Timeout != nil {
+		if params2.Timeout.Propose != nil {
+			res.Timeout.Propose = *params2.Timeout.GetPropose()
+		}
+		if params2.Timeout.ProposeDelta != nil {
+			res.Timeout.ProposeDelta = *params2.Timeout.GetProposeDelta()
+		}
+		if params2.Timeout.Vote != nil {
+			res.Timeout.Vote = *params2.Timeout.GetVote()
+		}
+		if params2.Timeout.VoteDelta != nil {
+			res.Timeout.VoteDelta = *params2.Timeout.GetVoteDelta()
+		}
+		if params2.Timeout.Commit != nil {
+			res.Timeout.Commit = *params2.Timeout.GetCommit()
+		}
+		res.Timeout.BypassCommitTimeout = params2.Timeout.GetBypassCommitTimeout()
+	}
 	return res
 }
 
@@ -306,6 +393,14 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 			MessageDelay: &params.Synchrony.MessageDelay,
 			Precision:    &params.Synchrony.Precision,
 		},
+		Timeout: &tmproto.TimeoutParams{
+			Propose:             &params.Timeout.Propose,
+			ProposeDelta:        &params.Timeout.ProposeDelta,
+			Vote:                &params.Timeout.Vote,
+			VoteDelta:           &params.Timeout.VoteDelta,
+			Commit:              &params.Timeout.Commit,
+			BypassCommitTimeout: params.Timeout.BypassCommitTimeout,
+		},
 	}
 }
 
@@ -335,5 +430,23 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 			c.Synchrony.Precision = *pbParams.Synchrony.GetPrecision()
 		}
 	}
+	if pbParams.Timeout != nil {
+		if pbParams.Timeout.Propose != nil {
+			c.Timeout.Propose = *pbParams.Timeout.GetPropose()
+		}
+		if pbParams.Timeout.ProposeDelta != nil {
+			c.Timeout.ProposeDelta = *pbParams.Timeout.GetProposeDelta()
+		}
+		if pbParams.Timeout.Vote != nil {
+			c.Timeout.Vote = *pbParams.Timeout.GetVote()
+		}
+		if pbParams.Timeout.VoteDelta != nil {
+			c.Timeout.VoteDelta = *pbParams.Timeout.GetVoteDelta()
+		}
+		if pbParams.Timeout.Commit != nil {
+			c.Timeout.Commit = *pbParams.Timeout.GetCommit()
+		}
+		c.Timeout.BypassCommitTimeout = pbParams.Timeout.BypassCommitTimeout
+	}
 	return c
 }

types/params_test.go

@@ -168,13 +168,19 @@ func TestConsensusParamsValidation(t *testing.T) {
 }
 
 type makeParamsArgs struct {
-	blockBytes       int64
-	blockGas         int64
-	evidenceAge      int64
-	maxEvidenceBytes int64
-	pubkeyTypes      []string
-	precision        time.Duration
-	messageDelay     time.Duration
+	blockBytes          int64
+	blockGas            int64
+	evidenceAge         int64
+	maxEvidenceBytes    int64
+	pubkeyTypes         []string
+	precision           time.Duration
+	messageDelay        time.Duration
+	propose             time.Duration
+	proposeDelta        time.Duration
+	vote                time.Duration
+	voteDelta           time.Duration
+	commit              time.Duration
+	bypassCommitTimeout bool
 }
 
 func makeParams(args makeParamsArgs) ConsensusParams {
@@ -198,8 +204,15 @@ func makeParams(args makeParamsArgs) ConsensusParams {
 			Precision:    args.precision,
 			MessageDelay: args.messageDelay,
 		},
+		Timeout: TimeoutParams{
+			Propose:             args.propose,
+			ProposeDelta:        args.proposeDelta,
+			Vote:                args.vote,
+			VoteDelta:           args.voteDelta,
+			Commit:              args.commit,
+			BypassCommitTimeout: args.bypassCommitTimeout,
+		},
 	}
-
 }
 
 func TestConsensusParamsHash(t *testing.T) {
@@ -252,6 +265,35 @@ func TestConsensusParamsUpdate(t *testing.T) {
 			},
 			updatedParams: makeParams(makeParamsArgs{evidenceAge: 3, precision: 2 * time.Second, messageDelay: 4 * time.Second}),
 		},
+		{
+			// update timeout params
+			intialParams: makeParams(makeParamsArgs{
+				propose:             3 * time.Second,
+				proposeDelta:        500 * time.Millisecond,
+				vote:                time.Second,
+				voteDelta:           500 * time.Millisecond,
+				commit:              time.Second,
+				bypassCommitTimeout: false,
+			}),
+			updates: &tmproto.ConsensusParams{
+				Timeout: &tmproto.TimeoutParams{
+					Propose:             durationPtr(2 * time.Second),
+					ProposeDelta:        durationPtr(400 * time.Millisecond),
+					Vote:                durationPtr(5 * time.Second),
+					VoteDelta:           durationPtr(400 * time.Millisecond),
+					Commit:              durationPtr(time.Minute),
+					BypassCommitTimeout: true,
+				},
+			},
+			updatedParams: makeParams(makeParamsArgs{
+				propose:             2 * time.Second,
+				proposeDelta:        400 * time.Millisecond,
+				vote:                5 * time.Second,
+				voteDelta:           400 * time.Millisecond,
+				commit:              time.Minute,
+				bypassCommitTimeout: true,
+			}),
+		},
 		// fine updates
 		{
 			intialParams: makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),

types/tx.go

@@ -159,11 +159,6 @@ func (t TxRecordSet) IncludedTxs() []Tx {
 	return t.included
 }
 
-// AddedTxs returns the transactions added by the application.
-func (t TxRecordSet) AddedTxs() []Tx {
-	return t.added
-}
-
 // RemovedTxs returns the transactions marked for removal by the application.
 func (t TxRecordSet) RemovedTxs() []Tx {
 	return t.removed