test(server/v2/cometbft): Add abci unit tests

server/v2/cometbft/go.mod

@@ -8,6 +8,7 @@ replace (
 	cosmossdk.io/core/testing => ../../../core/testing
 	cosmossdk.io/server/v2 => ../
 	cosmossdk.io/server/v2/appmanager => ../appmanager
+	cosmossdk.io/server/v2/stf => ../stf
 	cosmossdk.io/store => ../../../store
 	cosmossdk.io/store/v2 => ../../../store/v2
 	cosmossdk.io/x/accounts => ../../../x/accounts
@@ -27,6 +28,7 @@ require (
 	cosmossdk.io/log v1.4.1
 	cosmossdk.io/server/v2 v2.0.0-00010101000000-000000000000
 	cosmossdk.io/server/v2/appmanager v0.0.0-20240802110823-cffeedff643d
+	cosmossdk.io/server/v2/stf v0.0.0-20240708142107-25e99c54bac1
 	cosmossdk.io/store/v2 v2.0.0-00010101000000-000000000000
 	cosmossdk.io/x/consensus v0.0.0-00010101000000-000000000000
 	github.com/cometbft/cometbft v1.0.0-rc1
@@ -39,6 +41,7 @@ require (
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.19.0
+	github.com/stretchr/testify v1.9.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20240528184218-531527333157
 	google.golang.org/grpc v1.65.0
 	google.golang.org/protobuf v1.34.2
@@ -48,6 +51,7 @@ require (
 require (
 	buf.build/gen/go/cosmos/gogo-proto/protocolbuffers/go v1.34.2-20240130113600-88ef6483f90f.2 // indirect
 	cosmossdk.io/collections v0.4.0 // indirect
+	cosmossdk.io/core/testing v0.0.0-00010101000000-000000000000 // indirect
 	cosmossdk.io/depinject v1.0.0 // indirect
 	cosmossdk.io/errors/v2 v2.0.0-20240731132947-df72853b3ca5 // indirect
 	cosmossdk.io/math v1.3.0 // indirect
@@ -124,6 +128,7 @@ require (
 	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-sqlite3 v1.14.22 // indirect
 	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -149,7 +154,6 @@ require (
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.7.0 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/supranational/blst v0.3.12 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect

server/v2/cometbft/mock/mock_mempool.go

@@ -0,0 +1,23 @@
+package mock
+
+import (
+	"context"
+
+	"cosmossdk.io/core/transaction"
+	"cosmossdk.io/server/v2/cometbft/mempool"
+)
+
+var _ mempool.Mempool[transaction.Tx] = (*MockMempool[transaction.Tx])(nil)
+
+// MockMempool defines a no-op mempool. Transactions are completely discarded and
+// ignored when BaseApp interacts with the mempool.
+//
+// Note: When this mempool is used, it assumed that an application will rely
+// on CometBFT's transaction ordering defined in `RequestPrepareProposal`, which
+// is FIFO-ordered by default.
+type MockMempool[T transaction.Tx] struct{}
+
+func (MockMempool[T]) Insert(context.Context, T) error         { return nil }
+func (MockMempool[T]) Select(context.Context, []T) mempool.Iterator[T] { return nil }
+func (MockMempool[T]) CountTx() int                            { return 0 }
+func (MockMempool[T]) Remove([]T) error                        { return nil }

server/v2/cometbft/mock/mock_reader.go

@@ -0,0 +1,67 @@
+package mock
+
+import (
+	corestore "cosmossdk.io/core/store"
+	// ammstore "cosmossdk.io/server/v2/appmanager/store"
+	// "cosmossdk.io/server/v2/stf/branch"
+)
+
+// ReaderMap defines an adapter around a RootStore that only exposes read-only
+// operations. This is useful for exposing a read-only view of the RootStore at
+// a specific version in history, which could also be the latest state.
+type ReaderMap struct {
+	store   *MockStore
+	version uint64
+}
+
+func NewMockReaderMap(v uint64, rs *MockStore) *ReaderMap {
+	return &ReaderMap{
+		store:   rs,
+		version: v,
+	}
+}
+
+func (roa *ReaderMap) GetReader(actor []byte) (corestore.Reader, error) {
+	return NewMockReader(roa.version, roa.store, actor), nil
+}
+
+// Reader represents a read-only adapter for accessing data from the root store.
+type MockReader struct {
+	version uint64    // The version of the data.
+	store   *MockStore // The root store to read data from.
+	actor   []byte    // The actor associated with the data.
+}
+
+func NewMockReader(v uint64, rs *MockStore, actor []byte) *MockReader {
+	return &MockReader{
+		version: v,
+		store:   rs,
+		actor:   actor,
+	}
+}
+
+func (roa *MockReader) Has(key []byte) (bool, error) {
+	val, err := roa.store.GetStateStorage().Has(roa.actor, roa.version, key)
+	if err != nil {
+		return false, err
+	}
+
+	return val, nil
+}
+
+func (roa *MockReader) Get(key []byte) ([]byte, error) {
+	result, err := roa.store.GetStateStorage().Get(roa.actor, roa.version, key)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (roa *MockReader) Iterator(start, end []byte) (corestore.Iterator, error) {
+	return roa.store.GetStateStorage().Iterator(roa.actor, roa.version, start, end)
+}
+
+func (roa *MockReader) ReverseIterator(start, end []byte) (corestore.Iterator, error) {
+	return roa.store.GetStateStorage().ReverseIterator(roa.actor, roa.version, start, end)
+}

server/v2/cometbft/mock/mock_store.go

@@ -0,0 +1,142 @@
+package mock
+
+import (
+	"crypto/sha256"
+	"fmt"
+
+	"cosmossdk.io/core/log"
+	corestore "cosmossdk.io/core/store"
+
+
+	storev2 "cosmossdk.io/store/v2"
+	"cosmossdk.io/store/v2/commitment"
+	dbm "cosmossdk.io/store/v2/db"
+	"cosmossdk.io/store/v2/proof"
+	"cosmossdk.io/store/v2/storage"
+	"cosmossdk.io/store/v2/storage/sqlite"
+	"cosmossdk.io/store/v2/commitment/iavl"
+)
+
+type MockStore struct {
+	Storage  storev2.VersionedDatabase
+	Commiter storev2.Committer
+}
+
+func NewMockStorage(logger log.Logger, dir string) storev2.VersionedDatabase {
+	storageDB, _ := sqlite.New(dir)
+	ss := storage.NewStorageStore(storageDB, logger)
+	return ss
+}
+
+func NewMockCommiter(logger log.Logger, actors ...string) storev2.Committer {
+	treeMap := make(map[string]commitment.Tree)
+	for _, actor := range actors {
+		tree := iavl.NewIavlTree(dbm.NewMemDB(), logger, iavl.DefaultConfig())
+		treeMap[actor] = tree
+	}
+	sc, _ := commitment.NewCommitStore(treeMap, treeMap, dbm.NewMemDB(), logger)
+	return sc
+}
+
+func NewMockStore(ss storev2.VersionedDatabase, sc storev2.Committer) *MockStore {
+	return &MockStore{Storage: ss, Commiter: sc}
+}
+
+func (s *MockStore) GetLatestVersion() (uint64, error) {
+	lastCommitID, err := s.LastCommitID()
+	if err != nil {
+		return 0, err
+	}
+
+	return lastCommitID.Version, nil
+}
+
+func (s *MockStore) StateLatest() (uint64, corestore.ReaderMap, error) {
+	v, err := s.GetLatestVersion()
+	if err != nil {
+		return 0, nil, err
+	}
+
+	return v, NewMockReaderMap(v, s), nil
+}
+
+func (s *MockStore) Commit(changeset *corestore.Changeset) (corestore.Hash, error) {
+	v, _, _ := s.StateLatest()
+	err := s.Storage.ApplyChangeset(v, changeset)
+	if err != nil {
+		return []byte{}, err
+	}
+
+	err = s.Commiter.WriteChangeset(changeset)
+	if err != nil {
+		return []byte{}, err
+	}
+
+	commitInfo, err := s.Commiter.Commit(v+1)
+	fmt.Println("commitInfo", commitInfo, err)
+	return []byte{}, err
+}
+
+func (s *MockStore) StateAt(version uint64) (corestore.ReaderMap, error) {
+	info, err := s.Commiter.GetCommitInfo(version)
+	if err != nil || info == nil {
+		return nil, fmt.Errorf("failed to get commit info for version %d: %w", version, err)
+	}
+	return NewMockReaderMap(version, s), nil
+}
+
+func (s *MockStore) GetStateStorage() storev2.VersionedDatabase {
+	return s.Storage
+}
+
+func (s *MockStore) GetStateCommitment() storev2.Committer {
+	return s.Commiter
+}
+
+type Result struct {
+	key      []byte
+	value    []byte
+	version  uint64
+	proofOps []proof.CommitmentOp
+}
+
+func (s *MockStore) Query(storeKey []byte, version uint64, key []byte, prove bool) (storev2.QueryResult, error) {
+	state, err := s.StateAt(version)
+	reader, err := state.GetReader(storeKey)
+	value, err := reader.Get(key)
+	res := storev2.QueryResult{
+		Key:     key,
+		Value:   value,
+		Version: version,
+	}
+	return res, err
+}
+
+func (s *MockStore) LastCommitID() (proof.CommitID, error) {
+	v, err := s.GetStateCommitment().GetLatestVersion()
+	bz := sha256.Sum256([]byte{})
+	return proof.CommitID{
+		Version: v,
+		Hash:    bz[:],
+	}, err
+}
+
+func (s *MockStore) SetInitialVersion(v uint64) error {
+	return s.Commiter.SetInitialVersion(v)
+}
+
+func (s *MockStore) WorkingHash(changeset *corestore.Changeset) (corestore.Hash, error) {
+	v, _, _ := s.StateLatest()
+	err := s.Storage.ApplyChangeset(v, changeset)
+	if err != nil {
+		return []byte{}, err
+	}
+
+	err = s.Commiter.WriteChangeset(changeset)
+	if err != nil {
+		return []byte{}, err
+	}
+	return []byte{}, nil
+}
+
+

server/v2/stf/helper.go

@@ -0,0 +1,31 @@
+package stf
+
+import (
+	"context"
+
+	"cosmossdk.io/core/store"
+	"cosmossdk.io/server/v2/stf/mock"
+)
+
+// There some field not be exported
+// Helpers for cometbft test
+
+func GetExecutionContext(ctx context.Context) *executionContext {
+	executionCtx, ok := ctx.(*executionContext)
+	if !ok {
+		return nil
+	}
+	return executionCtx
+}
+
+func GetStateFromContext(ctx *executionContext) store.WriterMap {
+	return ctx.state
+}
+
+func SetMsgRouter(s *STF[mock.Tx], msgRouter coreRouterImpl) {
+	s.msgRouter = msgRouter
+}
+
+func SetQueryRouter(s *STF[mock.Tx], queryRouter coreRouterImpl) {
+	s.queryRouter = queryRouter
+}

server/v2/stf/mock/tx.go

@@ -65,56 +65,58 @@ func (t Tx) Bytes() []byte {
 	return tx
 }
 
-func (t *Tx) Decode(b []byte) {
+func (t *Tx) Decode(b []byte) error {
 	rawTx := new(encodedTx)
 	err := json.Unmarshal(b, rawTx)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	msgName, err := gogoproto.AnyMessageName(rawTx.Msg)
 	msgType := proto.MessageType(msgName).Elem()
 	if err != nil {
-		panic(err)
+		return err
 	}
 	msg := reflect.New(msgType).Interface().(proto.Message)
 	if err := gogoproto.UnmarshalAny(rawTx.Msg, msg); err != nil {
-		panic(err)
+		return err
 	}
 	t.Msg = msg
 	t.Sender = rawTx.Sender
 	t.GasLimit = rawTx.GasLimit
+	return nil
 }
 
-func (t *Tx) DecodeJSON(b []byte) {
+func (t *Tx) DecodeJSON(b []byte) error {
 	rawTx := new(encodedTx)
 	err := json.Unmarshal(b, rawTx)
 	if err != nil {
-		panic(err)
+		return err
 	}
 	msgName, err := gogoproto.AnyMessageName(rawTx.Msg)
 	msgType := proto.MessageType(msgName).Elem()
 	if err != nil {
-		panic(err)
+		return err
 	}
 	msg := reflect.New(msgType).Interface().(transaction.Msg)
 	if err := gogoproto.UnmarshalAny(rawTx.Msg, msg); err != nil {
-		panic(err)
+		return err
 	}
 	t.Msg = msg
 	t.Sender = rawTx.Sender
 	t.GasLimit = rawTx.GasLimit
+	return nil
 }
 
 type TxCodec struct{}
 
 func (TxCodec) Decode(bytes []byte) (Tx, error) {
 	t := new(Tx)
-	t.Decode(bytes)
-	return *t, nil
+	err := t.Decode(bytes)
+	return *t, err
 }
 
 func (TxCodec) DecodeJSON(bytes []byte) (Tx, error) {
 	t := new(Tx)
-	t.DecodeJSON(bytes)
-	return *t, nil
+	err := t.DecodeJSON(bytes)
+	return *t, err
 }