review updates

*bump linter to 1.47

Co-authored-by: William Banfield <4561443+williambanfield@users.noreply.github.com>

.golangci.yml

@@ -2,7 +2,7 @@ linters:
   enable:
     - asciicheck
     - bodyclose
-    - deadcode
+    # - deadcode
     - depguard
     - dogsled
     - dupl
@@ -18,15 +18,17 @@ linters:
     - ineffassign
     - misspell
     - nakedret
-    - nolintlint
+    # - nolintlint
     - prealloc
     - staticcheck
-    # - structcheck // to be fixed by golangci-lint
+    - structcheck
     - stylecheck
     - typecheck
     - unconvert
+  disable:
     - unused
-    - varcheck
+    - deadcode
+    - nolintlint
 
 issues:
   exclude-rules:
@@ -40,7 +42,5 @@ linters-settings:
     max-blank-identifiers: 3
   golint:
     min-confidence: 0
-  maligned:
-    suggest-new: true
   misspell:
     locale: US

CHANGELOG_PENDING.md

@@ -10,12 +10,13 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
 
 - CLI/RPC/Config
 
+  - [config] \#9259 Rename the fastsync section and the fast_sync key blocksync and block_sync respectively
+
 - Apps
 
   - [abci/counter] \#6684 Delete counter example app
   - [txResults] \#9175 Remove `gas_used` & `gas_wanted` from being merkelized in the lastresulthash in the header
   - [abci] \#5783 Make length delimiter encoding consistent (`uint64`) between ABCI and P2P wire-level protocols
-  - [abci] \##9145 Removes Response/Request `SetOption` from ABCI
 
 - P2P Protocol
 
@@ -30,7 +31,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
 
 ### IMPROVEMENTS
 
-- [abci] \#5706 Added `AbciVersion` to `RequestInfo` allowing applications to check ABCI version when connecting to Tendermint. (@marbar3778)
+- [config] \#9054 Flag added to overwrite abciresponses.
 
 ### BUG FIXES
 

abci/client/client.go

@@ -14,8 +14,6 @@ const (
 	echoRetryIntervalSeconds = 1
 )
 
-//go:generate mockery --case underscore --name Client
-
 // Client defines an interface for an ABCI client.
 // All `Async` methods return a `ReqRes` object.
 // All `Sync` methods return the appropriate protobuf ResponseXxx struct and an error.
@@ -30,36 +28,34 @@ type Client interface {
 	FlushAsync() *ReqRes
 	EchoAsync(msg string) *ReqRes
 	InfoAsync(types.RequestInfo) *ReqRes
+	SetOptionAsync(types.RequestSetOption) *ReqRes
 	DeliverTxAsync(types.RequestDeliverTx) *ReqRes
 	CheckTxAsync(types.RequestCheckTx) *ReqRes
 	QueryAsync(types.RequestQuery) *ReqRes
 	CommitAsync() *ReqRes
 	InitChainAsync(types.RequestInitChain) *ReqRes
-	PrepareProposalAsync(types.RequestPrepareProposal) *ReqRes
 	BeginBlockAsync(types.RequestBeginBlock) *ReqRes
 	EndBlockAsync(types.RequestEndBlock) *ReqRes
 	ListSnapshotsAsync(types.RequestListSnapshots) *ReqRes
 	OfferSnapshotAsync(types.RequestOfferSnapshot) *ReqRes
 	LoadSnapshotChunkAsync(types.RequestLoadSnapshotChunk) *ReqRes
 	ApplySnapshotChunkAsync(types.RequestApplySnapshotChunk) *ReqRes
-	ProcessProposalAsync(types.RequestProcessProposal) *ReqRes
 
 	FlushSync() error
 	EchoSync(msg string) (*types.ResponseEcho, error)
 	InfoSync(types.RequestInfo) (*types.ResponseInfo, error)
+	SetOptionSync(types.RequestSetOption) (*types.ResponseSetOption, error)
 	DeliverTxSync(types.RequestDeliverTx) (*types.ResponseDeliverTx, error)
 	CheckTxSync(types.RequestCheckTx) (*types.ResponseCheckTx, error)
 	QuerySync(types.RequestQuery) (*types.ResponseQuery, error)
 	CommitSync() (*types.ResponseCommit, error)
 	InitChainSync(types.RequestInitChain) (*types.ResponseInitChain, error)
-	PrepareProposalSync(types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error)
 	BeginBlockSync(types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
 	EndBlockSync(types.RequestEndBlock) (*types.ResponseEndBlock, error)
 	ListSnapshotsSync(types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
 	OfferSnapshotSync(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
 	LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
 	ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
-	ProcessProposalSync(types.RequestProcessProposal) (*types.ResponseProcessProposal, error)
 }
 
 //----------------------------------------

abci/client/grpc_client.go

@@ -192,6 +192,15 @@ func (cli *grpcClient) InfoAsync(params types.RequestInfo) *ReqRes {
 	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Info{Info: res}})
 }
 
+func (cli *grpcClient) SetOptionAsync(params types.RequestSetOption) *ReqRes {
+	req := types.ToRequestSetOption(params)
+	res, err := cli.client.SetOption(context.Background(), req.GetSetOption(), grpc.WaitForReady(true))
+	if err != nil {
+		cli.StopForError(err)
+	}
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_SetOption{SetOption: res}})
+}
+
 func (cli *grpcClient) DeliverTxAsync(params types.RequestDeliverTx) *ReqRes {
 	req := types.ToRequestDeliverTx(params)
 	res, err := cli.client.DeliverTx(context.Background(), req.GetDeliverTx(), grpc.WaitForReady(true))
@@ -291,25 +300,6 @@ func (cli *grpcClient) ApplySnapshotChunkAsync(params types.RequestApplySnapshot
 	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}})
 }
 
-func (cli *grpcClient) PrepareProposalAsync(params types.RequestPrepareProposal) *ReqRes {
-	req := types.ToRequestPrepareProposal(params)
-	res, err := cli.client.PrepareProposal(context.Background(), req.GetPrepareProposal(), grpc.WaitForReady(true))
-	if err != nil {
-		cli.StopForError(err)
-	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_PrepareProposal{PrepareProposal: res}})
-}
-
-func (cli *grpcClient) ProcessProposalAsync(params types.RequestProcessProposal) *ReqRes {
-	req := types.ToRequestProcessProposal(params)
-	res, err := cli.client.ProcessProposal(context.Background(), req.GetProcessProposal(), grpc.WaitForReady(true))
-	if err != nil {
-		cli.StopForError(err)
-	}
-
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ProcessProposal{ProcessProposal: res}})
-}
-
 // finishAsyncCall creates a ReqRes for an async call, and immediately populates it
 // with the response. We don't complete it until it's been ordered via the channel.
 func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes {
@@ -366,6 +356,11 @@ func (cli *grpcClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, err
 	return cli.finishSyncCall(reqres).GetInfo(), cli.Error()
 }
 
+func (cli *grpcClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
+	reqres := cli.SetOptionAsync(req)
+	return reqres.Response.GetSetOption(), cli.Error()
+}
+
 func (cli *grpcClient) DeliverTxSync(params types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
 	reqres := cli.DeliverTxAsync(params)
 	return cli.finishSyncCall(reqres).GetDeliverTx(), cli.Error()
@@ -422,14 +417,3 @@ func (cli *grpcClient) ApplySnapshotChunkSync(
 	reqres := cli.ApplySnapshotChunkAsync(params)
 	return cli.finishSyncCall(reqres).GetApplySnapshotChunk(), cli.Error()
 }
-
-func (cli *grpcClient) PrepareProposalSync(
-	params types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	reqres := cli.PrepareProposalAsync(params)
-	return cli.finishSyncCall(reqres).GetPrepareProposal(), cli.Error()
-}
-
-func (cli *grpcClient) ProcessProposalSync(params types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	reqres := cli.ProcessProposalAsync(params)
-	return cli.finishSyncCall(reqres).GetProcessProposal(), cli.Error()
-}

abci/client/local_client.go

@@ -75,6 +75,17 @@ func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {
 	)
 }
 
+func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.SetOption(req)
+	return app.callback(
+		types.ToRequestSetOption(req),
+		types.ToResponseSetOption(res),
+	)
+}
+
 func (app *localClient) DeliverTxAsync(params types.RequestDeliverTx) *ReqRes {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
@@ -196,28 +207,6 @@ func (app *localClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotCh
 	)
 }
 
-func (app *localClient) PrepareProposalAsync(req types.RequestPrepareProposal) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.PrepareProposal(req)
-	return app.callback(
-		types.ToRequestPrepareProposal(req),
-		types.ToResponsePrepareProposal(res),
-	)
-}
-
-func (app *localClient) ProcessProposalAsync(req types.RequestProcessProposal) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ProcessProposal(req)
-	return app.callback(
-		types.ToRequestProcessProposal(req),
-		types.ToResponseProcessProposal(res),
-	)
-}
-
 //-------------------------------------------------------
 
 func (app *localClient) FlushSync() error {
@@ -236,6 +225,14 @@ func (app *localClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, er
 	return &res, nil
 }
 
+func (app *localClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.SetOption(req)
+	return &res, nil
+}
+
 func (app *localClient) DeliverTxSync(req types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
@@ -326,22 +323,6 @@ func (app *localClient) ApplySnapshotChunkSync(
 	return &res, nil
 }
 
-func (app *localClient) PrepareProposalSync(req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.PrepareProposal(req)
-	return &res, nil
-}
-
-func (app *localClient) ProcessProposalSync(req types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ProcessProposal(req)
-	return &res, nil
-}
-
 //-------------------------------------------------------
 
 func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes {

abci/client/mocks/client.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v1.1.1. DO NOT EDIT.
 
 package mocks
 
@@ -575,84 +575,6 @@ func (_m *Client) OnStop() {
 	_m.Called()
 }
 
-// PrepareProposalAsync provides a mock function with given fields: _a0
-func (_m *Client) PrepareProposalAsync(_a0 types.RequestPrepareProposal) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// PrepareProposalSync provides a mock function with given fields: _a0
-func (_m *Client) PrepareProposalSync(_a0 types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponsePrepareProposal
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *types.ResponsePrepareProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponsePrepareProposal)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestPrepareProposal) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ProcessProposalAsync provides a mock function with given fields: _a0
-func (_m *Client) ProcessProposalAsync(_a0 types.RequestProcessProposal) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// ProcessProposalSync provides a mock function with given fields: _a0
-func (_m *Client) ProcessProposalSync(_a0 types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponseProcessProposal
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *types.ResponseProcessProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseProcessProposal)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestProcessProposal) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // QueryAsync provides a mock function with given fields: _a0
 func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes {
 	ret := _m.Called(_a0)
@@ -727,6 +649,45 @@ func (_m *Client) SetLogger(_a0 log.Logger) {
 	_m.Called(_a0)
 }
 
+// SetOptionAsync provides a mock function with given fields: _a0
+func (_m *Client) SetOptionAsync(_a0 types.RequestSetOption) *abcicli.ReqRes {
+	ret := _m.Called(_a0)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(types.RequestSetOption) *abcicli.ReqRes); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	return r0
+}
+
+// SetOptionSync provides a mock function with given fields: _a0
+func (_m *Client) SetOptionSync(_a0 types.RequestSetOption) (*types.ResponseSetOption, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseSetOption
+	if rf, ok := ret.Get(0).(func(types.RequestSetOption) *types.ResponseSetOption); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseSetOption)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestSetOption) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // SetResponseCallback provides a mock function with given fields: _a0
 func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) {
 	_m.Called(_a0)
@@ -773,18 +734,3 @@ func (_m *Client) String() string {
 
 	return r0
 }
-
-type mockConstructorTestingTNewClient interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewClient(t mockConstructorTestingTNewClient) *Client {
-	mock := &Client{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

abci/client/socket_client.go

@@ -231,6 +231,10 @@ func (cli *socketClient) InfoAsync(req types.RequestInfo) *ReqRes {
 	return cli.queueRequest(types.ToRequestInfo(req))
 }
 
+func (cli *socketClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
+	return cli.queueRequest(types.ToRequestSetOption(req))
+}
+
 func (cli *socketClient) DeliverTxAsync(req types.RequestDeliverTx) *ReqRes {
 	return cli.queueRequest(types.ToRequestDeliverTx(req))
 }
@@ -275,14 +279,6 @@ func (cli *socketClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotC
 	return cli.queueRequest(types.ToRequestApplySnapshotChunk(req))
 }
 
-func (cli *socketClient) PrepareProposalAsync(req types.RequestPrepareProposal) *ReqRes {
-	return cli.queueRequest(types.ToRequestPrepareProposal(req))
-}
-
-func (cli *socketClient) ProcessProposalAsync(req types.RequestProcessProposal) *ReqRes {
-	return cli.queueRequest(types.ToRequestProcessProposal(req))
-}
-
 //----------------------------------------
 
 func (cli *socketClient) FlushSync() error {
@@ -312,6 +308,15 @@ func (cli *socketClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, e
 	return reqres.Response.GetInfo(), cli.Error()
 }
 
+func (cli *socketClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
+	reqres := cli.queueRequest(types.ToRequestSetOption(req))
+	if err := cli.FlushSync(); err != nil {
+		return nil, err
+	}
+
+	return reqres.Response.GetSetOption(), cli.Error()
+}
+
 func (cli *socketClient) DeliverTxSync(req types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
 	reqres := cli.queueRequest(types.ToRequestDeliverTx(req))
 	if err := cli.FlushSync(); err != nil {
@@ -412,24 +417,6 @@ func (cli *socketClient) ApplySnapshotChunkSync(
 	return reqres.Response.GetApplySnapshotChunk(), cli.Error()
 }
 
-func (cli *socketClient) PrepareProposalSync(req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	reqres := cli.queueRequest(types.ToRequestPrepareProposal(req))
-	if err := cli.FlushSync(); err != nil {
-		return nil, err
-	}
-
-	return reqres.Response.GetPrepareProposal(), cli.Error()
-}
-
-func (cli *socketClient) ProcessProposalSync(req types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	reqres := cli.queueRequest(types.ToRequestProcessProposal(req))
-	if err := cli.FlushSync(); err != nil {
-		return nil, err
-	}
-
-	return reqres.Response.GetProcessProposal(), cli.Error()
-}
-
 //----------------------------------------
 
 func (cli *socketClient) queueRequest(req *types.Request) *ReqRes {
@@ -481,6 +468,8 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_Flush)
 	case *types.Request_Info:
 		_, ok = res.Value.(*types.Response_Info)
+	case *types.Request_SetOption:
+		_, ok = res.Value.(*types.Response_SetOption)
 	case *types.Request_DeliverTx:
 		_, ok = res.Value.(*types.Response_DeliverTx)
 	case *types.Request_CheckTx:
@@ -503,10 +492,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_ListSnapshots)
 	case *types.Request_OfferSnapshot:
 		_, ok = res.Value.(*types.Response_OfferSnapshot)
-	case *types.Request_PrepareProposal:
-		_, ok = res.Value.(*types.Response_PrepareProposal)
-	case *types.Request_ProcessProposal:
-		_, ok = res.Value.(*types.Response_ProcessProposal)
 	}
 	return ok
 }

abci/cmd/abci-cli/abci-cli.go

@@ -138,6 +138,7 @@ func addCommands() {
 	RootCmd.AddCommand(consoleCmd)
 	RootCmd.AddCommand(echoCmd)
 	RootCmd.AddCommand(infoCmd)
+	RootCmd.AddCommand(setOptionCmd)
 	RootCmd.AddCommand(deliverTxCmd)
 	RootCmd.AddCommand(checkTxCmd)
 	RootCmd.AddCommand(commitCmd)
@@ -163,6 +164,7 @@ you'd like to run:
 
 where example.file looks something like:
 
+    set_option serial on
     check_tx 0x00
     check_tx 0xff
     deliver_tx 0x00
@@ -184,7 +186,7 @@ This command opens an interactive console for running any of the other commands
 without opening a new connection each time
 `,
 	Args:      cobra.ExactArgs(0),
-	ValidArgs: []string{"echo", "info", "deliver_tx", "check_tx", "commit", "query"},
+	ValidArgs: []string{"echo", "info", "set_option", "deliver_tx", "check_tx", "commit", "query"},
 	RunE:      cmdConsole,
 }
 
@@ -202,6 +204,13 @@ var infoCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(0),
 	RunE:  cmdInfo,
 }
+var setOptionCmd = &cobra.Command{
+	Use:   "set_option",
+	Short: "set an option on the application",
+	Long:  "set an option on the application",
+	Args:  cobra.ExactArgs(2),
+	RunE:  cmdSetOption,
+}
 
 var deliverTxCmd = &cobra.Command{
 	Use:   "deliver_tx",
@@ -295,6 +304,7 @@ func cmdTest(cmd *cobra.Command, args []string) error {
 	return compose(
 		[]func() error{
 			func() error { return servertest.InitChain(client) },
+			func() error { return servertest.SetOption(client, "serial", "on") },
 			func() error { return servertest.Commit(client, nil) },
 			func() error { return servertest.DeliverTx(client, []byte("abc"), code.CodeTypeBadNonce, nil) },
 			func() error { return servertest.Commit(client, nil) },
@@ -409,6 +419,8 @@ func muxOnCommands(cmd *cobra.Command, pArgs []string) error {
 		return cmdInfo(cmd, actualArgs)
 	case "query":
 		return cmdQuery(cmd, actualArgs)
+	case "set_option":
+		return cmdSetOption(cmd, actualArgs)
 	default:
 		return cmdUnimplemented(cmd, pArgs)
 	}
@@ -432,6 +444,7 @@ func cmdUnimplemented(cmd *cobra.Command, args []string) error {
 	fmt.Printf("%s: %s\n", deliverTxCmd.Use, deliverTxCmd.Short)
 	fmt.Printf("%s: %s\n", queryCmd.Use, queryCmd.Short)
 	fmt.Printf("%s: %s\n", commitCmd.Use, commitCmd.Short)
+	fmt.Printf("%s: %s\n", setOptionCmd.Use, setOptionCmd.Short)
 	fmt.Println("Use \"[command] --help\" for more information about a command.")
 
 	return nil
@@ -471,6 +484,25 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 
 const codeBad uint32 = 10
 
+// Set an option on the application
+func cmdSetOption(cmd *cobra.Command, args []string) error {
+	if len(args) < 2 {
+		printResponse(cmd, args, response{
+			Code: codeBad,
+			Log:  "want at least arguments of the form: <key> <value>",
+		})
+		return nil
+	}
+
+	key, val := args[0], args[1]
+	_, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: val})
+	if err != nil {
+		return err
+	}
+	printResponse(cmd, args, response{Log: "OK (SetOption doesn't return anything.)"}) // NOTE: Nothing to show...
+	return nil
+}
+
 // Append a new tx to application
 func cmdDeliverTx(cmd *cobra.Command, args []string) error {
 	if len(args) == 0 {

abci/example/kvstore/kvstore.go

@@ -170,13 +170,3 @@ func (app *Application) Query(reqQuery types.RequestQuery) (resQuery types.Respo
 
 	return resQuery
 }
-
-func (app *Application) ProcessProposal(
-	req types.RequestProcessProposal) types.ResponseProcessProposal {
-	for _, tx := range req.Txs {
-		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}
-		}
-	}
-	return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}
-}

abci/example/kvstore/kvstore_test.go

@@ -162,7 +162,7 @@ func TestValUpdates(t *testing.T) {
 
 	makeApplyBlock(t, kvstore, 2, diff, tx1, tx2, tx3)
 
-	vals1 = append(vals[:nInit-2], vals[nInit+1]) // nolint: gocritic
+	vals1 = append(vals[:nInit-2], vals[nInit+1]) //nolint: gocritic
 	vals2 = kvstore.Validators()
 	valsEqual(t, vals1, vals2)
 

abci/example/kvstore/persistent_kvstore.go

@@ -62,6 +62,10 @@ func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.Respo
 	return res
 }
 
+func (app *PersistentKVStoreApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption {
+	return app.app.SetOption(req)
+}
+
 // tx is either "val:pubkey!power" or "key=value" or just arbitrary bytes
 func (app *PersistentKVStoreApplication) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
 	// if it starts with "val:", update the validator set
@@ -72,10 +76,6 @@ func (app *PersistentKVStoreApplication) DeliverTx(req types.RequestDeliverTx) t
 		return app.execValidatorTx(req.Tx)
 	}
 
-	if isPrepareTx(req.Tx) {
-		return app.execPrepareTx(req.Tx)
-	}
-
 	// otherwise, update the key-value store
 	return app.app.DeliverTx(req)
 }
@@ -126,7 +126,7 @@ func (app *PersistentKVStoreApplication) BeginBlock(req types.RequestBeginBlock)
 
 	// Punish validators who committed equivocation.
 	for _, ev := range req.ByzantineValidators {
-		if ev.Type == types.MisbehaviorType_DUPLICATE_VOTE {
+		if ev.Type == types.EvidenceType_DUPLICATE_VOTE {
 			addr := string(ev.Validator.Address)
 			if pubKey, ok := app.valAddrToPubKeyMap[addr]; ok {
 				app.updateValidator(types.ValidatorUpdate{
@@ -170,21 +170,6 @@ func (app *PersistentKVStoreApplication) ApplySnapshotChunk(
 	return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_ABORT}
 }
 
-func (app *PersistentKVStoreApplication) PrepareProposal(
-	req types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	return types.ResponsePrepareProposal{TxRecords: app.substPrepareTx(req.Txs, req.MaxTxBytes)}
-}
-
-func (app *PersistentKVStoreApplication) ProcessProposal(
-	req types.RequestProcessProposal) types.ResponseProcessProposal {
-	for _, tx := range req.Txs {
-		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}
-		}
-	}
-	return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}
-}
-
 //---------------------------------------------
 // update validators
 
@@ -299,50 +284,3 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
 
 	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
 }
-
-// -----------------------------
-
-const PreparePrefix = "prepare"
-
-func isPrepareTx(tx []byte) bool {
-	return bytes.HasPrefix(tx, []byte(PreparePrefix))
-}
-
-// execPrepareTx is noop. tx data is considered as placeholder
-// and is substitute at the PrepareProposal.
-func (app *PersistentKVStoreApplication) execPrepareTx(tx []byte) types.ResponseDeliverTx {
-	// noop
-	return types.ResponseDeliverTx{}
-}
-
-// substPrepareTx substitutes all the transactions prefixed with 'prepare' in the
-// proposal for transactions with the prefix stripped.
-// It marks all of the original transactions as 'REMOVED' so that
-// Tendermint will remove them from its mempool.
-func (app *PersistentKVStoreApplication) substPrepareTx(blockData [][]byte, maxTxBytes int64) []*types.TxRecord {
-	trs := make([]*types.TxRecord, 0, len(blockData))
-	var removed []*types.TxRecord
-	var totalBytes int64
-	for _, tx := range blockData {
-		txMod := tx
-		action := types.TxRecord_UNMODIFIED
-		if isPrepareTx(tx) {
-			removed = append(removed, &types.TxRecord{
-				Tx:     tx,
-				Action: types.TxRecord_REMOVED,
-			})
-			txMod = bytes.TrimPrefix(tx, []byte(PreparePrefix))
-			action = types.TxRecord_ADDED
-		}
-		totalBytes += int64(len(txMod))
-		if totalBytes > maxTxBytes {
-			break
-		}
-		trs = append(trs, &types.TxRecord{
-			Tx:     txMod,
-			Action: action,
-		})
-	}
-
-	return append(trs, removed...)
-}

abci/server/server.go

@@ -2,9 +2,8 @@
 Package server is used to start a new ABCI server.
 
 It contains two server implementation:
- * gRPC server
- * socket server
-
+  - gRPC server
+  - socket server
 */
 package server
 

abci/server/socket_server.go

@@ -200,6 +200,9 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_Info:
 		res := s.app.Info(*r.Info)
 		responses <- types.ToResponseInfo(res)
+	case *types.Request_SetOption:
+		res := s.app.SetOption(*r.SetOption)
+		responses <- types.ToResponseSetOption(res)
 	case *types.Request_DeliverTx:
 		res := s.app.DeliverTx(*r.DeliverTx)
 		responses <- types.ToResponseDeliverTx(res)
@@ -227,12 +230,6 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_OfferSnapshot:
 		res := s.app.OfferSnapshot(*r.OfferSnapshot)
 		responses <- types.ToResponseOfferSnapshot(res)
-	case *types.Request_PrepareProposal:
-		res := s.app.PrepareProposal(*r.PrepareProposal)
-		responses <- types.ToResponsePrepareProposal(res)
-	case *types.Request_ProcessProposal:
-		res := s.app.ProcessProposal(*r.ProcessProposal)
-		responses <- types.ToResponseProcessProposal(res)
 	case *types.Request_LoadSnapshotChunk:
 		res := s.app.LoadSnapshotChunk(*r.LoadSnapshotChunk)
 		responses <- types.ToResponseLoadSnapshotChunk(res)

abci/tests/server/client.go

@@ -29,6 +29,17 @@ func InitChain(client abcicli.Client) error {
 	return nil
 }
 
+func SetOption(client abcicli.Client, key, value string) error {
+	_, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: value})
+	if err != nil {
+		fmt.Println("Failed test: SetOption")
+		fmt.Printf("error while setting %v=%v: \nerror: %v\n", key, value, err)
+		return err
+	}
+	fmt.Println("Passed test: SetOption")
+	return nil
+}
+
 func Commit(client abcicli.Client, hashExp []byte) error {
 	res, err := client.CommitSync()
 	data := res.Data

abci/tests/test_cli/ex2.abci.out

@@ -1,4 +1,6 @@
 > set_option serial on
+-> code: OK
+-> log: OK (SetOption doesn't return anything.)
 
 > check_tx 0x00
 -> code: OK

abci/types/application.go

@@ -4,24 +4,21 @@ import (
 	context "golang.org/x/net/context"
 )
 
-//go:generate ../../scripts/mockery_generate.sh Application
-
 // Application is an interface that enables any finite, deterministic state machine
 // to be driven by a blockchain-based replication engine via the ABCI.
 // All methods take a RequestXxx argument and return a ResponseXxx argument,
 // except CheckTx/DeliverTx, which take `tx []byte`, and `Commit`, which takes nothing.
 type Application interface {
 	// Info/Query Connection
-	Info(RequestInfo) ResponseInfo    // Return application info
-	Query(RequestQuery) ResponseQuery // Query for state
+	Info(RequestInfo) ResponseInfo                // Return application info
+	SetOption(RequestSetOption) ResponseSetOption // Set application option
+	Query(RequestQuery) ResponseQuery             // Query for state
 
 	// Mempool Connection
 	CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool
 
 	// Consensus Connection
-	InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
-	PrepareProposal(RequestPrepareProposal) ResponsePrepareProposal
-	ProcessProposal(RequestProcessProposal) ResponseProcessProposal
+	InitChain(RequestInitChain) ResponseInitChain    // Initialize blockchain w validators/other info from TendermintCore
 	BeginBlock(RequestBeginBlock) ResponseBeginBlock // Signals the beginning of a block
 	DeliverTx(RequestDeliverTx) ResponseDeliverTx    // Deliver a tx for full processing
 	EndBlock(RequestEndBlock) ResponseEndBlock       // Signals the end of a block, returns changes to the validator set
@@ -50,6 +47,10 @@ func (BaseApplication) Info(req RequestInfo) ResponseInfo {
 	return ResponseInfo{}
 }
 
+func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption {
+	return ResponseSetOption{}
+}
+
 func (BaseApplication) DeliverTx(req RequestDeliverTx) ResponseDeliverTx {
 	return ResponseDeliverTx{Code: CodeTypeOK}
 }
@@ -94,27 +95,6 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
 	return ResponseApplySnapshotChunk{}
 }
 
-func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
-	trs := make([]*TxRecord, 0, len(req.Txs))
-	var totalBytes int64
-	for _, tx := range req.Txs {
-		totalBytes += int64(len(tx))
-		if totalBytes > req.MaxTxBytes {
-			break
-		}
-		trs = append(trs, &TxRecord{
-			Action: TxRecord_UNMODIFIED,
-			Tx:     tx,
-		})
-	}
-	return ResponsePrepareProposal{TxRecords: trs}
-}
-
-func (BaseApplication) ProcessProposal(req RequestProcessProposal) ResponseProcessProposal {
-	return ResponseProcessProposal{
-		Status: ResponseProcessProposal_ACCEPT}
-}
-
 //-------------------------------------------------------
 
 // GRPCApplication is a GRPC wrapper for Application
@@ -139,6 +119,11 @@ func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*Respon
 	return &res, nil
 }
 
+func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) {
+	res := app.app.SetOption(*req)
+	return &res, nil
+}
+
 func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
 	res := app.app.DeliverTx(*req)
 	return &res, nil
@@ -197,15 +182,3 @@ func (app *GRPCApplication) ApplySnapshotChunk(
 	res := app.app.ApplySnapshotChunk(*req)
 	return &res, nil
 }
-
-func (app *GRPCApplication) PrepareProposal(
-	ctx context.Context, req *RequestPrepareProposal) (*ResponsePrepareProposal, error) {
-	res := app.app.PrepareProposal(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) ProcessProposal(
-	ctx context.Context, req *RequestProcessProposal) (*ResponseProcessProposal, error) {
-	res := app.app.ProcessProposal(*req)
-	return &res, nil
-}

abci/types/messages.go

@@ -48,6 +48,12 @@ func ToRequestInfo(req RequestInfo) *Request {
 	}
 }
 
+func ToRequestSetOption(req RequestSetOption) *Request {
+	return &Request{
+		Value: &Request_SetOption{&req},
+	}
+}
+
 func ToRequestDeliverTx(req RequestDeliverTx) *Request {
 	return &Request{
 		Value: &Request_DeliverTx{&req},
@@ -114,18 +120,6 @@ func ToRequestApplySnapshotChunk(req RequestApplySnapshotChunk) *Request {
 	}
 }
 
-func ToRequestPrepareProposal(req RequestPrepareProposal) *Request {
-	return &Request{
-		Value: &Request_PrepareProposal{&req},
-	}
-}
-
-func ToRequestProcessProposal(req RequestProcessProposal) *Request {
-	return &Request{
-		Value: &Request_ProcessProposal{&req},
-	}
-}
-
 //----------------------------------------
 
 func ToResponseException(errStr string) *Response {
@@ -152,6 +146,12 @@ func ToResponseInfo(res ResponseInfo) *Response {
 	}
 }
 
+func ToResponseSetOption(res ResponseSetOption) *Response {
+	return &Response{
+		Value: &Response_SetOption{&res},
+	}
+}
+
 func ToResponseDeliverTx(res ResponseDeliverTx) *Response {
 	return &Response{
 		Value: &Response_DeliverTx{&res},
@@ -217,15 +217,3 @@ func ToResponseApplySnapshotChunk(res ResponseApplySnapshotChunk) *Response {
 		Value: &Response_ApplySnapshotChunk{&res},
 	}
 }
-
-func ToResponsePrepareProposal(res ResponsePrepareProposal) *Response {
-	return &Response{
-		Value: &Response_PrepareProposal{&res},
-	}
-}
-
-func ToResponseProcessProposal(res ResponseProcessProposal) *Response {
-	return &Response{
-		Value: &Response_ProcessProposal{&res},
-	}
-}

abci/types/mocks/application.go

@@ -1,238 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	types "github.com/tendermint/tendermint/abci/types"
-)
-
-// Application is an autogenerated mock type for the Application type
-type Application struct {
-	mock.Mock
-}
-
-// ApplySnapshotChunk provides a mock function with given fields: _a0
-func (_m *Application) ApplySnapshotChunk(_a0 types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseApplySnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseApplySnapshotChunk)
-	}
-
-	return r0
-}
-
-// BeginBlock provides a mock function with given fields: _a0
-func (_m *Application) BeginBlock(_a0 types.RequestBeginBlock) types.ResponseBeginBlock {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseBeginBlock
-	if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) types.ResponseBeginBlock); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseBeginBlock)
-	}
-
-	return r0
-}
-
-// CheckTx provides a mock function with given fields: _a0
-func (_m *Application) CheckTx(_a0 types.RequestCheckTx) types.ResponseCheckTx {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseCheckTx
-	if rf, ok := ret.Get(0).(func(types.RequestCheckTx) types.ResponseCheckTx); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseCheckTx)
-	}
-
-	return r0
-}
-
-// Commit provides a mock function with given fields:
-func (_m *Application) Commit() types.ResponseCommit {
-	ret := _m.Called()
-
-	var r0 types.ResponseCommit
-	if rf, ok := ret.Get(0).(func() types.ResponseCommit); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(types.ResponseCommit)
-	}
-
-	return r0
-}
-
-// DeliverTx provides a mock function with given fields: _a0
-func (_m *Application) DeliverTx(_a0 types.RequestDeliverTx) types.ResponseDeliverTx {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseDeliverTx
-	if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) types.ResponseDeliverTx); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseDeliverTx)
-	}
-
-	return r0
-}
-
-// EndBlock provides a mock function with given fields: _a0
-func (_m *Application) EndBlock(_a0 types.RequestEndBlock) types.ResponseEndBlock {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseEndBlock
-	if rf, ok := ret.Get(0).(func(types.RequestEndBlock) types.ResponseEndBlock); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseEndBlock)
-	}
-
-	return r0
-}
-
-// Info provides a mock function with given fields: _a0
-func (_m *Application) Info(_a0 types.RequestInfo) types.ResponseInfo {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseInfo
-	if rf, ok := ret.Get(0).(func(types.RequestInfo) types.ResponseInfo); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseInfo)
-	}
-
-	return r0
-}
-
-// InitChain provides a mock function with given fields: _a0
-func (_m *Application) InitChain(_a0 types.RequestInitChain) types.ResponseInitChain {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseInitChain
-	if rf, ok := ret.Get(0).(func(types.RequestInitChain) types.ResponseInitChain); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseInitChain)
-	}
-
-	return r0
-}
-
-// ListSnapshots provides a mock function with given fields: _a0
-func (_m *Application) ListSnapshots(_a0 types.RequestListSnapshots) types.ResponseListSnapshots {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseListSnapshots
-	if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) types.ResponseListSnapshots); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseListSnapshots)
-	}
-
-	return r0
-}
-
-// LoadSnapshotChunk provides a mock function with given fields: _a0
-func (_m *Application) LoadSnapshotChunk(_a0 types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseLoadSnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseLoadSnapshotChunk)
-	}
-
-	return r0
-}
-
-// OfferSnapshot provides a mock function with given fields: _a0
-func (_m *Application) OfferSnapshot(_a0 types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseOfferSnapshot
-	if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) types.ResponseOfferSnapshot); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseOfferSnapshot)
-	}
-
-	return r0
-}
-
-// PrepareProposal provides a mock function with given fields: _a0
-func (_m *Application) PrepareProposal(_a0 types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponsePrepareProposal
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) types.ResponsePrepareProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponsePrepareProposal)
-	}
-
-	return r0
-}
-
-// ProcessProposal provides a mock function with given fields: _a0
-func (_m *Application) ProcessProposal(_a0 types.RequestProcessProposal) types.ResponseProcessProposal {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseProcessProposal
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) types.ResponseProcessProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseProcessProposal)
-	}
-
-	return r0
-}
-
-// Query provides a mock function with given fields: _a0
-func (_m *Application) Query(_a0 types.RequestQuery) types.ResponseQuery {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseQuery
-	if rf, ok := ret.Get(0).(func(types.RequestQuery) types.ResponseQuery); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseQuery)
-	}
-
-	return r0
-}
-
-// SetOption provides a mock function with given fields: _a0
-func (_m *Application) SetOption(_a0 types.RequestSetOption) types.ResponseSetOption {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseSetOption
-	if rf, ok := ret.Get(0).(func(types.RequestSetOption) types.ResponseSetOption); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseSetOption)
-	}
-
-	return r0
-}
-
-type mockConstructorTestingTNewApplication interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewApplication creates a new instance of Application. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewApplication(t mockConstructorTestingTNewApplication) *Application {
-	mock := &Application{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

abci/types/mocks/base.go

@@ -1,187 +0,0 @@
-package mocks
-
-import (
-	types "github.com/tendermint/tendermint/abci/types"
-)
-
-// BaseMock provides a wrapper around the generated Application mock and a BaseApplication.
-// BaseMock first tries to use the mock's implementation of the method.
-// If no functionality was provided for the mock by the user, BaseMock dispatches
-// to the BaseApplication and uses its functionality.
-// BaseMock allows users to provide mocked functionality for only the methods that matter
-// for their test while avoiding a panic if the code calls Application methods that are
-// not relevant to the test.
-type BaseMock struct {
-	base *types.BaseApplication
-	*Application
-}
-
-func NewBaseMock() BaseMock {
-	return BaseMock{
-		base:        types.NewBaseApplication(),
-		Application: new(Application),
-	}
-}
-
-// Info/Query Connection
-// Return application info
-func (m BaseMock) Info(input types.RequestInfo) types.ResponseInfo {
-	var ret types.ResponseInfo
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Info(input)
-		}
-	}()
-	ret = m.Application.Info(input)
-	return ret
-}
-
-func (m BaseMock) Query(input types.RequestQuery) types.ResponseQuery {
-	var ret types.ResponseQuery
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Query(input)
-		}
-	}()
-	ret = m.Application.Query(input)
-	return ret
-}
-
-// Mempool Connection
-// Validate a tx for the mempool
-func (m BaseMock) CheckTx(input types.RequestCheckTx) types.ResponseCheckTx {
-	var ret types.ResponseCheckTx
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.CheckTx(input)
-		}
-	}()
-	ret = m.Application.CheckTx(input)
-	return ret
-}
-
-// Consensus Connection
-// Initialize blockchain w validators/other info from TendermintCore
-func (m BaseMock) InitChain(input types.RequestInitChain) types.ResponseInitChain {
-	var ret types.ResponseInitChain
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.InitChain(input)
-		}
-	}()
-	ret = m.Application.InitChain(input)
-	return ret
-}
-
-func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	var ret types.ResponsePrepareProposal
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.PrepareProposal(input)
-		}
-	}()
-	ret = m.Application.PrepareProposal(input)
-	return ret
-}
-
-func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) types.ResponseProcessProposal {
-	var ret types.ResponseProcessProposal
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ProcessProposal(input)
-		}
-	}()
-	ret = m.Application.ProcessProposal(input)
-	return ret
-}
-
-// Commit the state and return the application Merkle root hash
-func (m BaseMock) Commit() types.ResponseCommit {
-	var ret types.ResponseCommit
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Commit()
-		}
-	}()
-	ret = m.Application.Commit()
-	return ret
-}
-
-// State Sync Connection
-// List available snapshots
-func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) types.ResponseListSnapshots {
-	var ret types.ResponseListSnapshots
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ListSnapshots(input)
-		}
-	}()
-	ret = m.Application.ListSnapshots(input)
-	return ret
-}
-
-func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
-	var ret types.ResponseOfferSnapshot
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.OfferSnapshot(input)
-		}
-	}()
-	ret = m.Application.OfferSnapshot(input)
-	return ret
-}
-
-func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk {
-	var ret types.ResponseLoadSnapshotChunk
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.LoadSnapshotChunk(input)
-		}
-	}()
-	ret = m.Application.LoadSnapshotChunk(input)
-	return ret
-}
-
-func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
-	var ret types.ResponseApplySnapshotChunk
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ApplySnapshotChunk(input)
-		}
-	}()
-	ret = m.Application.ApplySnapshotChunk(input)
-	return ret
-}
-
-func (m BaseMock) BeginBlock(input types.RequestBeginBlock) types.ResponseBeginBlock {
-	var ret types.ResponseBeginBlock
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.BeginBlock(input)
-		}
-	}()
-	ret = m.Application.BeginBlock(input)
-	return ret
-}
-
-func (m BaseMock) DeliverTx(input types.RequestDeliverTx) types.ResponseDeliverTx {
-	var ret types.ResponseDeliverTx
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.DeliverTx(input)
-		}
-	}()
-	ret = m.Application.DeliverTx(input)
-	return ret
-}
-
-func (m BaseMock) EndBlock(input types.RequestEndBlock) types.ResponseEndBlock {
-	var ret types.ResponseEndBlock
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.EndBlock(input)
-		}
-	}()
-	ret = m.Application.EndBlock(input)
-	return ret
-}

abci/types/result.go

@@ -41,16 +41,6 @@ func (r ResponseQuery) IsErr() bool {
 	return r.Code != CodeTypeOK
 }
 
-// IsAccepted returns true if Code is ACCEPT
-func (r ResponseProcessProposal) IsAccepted() bool {
-	return r.Status == ResponseProcessProposal_ACCEPT
-}
-
-// IsStatusUnknown returns true if Code is UNKNOWN
-func (r ResponseProcessProposal) IsStatusUnknown() bool {
-	return r.Status == ResponseProcessProposal_UNKNOWN
-}
-
 //---------------------------------------------------------------------------
 // override JSON marshaling so we emit defaults (ie. disable omitempty)
 
@@ -62,6 +52,16 @@ var (
 	jsonpbUnmarshaller = jsonpb.Unmarshaler{}
 )
 
+func (r *ResponseSetOption) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseSetOption) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
 func (r *ResponseCheckTx) MarshalJSON() ([]byte, error) {
 	s, err := jsonpbMarshaller.MarshalToString(r)
 	return []byte(s), err
@@ -126,5 +126,6 @@ var _ jsonRoundTripper = (*ResponseCommit)(nil)
 var _ jsonRoundTripper = (*ResponseQuery)(nil)
 var _ jsonRoundTripper = (*ResponseDeliverTx)(nil)
 var _ jsonRoundTripper = (*ResponseCheckTx)(nil)
+var _ jsonRoundTripper = (*ResponseSetOption)(nil)
 
 var _ jsonRoundTripper = (*EventAttribute)(nil)

blocksync/msgs.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"errors"
@@ -6,7 +6,7 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	"github.com/tendermint/tendermint/types"
 )
 

blocksync/msgs_test.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync_test
 
 import (
 	"encoding/hex"
@@ -9,7 +9,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/blocksync"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -28,7 +29,7 @@ func TestBcBlockRequestMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			request := bcproto.BlockRequest{Height: tc.requestHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&request) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&request) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
@@ -48,14 +49,14 @@ func TestBcNoBlockResponseMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			nonResponse := bcproto.NoBlockResponse{Height: tc.nonResponseHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
 
 func TestBcStatusRequestMessageValidateBasic(t *testing.T) {
 	request := bcproto.StatusRequest{}
-	assert.NoError(t, ValidateMsg(&request))
+	assert.NoError(t, blocksync.ValidateMsg(&request))
 }
 
 func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
@@ -73,12 +74,12 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			response := bcproto.StatusResponse{Height: tc.responseHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&response) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&response) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
 
-// nolint:lll // ignore line length in tests
+//nolint:lll // ignore line length in tests
 func TestBlockchainMessageVectors(t *testing.T) {
 	block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil)
 	block.Version.Block = 11 // overwrite updated protocol version

blocksync/pool.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"errors"
@@ -58,7 +58,7 @@ var peerTimeout = 15 * time.Second // not const so we can override with tests
 	are not at peer limits, we can probably switch to consensus reactor
 */
 
-// BlockPool keeps track of the fast sync peers, block requests and block responses.
+// BlockPool keeps track of the block sync peers, block requests and block responses.
 type BlockPool struct {
 	service.BaseService
 	startTime time.Time
@@ -410,7 +410,7 @@ func (pool *BlockPool) sendError(err error, peerID p2p.ID) {
 }
 
 // for debugging purposes
-//nolint:unused
+
 func (pool *BlockPool) debug() string {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()

blocksync/pool_test.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"

blocksync/reactor.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"
@@ -7,15 +7,15 @@ import (
 
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 )
 
 const (
-	// BlockchainChannel is a channel for blocks and status updates (`BlockStore` height)
-	BlockchainChannel = byte(0x40)
+	// BlocksyncChannel is a channel for blocks and status updates (`BlockStore` height)
+	BlocksyncChannel = byte(0x40)
 
 	trySyncIntervalMS = 10
 
@@ -30,7 +30,7 @@ const (
 )
 
 type consensusReactor interface {
-	// for when we switch from blockchain reactor and fast sync to
+	// for when we switch from blockchain reactor and block sync to
 	// the consensus machine
 	SwitchToConsensus(state sm.State, skipWAL bool)
 }
@@ -54,7 +54,7 @@ type Reactor struct {
 	blockExec *sm.BlockExecutor
 	store     *store.BlockStore
 	pool      *BlockPool
-	fastSync  bool
+	blockSync bool
 
 	requestsCh <-chan BlockRequest
 	errorsCh   <-chan peerError
@@ -62,7 +62,7 @@ type Reactor struct {
 
 // NewReactor returns new reactor instance.
 func NewReactor(state sm.State, blockExec *sm.BlockExecutor, store *store.BlockStore,
-	fastSync bool) *Reactor {
+	blockSync bool) *Reactor {
 
 	if state.LastBlockHeight != store.Height() {
 		panic(fmt.Sprintf("state (%v) and store (%v) height mismatch", state.LastBlockHeight,
@@ -85,7 +85,7 @@ func NewReactor(state sm.State, blockExec *sm.BlockExecutor, store *store.BlockS
 		blockExec:    blockExec,
 		store:        store,
 		pool:         pool,
-		fastSync:     fastSync,
+		blockSync:    blockSync,
 		requestsCh:   requestsCh,
 		errorsCh:     errorsCh,
 	}
@@ -101,7 +101,7 @@ func (bcR *Reactor) SetLogger(l log.Logger) {
 
 // OnStart implements service.Service.
 func (bcR *Reactor) OnStart() error {
-	if bcR.fastSync {
+	if bcR.blockSync {
 		err := bcR.pool.Start()
 		if err != nil {
 			return err
@@ -111,9 +111,9 @@ func (bcR *Reactor) OnStart() error {
 	return nil
 }
 
-// SwitchToFastSync is called by the state sync reactor when switching to fast sync.
-func (bcR *Reactor) SwitchToFastSync(state sm.State) error {
-	bcR.fastSync = true
+// SwitchToBlockSync is called by the state sync reactor when switching to block sync.
+func (bcR *Reactor) SwitchToBlockSync(state sm.State) error {
+	bcR.blockSync = true
 	bcR.initialState = state
 
 	bcR.pool.height = state.LastBlockHeight + 1
@@ -127,7 +127,7 @@ func (bcR *Reactor) SwitchToFastSync(state sm.State) error {
 
 // OnStop implements service.Service.
 func (bcR *Reactor) OnStop() {
-	if bcR.fastSync {
+	if bcR.blockSync {
 		if err := bcR.pool.Stop(); err != nil {
 			bcR.Logger.Error("Error stopping pool", "err", err)
 		}
@@ -138,7 +138,7 @@ func (bcR *Reactor) OnStop() {
 func (bcR *Reactor) GetChannels() []*p2p.ChannelDescriptor {
 	return []*p2p.ChannelDescriptor{
 		{
-			ID:                  BlockchainChannel,
+			ID:                  BlocksyncChannel,
 			Priority:            5,
 			SendQueueCapacity:   1000,
 			RecvBufferCapacity:  50 * 4096,
@@ -157,7 +157,7 @@ func (bcR *Reactor) AddPeer(peer p2p.Peer) {
 		return
 	}
 
-	peer.Send(BlockchainChannel, msgBytes)
+	peer.Send(BlocksyncChannel, msgBytes)
 	// it's OK if send fails. will try later in poolRoutine
 
 	// peer is added to the pool once we receive the first
@@ -188,7 +188,7 @@ func (bcR *Reactor) respondToPeer(msg *bcproto.BlockRequest,
 			return false
 		}
 
-		return src.TrySend(BlockchainChannel, msgBytes)
+		return src.TrySend(BlocksyncChannel, msgBytes)
 	}
 
 	bcR.Logger.Info("Peer asking for a block we don't have", "src", src, "height", msg.Height)
@@ -199,7 +199,7 @@ func (bcR *Reactor) respondToPeer(msg *bcproto.BlockRequest,
 		return false
 	}
 
-	return src.TrySend(BlockchainChannel, msgBytes)
+	return src.TrySend(BlocksyncChannel, msgBytes)
 }
 
 // Receive implements Reactor by handling 4 types of messages (look below).
@@ -239,7 +239,7 @@ func (bcR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 			bcR.Logger.Error("could not convert msg to protobut", "err", err)
 			return
 		}
-		src.TrySend(BlockchainChannel, msgBytes)
+		src.TrySend(BlocksyncChannel, msgBytes)
 	case *bcproto.StatusResponse:
 		// Got a peer status. Unverified.
 		bcR.pool.SetPeerRange(src.ID(), msg.Base, msg.Height)
@@ -291,7 +291,7 @@ func (bcR *Reactor) poolRoutine(stateSynced bool) {
 					continue
 				}
 
-				queued := peer.TrySend(BlockchainChannel, msgBytes)
+				queued := peer.TrySend(BlocksyncChannel, msgBytes)
 				if !queued {
 					bcR.Logger.Debug("Send queue is full, drop block request", "peer", peer.ID(), "height", request.Height)
 				}
@@ -303,7 +303,7 @@ func (bcR *Reactor) poolRoutine(stateSynced bool) {
 
 			case <-statusUpdateTicker.C:
 				// ask for status updates
-				go bcR.BroadcastStatusRequest() // nolint: errcheck
+				go bcR.BroadcastStatusRequest() //nolint: errcheck
 
 			}
 		}
@@ -359,20 +359,14 @@ FOR_LOOP:
 				didProcessCh <- struct{}{}
 			}
 
-			firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
-			if err != nil {
-				bcR.Logger.Error("failed to make ",
-					"height", first.Height,
-					"err", err.Error())
-				break FOR_LOOP
-			}
+			firstParts := first.MakePartSet(types.BlockPartSizeBytes)
 			firstPartSetHeader := firstParts.Header()
 			firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 			// Finally, verify the first block using the second's commit
 			// NOTE: we can probably make this more efficient, but note that calling
 			// first.Hash() doesn't verify the tx contents, so MakePartSet() is
 			// currently necessary.
-			err = state.Validators.VerifyCommitLight(
+			err := state.Validators.VerifyCommitLight(
 				chainID, firstID, first.Height, second.LastCommit)
 
 			if err == nil {
@@ -415,7 +409,7 @@ FOR_LOOP:
 
 			if blocksSynced%100 == 0 {
 				lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
-				bcR.Logger.Info("Fast Sync Rate", "height", bcR.pool.height,
+				bcR.Logger.Info("Block Sync Rate", "height", bcR.pool.height,
 					"max_peer_height", bcR.pool.MaxPeerHeight(), "blocks/s", lastRate)
 				lastHundred = time.Now()
 			}
@@ -436,7 +430,7 @@ func (bcR *Reactor) BroadcastStatusRequest() error {
 		return fmt.Errorf("could not convert msg to proto: %w", err)
 	}
 
-	bcR.Switch.Broadcast(BlockchainChannel, bm)
+	bcR.Switch.Broadcast(BlocksyncChannel, bm)
 
 	return nil
 }

blocksync/reactor_test.go

@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"
@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
 	dbm "github.com/tendermint/tm-db"
@@ -16,11 +15,10 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
-	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
+	"github.com/tendermint/tendermint/mempool/mock"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -72,7 +70,9 @@ func newReactor(
 
 	blockDB := dbm.NewMemDB()
 	stateDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	blockStore := store.NewBlockStore(blockDB)
 
 	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
@@ -85,9 +85,11 @@ func newReactor(
 	// pool.height is determined from the store.
 	fastSync := true
 	db := dbm.NewMemDB()
-	stateStore = sm.NewStore(db)
+	stateStore = sm.NewStore(db, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mp, sm.EmptyEvidencePool{})
+		mock.Mempool{}, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -114,10 +116,9 @@ func newReactor(
 				lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
 		}
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
+		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
-		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -215,6 +216,7 @@ func TestBadBlockStopsPeer(t *testing.T) {
 	}()
 
 	reactorPairs := make([]ReactorPair, 4)
+
 	reactorPairs[0] = newReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
 	reactorPairs[1] = newReactor(log.TestingLogger(), genDoc, privVals, 0)
 	reactorPairs[2] = newReactor(log.TestingLogger(), genDoc, privVals, 0)
@@ -280,6 +282,21 @@ func TestBadBlockStopsPeer(t *testing.T) {
 	assert.True(t, lastReactorPair.reactor.Switch.Peers().Size() < len(reactorPairs)-1)
 }
 
+//----------------------------------------------
+// utility funcs
+
+func makeTxs(height int64) (txs []types.Tx) {
+	for i := 0; i < 10; i++ {
+		txs = append(txs, types.Tx([]byte{byte(height), byte(i)}))
+	}
+	return txs
+}
+
+func makeBlock(height int64, state sm.State, lastCommit *types.Commit) *types.Block {
+	block, _ := state.MakeBlock(height, makeTxs(height), lastCommit, nil, state.Validators.GetProposer().Address)
+	return block
+}
+
 type testApp struct {
 	abci.BaseApplication
 }

cmd/tendermint/commands/debug/kill.go

@@ -104,7 +104,7 @@ func killProc(pid uint64, dir string) error {
 	// pipe STDERR output from tailing the Tendermint process to a file
 	//
 	// NOTE: This will only work on UNIX systems.
-	cmd := exec.Command("tail", "-f", fmt.Sprintf("/proc/%d/fd/2", pid)) // nolint: gosec
+	cmd := exec.Command("tail", "-f", fmt.Sprintf("/proc/%d/fd/2", pid)) //nolint: gosec
 
 	outFile, err := os.Create(filepath.Join(dir, "stacktrace.out"))
 	if err != nil {

cmd/tendermint/commands/debug/util.go

@@ -67,7 +67,7 @@ func copyConfig(home, dir string) error {
 func dumpProfile(dir, addr, profile string, debug int) error {
 	endpoint := fmt.Sprintf("%s/debug/pprof/%s?debug=%d", addr, profile, debug)
 
-	resp, err := http.Get(endpoint) // nolint: gosec
+	resp, err := http.Get(endpoint) //nolint: gosec
 	if err != nil {
 		return fmt.Errorf("failed to query for %s profile: %w", profile, err)
 	}

cmd/tendermint/commands/reindex_event.go

@@ -40,6 +40,9 @@ replace the backend. The default start-height is 0, meaning the tooling will sta
 reindex from the base block height(inclusive); and the default end-height is 0, meaning 
 the tooling will reindex until the latest block height(inclusive). User can omit
 either or both arguments.
+
+Note: This operation requires ABCIResponses. Do not set DiscardABCIResponses to true if you
+want to use this command.
 	`,
 	Example: `
 	tendermint reindex-event

cmd/tendermint/commands/reindex_event_test.go

@@ -9,8 +9,6 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	dbm "github.com/tendermint/tm-db"
-
 	abcitypes "github.com/tendermint/tendermint/abci/types"
 	tmcfg "github.com/tendermint/tendermint/config"
 	prototmstate "github.com/tendermint/tendermint/proto/tendermint/state"
@@ -18,6 +16,7 @@ import (
 	"github.com/tendermint/tendermint/state/mocks"
 	txmocks "github.com/tendermint/tendermint/state/txindex/mocks"
 	"github.com/tendermint/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
 )
 
 const (

cmd/tendermint/commands/rollback.go

@@ -77,7 +77,9 @@ func loadStateAndBlockStore(config *cfg.Config) (*store.BlockStore, state.Store,
 	if err != nil {
 		return nil, nil, err
 	}
-	stateStore := state.NewStore(stateDB)
+	stateStore := state.NewStore(stateDB, state.StoreOptions{
+		DiscardABCIResponses: config.Storage.DiscardABCIResponses,
+	})
 
 	return blockStore, stateStore, nil
 }

cmd/tendermint/commands/root.go

@@ -53,6 +53,11 @@ func ParseConfig(cmd *cobra.Command) (*cfg.Config, error) {
 	if err := conf.ValidateBasic(); err != nil {
 		return nil, fmt.Errorf("error in config file: %v", err)
 	}
+	if warnings := conf.CheckDeprecated(); len(warnings) > 0 {
+		for _, warning := range warnings {
+			logger.Info("deprecated usage found in configuration file", "usage", warning)
+		}
+	}
 	return conf, nil
 }
 

cmd/tendermint/commands/run_node.go

@@ -31,7 +31,7 @@ func AddNodeFlags(cmd *cobra.Command) {
 		"socket address to listen on for connections from external priv_validator process")
 
 	// node flags
-	cmd.Flags().Bool("fast_sync", config.FastSyncMode, "fast blockchain syncing")
+	cmd.Flags().Bool("block_sync", config.BlockSyncMode, "sync the block chain using the blocksync algorithm")
 	cmd.Flags().BytesHexVar(
 		&genesisHash,
 		"genesis_hash",

config/config.go

@@ -68,14 +68,18 @@ type Config struct {
 	BaseConfig `mapstructure:",squash"`
 
 	// Options for services
-	RPC             *RPCConfig             `mapstructure:"rpc"`
-	P2P             *P2PConfig             `mapstructure:"p2p"`
-	Mempool         *MempoolConfig         `mapstructure:"mempool"`
-	StateSync       *StateSyncConfig       `mapstructure:"statesync"`
-	FastSync        *FastSyncConfig        `mapstructure:"fastsync"`
-	Consensus       *ConsensusConfig       `mapstructure:"consensus"`
-	TxIndex         *TxIndexConfig         `mapstructure:"tx_index"`
-	Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"`
+	RPC       *RPCConfig       `mapstructure:"rpc"`
+	P2P       *P2PConfig       `mapstructure:"p2p"`
+	Mempool   *MempoolConfig   `mapstructure:"mempool"`
+	StateSync *StateSyncConfig `mapstructure:"statesync"`
+	BlockSync *BlockSyncConfig `mapstructure:"blocksync"`
+	//TODO(williambanfield): remove this field once v0.37 is released.
+	// https://github.com/tendermint/tendermint/issues/9279
+	DeprecatedFastSyncConfig map[interface{}]interface{} `mapstructure:"fastsync"`
+	Consensus                *ConsensusConfig            `mapstructure:"consensus"`
+	Storage                  *StorageConfig              `mapstructure:"storage"`
+	TxIndex                  *TxIndexConfig              `mapstructure:"tx_index"`
+	Instrumentation          *InstrumentationConfig      `mapstructure:"instrumentation"`
 }
 
 // DefaultConfig returns a default configuration for a Tendermint node
@@ -86,8 +90,9 @@ func DefaultConfig() *Config {
 		P2P:             DefaultP2PConfig(),
 		Mempool:         DefaultMempoolConfig(),
 		StateSync:       DefaultStateSyncConfig(),
-		FastSync:        DefaultFastSyncConfig(),
+		BlockSync:       DefaultBlockSyncConfig(),
 		Consensus:       DefaultConsensusConfig(),
+		Storage:         DefaultStorageConfig(),
 		TxIndex:         DefaultTxIndexConfig(),
 		Instrumentation: DefaultInstrumentationConfig(),
 	}
@@ -101,8 +106,9 @@ func TestConfig() *Config {
 		P2P:             TestP2PConfig(),
 		Mempool:         TestMempoolConfig(),
 		StateSync:       TestStateSyncConfig(),
-		FastSync:        TestFastSyncConfig(),
+		BlockSync:       TestBlockSyncConfig(),
 		Consensus:       TestConsensusConfig(),
+		Storage:         TestStorageConfig(),
 		TxIndex:         TestTxIndexConfig(),
 		Instrumentation: TestInstrumentationConfig(),
 	}
@@ -136,8 +142,8 @@ func (cfg *Config) ValidateBasic() error {
 	if err := cfg.StateSync.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [statesync] section: %w", err)
 	}
-	if err := cfg.FastSync.ValidateBasic(); err != nil {
-		return fmt.Errorf("error in [fastsync] section: %w", err)
+	if err := cfg.BlockSync.ValidateBasic(); err != nil {
+		return fmt.Errorf("error in [blocksync] section: %w", err)
 	}
 	if err := cfg.Consensus.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [consensus] section: %w", err)
@@ -148,6 +154,17 @@ func (cfg *Config) ValidateBasic() error {
 	return nil
 }
 
+func (cfg *Config) CheckDeprecated() []string {
+	var warnings []string
+	if cfg.DeprecatedFastSyncConfig != nil {
+		warnings = append(warnings, "[fastsync] table detected. This section has been renamed to [blocksync]. The values in this deprecated section will be disregarded.")
+	}
+	if cfg.BaseConfig.DeprecatedFastSyncMode != nil {
+		warnings = append(warnings, "fast_sync key detected. This key has been renamed to block_sync. The value of this deprecated key will be disregarded.")
+	}
+	return warnings
+}
+
 //-----------------------------------------------------------------------------
 // BaseConfig
 
@@ -167,10 +184,14 @@ type BaseConfig struct { //nolint: maligned
 	// A custom human readable name for this node
 	Moniker string `mapstructure:"moniker"`
 
-	// If this node is many blocks behind the tip of the chain, FastSync
+	// If this node is many blocks behind the tip of the chain, Blocksync
 	// allows them to catchup quickly by downloading blocks in parallel
 	// and verifying their commits
-	FastSyncMode bool `mapstructure:"fast_sync"`
+	BlockSyncMode bool `mapstructure:"block_sync"`
+
+	//TODO(williambanfield): remove this field once v0.37 is released.
+	// https://github.com/tendermint/tendermint/issues/9279
+	DeprecatedFastSyncMode interface{} `mapstructure:"fast_sync"`
 
 	// Database backend: goleveldb | cleveldb | boltdb | rocksdb
 	// * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
@@ -238,7 +259,7 @@ func DefaultBaseConfig() BaseConfig {
 		ABCI:               "socket",
 		LogLevel:           DefaultLogLevel,
 		LogFormat:          LogFormatPlain,
-		FastSyncMode:       true,
+		BlockSyncMode:      true,
 		FilterPeers:        false,
 		DBBackend:          "goleveldb",
 		DBPath:             "data",
@@ -250,7 +271,7 @@ func TestBaseConfig() BaseConfig {
 	cfg := DefaultBaseConfig()
 	cfg.chainID = "tendermint_test"
 	cfg.ProxyApp = "kvstore"
-	cfg.FastSyncMode = false
+	cfg.BlockSyncMode = false
 	cfg.DBBackend = "memdb"
 	return cfg
 }
@@ -817,7 +838,7 @@ func DefaultStateSyncConfig() *StateSyncConfig {
 	}
 }
 
-// TestFastSyncConfig returns a default configuration for the state sync service
+// TestStateSyncConfig returns a default configuration for the state sync service
 func TestStateSyncConfig() *StateSyncConfig {
 	return DefaultStateSyncConfig()
 }
@@ -873,34 +894,34 @@ func (cfg *StateSyncConfig) ValidateBasic() error {
 }
 
 //-----------------------------------------------------------------------------
-// FastSyncConfig
+// BlockSyncConfig
 
-// FastSyncConfig defines the configuration for the Tendermint fast sync service
-type FastSyncConfig struct {
+// BlockSyncConfig (formerly known as FastSync) defines the configuration for the Tendermint block sync service
+type BlockSyncConfig struct {
 	Version string `mapstructure:"version"`
 }
 
-// DefaultFastSyncConfig returns a default configuration for the fast sync service
-func DefaultFastSyncConfig() *FastSyncConfig {
-	return &FastSyncConfig{
+// DefaultBlockSyncConfig returns a default configuration for the block sync service
+func DefaultBlockSyncConfig() *BlockSyncConfig {
+	return &BlockSyncConfig{
 		Version: "v0",
 	}
 }
 
-// TestFastSyncConfig returns a default configuration for the fast sync.
-func TestFastSyncConfig() *FastSyncConfig {
-	return DefaultFastSyncConfig()
+// TestBlockSyncConfig returns a default configuration for the block sync.
+func TestBlockSyncConfig() *BlockSyncConfig {
+	return DefaultBlockSyncConfig()
 }
 
 // ValidateBasic performs basic validation.
-func (cfg *FastSyncConfig) ValidateBasic() error {
+func (cfg *BlockSyncConfig) ValidateBasic() error {
 	switch cfg.Version {
 	case "v0":
 		return nil
 	case "v1", "v2":
-		return fmt.Errorf("fast sync version %s has been deprecated. Please use v0 instead", cfg.Version)
+		return fmt.Errorf("blocksync version %s has been deprecated. Please use v0 instead", cfg.Version)
 	default:
-		return fmt.Errorf("unknown fastsync version %s", cfg.Version)
+		return fmt.Errorf("unknown blocksync version %s", cfg.Version)
 	}
 }
 
@@ -1069,11 +1090,40 @@ func (cfg *ConsensusConfig) ValidateBasic() error {
 }
 
 //-----------------------------------------------------------------------------
+// StorageConfig
+
+// StorageConfig allows more fine-grained control over certain storage-related
+// behavior.
+type StorageConfig struct {
+	// Set to false to ensure ABCI responses are persisted. ABCI responses are
+	// required for `/block_results` RPC queries, and to reindex events in the
+	// command-line tool.
+	DiscardABCIResponses bool `mapstructure:"discard_abci_responses"`
+}
+
+// DefaultStorageConfig returns the default configuration options relating to
+// Tendermint storage optimization.
+func DefaultStorageConfig() *StorageConfig {
+	return &StorageConfig{
+		DiscardABCIResponses: false,
+	}
+}
+
+// TestStorageConfig returns storage configuration that can be used for
+// testing.
+func TestStorageConfig() *StorageConfig {
+	return &StorageConfig{
+		DiscardABCIResponses: false,
+	}
+}
+
 // TxIndexConfig
 // Remember that Event has the following structure:
 // type: [
-//  key: value,
-//  ...
+//	...
+//	key: value,
+//	...
+//
 // ]
 //
 // CompositeKeys are constructed by `type.key`

config/config_test.go

@@ -128,8 +128,8 @@ func TestStateSyncConfigValidateBasic(t *testing.T) {
 	require.NoError(t, cfg.ValidateBasic())
 }
 
-func TestFastSyncConfigValidateBasic(t *testing.T) {
-	cfg := TestFastSyncConfig()
+func TestBlockSyncConfigValidateBasic(t *testing.T) {
+	cfg := TestBlockSyncConfig()
 	assert.NoError(t, cfg.ValidateBasic())
 
 	// tamper with version
@@ -140,8 +140,8 @@ func TestFastSyncConfigValidateBasic(t *testing.T) {
 	assert.Error(t, cfg.ValidateBasic())
 }
 
+// nolint: lll
 func TestConsensusConfig_ValidateBasic(t *testing.T) {
-	// nolint: lll
 	testcases := map[string]struct {
 		modify    func(*ConsensusConfig)
 		expectErr bool
@@ -166,6 +166,7 @@ func TestConsensusConfig_ValidateBasic(t *testing.T) {
 		"PeerQueryMaj23SleepDuration negative": {func(c *ConsensusConfig) { c.PeerQueryMaj23SleepDuration = -1 }, true},
 		"DoubleSignCheckHeight negative":       {func(c *ConsensusConfig) { c.DoubleSignCheckHeight = -1 }, true},
 	}
+
 	for desc, tc := range testcases {
 		tc := tc // appease linter
 		t.Run(desc, func(t *testing.T) {

config/toml.go

@@ -87,10 +87,10 @@ proxy_app = "{{ .BaseConfig.ProxyApp }}"
 # A custom human readable name for this node
 moniker = "{{ .BaseConfig.Moniker }}"
 
-# If this node is many blocks behind the tip of the chain, FastSync
+# If this node is many blocks behind the tip of the chain, BlockSync
 # allows them to catchup quickly by downloading blocks in parallel
 # and verifying their commits
-fast_sync = {{ .BaseConfig.FastSyncMode }}
+block_sync = {{ .BaseConfig.BlockSyncMode }}
 
 # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb
 # * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
@@ -429,17 +429,17 @@ chunk_request_timeout = "{{ .StateSync.ChunkRequestTimeout }}"
 chunk_fetchers = "{{ .StateSync.ChunkFetchers }}"
 
 #######################################################
-###       Fast Sync Configuration Connections       ###
+###       Block Sync Configuration Options          ###
 #######################################################
-[fastsync]
+[blocksync]
 
-# Fast Sync version to use:
+# Block Sync version to use:
 # 
-# In v0.37, v1 and v2 of the fast sync protocol were deprecated.
+# In v0.37, v1 and v2 of the block sync protocols were deprecated.
 # Please use v0 instead.
 #
-#   1) "v0" - the default fast sync implementation
-version = "{{ .FastSync.Version }}"
+#   1) "v0" - the default block sync implementation
+version = "{{ .BlockSync.Version }}"
 
 #######################################################
 ###         Consensus Configuration Options         ###
@@ -482,6 +482,16 @@ create_empty_blocks_interval = "{{ .Consensus.CreateEmptyBlocksInterval }}"
 peer_gossip_sleep_duration = "{{ .Consensus.PeerGossipSleepDuration }}"
 peer_query_maj23_sleep_duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}"
 
+#######################################################
+###         Storage Configuration Options           ###
+#######################################################
+
+# Set to true to discard ABCI responses from the state store, which can save a
+# considerable amount of disk space. Set to false to ensure ABCI responses are
+# persisted. ABCI responses are required for /block_results RPC queries, and to
+# reindex events in the command-line tool.
+discard_abci_responses = {{ .Storage.DiscardABCIResponses}}
+
 #######################################################
 ###   Transaction Indexer Configuration Options     ###
 #######################################################

consensus/byzantine_test.go

@@ -50,7 +50,9 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 	for i := 0; i < nValidators; i++ {
 		logger := consensusLogger().With("test", "byzantine", "validator", i)
 		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB)
+		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		defer os.RemoveAll(thisConfig.RootDir)
@@ -211,11 +213,9 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		}
 		proposerAddr := lazyProposer.privValidatorPubKey.Address()
 
-		block, err := lazyProposer.blockExec.CreateProposalBlock(
-			lazyProposer.Height, lazyProposer.state, commit, proposerAddr, nil)
-		require.NoError(t, err)
-		blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		block, blockParts := lazyProposer.blockExec.CreateProposalBlock(
+			lazyProposer.Height, lazyProposer.state, commit, proposerAddr,
+		)
 
 		// Flush the WAL. Otherwise, we may not recompute the same proposal to sign,
 		// and the privValidator will refuse to sign anything.
@@ -463,10 +463,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	// Avoid sending on internalMsgQueue and running consensus state.
 
 	// Create a new proposal block from state/txs from the mempool.
-	block1, err := cs.createProposalBlock()
-	require.NoError(t, err)
-	blockParts1, err := block1.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block1, blockParts1 := cs.createProposalBlock()
 	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
 	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
 	p1 := proposal1.ToProto()
@@ -480,10 +477,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	deliverTxsRange(cs, 0, 1)
 
 	// Create a new proposal block from state/txs from the mempool.
-	block2, err := cs.createProposalBlock()
-	require.NoError(t, err)
-	blockParts2, err := block2.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block2, blockParts2 := cs.createProposalBlock()
 	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
 	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
 	p2 := proposal2.ToProto()

consensus/common_test.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/go-kit/log/term"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"path"
@@ -200,17 +199,13 @@ func startTestRound(cs *State, height int64, round int32) {
 
 // Create proposal block from cs1 but sign it with vs.
 func decideProposal(
-	t *testing.T,
 	cs1 *State,
 	vs *validatorStub,
 	height int64,
 	round int32,
 ) (proposal *types.Proposal, block *types.Block) {
 	cs1.mtx.Lock()
-	block, err := cs1.createProposalBlock()
-	require.NoError(t, err)
-	blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block, blockParts := cs1.createProposalBlock()
 	validRound := cs1.ValidRound
 	chainID := cs1.state.ChainID
 	cs1.mtx.Unlock()
@@ -431,7 +426,9 @@ func newStateWithConfigAndBlockStore(
 
 	// Make State
 	stateDB := blockDB
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	if err := stateStore.Save(state); err != nil { // for save height 1's validators info
 		panic(err)
 	}
@@ -461,16 +458,12 @@ func loadPrivValidator(config *cfg.Config) *privval.FilePV {
 }
 
 func randState(nValidators int) (*State, []*validatorStub) {
-	return randStateWithApp(nValidators, counter.NewApplication(true))
-}
-
-func randStateWithApp(nValidators int, app abci.Application) (*State, []*validatorStub) {
 	// Get State
 	state, privVals := randGenesisState(nValidators, false, 10)
 
 	vss := make([]*validatorStub, nValidators)
 
-	cs := newState(state, privVals[0], app)
+	cs := newState(state, privVals[0], kvstore.NewApplication())
 
 	for i := 0; i < nValidators; i++ {
 		vss[i] = newValidatorStub(privVals[i], int32(i))
@@ -685,33 +678,6 @@ func ensureVote(voteCh <-chan tmpubsub.Message, height int64, round int32,
 	}
 }
 
-func ensurePrevoteMatch(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32, hash []byte) {
-	t.Helper()
-	ensureVoteMatch(t, voteCh, height, round, hash, tmproto.PrevoteType)
-}
-
-func ensureVoteMatch(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32, hash []byte, voteType tmproto.SignedMsgType) {
-	t.Helper()
-	select {
-	case <-time.After(ensureTimeout):
-		t.Fatal("Timeout expired while waiting for NewVote event")
-	case msg := <-voteCh:
-		voteEvent, ok := msg.Data().(types.EventDataVote)
-		require.True(t, ok, "expected a EventDataVote, got %T. Wrong subscription channel?",
-			msg.Data())
-
-		vote := voteEvent.Vote
-		assert.Equal(t, height, vote.Height, "expected height %d, but got %d", height, vote.Height)
-		assert.Equal(t, round, vote.Round, "expected round %d, but got %d", round, vote.Round)
-		assert.Equal(t, voteType, vote.Type, "expected type %s, but got %s", voteType, vote.Type)
-		if hash == nil {
-			require.Nil(t, vote.BlockID.Hash, "Expected prevote to be for nil, got %X", vote.BlockID.Hash)
-		} else {
-			require.True(t, bytes.Equal(vote.BlockID.Hash, hash), "Expected prevote to be for %X, got %X", hash, vote.BlockID.Hash)
-		}
-	}
-}
-
 func ensurePrecommitTimeout(ch <-chan tmpubsub.Message) {
 	select {
 	case <-time.After(ensureTimeout):
@@ -752,7 +718,9 @@ func randConsensusNet(nValidators int, testName string, tickerFunc func() Timeou
 	configRootDirs := make([]string, 0, nValidators)
 	for i := 0; i < nValidators; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB)
+		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
@@ -790,7 +758,9 @@ func randConsensusNetWithPeers(
 	configRootDirs := make([]string, 0, nPeers)
 	for i := 0; i < nPeers; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB)
+		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)

consensus/mempool_test.go

@@ -113,7 +113,7 @@ func deliverTxsRange(cs *State, start, end int) {
 func TestMempoolTxConcurrentWithCommit(t *testing.T) {
 	state, privVals := randGenesisState(1, false, 10)
 	blockDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(blockDB)
+	stateStore := sm.NewStore(blockDB, sm.StoreOptions{DiscardABCIResponses: false})
 	cs := newStateWithConfigAndBlockStore(config, state, privVals[0], NewCounterApplication(), blockDB)
 	err := stateStore.Save(state)
 	require.NoError(t, err)
@@ -138,7 +138,7 @@ func TestMempoolRmBadTx(t *testing.T) {
 	state, privVals := randGenesisState(1, false, 10)
 	app := NewCounterApplication()
 	blockDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(blockDB)
+	stateStore := sm.NewStore(blockDB, sm.StoreOptions{DiscardABCIResponses: false})
 	cs := newStateWithConfigAndBlockStore(config, state, privVals[0], app, blockDB)
 	err := stateStore.Save(state)
 	require.NoError(t, err)
@@ -256,26 +256,3 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {
 	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
 	return abci.ResponseCommit{Data: hash}
 }
-
-func (app *CounterApplication) PrepareProposal(
-	req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
-
-	trs := make([]*abci.TxRecord, 0, len(req.Txs))
-	var totalBytes int64
-	for _, tx := range req.Txs {
-		totalBytes += int64(len(tx))
-		if totalBytes > req.MaxTxBytes {
-			break
-		}
-		trs = append(trs, &abci.TxRecord{
-			Action: abci.TxRecord_UNMODIFIED,
-			Tx:     tx,
-		})
-	}
-	return abci.ResponsePrepareProposal{TxRecords: trs}
-}
-
-func (app *CounterApplication) ProcessProposal(
-	req abci.RequestProcessProposal) abci.ResponseProcessProposal {
-	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
-}

consensus/metrics.gen.go

@@ -118,11 +118,11 @@ func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
 			Name:      "latest_block_height",
 			Help:      "The latest block height.",
 		}, labels).With(labelsAndValues...),
-		FastSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
+		BlockSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
-			Name:      "fast_syncing",
-			Help:      "Whether or not a node is fast syncing. 1 if yes, 0 if no.",
+			Name:      "block_syncing",
+			Help:      "Whether or not a node is block syncing. 1 if yes, 0 if no.",
 		}, labels).With(labelsAndValues...),
 		StateSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
@@ -184,7 +184,7 @@ func NopMetrics() *Metrics {
 		BlockSizeBytes:            discard.NewGauge(),
 		TotalTxs:                  discard.NewGauge(),
 		CommittedHeight:           discard.NewGauge(),
-		FastSyncing:               discard.NewGauge(),
+		BlockSyncing:              discard.NewGauge(),
 		StateSyncing:              discard.NewGauge(),
 		BlockParts:                discard.NewCounter(),
 		StepDurationSeconds:       discard.NewHistogram(),

consensus/metrics.go

@@ -59,8 +59,8 @@ type Metrics struct {
 	TotalTxs metrics.Gauge
 	// The latest block height.
 	CommittedHeight metrics.Gauge `metrics_name:"latest_block_height"`
-	// Whether or not a node is fast syncing. 1 if yes, 0 if no.
-	FastSyncing metrics.Gauge
+	// Whether or not a node is block syncing. 1 if yes, 0 if no.
+	BlockSyncing metrics.Gauge
 	// Whether or not a node is state syncing. 1 if yes, 0 if no.
 	StateSyncing metrics.Gauge
 

consensus/msgs_test.go

@@ -314,7 +314,6 @@ func TestWALMsgProto(t *testing.T) {
 	}
 }
 
-// nolint:lll //ignore line length for tests
 func TestConsMsgsVectors(t *testing.T) {
 	date := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC)
 	psh := types.PartSetHeader{

consensus/reactor.go

@@ -72,7 +72,7 @@ func NewReactor(consensusState *State, waitSync bool, options ...ReactorOption)
 }
 
 // OnStart implements BaseService by subscribing to events, which later will be
-// broadcasted to other peers and starting state if we're not in fast sync.
+// broadcasted to other peers and starting state if we're not in block sync.
 func (conR *Reactor) OnStart() error {
 	conR.Logger.Info("Reactor ", "waitSync", conR.WaitSync())
 
@@ -104,8 +104,8 @@ func (conR *Reactor) OnStop() {
 	}
 }
 
-// SwitchToConsensus switches from fast_sync mode to consensus mode.
-// It resets the state, turns off fast_sync, and starts the consensus state-machine
+// SwitchToConsensus switches from block_sync mode to consensus mode.
+// It resets the state, turns off block_sync, and starts the consensus state-machine
 func (conR *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) {
 	conR.Logger.Info("SwitchToConsensus")
 
@@ -121,7 +121,7 @@ func (conR *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) {
 	conR.mtx.Lock()
 	conR.waitSync = false
 	conR.mtx.Unlock()
-	conR.Metrics.FastSyncing.Set(0)
+	conR.Metrics.BlockSyncing.Set(0)
 	conR.Metrics.StateSyncing.Set(0)
 
 	if skipWAL {
@@ -198,7 +198,7 @@ func (conR *Reactor) AddPeer(peer p2p.Peer) {
 	go conR.queryMaj23Routine(peer, peerState)
 
 	// Send our state to peer.
-	// If we're fast_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus().
+	// If we're block_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus().
 	if !conR.WaitSync() {
 		conR.sendNewRoundStepMessage(peer)
 	}
@@ -218,7 +218,7 @@ func (conR *Reactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 }
 
 // Receive implements Reactor
-// NOTE: We process these messages even when we're fast_syncing.
+// NOTE: We process these messages even when we're block_syncing.
 // Messages affect either a peer state or the consensus state.
 // Peer state updates can happen in parallel, but processing of
 // proposals, block parts, and votes are ordered by the receiveRoutine
@@ -386,7 +386,7 @@ func (conR *Reactor) SetEventBus(b *types.EventBus) {
 	conR.conS.SetEventBus(b)
 }
 
-// WaitSync returns whether the consensus reactor is waiting for state/fast sync.
+// WaitSync returns whether the consensus reactor is waiting for state/block sync.
 func (conR *Reactor) WaitSync() bool {
 	conR.mtx.RLock()
 	defer conR.mtx.RUnlock()

consensus/reactor_test.go

@@ -138,7 +138,9 @@ func TestReactorWithEvidence(t *testing.T) {
 	logger := consensusLogger()
 	for i := 0; i < nValidators; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
-		stateStore := sm.NewStore(stateDB)
+		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		state, _ := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		defer os.RemoveAll(thisConfig.RootDir)
@@ -689,7 +691,7 @@ func capture() {
 // Ensure basic validation of structs is functioning
 
 func TestNewRoundStepMessageValidateBasic(t *testing.T) {
-	testCases := []struct { // nolint: maligned
+	testCases := []struct {
 		expectErr              bool
 		messageRound           int32
 		messageLastCommitRound int32
@@ -728,7 +730,7 @@ func TestNewRoundStepMessageValidateBasic(t *testing.T) {
 
 func TestNewRoundStepMessageValidateHeight(t *testing.T) {
 	initialHeight := int64(10)
-	testCases := []struct { // nolint: maligned
+	testCases := []struct { //nolint: maligned
 		expectErr              bool
 		messageLastCommitRound int32
 		messageHeight          int64
@@ -878,7 +880,7 @@ func TestHasVoteMessageValidateBasic(t *testing.T) {
 		invalidSignedMsgType tmproto.SignedMsgType = 0x03
 	)
 
-	testCases := []struct { // nolint: maligned
+	testCases := []struct { //nolint: maligned
 		expectErr     bool
 		messageRound  int32
 		messageIndex  int32
@@ -923,7 +925,7 @@ func TestVoteSetMaj23MessageValidateBasic(t *testing.T) {
 		},
 	}
 
-	testCases := []struct { // nolint: maligned
+	testCases := []struct { //nolint: maligned
 		expectErr      bool
 		messageRound   int32
 		messageHeight  int64

consensus/replay.go

@@ -418,7 +418,7 @@ func (h *Handshaker) ReplayBlocks(
 
 		case appBlockHeight == storeBlockHeight:
 			// We ran Commit, but didn't save the state, so replayBlock with mock app.
-			abciResponses, err := h.stateStore.LoadABCIResponses(storeBlockHeight)
+			abciResponses, err := h.stateStore.LoadLastABCIResponse(storeBlockHeight)
 			if err != nil {
 				return nil, err
 			}

consensus/replay_file.go

@@ -297,7 +297,9 @@ func newConsensusStateForReplay(config cfg.BaseConfig, csConfig *cfg.ConsensusCo
 	if err != nil {
 		tmos.Exit(err.Error())
 	}
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	gdoc, err := sm.MakeGenesisDocFromFile(config.GenesisFile())
 	if err != nil {
 		tmos.Exit(err.Error())

consensus/replay_test.go

@@ -30,7 +30,6 @@ import (
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -159,7 +158,9 @@ LOOP:
 		logger := log.NewNopLogger()
 		blockDB := dbm.NewMemDB()
 		stateDB := blockDB
-		stateStore := sm.NewStore(stateDB)
+		stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		state, err := sm.MakeGenesisStateFromFile(consensusReplayConfig.GenesisFile())
 		require.NoError(t, err)
 		privValidator := loadPrivValidator(consensusReplayConfig)
@@ -290,7 +291,6 @@ func (w *crashingWAL) Start() error { return w.next.Start() }
 func (w *crashingWAL) Stop() error  { return w.next.Stop() }
 func (w *crashingWAL) Wait()        { w.next.Wait() }
 
-//------------------------------------------------------------------------------------------
 type testSim struct {
 	GenesisState sm.State
 	Config       *cfg.Config
@@ -362,11 +362,9 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx1, nil, mempl.TxInfo{})
-	assert.NoError(t, err)
-	propBlock, err := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	require.NoError(t, err)
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	assert.Nil(t, err)
+	propBlock, _ := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlockParts := propBlock.MakePartSet(partSize)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 
 	proposal := types.NewProposal(vss[1].Height, round, -1, blockID)
@@ -394,11 +392,9 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
 	err = assertMempool(css[0].txNotifier).CheckTx(updateValidatorTx1, nil, mempl.TxInfo{})
-	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	require.NoError(t, err)
-	propBlockParts, err = propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	assert.Nil(t, err)
+	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlockParts = propBlock.MakePartSet(partSize)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 
 	proposal = types.NewProposal(vss[2].Height, round, -1, blockID)
@@ -433,11 +429,9 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx3, nil, mempl.TxInfo{})
-	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	require.NoError(t, err)
-	propBlockParts, err = propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	assert.Nil(t, err)
+	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlockParts = propBlock.MakePartSet(partSize)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss := make([]*validatorStub, nVals+1)
 	copy(newVss, vss[:nVals+1])
@@ -510,11 +504,9 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	incrementHeight(vss...)
 	removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0)
 	err = assertMempool(css[0].txNotifier).CheckTx(removeValidatorTx3, nil, mempl.TxInfo{})
-	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	require.NoError(t, err)
-	propBlockParts, err = propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	assert.Nil(t, err)
+	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlockParts = propBlock.MakePartSet(partSize)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss = make([]*validatorStub, nVals+3)
 	copy(newVss, vss[:nVals+3])
@@ -673,7 +665,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		config = sim.Config
 		chain = append([]*types.Block{}, sim.Chain...) // copy chain
 		commits = sim.Commits
-		store = newMockBlockStore(t, config, genesisState.ConsensusParams)
+		store = newMockBlockStore(config, genesisState.ConsensusParams)
 	} else { // test single node
 		testConfig := ResetConfig(fmt.Sprintf("%s_%v_s", t.Name(), mode))
 		defer os.RemoveAll(testConfig.RootDir)
@@ -698,16 +690,18 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		require.NoError(t, err)
 		pubKey, err := privVal.GetPubKey()
 		require.NoError(t, err)
-		stateDB, genesisState, store = stateAndStore(t, config, pubKey, kvstore.ProtocolVersion)
+		stateDB, genesisState, store = stateAndStore(config, pubKey, kvstore.ProtocolVersion)
 
 	}
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	store.chain = chain
 	store.commits = commits
 
 	state := genesisState.Copy()
 	// run the chain through state.ApplyBlock to build up the tendermint state
-	state = buildTMStateFromChain(t, config, stateStore, state, chain, nBlocks, mode)
+	state = buildTMStateFromChain(config, stateStore, state, chain, nBlocks, mode)
 	latestAppHash := state.AppHash
 
 	// make a new client creator
@@ -720,10 +714,12 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		// use a throwaway tendermint state
 		proxyApp := proxy.NewAppConns(clientCreator2, proxy.NopMetrics())
 		stateDB1 := dbm.NewMemDB()
-		stateStore := sm.NewStore(stateDB1)
+		stateStore := sm.NewStore(stateDB1, sm.StoreOptions{
+			DiscardABCIResponses: false,
+		})
 		err := stateStore.Save(genesisState)
 		require.NoError(t, err)
-		buildAppStateFromChain(t, proxyApp, stateStore, genesisState, chain, nBlocks, mode)
+		buildAppStateFromChain(proxyApp, stateStore, genesisState, chain, nBlocks, mode)
 	}
 
 	// Prune block store if requested
@@ -783,19 +779,19 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 	}
 }
 
-func applyBlock(t *testing.T, stateStore sm.Store, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State {
+func applyBlock(stateStore sm.Store, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State {
 	testPartSize := types.BlockPartSizeBytes
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
 
-	bps, err := blk.MakePartSet(testPartSize)
-	require.NoError(t, err)
-	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: bps.Header()}
+	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()}
 	newState, _, err := blockExec.ApplyBlock(st, blkID, blk)
-	require.NoError(t, err)
+	if err != nil {
+		panic(err)
+	}
 	return newState
 }
 
-func buildAppStateFromChain(t *testing.T, proxyApp proxy.AppConns, stateStore sm.Store,
+func buildAppStateFromChain(proxyApp proxy.AppConns, stateStore sm.Store,
 	state sm.State, chain []*types.Block, nBlocks int, mode uint) {
 	// start a new app without handshake, play nBlocks blocks
 	if err := proxyApp.Start(); err != nil {
@@ -817,18 +813,18 @@ func buildAppStateFromChain(t *testing.T, proxyApp proxy.AppConns, stateStore sm
 	case 0:
 		for i := 0; i < nBlocks; i++ {
 			block := chain[i]
-			state = applyBlock(t, stateStore, state, block, proxyApp)
+			state = applyBlock(stateStore, state, block, proxyApp)
 		}
 	case 1, 2, 3:
 		for i := 0; i < nBlocks-1; i++ {
 			block := chain[i]
-			state = applyBlock(t, stateStore, state, block, proxyApp)
+			state = applyBlock(stateStore, state, block, proxyApp)
 		}
 
 		if mode == 2 || mode == 3 {
 			// update the kvstore height and apphash
 			// as if we ran commit but not
-			state = applyBlock(t, stateStore, state, chain[nBlocks-1], proxyApp)
+			state = applyBlock(stateStore, state, chain[nBlocks-1], proxyApp)
 		}
 	default:
 		panic(fmt.Sprintf("unknown mode %v", mode))
@@ -837,7 +833,6 @@ func buildAppStateFromChain(t *testing.T, proxyApp proxy.AppConns, stateStore sm
 }
 
 func buildTMStateFromChain(
-	t *testing.T,
 	config *cfg.Config,
 	stateStore sm.Store,
 	state sm.State,
@@ -868,19 +863,19 @@ func buildTMStateFromChain(
 	case 0:
 		// sync right up
 		for _, block := range chain {
-			state = applyBlock(t, stateStore, state, block, proxyApp)
+			state = applyBlock(stateStore, state, block, proxyApp)
 		}
 
 	case 1, 2, 3:
 		// sync up to the penultimate as if we stored the block.
 		// whether we commit or not depends on the appHash
 		for _, block := range chain[:len(chain)-1] {
-			state = applyBlock(t, stateStore, state, block, proxyApp)
+			state = applyBlock(stateStore, state, block, proxyApp)
 		}
 
 		// apply the final block to a state copy so we can
 		// get the right next appHash but keep the state back
-		applyBlock(t, stateStore, state, chain[len(chain)-1], proxyApp)
+		applyBlock(stateStore, state, chain[len(chain)-1], proxyApp)
 	default:
 		panic(fmt.Sprintf("unknown mode %v", mode))
 	}
@@ -899,14 +894,14 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	const appVersion = 0x0
 	pubKey, err := privVal.GetPubKey()
 	require.NoError(t, err)
-	stateDB, state, store := stateAndStore(t, config, pubKey, appVersion)
-	stateStore := sm.NewStore(stateDB)
+	stateDB, state, store := stateAndStore(config, pubKey, appVersion)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	genDoc, _ := sm.MakeGenesisDocFromFile(config.GenesisFile())
 	state.LastValidators = state.Validators.Copy()
 	// mode = 0 for committing all the blocks
-	blocks, err := sf.MakeBlocks(3, &state, privVal)
-	require.NoError(t, err)
-
+	blocks := makeBlocks(3, &state, privVal)
 	store.chain = blocks
 
 	// 2. Tendermint must panic if app returns wrong hash for the first block
@@ -958,6 +953,52 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	}
 }
 
+func makeBlocks(n int, state *sm.State, privVal types.PrivValidator) []*types.Block {
+	blocks := make([]*types.Block, 0)
+
+	var (
+		prevBlock     *types.Block
+		prevBlockMeta *types.BlockMeta
+	)
+
+	appHeight := byte(0x01)
+	for i := 0; i < n; i++ {
+		height := int64(i + 1)
+
+		block, parts := makeBlock(*state, prevBlock, prevBlockMeta, privVal, height)
+		blocks = append(blocks, block)
+
+		prevBlock = block
+		prevBlockMeta = types.NewBlockMeta(block, parts)
+
+		// update state
+		state.AppHash = []byte{appHeight}
+		appHeight++
+		state.LastBlockHeight = height
+	}
+
+	return blocks
+}
+
+func makeBlock(state sm.State, lastBlock *types.Block, lastBlockMeta *types.BlockMeta,
+	privVal types.PrivValidator, height int64) (*types.Block, *types.PartSet) {
+
+	lastCommit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
+	if height > 1 {
+		vote, _ := types.MakeVote(
+			lastBlock.Header.Height,
+			lastBlockMeta.BlockID,
+			state.Validators,
+			privVal,
+			lastBlock.Header.ChainID,
+			time.Now())
+		lastCommit = types.NewCommit(vote.Height, vote.Round,
+			lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
+	}
+
+	return state.MakeBlock(height, []types.Tx{}, lastCommit, nil, state.Validators.GetProposer().Address)
+}
+
 type badApp struct {
 	abci.BaseApplication
 	numBlocks           byte
@@ -1109,19 +1150,19 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {
 
 // fresh state and mock store
 func stateAndStore(
-	t *testing.T,
 	config *cfg.Config,
 	pubKey crypto.PubKey,
-	appVersion uint64,
-) (dbm.DB, sm.State, *mockBlockStore) {
+	appVersion uint64) (dbm.DB, sm.State, *mockBlockStore) {
 	stateDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(stateDB)
-	state, err := sm.MakeGenesisStateFromFile(config.GenesisFile())
-	require.NoError(t, err)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
+	state, _ := sm.MakeGenesisStateFromFile(config.GenesisFile())
 	state.Version.Consensus.App = appVersion
-	store := newMockBlockStore(t, config, state.ConsensusParams)
-	require.NoError(t, stateStore.Save(state))
-
+	store := newMockBlockStore(config, state.ConsensusParams)
+	if err := stateStore.Save(state); err != nil {
+		panic(err)
+	}
 	return stateDB, state, store
 }
 
@@ -1134,16 +1175,11 @@ type mockBlockStore struct {
 	chain   []*types.Block
 	commits []*types.Commit
 	base    int64
-	t       *testing.T
 }
 
 // TODO: NewBlockStore(db.NewMemDB) ...
-func newMockBlockStore(t *testing.T, config *cfg.Config, params tmproto.ConsensusParams) *mockBlockStore {
-	return &mockBlockStore{
-		config: config,
-		params: params,
-		t:      t,
-	}
+func newMockBlockStore(config *cfg.Config, params tmproto.ConsensusParams) *mockBlockStore {
+	return &mockBlockStore{config, params, nil, nil, 0}
 }
 
 func (bs *mockBlockStore) Height() int64                       { return int64(len(bs.chain)) }
@@ -1156,10 +1192,8 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
 }
 func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	block := bs.chain[height-1]
-	bps, err := block.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(bs.t, err)
 	return &types.BlockMeta{
-		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()},
+		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
 		Header:  block.Header,
 	}
 }
@@ -1198,8 +1232,10 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	privVal := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
 	pubKey, err := privVal.GetPubKey()
 	require.NoError(t, err)
-	stateDB, state, store := stateAndStore(t, config, pubKey, 0x0)
-	stateStore := sm.NewStore(stateDB)
+	stateDB, state, store := stateAndStore(config, pubKey, 0x0)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 
 	oldValAddr := state.Validators.Validators[0].Address
 

consensus/state.go

@@ -978,7 +978,9 @@ func (cs *State) handleTxsAvailable() {
 // Used internally by handleTimeout and handleMsg to make state transitions
 
 // Enter: `timeoutNewHeight` by startTime (commitTime+timeoutCommit),
-// 	or, if SkipTimeoutCommit==true, after receiving all precommits from (height,round-1)
+//
+//	or, if SkipTimeoutCommit==true, after receiving all precommits from (height,round-1)
+//
 // Enter: `timeoutPrecommits` after any +2/3 precommits from (height,round-1)
 // Enter: +2/3 precommits for nil at (height,round-1)
 // Enter: +2/3 prevotes any or +2/3 precommits for block or any from (height, round)
@@ -1060,7 +1062,9 @@ func (cs *State) needProofBlock(height int64) bool {
 
 // Enter (CreateEmptyBlocks): from enterNewRound(height,round)
 // Enter (CreateEmptyBlocks, CreateEmptyBlocksInterval > 0 ):
-// 		after enterNewRound(height,round), after timeout of CreateEmptyBlocksInterval
+//
+//	after enterNewRound(height,round), after timeout of CreateEmptyBlocksInterval
+//
 // Enter (!CreateEmptyBlocks) : after enterNewRound(height,round), once txs are in the mempool
 func (cs *State) enterPropose(height int64, round int32) {
 	logger := cs.Logger.With("height", height, "round", round)
@@ -1136,17 +1140,8 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 		block, blockParts = cs.ValidBlock, cs.ValidBlockParts
 	} else {
 		// Create a new proposal block from state/txs from the mempool.
-		var err error
-		block, err = cs.createProposalBlock()
-		if err != nil {
-			cs.Logger.Error("unable to create proposal block", "error", err)
-			return
-		} else if block == nil {
-			panic("Method createProposalBlock should not provide a nil block without errors")
-		}
-		blockParts, err = block.MakePartSet(types.BlockPartSizeBytes)
-		if err != nil {
-			cs.Logger.Error("unable to create proposal block part set", "error", err)
+		block, blockParts = cs.createProposalBlock()
+		if block == nil {
 			return
 		}
 	}
@@ -1201,9 +1196,9 @@ func (cs *State) isProposalComplete() bool {
 //
 // NOTE: keep it side-effect free for clarity.
 // CONTRACT: cs.privValidator is not nil.
-func (cs *State) createProposalBlock() (*types.Block, error) {
+func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.PartSet) {
 	if cs.privValidator == nil {
-		return nil, errors.New("entered createProposalBlock with privValidator being nil")
+		panic("entered createProposalBlock with privValidator being nil")
 	}
 
 	var commit *types.Commit
@@ -1218,22 +1213,20 @@ func (cs *State) createProposalBlock() (*types.Block, error) {
 		commit = cs.LastCommit.MakeCommit()
 
 	default: // This shouldn't happen.
-		return nil, errors.New("propose step; cannot propose anything without commit for the previous block")
+		cs.Logger.Error("propose step; cannot propose anything without commit for the previous block")
+		return
 	}
 
 	if cs.privValidatorPubKey == nil {
 		// If this node is a validator & proposer in the current round, it will
 		// miss the opportunity to create a block.
-		return nil, fmt.Errorf("propose step; empty priv validator public key, error: %w", errPubKeyIsNotSet)
+		cs.Logger.Error("propose step; empty priv validator public key", "err", errPubKeyIsNotSet)
+		return
 	}
 
 	proposerAddr := cs.privValidatorPubKey.Address()
 
-	ret, err := cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr, cs.LastCommit.GetVotes())
-	if err != nil {
-		panic(err)
-	}
-	return ret, nil
+	return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
 }
 
 // Enter: `timeoutPropose` after entering Propose.
@@ -1283,36 +1276,11 @@ func (cs *State) defaultDoPrevote(height int64, round int32) {
 		return
 	}
 
-	// Validate proposal block, from Tendermint's perspective
+	// Validate proposal block
 	err := cs.blockExec.ValidateBlock(cs.state, cs.ProposalBlock)
 	if err != nil {
 		// ProposalBlock is invalid, prevote nil.
-		logger.Error("prevote step: consensus deems this block invalid; prevoting nil",
-			"err", err)
-		cs.signAddVote(tmproto.PrevoteType, nil, types.PartSetHeader{})
-		return
-	}
-
-	/*
-		Before prevoting on the block received from the proposer for the current round and height,
-		we request the Application, via `ProcessProposal` ABCI call, to confirm that the block is
-		valid. If the Application does not accept the block, Tendermint prevotes `nil`.
-
-		WARNING: misuse of block rejection by the Application can seriously compromise Tendermint's
-		liveness properties. Please see `PrepareProosal`-`ProcessProposal` coherence and determinism
-		properties in the ABCI++ specification.
-	*/
-	isAppValid, err := cs.blockExec.ProcessProposal(cs.ProposalBlock, cs.state)
-	if err != nil {
-		panic(fmt.Sprintf(
-			"state machine returned an error (%v) when calling ProcessProposal", err,
-		))
-	}
-
-	// Vote nil if the Application rejected the block
-	if !isAppValid {
-		logger.Error("prevote step: state machine rejected a proposed block; this should not happen:"+
-			"the proposer may be misbehaving; prevoting nil", "err", err)
+		logger.Error("prevote step: ProposalBlock is invalid", "err", err)
 		cs.signAddVote(tmproto.PrevoteType, nil, types.PartSetHeader{})
 		return
 	}
@@ -2000,7 +1968,7 @@ func (cs *State) tryAddVote(vote *types.Vote, peerID p2p.ID) (bool, error) {
 		// If the vote height is off, we'll just ignore it,
 		// But if it's a conflicting sig, add it to the cs.evpool.
 		// If it's otherwise invalid, punish peer.
-		// nolint: gocritic
+		//nolint: gocritic
 		if voteErr, ok := err.(*types.ErrVoteConflictingVotes); ok {
 			if cs.privValidatorPubKey == nil {
 				return false, errPubKeyIsNotSet

consensus/state_test.go

@@ -8,15 +8,11 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	"github.com/tendermint/tendermint/abci/example/counter"
-	abci "github.com/tendermint/tendermint/abci/types"
-	abcimocks "github.com/tendermint/tendermint/abci/types/mocks"
+	"github.com/tendermint/tendermint/abci/example/kvstore"
 	cstypes "github.com/tendermint/tendermint/consensus/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	tmbytes "github.com/tendermint/tendermint/libs/bytes"
 	"github.com/tendermint/tendermint/libs/log"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
@@ -195,8 +191,7 @@ func TestStateBadProposal(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 
-	propBlock, err := cs1.createProposalBlock() // changeProposer(t, cs1, vs2)
-	require.NoError(t, err)
+	propBlock, _ := cs1.createProposalBlock() // changeProposer(t, cs1, vs2)
 
 	// make the second validator the proposer by incrementing round
 	round++
@@ -209,8 +204,7 @@ func TestStateBadProposal(t *testing.T) {
 	}
 	stateHash[0] = (stateHash[0] + 1) % 255
 	propBlock.AppHash = stateHash
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	proposal := types.NewProposal(vs2.Height, round, -1, blockID)
 	p := proposal.ToProto()
@@ -236,19 +230,13 @@ func TestStateBadProposal(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], nil)
 
 	// add bad prevote from vs2 and wait for it
-	bps, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 
 	// wait for precommit
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-
-	bps2, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 }
 
 func TestStateOversizedBlock(t *testing.T) {
@@ -262,8 +250,7 @@ func TestStateOversizedBlock(t *testing.T) {
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 
-	propBlock, err := cs1.createProposalBlock()
-	require.NoError(t, err)
+	propBlock, _ := cs1.createProposalBlock()
 	propBlock.Data.Txs = []types.Tx{tmrand.Bytes(2001)}
 	propBlock.Header.DataHash = propBlock.Data.Hash()
 
@@ -271,8 +258,7 @@ func TestStateOversizedBlock(t *testing.T) {
 	round++
 	incrementRound(vss[1:]...)
 
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	proposal := types.NewProposal(height, round, -1, blockID)
 	p := proposal.ToProto()
@@ -304,18 +290,11 @@ func TestStateOversizedBlock(t *testing.T) {
 	// precommit on it
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], nil)
-
-	bps, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-
-	bps2, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 }
 
 //----------------------------------------------------------------------------------------------------
@@ -487,7 +466,9 @@ func TestStateLockNoPOL(t *testing.T) {
 
 	rs := cs1.GetRoundState()
 
-	require.Nil(t, rs.ProposalBlock, "Expected proposal block to be nil")
+	if rs.ProposalBlock != nil {
+		panic("Expected proposal block to be nil")
+	}
 
 	// wait to finish prevote
 	ensurePrevote(voteCh, height, round)
@@ -495,10 +476,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], rs.LockedBlock.Hash())
 
 	// add a conflicting prevote from the other validator
-	bps, err := rs.LockedBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
-	signAddVotes(cs1, tmproto.PrevoteType, hash, bps.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 
 	// now we're going to enter prevote again, but with invalid args
@@ -511,9 +489,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash)
 
 	// add conflicting precommit from vs2
-	bps2, err := rs.LockedBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	signAddVotes(cs1, tmproto.PrecommitType, hash, bps2.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrecommitType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrecommit(voteCh, height, round)
 
 	// (note we're entering precommit for a second time this round, but with invalid args
@@ -543,9 +519,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	ensurePrevote(voteCh, height, round) // prevote
 	validatePrevote(t, cs1, round, vss[0], rs.LockedBlock.Hash())
 
-	bps0, err := rs.ProposalBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	signAddVotes(cs1, tmproto.PrevoteType, hash, bps0.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, hash, rs.ProposalBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
@@ -553,13 +527,11 @@ func TestStateLockNoPOL(t *testing.T) {
 
 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but be locked on proposal
 
-	bps1, err := rs.ProposalBlock.MakePartSet(partSize)
-	require.NoError(t, err)
 	signAddVotes(
 		cs1,
 		tmproto.PrecommitType,
 		hash,
-		bps1.Header(),
+		rs.ProposalBlock.MakePartSet(partSize).Header(),
 		vs2) // NOTE: conflicting precommits at same height
 	ensurePrecommit(voteCh, height, round)
 
@@ -567,7 +539,7 @@ func TestStateLockNoPOL(t *testing.T) {
 
 	cs2, _ := randState(2) // needed so generated block is different than locked block
 	// before we time out into new round, set next proposal block
-	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
@@ -583,9 +555,7 @@ func TestStateLockNoPOL(t *testing.T) {
 
 	// now we're on a new round and not the proposer
 	// so set the proposal block
-	bps3, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	if err := cs1.SetProposalAndBlock(prop, propBlock, bps3, ""); err != nil {
+	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlock.MakePartSet(partSize), ""); err != nil {
 		t.Fatal(err)
 	}
 
@@ -595,23 +565,18 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrevote(t, cs1, 3, vss[0], cs1.LockedBlock.Hash())
 
 	// prevote for proposed block
-	bps4, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps4.Header(), vs2)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but locked on proposal
 
-	bps5, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
 	signAddVotes(
 		cs1,
 		tmproto.PrecommitType,
 		propBlock.Hash(),
-		bps5.Header(),
+		propBlock.MakePartSet(partSize).Header(),
 		vs2) // NOTE: conflicting precommits at same height
 	ensurePrecommit(voteCh, height, round)
 }
@@ -665,14 +630,12 @@ func TestStateLockPOLRelock(t *testing.T) {
 	signAddVotes(cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
 	// before we timeout to the new round set the new proposal
-	cs2 := newState(cs1.state, vs2, counter.NewApplication(true))
-	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
+	cs2 := newState(cs1.state, vs2, kvstore.NewApplication())
+	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
+	propBlockParts := propBlock.MakePartSet(partSize)
 	propBlockHash := propBlock.Hash()
 	require.NotEqual(t, propBlockHash, theBlockHash)
 
@@ -765,9 +728,8 @@ func TestStateLockPOLUnlock(t *testing.T) {
 	signAddVotes(cs1, tmproto.PrecommitType, theBlockHash, theBlockParts, vs3)
 
 	// before we time out into new round, set next proposal block
-	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	// timeout to new round
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
@@ -853,14 +815,12 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {
 	signAddVotes(cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
 	// before we timeout to the new round set the new proposal
-	cs2 := newState(cs1.state, vs2, counter.NewApplication(true))
-	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
+	cs2 := newState(cs1.state, vs2, kvstore.NewApplication())
+	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	secondBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
+	secondBlockParts := propBlock.MakePartSet(partSize)
 	secondBlockHash := propBlock.Hash()
 	require.NotEqual(t, secondBlockHash, firstBlockHash)
 
@@ -904,8 +864,7 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	thirdPropBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	thirdPropBlockParts := propBlock.MakePartSet(partSize)
 	thirdPropBlockHash := propBlock.Hash()
 	require.NotEqual(t, secondBlockHash, thirdPropBlockHash)
 
@@ -969,10 +928,7 @@ func TestStateLockPOLSafety1(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], propBlock.Hash())
 
 	// the others sign a polka but we don't see it
-	bps, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-
-	prevotes := signVotes(tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2, vs3, vs4)
+	prevotes := signVotes(tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)
 
 	t.Logf("old prop hash %v", fmt.Sprintf("%X", propBlock.Hash()))
 
@@ -985,10 +941,9 @@ func TestStateLockPOLSafety1(t *testing.T) {
 
 	t.Log("### ONTO ROUND 1")
 
-	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash := propBlock.Hash()
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	incrementRound(vs2, vs3, vs4)
 
@@ -1082,20 +1037,18 @@ func TestStateLockPOLSafety2(t *testing.T) {
 
 	// the block for R0: gets polkad but we miss it
 	// (even though we signed it, shhh)
-	_, propBlock0 := decideProposal(t, cs1, vss[0], height, round)
+	_, propBlock0 := decideProposal(cs1, vss[0], height, round)
 	propBlockHash0 := propBlock0.Hash()
-	propBlockParts0, err := propBlock0.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts0 := propBlock0.MakePartSet(partSize)
 	propBlockID0 := types.BlockID{Hash: propBlockHash0, PartSetHeader: propBlockParts0.Header()}
 
 	// the others sign a polka but we don't see it
 	prevotes := signVotes(tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4)
 
 	// the block for round 1
-	prop1, propBlock1 := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
+	prop1, propBlock1 := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash1 := propBlock1.Hash()
-	propBlockParts1, err := propBlock1.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts1 := propBlock1.MakePartSet(partSize)
 
 	incrementRound(vs2, vs3, vs4)
 
@@ -1193,9 +1146,7 @@ func TestProposeValidBlock(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)
 
 	// the others sign a polka
-	bps, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
-	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, bps.Header(), vs2, vs3, vs4)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)
 
 	ensurePrecommit(voteCh, height, round)
 	// we should have precommitted
@@ -1279,8 +1230,7 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 	rs := cs1.GetRoundState()
 	propBlock := rs.ProposalBlock
 	propBlockHash := propBlock.Hash()
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)
@@ -1346,10 +1296,9 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], nil)
 
-	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash := propBlock.Hash()
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	// vs2, vs3 and vs4 send prevote for propBlock
 	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
@@ -1372,55 +1321,6 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	assert.True(t, rs.ValidRound == round)
 }
 
-func TestProcessProposalAccept(t *testing.T) {
-	for _, testCase := range []struct {
-		name               string
-		accept             bool
-		expectedNilPrevote bool
-	}{
-		{
-			name:               "accepted block is prevoted",
-			accept:             true,
-			expectedNilPrevote: false,
-		},
-		{
-			name:               "rejected block is not prevoted",
-			accept:             false,
-			expectedNilPrevote: true,
-		},
-	} {
-		t.Run(testCase.name, func(t *testing.T) {
-			m := abcimocks.NewApplication(t)
-			status := abci.ResponseProcessProposal_REJECT
-			if testCase.accept {
-				status = abci.ResponseProcessProposal_ACCEPT
-			}
-			m.On("ProcessProposal", mock.Anything).Return(abci.ResponseProcessProposal{Status: status})
-			m.On("PrepareProposal", mock.Anything).Return(abci.ResponsePrepareProposal{}).Maybe()
-			cs1, _ := randStateWithApp(4, m)
-			height, round := cs1.Height, cs1.Round
-
-			proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-			newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-			pv1, err := cs1.privValidator.GetPubKey()
-			require.NoError(t, err)
-			addr := pv1.Address()
-			voteCh := subscribeToVoter(cs1, addr)
-
-			startTestRound(cs1, cs1.Height, round)
-			ensureNewRound(newRoundCh, height, round)
-
-			ensureNewProposal(proposalCh, height, round)
-			rs := cs1.GetRoundState()
-			var prevoteHash tmbytes.HexBytes
-			if !testCase.expectedNilPrevote {
-				prevoteHash = rs.ProposalBlock.Hash()
-			}
-			ensurePrevoteMatch(t, voteCh, height, round, prevoteHash)
-		})
-	}
-}
-
 // 4 vals, 3 Nil Precommits at P0
 // What we want:
 // P0 waits for timeoutPrecommit before starting next round
@@ -1556,10 +1456,9 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) {
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
 
-	_, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round)
+	_, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
 	propBlockHash := propBlock.Hash()
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	// start round in which PO is not proposer
 	startTestRound(cs1, height, round)
@@ -1590,10 +1489,9 @@ func TestCommitFromPreviousRound(t *testing.T) {
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 
-	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round)
+	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
 	propBlockHash := propBlock.Hash()
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	// start round in which PO is not proposer
 	startTestRound(cs1, height, round)
@@ -1736,9 +1634,8 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 
 	ensureNewBlockHeader(newBlockHeader, height, theBlockHash)
 
-	prop, propBlock := decideProposal(t, cs1, vs2, height+1, 0)
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	prop, propBlock := decideProposal(cs1, vs2, height+1, 0)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
@@ -1859,8 +1756,7 @@ func TestStateHalt1(t *testing.T) {
 	ensureNewProposal(proposalCh, height, round)
 	rs := cs1.GetRoundState()
 	propBlock := rs.ProposalBlock
-	propBlockParts, err := propBlock.MakePartSet(partSize)
-	require.NoError(t, err)
+	propBlockParts := propBlock.MakePartSet(partSize)
 
 	ensurePrevote(voteCh, height, round)
 

consensus/types/round_state.go

@@ -80,15 +80,6 @@ type RoundState struct {
 	LockedBlock        *types.Block        `json:"locked_block"`
 	LockedBlockParts   *types.PartSet      `json:"locked_block_parts"`
 
-	// The variables below starting with "Valid..." derive their name from
-	// the algorithm presented in this paper:
-	// [The latest gossip on BFT consensus](https://arxiv.org/abs/1807.04938).
-	// Therefore, "Valid...":
-	//   * means that the block or round that the variable refers to has
-	//     received 2/3+ non-`nil` prevotes (a.k.a. a *polka*)
-	//   * has nothing to do with whether the Application returned "Accept" in its
-	//     response to `ProcessProposal`, or "Reject"
-
 	// Last known round with POL for non-nil valid block.
 	ValidRound int32        `json:"valid_round"`
 	ValidBlock *types.Block `json:"valid_block"` // Last known block of POL mentioned above.
@@ -195,8 +186,8 @@ func (rs *RoundState) StringIndented(indent string) string {
 %s  ProposalBlock: %v %v
 %s  LockedRound:   %v
 %s  LockedBlock:   %v %v
-%s  ValidRound:    %v
-%s  ValidBlock:    %v %v
+%s  ValidRound:   %v
+%s  ValidBlock:   %v %v
 %s  Votes:         %v
 %s  LastCommit:    %v
 %s  LastValidators:%v

consensus/wal_generator.go

@@ -47,7 +47,9 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 	}
 	blockStoreDB := db.NewMemDB()
 	stateDB := blockStoreDB
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	state, err := sm.MakeGenesisState(genDoc)
 	if err != nil {
 		return fmt.Errorf("failed to make genesis state: %w", err)

crypto/armor/armor.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"io"
 
-	"golang.org/x/crypto/openpgp/armor" // nolint: staticcheck
+	"golang.org/x/crypto/openpgp/armor"
 )
 
 func EncodeArmor(blockType string, headers map[string]string, data []byte) string {

crypto/merkle/doc.go

@@ -12,20 +12,19 @@ second pre-image attacks. Hence, use this library with caution.
 Otherwise you might run into similar issues as, e.g., in early Bitcoin:
 https://bitcointalk.org/?topic=102395
 
-                        *
-                       / \
-                     /     \
-                   /         \
-                 /             \
-                *               *
-               / \             / \
-              /   \           /   \
-             /     \         /     \
-            *       *       *       h6
-           / \     / \     / \
-          h0  h1  h2  h3  h4  h5
+	              *
+	             / \
+	           /     \
+	         /         \
+	       /             \
+	      *               *
+	     / \             / \
+	    /   \           /   \
+	   /     \         /     \
+	  *       *       *       h6
+	 / \     / \     / \
+	h0  h1  h2  h3  h4  h5
 
 TODO(ismail): add 2nd pre-image protection or clarify further on how we use this and why this secure.
-
 */
 package merkle

crypto/merkle/proof_value.go

@@ -85,8 +85,8 @@ func (op ValueOp) Run(args [][]byte) ([][]byte, error) {
 
 	bz := new(bytes.Buffer)
 	// Wrap <op.Key, vhash> to hash the KVPair.
-	encodeByteSlice(bz, op.key) // nolint: errcheck // does not error
-	encodeByteSlice(bz, vhash)  // nolint: errcheck // does not error
+	encodeByteSlice(bz, op.key)
+	encodeByteSlice(bz, vhash)
 	kvhash := leafHash(bz.Bytes())
 
 	if !bytes.Equal(kvhash, op.Proof.LeafHash) {

crypto/merkle/tree.go

@@ -47,10 +47,10 @@ func HashFromByteSlices(items [][]byte) []byte {
 //
 // These preliminary results suggest:
 //
-// 1. The performance of the HashFromByteSlice is pretty good
-// 2. Go has low overhead for recursive functions
-// 3. The performance of the HashFromByteSlice routine is dominated
-//    by the actual hashing of data
+//  1. The performance of the HashFromByteSlice is pretty good
+//  2. Go has low overhead for recursive functions
+//  3. The performance of the HashFromByteSlice routine is dominated
+//     by the actual hashing of data
 //
 // Although this work is in no way exhaustive, point #3 suggests that
 // optimization of this routine would need to take an alternative

crypto/secp256k1/secp256k1.go

@@ -9,13 +9,12 @@ import (
 	"math/big"
 
 	secp256k1 "github.com/btcsuite/btcd/btcec"
-	"golang.org/x/crypto/ripemd160" // nolint: staticcheck // necessary for Bitcoin address format
+	"golang.org/x/crypto/ripemd160" //nolint: staticcheck // necessary for Bitcoin address format
 
 	"github.com/tendermint/tendermint/crypto"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 )
 
-//-------------------------------------
 const (
 	PrivKeyName = "tendermint/PrivKeySecp256k1"
 	PubKeyName  = "tendermint/PubKeySecp256k1"
@@ -124,8 +123,8 @@ func GenPrivKeySecp256k1(secret []byte) PrivKey {
 
 // used to reject malleable signatures
 // see:
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/crypto.go#L39
+//   - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
+//   - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/crypto.go#L39
 var secp256k1halfN = new(big.Int).Rsh(secp256k1.S256().N, 1)
 
 // Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.

docs/rfc/README.md

@@ -60,5 +60,6 @@ sections.
 - [RFC-020: Onboarding Projects](./rfc-020-onboarding-projects.rst)
 - [RFC-021: The Future of the Socket Protocol](./rfc-021-socket-protocol.md)
 - [RFC-023: Semi-permanent Testnet](./rfc-023-semi-permanent-testnet.md)
+- [RFC-024: Block Structure Consolidation](./rfc-024-block-structure-consolidation.md)
 
 <!-- - [RFC-NNN: Title](./rfc-NNN-title.md) -->

docs/rfc/rfc-024-block-structure-consolidation.md

@@ -0,0 +1,364 @@
+# RFC 024: Block Structure Consolidation
+
+## Changelog
+
+- 19-Apr-2022: Initial draft started (@williambanfield).
+- 3-May-2022: Initial draft complete (@williambanfield).
+
+## Abstract
+
+The `Block` data structure is a very central structure within Tendermint. Because
+of its centrality, it has gained several fields over the years through accretion.
+Not all of these fields may be necessary any more. This document examines which
+of these fields may no longer be necessary for inclusion in the block and makes
+recommendations about how to proceed with each of them.
+
+## Background
+
+The current block structure contains multiple fields that are not required for
+validation or execution of a Tendermint block. Some of these fields had vestigial
+purposes that they no longer serve and some of these fields exist as a result of
+internal Tendermint domain objects leaking out into the external data structure.
+
+In so far as is possible, we should consolidate and prune these superfluous
+fields before releasing a 1.0 version of Tendermint. All pruning of these
+fields should be done with the aim of simplifying the structures to what
+is needed while preserving information that aids with debugging and that also
+allow external protocols to function more efficiently than if they were removed.
+
+### Current Block Structure
+
+The current block structures are included here to aid discussion.
+
+```proto
+message Block {
+  Header                        header      = 1;
+  Data                          data        = 2;
+  tendermint.types.EvidenceList evidence    = 3;
+  Commit                        last_commit = 4;
+}
+```
+
+```proto
+message Header {
+  tendermint.version.Consensus version              = 1;
+  string                       chain_id             = 2;
+  int64                        height               = 3;
+  google.protobuf.Timestamp    time                 = 4;
+  BlockID                      last_block_id        = 5;
+  bytes                        last_commit_hash     = 6;
+  bytes                        data_hash            = 7;
+  bytes                        validators_hash      = 8;
+  bytes                        next_validators_hash = 9;
+  bytes                        consensus_hash       = 10;
+  bytes                        app_hash             = 11;
+  bytes                        last_results_hash    = 12;
+  bytes                        evidence_hash        = 13;
+  bytes                        proposer_address     = 14;
+}
+
+```
+
+```proto
+message Data {
+  repeated bytes txs = 1;
+}
+```
+
+```proto
+message EvidenceList {
+  repeated Evidence evidence = 1;
+}
+```
+
+```proto
+message Commit {
+  int64              height     = 1;
+  int32              round      = 2;
+  BlockID            block_id   = 3;
+  repeated CommitSig signatures = 4;
+}
+```
+
+```proto
+message CommitSig {
+  BlockIDFlag               block_id_flag     = 1;
+  bytes                     validator_address = 2;
+  google.protobuf.Timestamp timestamp         = 3;
+  bytes                     signature         = 4;
+}
+```
+
+```proto
+message BlockID {
+  bytes         hash            = 1;
+  PartSetHeader part_set_header = 2;
+}
+```
+
+### On Tendermint Blocks
+
+#### What is a Tendermint 'Block'?
+
+A block is the structure produced as the result of an instance of the Tendermint
+consensus algorithm. At its simplest, the 'block' can be represented as a Merkle
+root hash of all of the data used to construct and produce the hash. Our current
+block proto structure includes _far_ from all of the data used to produce the
+hashes included in the block.
+
+It does not contain the full `AppState`, it does not contain the `ConsensusParams`,
+nor the `LastResults`, nor the `ValidatorSet`. Additionally, the layout of
+the block structure is not inherently tied to this Merkle root hash. Different
+layouts of the same set of data could trivially be used to construct the
+exact same hash. The thing we currently call the 'Block' is really just a view
+into a subset of the data used to construct the root hash. Sections of the
+structure can be modified as long as alternative methods exist to query and
+retrieve the constituent values.
+
+#### Why this digression?
+
+This digression is aimed at informing what it means to consolidate 'fields' in the
+'block'. The discussion of what should be included in the block can be teased
+apart into a few different lines of inquiry.
+
+1. What values need to be included as part of the Merkle tree so that the
+consensus algorithm can use proof-of-stake consensus to validate all of the
+properties of the chain that we would like?
+2. How can we create views of the data that can be easily retrieved, stored, and
+verified by the relevant protocols?
+
+These two concerns are intertwined at the moment as a result of how we store
+and propagate our data but they don't necessarily need to be. This document
+focuses primarily on the first concern by suggesting fields that can be
+completely removed without any loss in the function of our consensus algorithm.
+
+This document also suggests ways that we may update our storage and propagation
+mechanisms to better take advantage of Merkle tree nature of our data although
+these are not its primary concern.
+
+## Discussion
+
+### Data to consider removing
+
+This section proposes a list of data that could be completely removed from the 
+Merkle tree with no loss to the functionality of our consensus algorithm.
+
+Where the change is possible but would hamper external protocols or make
+debugging more difficult, that is noted in discussion.
+
+#### CommitSig.Timestamp
+
+This field contains the timestamp included in the precommit message that was
+issued for the block. The field was once used to produce the timestamp of the block.
+With the introduction of Proposer-Based Timestamps, This field is no longer used
+in any Tendermint algorithms and can be completely removed.
+
+#### CommitSig.ValidatorAddress
+
+The `ValidatorAddress` is included in each `CommitSig` structure. This field
+is hashed along with all of the other fields of the `CommitSig`s in the block
+to form the `LastCommitHash` field in the `Header`. The `ValidatorAddress` is
+somewhat redundant in the hash. Each validator has a unique position in the
+`CommitSig` and the hash is built preserving this order. Therefore, the
+information of which signature corresponds to which validator is included in
+the root hash, even if the address is absent.
+
+It's worth noting that the validator address could still be included in the
+_hash_ even if it is absent from the `CommitSig` structure in the block by
+simply hashing it locally at each validator but not including it in the block.
+The reverse is also true. It would be perfectly possible to not include the
+`ValidatorAddress` data in the `LastCommitHash` but still include the field in
+the block.
+
+#### BlockID.PartSetHeader
+
+The [BlockID][block-id] field comprises the [PartSetHeader][part-set-header] and the hash of the block.
+The `PartSetHeader` is used by nodes to gossip the block by dividing it into
+parts. Nodes receive the `PartSetHeader` from their peers, informing them of
+what pieces of the block to gather. There is no strong reason to include this
+value in the block. Validators will still be able to gossip and validate the
+blocks that they received from their peers using this mechanism even if it is
+not written into the block. The `BlockID` can therefore be consolidated into
+just the hash of the block. This is by far the most uncontroversial change
+and there appears to be no good reason _not_ to do it. Further evidence that
+the field is not meaningful can be found in the fact that the field is not
+actually validated to ensure it is correct during block validation. Validation
+only checks that the [field is well formed][psh-check].
+
+#### ChainID
+
+The `ChainID` is a string selected by the chain operators, usually a
+human-readable name for the network. This value is immutable for the lifetime
+of the chain and is defined in the genesis file. It is therefore hashed into the
+original block and therefore transitively included as in the Merkle root hash of
+every block. The redundant field is a candidate for removal from the root hash
+of each block. However, aesthetically, it's somewhat nice to include in each
+block, as if the block was 'stamped' with the ID. Additionally, re-validating
+the value from genesis would be painful and require reconstituting potentially
+large chains. I'm therefore mildly in favor of maintaining this redundant
+piece of information. We pay almost no storage cost for maintaining this
+identical data, so the only cost is in the time required to hash it into the
+structure.
+
+#### LastResultsHash
+
+`LastResultsHash` is a hash covering the result of executing the transactions
+from the previous block. It covers the response `Code`, `Data`, `GasWanted`,
+and `GasUsed` with the aim of ensuring that execution of all of the transactions
+was performed identically on each node. The data covered by this field _should_
+be also reflected in the `AppHash`. The `AppHash` is provided by the application
+and should be deterministically calculated by each node. This field could
+therefore be removed on the grounds that its data is already reflected elsewhere.
+
+I would advocate for keeping this field. This field provides an additional check
+for determinism across nodes. Logic to update the application hash is more
+complicated for developers to implement because it relies either on building a
+complete view of the state of the application data. The `Results` returned by
+the application contain simple response codes and deterministic data bytes.
+Leaving the field will allow for transaction execution issues that are not
+correctly reflected in the `AppHash` to be more completely diagnosed.
+
+Take the case of mismatch of `LastResultsHash` between two nodes, A and B, where both
+nodes report divergent values. If `A` and `B` both report
+the same `AppHash`, then some non-deterministic behavior occurred that was not
+accurately reflected in the `AppHash`. The issue caused by this
+non-determinism may not show itself for several blocks, but catching the divergent
+state earlier will improve the chances that a chain is able to recover.
+
+#### ValidatorsHash
+
+Both `ValidatorsHash` and `NextValidatorsHash` are included in the block
+header. `Validatorshash` contains the hash of the [public key and voting power][val-hash]
+of each validator in the active set for the current block and `NextValidatorsHash`
+contains the same data but for the next height.
+
+This data is effectively redundant. Having both values present in the block
+structure is helpful for light client verification. The light client is able to
+easily determine if two sequential blocks used the same validator set by querying
+only one header.
+
+`ValidatorsHash` is also important to the light client algorithm for performing block
+validation. The light client uses this field to ensure that the validator set
+it fetched from a full node is correct. It can be sure of the correctness of
+the retrieved structure by hashing it and checking the hash against the `ValidatorsHash`
+of the block it is verifying. Because a validator that the light client trusts 
+signed over the `ValidatorsHash`, it can be certain of the validity of the
+structure. Without this check, phony validator sets could be handed to the light
+client and the code tricked into believing a different validator set was present
+at a height, opening up a major hole in the light client security model.
+
+This creates a recursive problem. To verify the validator set that signed the
+block at height `H`, what information do we need? We could fetch the
+`NextValidatorsHash` from height `H-1`, but how do we verify that that hash is correct?
+
+#### ProposerAddress
+
+The section below details a change to allow the `ProposerAddress` to be calculated
+from a field added to the block. This would allow the `Address` to be dropped
+from the block. Consumers of the chain could run the proposer selection [algorithm][proposer-selection]
+to determine who proposed each block.
+
+I would advocate against this. Any consumer of the chain that wanted to
+know which validator proposed a block would have to run the proposer selection
+algorithm. This algorithm is not widely implemented, meaning that consumers
+in other languages would need to implement the algorithm to determine a piece
+of basic information about the chain.
+
+### Data to consider adding
+
+#### ProofOfLockRound
+
+The *proof of lock round* is the round of consensus for a height in which the
+Tendermint algorithm observed a super majority of voting power on the network for
+a block.
+
+Including this value in the block will allow validation of currently
+un-validated metadata. Specifically, including this value will allow Tendermint
+to validate that the `ProposerAddress` in the block is correct. Without knowing
+the locked round number, Tendermint cannot calculate which validator was supposed
+to propose a height. Because of this, our [validation logic][proposer-check] does not check that
+the `ProposerAddress` included in the block corresponds to the validator that
+proposed the height. Instead, the validation logic simply checks that the value
+is an address of one of the known validators.
+
+Currently, we maintain the _committed round_ in the `Commit` for height `H`, which is
+written into the block at height `H+1`. This value corresponds to the round in
+which the proposer of height `H+1` received the commit for height `H`. The proof
+of lock round would not subsume this value.
+
+### Additional possible updates
+
+#### Updates to storage
+
+Currently we store the [every piece of each block][save-block] in the `BlockStore`.
+I suspect that this has lead to some mistakes in reasoning around the merits of
+consolidating fields in the block. We could update the storage scheme we use to
+store only some pieces of each block and still achieve a space savings without having
+to change the block structure at all.
+
+The main way to achieve this would be by _no longer saving data that does not change_.
+At each height we save a set of data that is unlikely to have changed from the
+previous height in the block structure, this includes the `ValidatorAddress`es,
+the `ValidatorsHash`, the `ChainID`. These do not need to be saved along with
+_each_ block. We could easily save the value and the height at which the value
+was updated and construct each block using the data that existed at the time.
+
+This document does not make any specific recommendations around storage since
+that is likely to change with upcoming improvements to to the database infrastructure.
+However, it's important to note that removing fields from the block for the
+purposes of 'saving space' may not be that meaningful. We should instead focus
+our attention of removing fields from the block that are no longer needed
+for correct functioning of the protocol.
+
+#### Updates to propagation
+
+Block propagation suffers from the same issue that plagues block storage, we
+propagate all of the contents of each block proto _even when these contents are redundant
+or unchanged from previous blocks_. For example, we propagate the `ValidatorAddress`es
+for each block in the `CommitSig` structure even when it never changed from a
+previous height. We could achieve a speed-up in many cases by communicating the
+hashes _first_ and letting peers request additional information when they do not
+recognize the communicated hash. 
+
+For example, in the case of the `ValidatorAddress`es, the node would first
+communicate the `ValidatorsHash` of the block to its peers. The peers would
+check their storage for a validator set matching the provided hash. If the peer
+has a matching set, it would populate its local block structure with the
+appropriate values from its store. If peer did not have a matching set, it would
+issue a request to its peers, either via P2P or RPC for the data it did not have.
+
+Conceptually, this is very similar to how content addressing works in protocols
+such as git where pushing a commit does not require pushing the entire contents
+of the tree referenced by the commit.
+
+### Impact on light clients
+
+As outlined in the section [On Tendermint Blocks](#on-tendermint-blocks), there
+is a distinction between what data is referenced in the Merkle root hash and the
+contents of the proto structure we currently call the `Block`.
+
+Any changes to the Merkle root hash will necessarily be breaking for legacy light clients.
+Either a soft-upgrades scheme will need to be implemented or a hard fork will
+be required for chains and light clients to function with the new hashes.
+This means that all of the additions and deletions from the Merkle root hash
+proposed by this document will be light client breaking.
+
+Changes to the block structure alone are not necessarily light client breaking if the
+data being hashed are identical and legacy views into the data are provided
+for old light clients during transitions. For example, a newer version of the
+block structure could move the `ValidatorAddress` field to a different field
+in the block while still including it in the hashed data of the `LastCommitHash`.
+As long as old light clients could still fetch the old data structure, then
+this would not be light client breaking.
+
+## References
+
+[light-verify-trusting]: https://github.com/tendermint/tendermint/blob/208a15dadf01e4e493c187d8c04a55a61758c3cc/types/validation.go#L124
+[part-set-header]: https://github.com/tendermint/tendermint/blob/208a15dadf01e4e493c187d8c04a55a61758c3cc/types/part_set.go#L94
+[block-id]: https://github.com/tendermint/tendermint/blob/208a15dadf01e4e493c187d8c04a55a61758c3cc/types/block.go#L1090
+[psh-check]: https://github.com/tendermint/tendermint/blob/208a15dadf01e4e493c187d8c04a55a61758c3cc/types/part_set.go#L116
+[proposer-selection]: https://github.com/tendermint/tendermint/blob/208a15dadf01e4e493c187d8c04a55a61758c3cc/spec/consensus/proposer-selection.md
+[chain-experiment]: https://github.com/williambanfield/tmtools/blob/master/hash-changes/RUN.txt
+[val-hash]: https://github.com/tendermint/tendermint/blob/29e5fbcc648510e4763bd0af0b461aed92c21f30/types/validator.go#L160
+[proposer-check]: https://github.com/tendermint/tendermint/blob/29e5fbcc648510e4763bd0af0b461aed92c21f30/internal/state/validation.go#L102
+[save-block]: https://github.com/tendermint/tendermint/blob/59f0236b845c83009bffa62ed44053b04370b8a9/internal/store/store.go#L490

docs/tendermint-core/README.md

@@ -17,7 +17,7 @@ This section dives into the internals of Tendermint the implementation.
 - [Subscribing to events](./subscription.md)
 - [Block Structure](./block-structure.md)
 - [RPC](./rpc.md)
-- [Fast Sync](./fast-sync.md)
+- [Block Sync](./block-sync.md)
 - [State Sync](./state-sync.md)
 - [Mempool](./mempool.md)
 - [Light Client](./light-client.md)

docs/tendermint-core/block-sync.md

@@ -2,7 +2,8 @@
 order: 10
 ---
 
-# Fast Sync
+# Block Sync
+*Formerly known as Fast Sync*
 
 In a proof of work blockchain, syncing with the chain is the same
 process as staying up-to-date with the consensus: download blocks, and
@@ -14,35 +15,37 @@ scratch can take a very long time. It's much faster to just download
 blocks and check the merkle tree of validators than to run the real-time
 consensus gossip protocol.
 
-## Using Fast Sync
+## Using Block Sync
 
-To support faster syncing, Tendermint offers a `fast-sync` mode, which
+To support faster syncing, Tendermint offers a `block-sync` mode, which
 is enabled by default, and can be toggled in the `config.toml` or via
-`--fast_sync=false`.
+`--block_sync=false`.
 
 In this mode, the Tendermint daemon will sync hundreds of times faster
 than if it used the real-time consensus process. Once caught up, the
-daemon will switch out of fast sync and into the normal consensus mode.
+daemon will switch out of Block Sync and into the normal consensus mode.
 After running for some time, the node is considered `caught up` if it
 has at least one peer and it's height is at least as high as the max
 reported peer height. See [the IsCaughtUp
 method](https://github.com/tendermint/tendermint/blob/b467515719e686e4678e6da4e102f32a491b85a0/blockchain/pool.go#L128).
 
-Note: There are three versions of fast sync. We recommend using v0 as v1 and v2 are still in beta. 
-  If you would like to use a different version you can do so by changing the version in the `config.toml`:
+Note: While there have historically been multiple versions of blocksync, v0, v1, and v2, all versions
+other than v0 have been deprecated in favor of the simplest and most well understood algorithm.
 
 ```toml
 #######################################################
-###       Fast Sync Configuration Connections       ###
+###       Block Sync Configuration Options          ###
 #######################################################
-[fastsync]
+[blocksync]
 
-# Fast Sync version to use:
-#   1) "v0" (default) - the legacy fast sync implementation
-#   2) "v1" - refactor of v0 version for better testability
-#   2) "v2" - complete redesign of v0, optimized for testability & readability 
+# Block Sync version to use:
+# 
+# In v0.37, v1 and v2 of the block sync protocols were deprecated.
+# Please use v0 instead.
+#
+#   1) "v0" - the default block sync implementation
 version = "v0"
 ```
 
-If we're lagging sufficiently, we should go back to fast syncing, but
+If we're lagging sufficiently, we should go back to block syncing, but
 this is an [open issue](https://github.com/tendermint/tendermint/issues/129).

docs/tendermint-core/configuration.md

@@ -36,10 +36,10 @@ proxy_app = "tcp://127.0.0.1:26658"
 # A custom human readable name for this node
 moniker = "anonymous"
 
-# If this node is many blocks behind the tip of the chain, FastSync
+# If this node is many blocks behind the tip of the chain, BlockSync
 # allows them to catchup quickly by downloading blocks in parallel
 # and verifying their commits
-fast_sync = true
+block_sync = true
 
 # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb
 # * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
@@ -319,16 +319,16 @@ trust_period = "0s"
 temp_dir = ""
 
 #######################################################
-###       Fast Sync Configuration Connections       ###
+###       Block Sync Configuration Options          ###
 #######################################################
-[fastsync]
+[blocksync]
 
-# Fast Sync version to use:
-#
-# In v0.37, the v1 and v2 fast sync protocols were deprecated.
+# Block Sync version to use:
+# 
+# In v0.37, v1 and v2 of the block sync protocols were deprecated.
 # Please use v0 instead.
 #
-#   1) "v0" (default) - the legacy fast sync implementation
+#   1) "v0" - the default block sync implementation
 version = "v0"
 
 #######################################################

docs/tendermint-core/metrics.md

@@ -37,7 +37,7 @@ The following metrics are available:
 | consensus_total_txs                    | Gauge     |                 | Total number of transactions committed                                                                                                     |
 | consensus_block_parts                  | counter   | peer_id         | number of blockparts transmitted by peer                                                                                                   |
 | consensus_latest_block_height          | gauge     |                 | /status sync_info number                                                                                                                   |
-| consensus_fast_syncing                 | gauge     |                 | either 0 (not fast syncing) or 1 (syncing)                                                                                                 |
+| consensus_block_syncing                | gauge     |                 | either 0 (not block syncing) or 1 (syncing)                                                                                                 |
 | consensus_state_syncing                | gauge     |                 | either 0 (not state syncing) or 1 (syncing)                                                                                                |
 | consensus_block_size_bytes             | Gauge     |                 | Block size in bytes                                                                                                                        |
 | consensus_step_duration                | Histogram | step            | Histogram of durations for each step in the consensus protocol                                                                             |

docs/tendermint-core/state-sync.md

@@ -4,7 +4,7 @@ order: 11
 
 # State Sync
 
-With fast sync a node is downloading all of the data of an application from genesis and verifying it. 
+With block sync a node is downloading all of the data of an application from genesis and verifying it. 
 With state sync your node will download data related to the head or near the head of the chain and verify the data. 
 This leads to drastically shorter times for joining a network. 
 

docs/tutorials/go-built-in.md

@@ -109,6 +109,10 @@ func (KVStoreApplication) Info(req abcitypes.RequestInfo) abcitypes.ResponseInfo
 	return abcitypes.ResponseInfo{}
 }
 
+func (KVStoreApplication) SetOption(req abcitypes.RequestSetOption) abcitypes.ResponseSetOption {
+	return abcitypes.ResponseSetOption{}
+}
+
 func (KVStoreApplication) DeliverTx(req abcitypes.RequestDeliverTx) abcitypes.ResponseDeliverTx {
 	return abcitypes.ResponseDeliverTx{Code: 0}
 }

docs/tutorials/go.md

@@ -111,6 +111,11 @@ func NewKVStoreApplication() *KVStoreApplication {
 func (KVStoreApplication) Info(req abcitypes.RequestInfo) abcitypes.ResponseInfo {
 	return abcitypes.ResponseInfo{}
 }
+
+func (KVStoreApplication) SetOption(req abcitypes.RequestSetOption) abcitypes.ResponseSetOption {
+	return abcitypes.ResponseSetOption{}
+}
+
 func (KVStoreApplication) DeliverTx(req abcitypes.RequestDeliverTx) abcitypes.ResponseDeliverTx {
 	return abcitypes.ResponseDeliverTx{Code: 0}
 }

evidence/doc.go

@@ -3,7 +3,7 @@ Package evidence handles all evidence storage and gossiping from detection to bl
 For the different types of evidence refer to the `evidence.go` file in the types package
 or https://github.com/tendermint/spec/blob/master/spec/consensus/light-client/accountability.md.
 
-Gossiping
+# Gossiping
 
 The core functionality begins with the evidence reactor (see reactor.
 go) which operates both the sending and receiving of evidence.
@@ -29,7 +29,7 @@ There are two buckets that evidence can be stored in: Pending & Committed.
 
 All evidence is proto encoded to disk.
 
-Proposing
+# Proposing
 
 When a new block is being proposed (in state/execution.go#CreateProposalBlock),
 `PendingEvidence(maxBytes)` is called to send up to the maxBytes of uncommitted evidence, from the evidence store,
@@ -42,12 +42,11 @@ Once the proposed evidence is submitted,
 the evidence is marked as committed and is moved from the broadcasted set to the committed set.
 As a result it is also removed from the concurrent list so that it is no longer gossiped.
 
-Minor Functionality
+# Minor Functionality
 
 As all evidence (including POLC's) are bounded by an expiration date, those that exceed this are no longer needed
 and hence pruned. Currently, only committed evidence in which a marker to the height that the evidence was committed
 and hence very small is saved. All updates are made from the `Update(block, state)` function which should be called
 when a new block is committed.
-
 */
 package evidence

evidence/pool.go

@@ -97,11 +97,11 @@ func (evpool *Pool) PendingEvidence(maxBytes int64) ([]types.Evidence, int64) {
 
 // Update takes both the new state and the evidence committed at that height and performs
 // the following operations:
-// 1. Take any conflicting votes from consensus and use the state's LastBlockTime to form
-//    DuplicateVoteEvidence and add it to the pool.
-// 2. Update the pool's state which contains evidence params relating to expiry.
-// 3. Moves pending evidence that has now been committed into the committed pool.
-// 4. Removes any expired evidence based on both height and time.
+//  1. Take any conflicting votes from consensus and use the state's LastBlockTime to form
+//     DuplicateVoteEvidence and add it to the pool.
+//  2. Update the pool's state which contains evidence params relating to expiry.
+//  3. Moves pending evidence that has now been committed into the committed pool.
+//  4. Removes any expired evidence based on both height and time.
 func (evpool *Pool) Update(state sm.State, ev types.EvidenceList) {
 	// sanity check
 	if state.LastBlockHeight <= evpool.state.LastBlockHeight {

evidence/pool_test.go

@@ -18,7 +18,6 @@ import (
 	tmversion "github.com/tendermint/tendermint/proto/tendermint/version"
 	sm "github.com/tendermint/tendermint/state"
 	smmocks "github.com/tendermint/tendermint/state/mocks"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 	"github.com/tendermint/tendermint/version"
@@ -148,7 +147,7 @@ func TestAddExpiredEvidence(t *testing.T) {
 func TestReportConflictingVotes(t *testing.T) {
 	var height int64 = 10
 
-	pool, pv := defaultTestPool(t, height)
+	pool, pv := defaultTestPool(height)
 	val := types.NewValidator(pv.PrivKey.PubKey(), 10)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height+1, defaultEvidenceTime, pv, evidenceChainID)
 
@@ -182,7 +181,7 @@ func TestReportConflictingVotes(t *testing.T) {
 
 func TestEvidencePoolUpdate(t *testing.T) {
 	height := int64(21)
-	pool, val := defaultTestPool(t, height)
+	pool, val := defaultTestPool(height)
 	state := pool.State()
 
 	// create new block (no need to save it to blockStore)
@@ -215,7 +214,7 @@ func TestEvidencePoolUpdate(t *testing.T) {
 
 func TestVerifyPendingEvidencePasses(t *testing.T) {
 	var height int64 = 1
-	pool, val := defaultTestPool(t, height)
+	pool, val := defaultTestPool(height)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height, defaultEvidenceTime.Add(1*time.Minute),
 		val, evidenceChainID)
 	err := pool.AddEvidence(ev)
@@ -227,7 +226,7 @@ func TestVerifyPendingEvidencePasses(t *testing.T) {
 
 func TestVerifyDuplicatedEvidenceFails(t *testing.T) {
 	var height int64 = 1
-	pool, val := defaultTestPool(t, height)
+	pool, val := defaultTestPool(height)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height, defaultEvidenceTime.Add(1*time.Minute),
 		val, evidenceChainID)
 	err := pool.CheckEvidence(types.EvidenceList{ev, ev})
@@ -307,8 +306,7 @@ func TestRecoverPendingEvidence(t *testing.T) {
 	stateStore := initializeValidatorState(val, height)
 	state, err := stateStore.Load()
 	require.NoError(t, err)
-	blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
-	require.NoError(t, err)
+	blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
 	// create previous pool and populate it
 	pool, err := evidence.NewPool(evidenceDB, stateStore, blockStore)
 	require.NoError(t, err)
@@ -350,7 +348,9 @@ func TestRecoverPendingEvidence(t *testing.T) {
 
 func initializeStateFromValidatorSet(valSet *types.ValidatorSet, height int64) sm.Store {
 	stateDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	state := sm.State{
 		ChainID:                     evidenceChainID,
 		InitialHeight:               1,
@@ -400,25 +400,23 @@ func initializeValidatorState(privVal types.PrivValidator, height int64) sm.Stor
 
 // initializeBlockStore creates a block storage and populates it w/ a dummy
 // block at +height+.
-func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) (*store.BlockStore, error) {
+func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) *store.BlockStore {
 	blockStore := store.NewBlockStore(db)
 
 	for i := int64(1); i <= state.LastBlockHeight; i++ {
 		lastCommit := makeCommit(i-1, valAddr)
-		block := sf.MakeBlock(state, i, lastCommit)
+		block, _ := state.MakeBlock(i, []types.Tx{}, lastCommit, nil,
+			state.Validators.GetProposer().Address)
 		block.Header.Time = defaultEvidenceTime.Add(time.Duration(i) * time.Minute)
 		block.Header.Version = tmversion.Consensus{Block: version.BlockProtocol, App: 1}
 		const parts = 1
-		partSet, err := block.MakePartSet(parts)
-		if err != nil {
-			return nil, err
-		}
+		partSet := block.MakePartSet(parts)
 
 		seenCommit := makeCommit(i, valAddr)
 		blockStore.SaveBlock(block, partSet, seenCommit)
 	}
 
-	return blockStore, nil
+	return blockStore
 }
 
 func makeCommit(height int64, valAddr []byte) *types.Commit {
@@ -431,15 +429,13 @@ func makeCommit(height int64, valAddr []byte) *types.Commit {
 	return types.NewCommit(height, 0, types.BlockID{}, commitSigs)
 }
 
-func defaultTestPool(t *testing.T, height int64) (*evidence.Pool, types.MockPV) {
-	t.Helper()
+func defaultTestPool(height int64) (*evidence.Pool, types.MockPV) {
 	val := types.NewMockPV()
 	valAddress := val.PrivKey.PubKey().Address()
 	evidenceDB := dbm.NewMemDB()
 	stateStore := initializeValidatorState(val, height)
 	state, _ := stateStore.Load()
-	blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
-	require.NoError(t, err)
+	blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
 	pool, err := evidence.NewPool(evidenceDB, stateStore, blockStore)
 	if err != nil {
 		panic("test evidence pool could not be created")

evidence/reactor_test.go

@@ -367,7 +367,6 @@ func exampleVote(t byte) *types.Vote {
 	}
 }
 
-// nolint:lll //ignore line length for tests
 func TestEvidenceVectors(t *testing.T) {
 
 	val := &types.Validator{

evidence/verify.go

@@ -102,13 +102,13 @@ func (evpool *Pool) verify(evidence types.Evidence) error {
 
 // VerifyLightClientAttack verifies LightClientAttackEvidence against the state of the full node. This involves
 // the following checks:
-//     - the common header from the full node has at least 1/3 voting power which is also present in
-//       the conflicting header's commit
-//     - 2/3+ of the conflicting validator set correctly signed the conflicting block
-//     - the nodes trusted header at the same height as the conflicting header has a different hash
-//
+//   - the common header from the full node has at least 1/3 voting power which is also present in
+//     the conflicting header's commit
+//   - 2/3+ of the conflicting validator set correctly signed the conflicting block
+//   - the nodes trusted header at the same height as the conflicting header has a different hash
+
 // CONTRACT: must run ValidateBasic() on the evidence before verifying
-//           must check that the evidence has not expired (i.e. is outside the maximum age threshold)
+//	must check that the evidence has not expired (i.e. is outside the maximum age threshold)
 func VerifyLightClientAttack(e *types.LightClientAttackEvidence, commonHeader, trustedHeader *types.SignedHeader,
 	commonVals *types.ValidatorSet, now time.Time, trustPeriod time.Duration) error {
 	// In the case of lunatic attack there will be a different commonHeader height. Therefore the node perform a single
@@ -154,10 +154,10 @@ func VerifyLightClientAttack(e *types.LightClientAttackEvidence, commonHeader, t
 
 // VerifyDuplicateVote verifies DuplicateVoteEvidence against the state of full node. This involves the
 // following checks:
-//      - the validator is in the validator set at the height of the evidence
-//      - the height, round, type and validator address of the votes must be the same
-//      - the block ID's must be different
-//      - The signatures must both be valid
+//   - the validator is in the validator set at the height of the evidence
+//   - the height, round, type and validator address of the votes must be the same
+//   - the block ID's must be different
+//   - The signatures must both be valid
 func VerifyDuplicateVote(e *types.DuplicateVoteEvidence, chainID string, valSet *types.ValidatorSet) error {
 	_, val := valSet.GetByAddress(e.VoteA.ValidatorAddress)
 	if val == nil {

go.sum

@@ -1031,6 +1031,7 @@ golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRu
 golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug=
 golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=

libs/cli/flags/log_level.go

@@ -17,7 +17,8 @@ const (
 // all other modules).
 //
 // Example:
-//		ParseLogLevel("consensus:debug,mempool:debug,*:error", log.NewTMLogger(os.Stdout), "info")
+//
+//	ParseLogLevel("consensus:debug,mempool:debug,*:error", log.NewTMLogger(os.Stdout), "info")
 func ParseLogLevel(lvl string, logger log.Logger, defaultLogLevelValue string) (log.Logger, error) {
 	if lvl == "" {
 		return nil, errors.New("empty log level")

libs/clist/clist.go

@@ -24,7 +24,6 @@ import (
 const MaxLength = int(^uint(0) >> 1)
 
 /*
-
 CElement is an element of a linked-list
 Traversal from a CElement is goroutine-safe.
 
@@ -41,7 +40,6 @@ the for-loop. Use sync.Cond when you need serial access to the
 "condition". In our case our condition is if `next != nil || removed`,
 and there's no reason to serialize that condition for goroutines
 waiting on NextWait() (since it's just a read operation).
-
 */
 type CElement struct {
 	mtx        tmsync.RWMutex

libs/clist/clist_test.go

@@ -68,7 +68,6 @@ func TestSmall(t *testing.T) {
 
 // This test is quite hacky because it relies on SetFinalizer
 // which isn't guaranteed to run at all.
-//nolint:unused,deadcode
 func _TestGCFifo(t *testing.T) {
 	if runtime.GOARCH != "amd64" {
 		t.Skipf("Skipping on non-amd64 machine")
@@ -117,6 +116,7 @@ func _TestGCFifo(t *testing.T) {
 
 // This test is quite hacky because it relies on SetFinalizer
 // which isn't guaranteed to run at all.
+//
 //nolint:unused,deadcode
 func _TestGCRandom(t *testing.T) {
 	if runtime.GOARCH != "amd64" {

libs/flowrate/flowrate.go

@@ -39,10 +39,10 @@ type Monitor struct {
 // weight of each sample in the exponential moving average (EMA) calculation.
 // The exact formulas are:
 //
-// 	sampleTime = currentTime - prevSampleTime
-// 	sampleRate = byteCount / sampleTime
-// 	weight     = 1 - exp(-sampleTime/windowSize)
-// 	newRate    = weight*sampleRate + (1-weight)*oldRate
+//	sampleTime = currentTime - prevSampleTime
+//	sampleRate = byteCount / sampleTime
+//	weight     = 1 - exp(-sampleTime/windowSize)
+//	newRate    = weight*sampleRate + (1-weight)*oldRate
 //
 // The default values for sampleRate and windowSize (if <= 0) are 100ms and 1s,
 // respectively.

libs/json/doc.go

@@ -13,12 +13,12 @@
 // compatibility with e.g. Javascript (which uses 64-bit floats for numbers, having 53-bit
 // precision):
 //
-// 	int32(32)  // Output: 32
-// 	uint32(32) // Output: 32
-// 	int64(64)  // Output: "64"
-// 	uint64(64) // Output: "64"
-// 	int(64)    // Output: "64"
-// 	uint(64)   // Output: "64"
+//	int32(32)  // Output: 32
+//	uint32(32) // Output: 32
+//	int64(64)  // Output: "64"
+//	uint64(64) // Output: "64"
+//	int(64)    // Output: "64"
+//	uint(64)   // Output: "64"
 //
 // Encoding of other scalars follows encoding/json:
 //
@@ -50,7 +50,7 @@
 // Times are encoded as encoding/json, in RFC3339Nano format, but requiring UTC time zone (with zero
 // times emitted as "0001-01-01T00:00:00Z" as with encoding/json):
 //
-// 	time.Date(2020, 6, 8, 16, 21, 28, 123, time.FixedZone("UTC+2", 2*60*60))
+//	time.Date(2020, 6, 8, 16, 21, 28, 123, time.FixedZone("UTC+2", 2*60*60))
 //	// Output: "2020-06-08T14:21:28.000000123Z"
 //	time.Time{}       // Output: "0001-01-01T00:00:00Z"
 //	(*time.Time)(nil) // Output: null
@@ -95,5 +95,4 @@
 //
 //	Struct{Car: &Car{Wheels: 4}, Vehicle: &Car{Wheels: 4}}
 //	// Output: {"Car": {"Wheels: 4"}, "Vehicle": {"type":"vehicle/car","value":{"Wheels":4}}}
-//
 package json

libs/log/filter.go

@@ -69,18 +69,19 @@ func (l *filter) Error(msg string, keyvals ...interface{}) {
 // Allow*With methods, it is used as the logger's level.
 //
 // Examples:
-//     logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"))
-//		 logger.With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto"
 //
-//     logger = log.NewFilter(logger, log.AllowError(),
-//				log.AllowInfoWith("module", "crypto"),
-// 				log.AllowNoneWith("user", "Sam"))
-//		 logger.With("module", "crypto", "user", "Sam").Info("Hello") # returns nil
+//	    logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"))
+//			 logger.With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto"
 //
-//     logger = log.NewFilter(logger,
-// 				log.AllowError(),
-// 				log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
-//		 logger.With("user", "Sam").With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto user=Sam"
+//	    logger = log.NewFilter(logger, log.AllowError(),
+//					log.AllowInfoWith("module", "crypto"),
+//					log.AllowNoneWith("user", "Sam"))
+//			 logger.With("module", "crypto", "user", "Sam").Info("Hello") # returns nil
+//
+//	    logger = log.NewFilter(logger,
+//					log.AllowError(),
+//					log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
+//			 logger.With("user", "Sam").With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto user=Sam"
 func (l *filter) With(keyvals ...interface{}) Logger {
 	keyInAllowedKeyvals := false
 

libs/log/logger.go

@@ -22,9 +22,9 @@ type Logger interface {
 //
 // If w implements the following interface, so does the returned writer.
 //
-//    interface {
-//        Fd() uintptr
-//    }
+//	interface {
+//	    Fd() uintptr
+//	}
 func NewSyncWriter(w io.Writer) io.Writer {
 	return kitlog.NewSyncWriter(w)
 }

libs/log/tmfmt_logger.go

@@ -65,7 +65,7 @@ func (l tmfmtLogger) Log(keyvals ...interface{}) error {
 		switch keyvals[i] {
 		case kitlevel.Key():
 			excludeIndexes = append(excludeIndexes, i)
-			switch keyvals[i+1].(type) { // nolint:gocritic
+			switch keyvals[i+1].(type) { //nolint:gocritic
 			case string:
 				lvl = keyvals[i+1].(string)
 			case kitlevel.Value:

libs/log/tmfmt_logger_test.go

@@ -83,7 +83,6 @@ func benchmarkRunnerKitlog(b *testing.B, logger kitlog.Logger, f func(kitlog.Log
 	}
 }
 
-//nolint: errcheck // ignore errors
 var (
 	baseMessage = func(logger kitlog.Logger) { logger.Log("foo_key", "foo_value") }
 	withMessage = func(logger kitlog.Logger) { kitlog.With(logger, "a", "b").Log("d", "f") }

libs/pubsub/pubsub.go

@@ -12,26 +12,25 @@
 //
 // Example:
 //
-//     q, err := query.New("account.name='John'")
-//     if err != nil {
-//         return err
-//     }
-//     ctx, cancel := context.WithTimeout(context.Background(), 1 * time.Second)
-//     defer cancel()
-//     subscription, err := pubsub.Subscribe(ctx, "johns-transactions", q)
-//     if err != nil {
-//         return err
-//     }
-//
-//     for {
-//         select {
-//         case msg <- subscription.Out():
-//             // handle msg.Data() and msg.Events()
-//         case <-subscription.Canceled():
-//             return subscription.Err()
-//         }
-//     }
+//	q, err := query.New("account.name='John'")
+//	if err != nil {
+//	    return err
+//	}
+//	ctx, cancel := context.WithTimeout(context.Background(), 1 * time.Second)
+//	defer cancel()
+//	subscription, err := pubsub.Subscribe(ctx, "johns-transactions", q)
+//	if err != nil {
+//	    return err
+//	}
 //
+//	for {
+//	    select {
+//	    case msg <- subscription.Out():
+//	        // handle msg.Data() and msg.Events()
+//	    case <-subscription.Cancelled():
+//	        return subscription.Err()
+//	    }
+//	}
 package pubsub
 
 import (

libs/pubsub/query/query.go

@@ -1,6 +1,6 @@
 // Package query provides a parser for a custom query format:
 //
-//		abci.invoice.number=22 AND abci.invoice.owner=Ivan
+//	abci.invoice.number=22 AND abci.invoice.owner=Ivan
 //
 // See query.peg for the grammar, which is a https://en.wikipedia.org/wiki/Parsing_expression_grammar.
 // More: https://github.com/PhilippeSigaud/Pegged/wiki/PEG-Basics

libs/pubsub/subscription.go

@@ -43,10 +43,9 @@ func (s *Subscription) Out() <-chan Message {
 	return s.out
 }
 
-// nolint: misspell
 // Cancelled returns a channel that's closed when the subscription is
 // terminated and supposed to be used in a select statement.
-func (s *Subscription) Cancelled() <-chan struct{} { // nolint: misspell
+func (s *Subscription) Cancelled() <-chan struct{} {
 	return s.canceled
 }
 
@@ -54,7 +53,8 @@ func (s *Subscription) Cancelled() <-chan struct{} { // nolint: misspell
 // If the channel is closed, Err returns a non-nil error explaining why:
 //   - ErrUnsubscribed if the subscriber choose to unsubscribe,
 //   - ErrOutOfCapacity if the subscriber is not pulling messages fast enough
-//   and the channel returned by Out became full,
+//     and the channel returned by Out became full,
+//
 // After Err returns a non-nil error, successive calls to Err return the same
 // error.
 func (s *Subscription) Err() error {

libs/rand/random.go

@@ -48,7 +48,7 @@ func (r *Rand) init() {
 }
 
 func (r *Rand) reset(seed int64) {
-	r.rand = mrand.New(mrand.NewSource(seed)) // nolint:gosec // G404: Use of weak random number generator
+	r.rand = mrand.New(mrand.NewSource(seed)) //nolint:gosec // G404: Use of weak random number generator
 }
 
 //----------------------------------------

light/client.go

@@ -284,16 +284,16 @@ func (c *Client) restoreTrustedLightBlock() error {
 
 // if options.Height:
 //
-//     1) ahead of trustedLightBlock.Height => fetch light blocks (same height as
+//  1) ahead of trustedLightBlock.Height => fetch light blocks (same height as
 //     trustedLightBlock) from primary provider and check it's hash matches the
 //     trustedLightBlock's hash (if not, remove trustedLightBlock and all the light blocks
 //     before)
 //
-//     2) equals trustedLightBlock.Height => check options.Hash matches the
+//  2) equals trustedLightBlock.Height => check options.Hash matches the
 //     trustedLightBlock's hash (if not, remove trustedLightBlock and all the light blocks
 //     before)
 //
-//     3) behind trustedLightBlock.Height => remove all the light blocks between
+//  3) behind trustedLightBlock.Height => remove all the light blocks between
 //     options.Height and trustedLightBlock.Height, update trustedLightBlock, then
 //     check options.Hash matches the trustedLightBlock's hash (if not, remove
 //     trustedLightBlock and all the light blocks before)
@@ -395,10 +395,10 @@ func (c *Client) initializeWithTrustOptions(ctx context.Context, options TrustOp
 // TrustedLightBlock returns a trusted light block at the given height (0 - the latest).
 //
 // It returns an error if:
-//  - there are some issues with the trusted store, although that should not
-//  happen normally;
-//  - negative height is passed;
-//  - header has not been verified yet and is therefore not in the store
+//   - there are some issues with the trusted store, although that should not
+//     happen normally;
+//   - negative height is passed;
+//   - header has not been verified yet and is therefore not in the store
 //
 // Safe for concurrent use by multiple goroutines.
 func (c *Client) TrustedLightBlock(height int64) (*types.LightBlock, error) {
@@ -510,8 +510,9 @@ func (c *Client) VerifyLightBlockAtHeight(ctx context.Context, height int64, now
 //
 // If the header, which is older than the currently trusted header, is
 // requested and the light client does not have it, VerifyHeader will perform:
-//		a) verifySkipping verification if nearest trusted header is found & not expired
-//		b) backwards verification in all other cases
+//
+//	a) verifySkipping verification if nearest trusted header is found & not expired
+//	b) backwards verification in all other cases
 //
 // It returns ErrOldHeaderExpired if the latest trusted header expired.
 //
@@ -980,12 +981,12 @@ func (c *Client) backwards(
 // lightBlockFromPrimary retrieves the lightBlock from the primary provider
 // at the specified height. This method also handles provider behavior as follows:
 //
-// 1. If the provider does not respond or does not have the block, it tries again
-//    with a different provider
-// 2. If all providers return the same error, the light client forwards the error to
-//    where the initial request came from
-// 3. If the provider provides an invalid light block, is deemed unreliable or returns
-//    any other error, the primary is permanently dropped and is replaced by a witness.
+//  1. If the provider does not respond or does not have the block, it tries again
+//     with a different provider
+//  2. If all providers return the same error, the light client forwards the error to
+//     where the initial request came from
+//  3. If the provider provides an invalid light block, is deemed unreliable or returns
+//     any other error, the primary is permanently dropped and is replaced by a witness.
 func (c *Client) lightBlockFromPrimary(ctx context.Context, height int64) (*types.LightBlock, error) {
 	c.providerMutex.Lock()
 	l, err := c.primary.LightBlock(ctx, height)

light/detector.go

@@ -109,7 +109,9 @@ func (c *Client) detectDivergence(ctx context.Context, primaryTrace []*types.Lig
 //
 // 1: errConflictingHeaders -> there may have been an attack on this light client
 // 2: errBadWitness -> the witness has either not responded, doesn't have the header or has given us an invalid one
-//    Note: In the case of an invalid header we remove the witness
+//
+//	Note: In the case of an invalid header we remove the witness
+//
 // 3: nil -> the hashes of the two headers match
 func (c *Client) compareNewHeaderWithWitness(ctx context.Context, errc chan error, h *types.SignedHeader,
 	witness provider.Provider, witnessIndex int) {
@@ -275,16 +277,16 @@ func (c *Client) handleConflictingHeaders(
 // it has received from another and preforms verifySkipping at the heights of each of the intermediate
 // headers in the trace until it reaches the divergentHeader. 1 of 2 things can happen.
 //
-// 1. The light client verifies a header that is different to the intermediate header in the trace. This
-//    is the bifurcation point and the light client can create evidence from it
-// 2. The source stops responding, doesn't have the block or sends an invalid header in which case we
-//    return the error and remove the witness
+//  1. The light client verifies a header that is different to the intermediate header in the trace. This
+//     is the bifurcation point and the light client can create evidence from it
+//  2. The source stops responding, doesn't have the block or sends an invalid header in which case we
+//     return the error and remove the witness
 //
 // CONTRACT:
-// 1. Trace can not be empty len(trace) > 0
-// 2. The last block in the trace can not be of a lower height than the target block
-//    trace[len(trace)-1].Height >= targetBlock.Height
-// 3. The
+//  1. Trace can not be empty len(trace) > 0
+//  2. The last block in the trace can not be of a lower height than the target block
+//     trace[len(trace)-1].Height >= targetBlock.Height
+//  3. The
 func (c *Client) examineConflictingHeaderAgainstTrace(
 	ctx context.Context,
 	trace []*types.LightBlock,

light/doc.go

@@ -63,31 +63,31 @@ This package provides three major things:
 
 Example usage:
 
-		db, err := dbm.NewGoLevelDB("light-client-db", dbDir)
-		if err != nil {
-			// handle error
-		}
+	db, err := dbm.NewGoLevelDB("light-client-db", dbDir)
+	if err != nil {
+		// handle error
+	}
 
-		c, err := NewHTTPClient(
-			chainID,
-			TrustOptions{
-				Period: 504 * time.Hour, // 21 days
-				Height: 100,
-				Hash:   header.Hash(),
-			},
-			"http://localhost:26657",
-			[]string{"http://witness1:26657"},
-			dbs.New(db, ""),
-		)
-		if err != nil {
-			// handle error
-		}
+	c, err := NewHTTPClient(
+		chainID,
+		TrustOptions{
+			Period: 504 * time.Hour, // 21 days
+			Height: 100,
+			Hash:   header.Hash(),
+		},
+		"http://localhost:26657",
+		[]string{"http://witness1:26657"},
+		dbs.New(db, ""),
+	)
+	if err != nil {
+		// handle error
+	}
 
-		h, err := c.TrustedHeader(100)
-		if err != nil {
-			// handle error
-		}
-		fmt.Println("header", h)
+	h, err := c.TrustedHeader(100)
+	if err != nil {
+		// handle error
+	}
+	fmt.Println("header", h)
 
 Check out other examples in example_test.go
 

light/provider/http/http.go

@@ -216,6 +216,6 @@ func validateHeight(height int64) (*int64, error) {
 // exponential backoff (with jitter)
 // 0.5s -> 2s -> 4.5s -> 8s -> 12.5 with 1s variation
 func backoffTimeout(attempt uint16) time.Duration {
-	// nolint:gosec // G404: Use of weak random number generator
+	//nolint:gosec // G404: Use of weak random number generator
 	return time.Duration(500*attempt*attempt)*time.Millisecond + time.Duration(rand.Intn(1000))*time.Millisecond
 }

light/proxy/routes.go

@@ -62,7 +62,7 @@ func makeHealthFunc(c *lrpc.Client) rpcHealthFunc {
 
 type rpcStatusFunc func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error)
 
-// nolint: interfacer
+//nolint: interfacer
 func makeStatusFunc(c *lrpc.Client) rpcStatusFunc {
 	return func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) {
 		return c.Status(ctx.Context())
@@ -278,7 +278,7 @@ func makeABCIInfoFunc(c *lrpc.Client) rpcABCIInfoFunc {
 
 type rpcBroadcastEvidenceFunc func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error)
 
-// nolint: interfacer
+//nolint: interfacer
 func makeBroadcastEvidenceFunc(c *lrpc.Client) rpcBroadcastEvidenceFunc {
 	return func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) {
 		return c.BroadcastEvidence(ctx.Context(), ev)

light/verifier.go

@@ -19,13 +19,13 @@ var (
 // VerifyNonAdjacent verifies non-adjacent untrustedHeader against
 // trustedHeader. It ensures that:
 //
-//	a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
-//	b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
-//	c) trustLevel ([1/3, 1]) of trustedHeaderVals (or trustedHeaderNextVals)
-//  signed correctly (if not, ErrNewValSetCantBeTrusted is returned)
-//	d) more than 2/3 of untrustedVals have signed h2
-//    (otherwise, ErrInvalidHeader is returned)
-//  e) headers are non-adjacent.
+//		a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
+//		b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
+//		c) trustLevel ([1/3, 1]) of trustedHeaderVals (or trustedHeaderNextVals)
+//	 signed correctly (if not, ErrNewValSetCantBeTrusted is returned)
+//		d) more than 2/3 of untrustedVals have signed h2
+//	   (otherwise, ErrInvalidHeader is returned)
+//	 e) headers are non-adjacent.
 //
 // maxClockDrift defines how much untrustedHeader.Time can drift into the
 // future.
@@ -81,12 +81,12 @@ func VerifyNonAdjacent(
 // VerifyAdjacent verifies directly adjacent untrustedHeader against
 // trustedHeader. It ensures that:
 //
-//  a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
-//  b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
-//  c) untrustedHeader.ValidatorsHash equals trustedHeader.NextValidatorsHash
-//  d) more than 2/3 of new validators (untrustedVals) have signed h2
-//    (otherwise, ErrInvalidHeader is returned)
-//  e) headers are adjacent.
+//	a) trustedHeader can still be trusted (if not, ErrOldHeaderExpired is returned)
+//	b) untrustedHeader is valid (if not, ErrInvalidHeader is returned)
+//	c) untrustedHeader.ValidatorsHash equals trustedHeader.NextValidatorsHash
+//	d) more than 2/3 of new validators (untrustedVals) have signed h2
+//	  (otherwise, ErrInvalidHeader is returned)
+//	e) headers are adjacent.
 //
 // maxClockDrift defines how much untrustedHeader.Time can drift into the
 // future.
@@ -212,12 +212,12 @@ func HeaderExpired(h *types.SignedHeader, trustingPeriod time.Duration, now time
 // VerifyBackwards verifies an untrusted header with a height one less than
 // that of an adjacent trusted header. It ensures that:
 //
-// 	a) untrusted header is valid
-//  b) untrusted header has a time before the trusted header
-//  c) that the LastBlockID hash of the trusted header is the same as the hash
-//  of the trusted header
+//		a) untrusted header is valid
+//	 b) untrusted header has a time before the trusted header
+//	 c) that the LastBlockID hash of the trusted header is the same as the hash
+//	 of the trusted header
 //
-//  For any of these cases ErrInvalidHeader is returned.
+//	 For any of these cases ErrInvalidHeader is returned.
 func VerifyBackwards(untrustedHeader, trustedHeader *types.Header) error {
 	if err := untrustedHeader.ValidateBasic(); err != nil {
 		return ErrInvalidHeader{err}

mempool/mempool.go

@@ -23,8 +23,6 @@ const (
 	MaxActiveIDs = math.MaxUint16
 )
 
-//go:generate mockery --case underscore --name Mempool
-
 // Mempool defines the mempool interface.
 //
 // Updates to the mempool need to be synchronized with committing a block so

mempool/mock/mempool.go

@@ -0,0 +1,43 @@
+package mock
+
+import (
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/libs/clist"
+	"github.com/tendermint/tendermint/mempool"
+	"github.com/tendermint/tendermint/types"
+)
+
+// Mempool is an empty implementation of a Mempool, useful for testing.
+type Mempool struct{}
+
+var _ mempool.Mempool = Mempool{}
+
+func (Mempool) Lock()     {}
+func (Mempool) Unlock()   {}
+func (Mempool) Size() int { return 0 }
+func (Mempool) CheckTx(_ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error {
+	return nil
+}
+func (Mempool) RemoveTxByKey(txKey types.TxKey) error   { return nil }
+func (Mempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} }
+func (Mempool) ReapMaxTxs(n int) types.Txs              { return types.Txs{} }
+func (Mempool) Update(
+	_ int64,
+	_ types.Txs,
+	_ []*abci.ResponseDeliverTx,
+	_ mempool.PreCheckFunc,
+	_ mempool.PostCheckFunc,
+) error {
+	return nil
+}
+func (Mempool) Flush()                        {}
+func (Mempool) FlushAppConn() error           { return nil }
+func (Mempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) }
+func (Mempool) EnableTxsAvailable()           {}
+func (Mempool) SizeBytes() int64              { return 0 }
+
+func (Mempool) TxsFront() *clist.CElement    { return nil }
+func (Mempool) TxsWaitChan() <-chan struct{} { return nil }
+
+func (Mempool) InitWAL() error { return nil }
+func (Mempool) CloseWAL()      {}

mempool/mocks/mempool.go

@@ -1,184 +0,0 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
-
-package mocks
-
-import (
-	abcitypes "github.com/tendermint/tendermint/abci/types"
-	mempool "github.com/tendermint/tendermint/mempool"
-
-	mock "github.com/stretchr/testify/mock"
-
-	types "github.com/tendermint/tendermint/types"
-)
-
-// Mempool is an autogenerated mock type for the Mempool type
-type Mempool struct {
-	mock.Mock
-}
-
-// CheckTx provides a mock function with given fields: tx, callback, txInfo
-func (_m *Mempool) CheckTx(tx types.Tx, callback func(*abcitypes.Response), txInfo mempool.TxInfo) error {
-	ret := _m.Called(tx, callback, txInfo)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(types.Tx, func(*abcitypes.Response), mempool.TxInfo) error); ok {
-		r0 = rf(tx, callback, txInfo)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// EnableTxsAvailable provides a mock function with given fields:
-func (_m *Mempool) EnableTxsAvailable() {
-	_m.Called()
-}
-
-// Flush provides a mock function with given fields:
-func (_m *Mempool) Flush() {
-	_m.Called()
-}
-
-// FlushAppConn provides a mock function with given fields:
-func (_m *Mempool) FlushAppConn() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Lock provides a mock function with given fields:
-func (_m *Mempool) Lock() {
-	_m.Called()
-}
-
-// ReapMaxBytesMaxGas provides a mock function with given fields: maxBytes, maxGas
-func (_m *Mempool) ReapMaxBytesMaxGas(maxBytes int64, maxGas int64) types.Txs {
-	ret := _m.Called(maxBytes, maxGas)
-
-	var r0 types.Txs
-	if rf, ok := ret.Get(0).(func(int64, int64) types.Txs); ok {
-		r0 = rf(maxBytes, maxGas)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(types.Txs)
-		}
-	}
-
-	return r0
-}
-
-// ReapMaxTxs provides a mock function with given fields: max
-func (_m *Mempool) ReapMaxTxs(max int) types.Txs {
-	ret := _m.Called(max)
-
-	var r0 types.Txs
-	if rf, ok := ret.Get(0).(func(int) types.Txs); ok {
-		r0 = rf(max)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(types.Txs)
-		}
-	}
-
-	return r0
-}
-
-// RemoveTxByKey provides a mock function with given fields: txKey
-func (_m *Mempool) RemoveTxByKey(txKey types.TxKey) error {
-	ret := _m.Called(txKey)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(types.TxKey) error); ok {
-		r0 = rf(txKey)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Size provides a mock function with given fields:
-func (_m *Mempool) Size() int {
-	ret := _m.Called()
-
-	var r0 int
-	if rf, ok := ret.Get(0).(func() int); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(int)
-	}
-
-	return r0
-}
-
-// SizeBytes provides a mock function with given fields:
-func (_m *Mempool) SizeBytes() int64 {
-	ret := _m.Called()
-
-	var r0 int64
-	if rf, ok := ret.Get(0).(func() int64); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(int64)
-	}
-
-	return r0
-}
-
-// TxsAvailable provides a mock function with given fields:
-func (_m *Mempool) TxsAvailable() <-chan struct{} {
-	ret := _m.Called()
-
-	var r0 <-chan struct{}
-	if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(<-chan struct{})
-		}
-	}
-
-	return r0
-}
-
-// Unlock provides a mock function with given fields:
-func (_m *Mempool) Unlock() {
-	_m.Called()
-}
-
-// Update provides a mock function with given fields: blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn
-func (_m *Mempool) Update(blockHeight int64, blockTxs types.Txs, deliverTxResponses []*abcitypes.ResponseDeliverTx, newPreFn mempool.PreCheckFunc, newPostFn mempool.PostCheckFunc) error {
-	ret := _m.Called(blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(int64, types.Txs, []*abcitypes.ResponseDeliverTx, mempool.PreCheckFunc, mempool.PostCheckFunc) error); ok {
-		r0 = rf(blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-type mockConstructorTestingTNewMempool interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewMempool creates a new instance of Mempool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMempool(t mockConstructorTestingTNewMempool) *Mempool {
-	mock := &Mempool{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

mempool/v0/clist_mempool.go

@@ -194,7 +194,9 @@ func (mem *CListMempool) TxsWaitChan() <-chan struct{} {
 
 // It blocks if we're waiting on Update() or Reap().
 // cb: A callback from the CheckTx command.
-//     It gets called from another goroutine.
+//
+//	It gets called from another goroutine.
+//
 // CONTRACT: Either cb will get called, or err returned.
 //
 // Safe for concurrent use by multiple goroutines.
@@ -310,7 +312,7 @@ func (mem *CListMempool) reqResCb(
 }
 
 // Called from:
-//  - resCbFirstTime (lock not held) if tx is valid
+//   - resCbFirstTime (lock not held) if tx is valid
 func (mem *CListMempool) addTx(memTx *mempoolTx) {
 	e := mem.txs.PushBack(memTx)
 	mem.txsMap.Store(memTx.tx.Key(), e)
@@ -319,8 +321,8 @@ func (mem *CListMempool) addTx(memTx *mempoolTx) {
 }
 
 // Called from:
-//  - Update (lock held) if tx was committed
-// 	- resCbRecheck (lock not held) if tx was invalidated
+//   - Update (lock held) if tx was committed
+//   - resCbRecheck (lock not held) if tx was invalidated
 func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromCache bool) {
 	mem.txs.Remove(elem)
 	elem.DetachPrev()

mempool/v1/mempool.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/creachadair/taskgroup"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/clist"

mempool/v1/mempool_bench_test.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-
 	"github.com/tendermint/tendermint/mempool"
 )
 

node/doc.go

@@ -6,35 +6,34 @@ Adding new p2p.Reactor(s)
 
 To add a new p2p.Reactor, use the CustomReactors option:
 
-		node, err := NewNode(
-				config,
-				privVal,
-				nodeKey,
-				clientCreator,
-				genesisDocProvider,
-				dbProvider,
-				metricsProvider,
-				logger,
-				CustomReactors(map[string]p2p.Reactor{"CUSTOM": customReactor}),
-		)
+	node, err := NewNode(
+			config,
+			privVal,
+			nodeKey,
+			clientCreator,
+			genesisDocProvider,
+			dbProvider,
+			metricsProvider,
+			logger,
+			CustomReactors(map[string]p2p.Reactor{"CUSTOM": customReactor}),
+	)
 
 Replacing existing p2p.Reactor(s)
 
 To replace the built-in p2p.Reactor, use the CustomReactors option:
 
-		node, err := NewNode(
-				config,
-				privVal,
-				nodeKey,
-				clientCreator,
-				genesisDocProvider,
-				dbProvider,
-				metricsProvider,
-				logger,
-				CustomReactors(map[string]p2p.Reactor{"BLOCKCHAIN": customBlockchainReactor}),
-		)
+	node, err := NewNode(
+			config,
+			privVal,
+			nodeKey,
+			clientCreator,
+			genesisDocProvider,
+			dbProvider,
+			metricsProvider,
+			logger,
+			CustomReactors(map[string]p2p.Reactor{"BLOCKCHAIN": customBlockchainReactor}),
+	)
 
 The list of existing reactors can be found in CustomReactors documentation.
-
 */
 package node

node/node.go

@@ -16,7 +16,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	bc "github.com/tendermint/tendermint/blockchain"
+	bc "github.com/tendermint/tendermint/blocksync"
 	cfg "github.com/tendermint/tendermint/config"
 	cs "github.com/tendermint/tendermint/consensus"
 	"github.com/tendermint/tendermint/crypto"
@@ -51,7 +51,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/types/time"
 	"github.com/tendermint/tendermint/version"
 
-	_ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port
+	_ "net/http/pprof" //nolint: gosec // securely exposed on separate, optional port
 
 	_ "github.com/lib/pq" // provide the psql db driver
 )
@@ -133,10 +133,10 @@ func DefaultMetricsProvider(config *cfg.InstrumentationConfig) MetricsProvider {
 // Option sets a parameter for the node.
 type Option func(*Node)
 
-// Temporary interface for switching to fast sync, we should get rid of v0 and v1 reactors.
+// Temporary interface for switching to block sync, we should get rid of v0 and v1 reactors.
 // See: https://github.com/tendermint/tendermint/issues/4595
-type fastSyncReactor interface {
-	SwitchToFastSync(sm.State) error
+type blockSyncReactor interface {
+	SwitchToBlockSync(sm.State) error
 }
 
 // CustomReactors allows you to add custom reactors (name -> p2p.Reactor) to
@@ -145,12 +145,12 @@ type fastSyncReactor interface {
 // WARNING: using any name from the below list of the existing reactors will
 // result in replacing it with the custom one.
 //
-//  - MEMPOOL
-//  - BLOCKCHAIN
-//  - CONSENSUS
-//  - EVIDENCE
-//  - PEX
-//  - STATESYNC
+//   - MEMPOOL
+//   - BLOCKCHAIN
+//   - CONSENSUS
+//   - EVIDENCE
+//   - PEX
+//   - STATESYNC
 func CustomReactors(reactors map[string]p2p.Reactor) Option {
 	return func(n *Node) {
 		for name, reactor := range reactors {
@@ -212,7 +212,7 @@ type Node struct {
 	eventBus          *types.EventBus // pub/sub for services
 	stateStore        sm.Store
 	blockStore        *store.BlockStore // store the blockchain to disk
-	bcReactor         p2p.Reactor       // for fast-syncing
+	bcReactor         p2p.Reactor       // for block-syncing
 	mempoolReactor    p2p.Reactor       // for gossipping transactions
 	mempool           mempl.Mempool
 	stateSync         bool                    // whether the node should state sync on startup
@@ -430,7 +430,9 @@ func createEvidenceReactor(config *cfg.Config, dbProvider DBProvider,
 		return nil, nil, err
 	}
 	evidenceLogger := logger.With("module", "evidence")
-	evidencePool, err := evidence.NewPool(evidenceDB, sm.NewStore(stateDB), blockStore)
+	evidencePool, err := evidence.NewPool(evidenceDB, sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: config.Storage.DiscardABCIResponses,
+	}), blockStore)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -443,16 +445,16 @@ func createBlockchainReactor(config *cfg.Config,
 	state sm.State,
 	blockExec *sm.BlockExecutor,
 	blockStore *store.BlockStore,
-	fastSync bool,
+	blockSync bool,
 	logger log.Logger) (bcReactor p2p.Reactor, err error) {
 
-	switch config.FastSync.Version {
+	switch config.BlockSync.Version {
 	case "v0":
-		bcReactor = bc.NewReactor(state.Copy(), blockExec, blockStore, fastSync)
+		bcReactor = bc.NewReactor(state.Copy(), blockExec, blockStore, blockSync)
 	case "v1", "v2":
-		return nil, fmt.Errorf("fast sync version %s has been deprecated. Please use v0", config.FastSync.Version)
+		return nil, fmt.Errorf("block sync version %s has been deprecated. Please use v0", config.BlockSync.Version)
 	default:
-		return nil, fmt.Errorf("unknown fastsync version %s", config.FastSync.Version)
+		return nil, fmt.Errorf("unknown fastsync version %s", config.BlockSync.Version)
 	}
 
 	bcReactor.SetLogger(logger.With("module", "blockchain"))
@@ -642,9 +644,9 @@ func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, config *cfg.Config,
 	return pexReactor
 }
 
-// startStateSync starts an asynchronous state sync process, then switches to fast sync mode.
-func startStateSync(ssR *statesync.Reactor, bcR fastSyncReactor, conR *cs.Reactor,
-	stateProvider statesync.StateProvider, config *cfg.StateSyncConfig, fastSync bool,
+// startStateSync starts an asynchronous state sync process, then switches to block sync mode.
+func startStateSync(ssR *statesync.Reactor, bcR blockSyncReactor, conR *cs.Reactor,
+	stateProvider statesync.StateProvider, config *cfg.StateSyncConfig, blockSync bool,
 	stateStore sm.Store, blockStore *store.BlockStore, state sm.State) error {
 	ssR.Logger.Info("Starting state sync")
 
@@ -682,13 +684,13 @@ func startStateSync(ssR *statesync.Reactor, bcR fastSyncReactor, conR *cs.Reacto
 			return
 		}
 
-		if fastSync {
+		if blockSync {
 			// FIXME Very ugly to have these metrics bleed through here.
 			conR.Metrics.StateSyncing.Set(0)
-			conR.Metrics.FastSyncing.Set(1)
-			err = bcR.SwitchToFastSync(state)
+			conR.Metrics.BlockSyncing.Set(1)
+			err = bcR.SwitchToBlockSync(state)
 			if err != nil {
-				ssR.Logger.Error("Failed to switch to fast sync", "err", err)
+				ssR.Logger.Error("Failed to switch to block sync", "err", err)
 				return
 			}
 		} else {
@@ -714,7 +716,9 @@ func NewNode(config *cfg.Config,
 		return nil, err
 	}
 
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: config.Storage.DiscardABCIResponses,
+	})
 
 	state, genDoc, err := LoadStateFromDBOrGenesisDocProvider(stateDB, genesisDocProvider)
 	if err != nil {
@@ -783,9 +787,9 @@ func NewNode(config *cfg.Config,
 		}
 	}
 
-	// Determine whether we should do fast sync. This must happen after the handshake, since the
+	// Determine whether we should do block sync. This must happen after the handshake, since the
 	// app may modify the validator set, specifying ourself as the only validator.
-	fastSync := config.FastSyncMode && !onlyValidatorIsUs(state, pubKey)
+	blockSync := config.BlockSyncMode && !onlyValidatorIsUs(state, pubKey)
 
 	logNodeStartupInfo(state, pubKey, logger, consensusLogger)
 
@@ -808,26 +812,26 @@ func NewNode(config *cfg.Config,
 		sm.BlockExecutorWithMetrics(smMetrics),
 	)
 
-	// Make BlockchainReactor. Don't start fast sync if we're doing a state sync first.
-	bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, fastSync && !stateSync, logger)
+	// Make BlockchainReactor. Don't start block sync if we're doing a state sync first.
+	bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, blockSync && !stateSync, logger)
 	if err != nil {
 		return nil, fmt.Errorf("could not create blockchain reactor: %w", err)
 	}
 
-	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or fast sync first.
+	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first.
 	// FIXME We need to update metrics here, since other reactors don't have access to them.
 	if stateSync {
 		csMetrics.StateSyncing.Set(1)
-	} else if fastSync {
-		csMetrics.FastSyncing.Set(1)
+	} else if blockSync {
+		csMetrics.BlockSyncing.Set(1)
 	}
 	consensusReactor, consensusState := createConsensusReactor(
 		config, state, blockExec, blockStore, mempool, evidencePool,
-		privValidator, csMetrics, stateSync || fastSync, eventBus, consensusLogger,
+		privValidator, csMetrics, stateSync || blockSync, eventBus, consensusLogger,
 	)
 
 	// Set up state sync reactor, and schedule a sync if requested.
-	// FIXME The way we do phased startups (e.g. replay -> fast sync -> consensus) is very messy,
+	// FIXME The way we do phased startups (e.g. replay -> block sync -> consensus) is very messy,
 	// we should clean this whole thing up. See:
 	// https://github.com/tendermint/tendermint/issues/4644
 	stateSyncReactor := statesync.NewReactor(
@@ -982,12 +986,12 @@ func (n *Node) OnStart() error {
 
 	// Run state sync
 	if n.stateSync {
-		bcR, ok := n.bcReactor.(fastSyncReactor)
+		bcR, ok := n.bcReactor.(blockSyncReactor)
 		if !ok {
 			return fmt.Errorf("this blockchain reactor does not support switching from state sync")
 		}
 		err := startStateSync(n.stateSyncReactor, bcR, n.consensusReactor, n.stateSyncProvider,
-			n.config.StateSync, n.config.FastSyncMode, n.stateStore, n.blockStore, n.stateSyncGenesis)
+			n.config.StateSync, n.config.BlockSyncMode, n.stateStore, n.blockStore, n.stateSyncGenesis)
 		if err != nil {
 			return fmt.Errorf("failed to start state sync: %w", err)
 		}
@@ -1335,7 +1339,7 @@ func makeNodeInfo(
 		Network:       genDoc.ChainID,
 		Version:       version.TMCoreSemVer,
 		Channels: []byte{
-			bc.BlockchainChannel,
+			bc.BlocksyncChannel,
 			cs.StateChannel, cs.DataChannel, cs.VoteChannel, cs.VoteSetBitsChannel,
 			mempl.MempoolChannel,
 			evidence.EvidenceChannel,
@@ -1390,7 +1394,9 @@ func LoadStateFromDBOrGenesisDocProvider(
 			return sm.State{}, nil, err
 		}
 	}
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 	if err != nil {
 		return sm.State{}, nil, err

node/node_test.go

@@ -235,7 +235,9 @@ func TestCreateProposalBlock(t *testing.T) {
 
 	var height int64 = 1
 	state, stateDB, privVals := state(1, height)
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	maxBytes := 16384
 	var partSize uint32 = 256
 	maxEvidenceBytes := int64(maxBytes / 2)
@@ -305,17 +307,14 @@ func TestCreateProposalBlock(t *testing.T) {
 	)
 
 	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
-	block, err := blockExec.CreateProposalBlock(
+	block, _ := blockExec.CreateProposalBlock(
 		height,
 		state, commit,
 		proposerAddr,
-		nil,
 	)
-	require.NoError(t, err)
 
 	// check that the part set does not exceed the maximum block size
-	partSet, err := block.MakePartSet(partSize)
-	require.NoError(t, err)
+	partSet := block.MakePartSet(partSize)
 	assert.Less(t, partSet.ByteSize(), int64(maxBytes))
 
 	partSetFromHeader := types.NewPartSetFromHeader(partSet.Header())
@@ -343,7 +342,9 @@ func TestMaxProposalBlockSize(t *testing.T) {
 
 	var height int64 = 1
 	state, stateDB, _ := state(1, height)
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	var maxBytes int64 = 16384
 	var partSize uint32 = 256
 	state.ConsensusParams.Block.MaxBytes = maxBytes
@@ -386,21 +387,18 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	)
 
 	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
-	block, err := blockExec.CreateProposalBlock(
+	block, _ := blockExec.CreateProposalBlock(
 		height,
 		state, commit,
 		proposerAddr,
-		nil,
 	)
-	require.NoError(t, err)
 
 	pb, err := block.ToProto()
 	require.NoError(t, err)
 	assert.Less(t, int64(pb.Size()), maxBytes)
 
 	// check that the part set does not exceed the maximum block size
-	partSet, err := block.MakePartSet(partSize)
-	require.NoError(t, err)
+	partSet := block.MakePartSet(partSize)
 	assert.EqualValues(t, partSet.ByteSize(), int64(pb.Size()))
 }
 
@@ -470,7 +468,9 @@ func state(nVals int, height int64) (sm.State, dbm.DB, []types.PrivValidator) {
 
 	// save validators to db for 2 heights
 	stateDB := dbm.NewMemDB()
-	stateStore := sm.NewStore(stateDB)
+	stateStore := sm.NewStore(stateDB, sm.StoreOptions{
+		DiscardABCIResponses: false,
+	})
 	if err := stateStore.Save(s); err != nil {
 		panic(err)
 	}