add ABCI interface for state sync snapshots (#4704)

Adds the ABCI interface for [state sync](https://github.com/tendermint/tendermint/issues/828) as outlined in [ADR-053](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-053-state-sync-prototype.md), and bumps ABCIVersion to `0.17.0`.

The interface adds a new ABCI connection which Tendermint can use to query and load snapshots from the app (for serving snapshots to other nodes), and to offer and apply snapshots to the app (for state syncing a local node from peers).

Split out from the original PR in #4645, state sync reactor will be submitted as a separate PR. The interface is implemented by the Cosmos SDK in https://github.com/cosmos/cosmos-sdk/pull/5803.

proxy/app_conn.go

@@ -5,6 +5,8 @@ import (
 	"github.com/tendermint/tendermint/abci/types"
 )
 
+//go:generate mockery -case underscore -name AppConnConsensus|AppConnMempool|AppConnQuery|AppConnSnapshot
+
 //----------------------------------------------------------------------------------------
 // Enforce which abci msgs can be sent on a connection at the type level
 
@@ -40,6 +42,15 @@ type AppConnQuery interface {
 	//	SetOptionSync(key string, value string) (res types.Result)
 }
 
+type AppConnSnapshot interface {
+	Error() 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)
+}
+
 //-----------------------------------------------------------------------------------------
 // Implements AppConnConsensus (subset of abcicli.Client)
 
@@ -142,3 +153,38 @@ func (app *appConnQuery) InfoSync(req types.RequestInfo) (*types.ResponseInfo, e
 func (app *appConnQuery) QuerySync(reqQuery types.RequestQuery) (*types.ResponseQuery, error) {
 	return app.appConn.QuerySync(reqQuery)
 }
+
+//------------------------------------------------
+// Implements AppConnSnapshot (subset of abcicli.Client)
+
+type appConnSnapshot struct {
+	appConn abcicli.Client
+}
+
+func NewAppConnSnapshot(appConn abcicli.Client) AppConnSnapshot {
+	return &appConnSnapshot{
+		appConn: appConn,
+	}
+}
+
+func (app *appConnSnapshot) Error() error {
+	return app.appConn.Error()
+}
+
+func (app *appConnSnapshot) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
+	return app.appConn.ListSnapshotsSync(req)
+}
+
+func (app *appConnSnapshot) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
+	return app.appConn.OfferSnapshotSync(req)
+}
+
+func (app *appConnSnapshot) LoadSnapshotChunkSync(
+	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+	return app.appConn.LoadSnapshotChunkSync(req)
+}
+
+func (app *appConnSnapshot) ApplySnapshotChunkSync(
+	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+	return app.appConn.ApplySnapshotChunkSync(req)
+}

proxy/mocks/app_conn_consensus.go

@@ -0,0 +1,142 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	abcicli "github.com/tendermint/tendermint/abci/client"
+
+	types "github.com/tendermint/tendermint/abci/types"
+)
+
+// AppConnConsensus is an autogenerated mock type for the AppConnConsensus type
+type AppConnConsensus struct {
+	mock.Mock
+}
+
+// BeginBlockSync provides a mock function with given fields: _a0
+func (_m *AppConnConsensus) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseBeginBlock
+	if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *types.ResponseBeginBlock); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseBeginBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestBeginBlock) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CommitSync provides a mock function with given fields:
+func (_m *AppConnConsensus) CommitSync() (*types.ResponseCommit, error) {
+	ret := _m.Called()
+
+	var r0 *types.ResponseCommit
+	if rf, ok := ret.Get(0).(func() *types.ResponseCommit); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseCommit)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeliverTxAsync provides a mock function with given fields: _a0
+func (_m *AppConnConsensus) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes {
+	ret := _m.Called(_a0)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *abcicli.ReqRes); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	return r0
+}
+
+// EndBlockSync provides a mock function with given fields: _a0
+func (_m *AppConnConsensus) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlock, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseEndBlock
+	if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *types.ResponseEndBlock); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseEndBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestEndBlock) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Error provides a mock function with given fields:
+func (_m *AppConnConsensus) Error() 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
+}
+
+// InitChainSync provides a mock function with given fields: _a0
+func (_m *AppConnConsensus) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInitChain, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseInitChain
+	if rf, ok := ret.Get(0).(func(types.RequestInitChain) *types.ResponseInitChain); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseInitChain)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestInitChain) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetResponseCallback provides a mock function with given fields: _a0
+func (_m *AppConnConsensus) SetResponseCallback(_a0 abcicli.Callback) {
+	_m.Called(_a0)
+}

proxy/mocks/app_conn_mempool.go

@@ -0,0 +1,80 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+	abcicli "github.com/tendermint/tendermint/abci/client"
+
+	types "github.com/tendermint/tendermint/abci/types"
+)
+
+// AppConnMempool is an autogenerated mock type for the AppConnMempool type
+type AppConnMempool struct {
+	mock.Mock
+}
+
+// CheckTxAsync provides a mock function with given fields: _a0
+func (_m *AppConnMempool) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes {
+	ret := _m.Called(_a0)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *abcicli.ReqRes); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	return r0
+}
+
+// Error provides a mock function with given fields:
+func (_m *AppConnMempool) Error() 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
+}
+
+// FlushAsync provides a mock function with given fields:
+func (_m *AppConnMempool) FlushAsync() *abcicli.ReqRes {
+	ret := _m.Called()
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	return r0
+}
+
+// FlushSync provides a mock function with given fields:
+func (_m *AppConnMempool) FlushSync() 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
+}
+
+// SetResponseCallback provides a mock function with given fields: _a0
+func (_m *AppConnMempool) SetResponseCallback(_a0 abcicli.Callback) {
+	_m.Called(_a0)
+}

proxy/mocks/app_conn_query.go

@@ -0,0 +1,97 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	types "github.com/tendermint/tendermint/abci/types"
+)
+
+// AppConnQuery is an autogenerated mock type for the AppConnQuery type
+type AppConnQuery struct {
+	mock.Mock
+}
+
+// EchoSync provides a mock function with given fields: _a0
+func (_m *AppConnQuery) EchoSync(_a0 string) (*types.ResponseEcho, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseEcho
+	if rf, ok := ret.Get(0).(func(string) *types.ResponseEcho); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseEcho)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Error provides a mock function with given fields:
+func (_m *AppConnQuery) Error() 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
+}
+
+// InfoSync provides a mock function with given fields: _a0
+func (_m *AppConnQuery) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseInfo
+	if rf, ok := ret.Get(0).(func(types.RequestInfo) *types.ResponseInfo); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseInfo)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestInfo) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// QuerySync provides a mock function with given fields: _a0
+func (_m *AppConnQuery) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseQuery
+	if rf, ok := ret.Get(0).(func(types.RequestQuery) *types.ResponseQuery); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseQuery)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestQuery) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

proxy/mocks/app_conn_snapshot.go

@@ -0,0 +1,120 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	mock "github.com/stretchr/testify/mock"
+
+	types "github.com/tendermint/tendermint/abci/types"
+)
+
+// AppConnSnapshot is an autogenerated mock type for the AppConnSnapshot type
+type AppConnSnapshot struct {
+	mock.Mock
+}
+
+// ApplySnapshotChunkSync provides a mock function with given fields: _a0
+func (_m *AppConnSnapshot) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseApplySnapshotChunk
+	if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseApplySnapshotChunk)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestApplySnapshotChunk) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Error provides a mock function with given fields:
+func (_m *AppConnSnapshot) Error() 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
+}
+
+// ListSnapshotsSync provides a mock function with given fields: _a0
+func (_m *AppConnSnapshot) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseListSnapshots
+	if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *types.ResponseListSnapshots); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseListSnapshots)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestListSnapshots) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// LoadSnapshotChunkSync provides a mock function with given fields: _a0
+func (_m *AppConnSnapshot) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseLoadSnapshotChunk
+	if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseLoadSnapshotChunk)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestLoadSnapshotChunk) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OfferSnapshotSync provides a mock function with given fields: _a0
+func (_m *AppConnSnapshot) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *types.ResponseOfferSnapshot
+	if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseOfferSnapshot)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.RequestOfferSnapshot) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

proxy/multi_app_conn.go

@@ -1,7 +1,7 @@
 package proxy
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/tendermint/tendermint/libs/service"
 )
@@ -15,6 +15,7 @@ type AppConns interface {
 	Mempool() AppConnMempool
 	Consensus() AppConnConsensus
 	Query() AppConnQuery
+	Snapshot() AppConnSnapshot
 }
 
 func NewAppConns(clientCreator ClientCreator) AppConns {
@@ -33,6 +34,7 @@ type multiAppConn struct {
 	mempoolConn   AppConnMempool
 	consensusConn AppConnConsensus
 	queryConn     AppConnQuery
+	snapshotConn  AppConnSnapshot
 
 	clientCreator ClientCreator
 }
@@ -61,37 +63,53 @@ func (app *multiAppConn) Query() AppConnQuery {
 	return app.queryConn
 }
 
+// Returns the snapshot Connection
+func (app *multiAppConn) Snapshot() AppConnSnapshot {
+	return app.snapshotConn
+}
+
 func (app *multiAppConn) OnStart() error {
 	// query connection
 	querycli, err := app.clientCreator.NewABCIClient()
 	if err != nil {
-		return errors.Wrap(err, "Error creating ABCI client (query connection)")
+		return fmt.Errorf("error creating ABCI client (query connection): %w", err)
 	}
 	querycli.SetLogger(app.Logger.With("module", "abci-client", "connection", "query"))
 	if err := querycli.Start(); err != nil {
-		return errors.Wrap(err, "Error starting ABCI client (query connection)")
+		return fmt.Errorf("error starting ABCI client (query connection): %w", err)
 	}
 	app.queryConn = NewAppConnQuery(querycli)
 
+	// snapshot connection
+	snapshotcli, err := app.clientCreator.NewABCIClient()
+	if err != nil {
+		return fmt.Errorf("error creating ABCI client (snapshot connection): %w", err)
+	}
+	snapshotcli.SetLogger(app.Logger.With("module", "abci-client", "connection", "snapshot"))
+	if err := snapshotcli.Start(); err != nil {
+		return fmt.Errorf("error starting ABCI client (snapshot connection): %w", err)
+	}
+	app.snapshotConn = NewAppConnSnapshot(snapshotcli)
+
 	// mempool connection
 	memcli, err := app.clientCreator.NewABCIClient()
 	if err != nil {
-		return errors.Wrap(err, "Error creating ABCI client (mempool connection)")
+		return fmt.Errorf("error creating ABCI client (mempool connection): %w", err)
 	}
 	memcli.SetLogger(app.Logger.With("module", "abci-client", "connection", "mempool"))
 	if err := memcli.Start(); err != nil {
-		return errors.Wrap(err, "Error starting ABCI client (mempool connection)")
+		return fmt.Errorf("error starting ABCI client (mempool connection): %w", err)
 	}
 	app.mempoolConn = NewAppConnMempool(memcli)
 
 	// consensus connection
 	concli, err := app.clientCreator.NewABCIClient()
 	if err != nil {
-		return errors.Wrap(err, "Error creating ABCI client (consensus connection)")
+		return fmt.Errorf("error creating ABCI client (consensus connection): %w", err)
 	}
 	concli.SetLogger(app.Logger.With("module", "abci-client", "connection", "consensus"))
 	if err := concli.Start(); err != nil {
-		return errors.Wrap(err, "Error starting ABCI client (consensus connection)")
+		return fmt.Errorf("error starting ABCI client (consensus connection): %w", err)
 	}
 	app.consensusConn = NewAppConnConsensus(concli)