feat: ABCI 1.0 baseapp integration

baseapp/abci.go

@@ -21,6 +21,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/types/mempool"
 )
 
 // Supported ABCI Query prefixes
@@ -38,6 +39,8 @@ func (app *BaseApp) InitChain(req abci.RequestInitChain) (res abci.ResponseInitC
 	// req.InitialHeight is 1 by default.
 	initHeader := tmproto.Header{ChainID: req.ChainId, Time: req.Time}
 
+	app.logger.Info("InitChain", "initialHeight", req.InitialHeight, "chainID", req.ChainId)
+
 	// If req.InitialHeight is > 1, then we set the initial version in the
 	// stores.
 	if req.InitialHeight > 1 {
@@ -49,9 +52,11 @@ func (app *BaseApp) InitChain(req abci.RequestInitChain) (res abci.ResponseInitC
 		}
 	}
 
-	// initialize the deliver state and check state with a correct header
+	// initialize states with a correct header
 	app.setDeliverState(initHeader)
 	app.setCheckState(initHeader)
+	app.setPrepareProposalState(initHeader)
+	app.setProcessProposalState(initHeader)
 
 	// Store the consensus params in the BaseApp's paramstore. Note, this must be
 	// done after the deliver state and context have been set as it's persisted
@@ -182,8 +187,6 @@ func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeg
 		WithHeaderHash(req.Hash).
 		WithConsensusParams(app.GetConsensusParams(app.deliverState.ctx))
 
-	// we also set block gas meter to checkState in case the application needs to
-	// verify gas consumption during (Re)CheckTx
 	if app.checkState != nil {
 		app.checkState.ctx = app.checkState.ctx.
 			WithBlockGasMeter(gasMeter).
@@ -238,19 +241,50 @@ func (app *BaseApp) EndBlock(req abci.RequestEndBlock) (res abci.ResponseEndBloc
 // work in a block before proposing it.
 //
 // Transactions can be modified, removed, or added by the application. Since the
-// application maintains it's own local mempool, it will ignore the transactions
+// application maintains its own local mempool, it will ignore the transactions
 // provided to it in RequestPrepareProposal. Instead, it will determine which
 // transactions to return based on the mempool's semantics and the MaxTxBytes
 // provided by the client's request.
 //
-// Note, there is no need to execute the transactions for validity as they have
-// already passed CheckTx.
-//
 // Ref: https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-060-abci-1.0.md
 // Ref: https://github.com/tendermint/tendermint/blob/main/spec/abci/abci%2B%2B_basic_concepts.md
 func (app *BaseApp) PrepareProposal(req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
-	// TODO: Implement.
-	return abci.ResponsePrepareProposal{Txs: req.Txs}
+	var (
+		txsBytes  [][]byte
+		byteCount int64
+	)
+
+	ctx := app.getContextForTx(runTxPrepareProposal, []byte{})
+	iterator := app.mempool.Select(ctx, req.Txs)
+
+	for iterator != nil {
+		memTx := iterator.Tx()
+
+		bz, err := app.txEncoder(memTx)
+		if err != nil {
+			panic(err)
+		}
+
+		txSize := int64(len(bz))
+
+		_, _, _, _, err = app.runTx(runTxPrepareProposal, bz)
+		if err != nil {
+			err := app.mempool.Remove(memTx)
+			if err != nil && !errors.Is(err, mempool.ErrTxNotFound) {
+				panic(err)
+			}
+			iterator = iterator.Next()
+			continue
+		} else if byteCount += txSize; byteCount <= req.MaxTxBytes {
+			txsBytes = append(txsBytes, bz)
+		} else {
+			break
+		}
+
+		iterator = iterator.Next()
+	}
+
+	return abci.ResponsePrepareProposal{Txs: txsBytes}
 }
 
 // ProcessProposal implements the ProcessProposal ABCI method and returns a
@@ -266,8 +300,19 @@ func (app *BaseApp) PrepareProposal(req abci.RequestPrepareProposal) abci.Respon
 // Ref: https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-060-abci-1.0.md
 // Ref: https://github.com/tendermint/tendermint/blob/main/spec/abci/abci%2B%2B_basic_concepts.md
 func (app *BaseApp) ProcessProposal(req abci.RequestProcessProposal) abci.ResponseProcessProposal {
-	// TODO: Implement.
-	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
+	if app.processProposal == nil {
+		panic("app.ProcessProposal is not set")
+	}
+
+	ctx := app.processProposalState.ctx.
+		WithVoteInfos(app.voteInfos).
+		WithBlockHeight(req.Height).
+		WithBlockTime(req.Time).
+		WithHeaderHash(req.Hash).
+		WithProposer(req.ProposerAddress)
+	ctx = ctx.WithConsensusParams(app.GetConsensusParams(ctx))
+
+	return app.processProposal(ctx, req)
 }
 
 // CheckTx implements the ABCI interface and executes a tx in CheckTx mode. In
@@ -367,6 +412,8 @@ func (app *BaseApp) Commit() (res abci.ResponseCommit) {
 	// NOTE: This is safe because Tendermint holds a lock on the mempool for
 	// Commit. Use the header from this latest block.
 	app.setCheckState(header)
+	app.setPrepareProposalState(header)
+	app.setProcessProposalState(header)
 
 	// empty/reset the deliver state
 	app.deliverState = nil

baseapp/abci_v1_test.go

@@ -0,0 +1,196 @@
+package baseapp_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+	"cosmossdk.io/depinject"
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	baseapptestutil "github.com/cosmos/cosmos-sdk/baseapp/testutil"
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/runtime"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/mempool"
+	authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
+)
+
+type NoopCounterServerImpl struct{}
+
+func (m NoopCounterServerImpl) IncrementCounter(
+	_ context.Context,
+	_ *baseapptestutil.MsgCounter,
+) (*baseapptestutil.MsgCreateCounterResponse, error) {
+	return &baseapptestutil.MsgCreateCounterResponse{}, nil
+}
+
+type ABCIv1TestSuite struct {
+	suite.Suite
+	baseApp  *baseapp.BaseApp
+	mempool  mempool.Mempool
+	txConfig client.TxConfig
+	cdc      codec.ProtoCodecMarshaler
+}
+
+func TestABCIv1TestSuite(t *testing.T) {
+	suite.Run(t, new(ABCIv1TestSuite))
+}
+
+func (s *ABCIv1TestSuite) SetupTest() {
+	t := s.T()
+	anteKey := []byte("ante-key")
+	pool := mempool.NewNonceMempool()
+	anteOpt := func(bapp *baseapp.BaseApp) {
+		bapp.SetAnteHandler(anteHandlerTxTest(t, capKey1, anteKey))
+	}
+
+	var (
+		appBuilder *runtime.AppBuilder
+		cdc        codec.ProtoCodecMarshaler
+		registry   codectypes.InterfaceRegistry
+	)
+	err := depinject.Inject(makeMinimalConfig(), &appBuilder, &cdc, &registry)
+	require.NoError(t, err)
+
+	app := setupBaseApp(t, anteOpt, baseapp.SetMempool(pool))
+	baseapptestutil.RegisterInterfaces(registry)
+	app.SetMsgServiceRouter(baseapp.NewMsgServiceRouter())
+	app.SetInterfaceRegistry(registry)
+
+	baseapptestutil.RegisterKeyValueServer(app.MsgServiceRouter(), MsgKeyValueImpl{})
+	baseapptestutil.RegisterCounterServer(app.MsgServiceRouter(), NoopCounterServerImpl{})
+	header := tmproto.Header{Height: app.LastBlockHeight() + 1}
+
+	app.InitChain(abci.RequestInitChain{
+		ConsensusParams: &tmproto.ConsensusParams{},
+	})
+
+	app.BeginBlock(abci.RequestBeginBlock{Header: header})
+
+	// patch in TxConfig insted of using an output from x/auth/tx
+	txConfig := authtx.NewTxConfig(cdc, authtx.DefaultSignModes)
+
+	app.SetTxDecoder(txConfig.TxDecoder())
+	app.SetTxEncoder(txConfig.TxEncoder())
+
+	s.baseApp = app
+	s.mempool = pool
+	s.txConfig = txConfig
+	s.cdc = cdc
+}
+
+func (s *ABCIv1TestSuite) TestABCIv1_HappyPath() {
+	txConfig := s.txConfig
+	t := s.T()
+
+	tx := newTxCounter(txConfig, 0, 1)
+	txBytes, err := txConfig.TxEncoder()(tx)
+	require.NoError(t, err)
+
+	reqCheckTx := abci.RequestCheckTx{
+		Tx:   txBytes,
+		Type: abci.CheckTxType_New,
+	}
+	s.baseApp.CheckTx(reqCheckTx)
+
+	tx2 := newTxCounter(txConfig, 1, 1)
+
+	tx2Bytes, err := txConfig.TxEncoder()(tx2)
+	require.NoError(t, err)
+
+	err = s.mempool.Insert(sdk.Context{}, tx2)
+	require.NoError(t, err)
+	reqPreparePropossal := abci.RequestPrepareProposal{
+		MaxTxBytes: 1000,
+	}
+	resPreparePropossal := s.baseApp.PrepareProposal(reqPreparePropossal)
+
+	require.Equal(t, 2, len(resPreparePropossal.Txs))
+
+	var reqProposalTxBytes [2][]byte
+	reqProposalTxBytes[0] = txBytes
+	reqProposalTxBytes[1] = tx2Bytes
+	reqProcessProposal := abci.RequestProcessProposal{
+		Txs: reqProposalTxBytes[:],
+	}
+
+	s.baseApp.SetProcessProposal(nil)
+	require.Panics(t, func() { s.baseApp.ProcessProposal(reqProcessProposal) })
+	s.baseApp.SetProcessProposal(s.baseApp.DefaultProcessProposal())
+
+	resProcessProposal := s.baseApp.ProcessProposal(reqProcessProposal)
+	require.Equal(t, abci.ResponseProcessProposal_ACCEPT, resProcessProposal.Status)
+
+	res := s.baseApp.DeliverTx(abci.RequestDeliverTx{Tx: txBytes})
+	require.Equal(t, 1, s.mempool.CountTx())
+
+	require.NotEmpty(t, res.Events)
+	require.True(t, res.IsOK(), fmt.Sprintf("%v", res))
+}
+
+func (s *ABCIv1TestSuite) TestABCIv1_PrepareProposal_ReachedMaxBytes() {
+	txConfig := s.txConfig
+	t := s.T()
+
+	for i := 0; i < 100; i++ {
+		tx2 := newTxCounter(txConfig, int64(i), int64(i))
+		err := s.mempool.Insert(sdk.Context{}, tx2)
+		require.NoError(t, err)
+	}
+
+	reqPreparePropossal := abci.RequestPrepareProposal{
+		MaxTxBytes: 1500,
+	}
+	resPreparePropossal := s.baseApp.PrepareProposal(reqPreparePropossal)
+
+	require.Equal(t, 10, len(resPreparePropossal.Txs))
+}
+
+func (s *ABCIv1TestSuite) TestABCIv1_PrepareProposal_BadEncoding() {
+	txConfig := authtx.NewTxConfig(s.cdc, authtx.DefaultSignModes)
+
+	t := s.T()
+
+	tx := newTxCounter(txConfig, 0, 0)
+	err := s.mempool.Insert(sdk.Context{}, tx)
+	require.NoError(t, err)
+
+	reqPrepareProposal := abci.RequestPrepareProposal{
+		MaxTxBytes: 1000,
+	}
+	resPrepareProposal := s.baseApp.PrepareProposal(reqPrepareProposal)
+
+	require.Equal(t, 1, len(resPrepareProposal.Txs))
+}
+
+func (s *ABCIv1TestSuite) TestABCIv1_PrepareProposal_Failures() {
+	tx := newTxCounter(s.txConfig, 0, 0)
+	txBytes, err := s.txConfig.TxEncoder()(tx)
+	s.NoError(err)
+
+	reqCheckTx := abci.RequestCheckTx{
+		Tx:   txBytes,
+		Type: abci.CheckTxType_New,
+	}
+	checkTxRes := s.baseApp.CheckTx(reqCheckTx)
+	s.True(checkTxRes.IsOK())
+
+	failTx := newTxCounter(s.txConfig, 1, 1)
+	failTx = setFailOnAnte(s.txConfig, failTx, true)
+	err = s.mempool.Insert(sdk.Context{}, failTx)
+	s.NoError(err)
+	s.Equal(2, s.mempool.CountTx())
+
+	req := abci.RequestPrepareProposal{
+		MaxTxBytes: 1000,
+	}
+	res := s.baseApp.PrepareProposal(req)
+	s.Equal(1, len(res.Txs))
+}