feat(server/v2): introduce cometbft v2 (#20483)

core/app/app.go

@@ -28,6 +28,9 @@ type BlockRequest[T any] struct {
 	AppHash           []byte
 	Txs               []T
 	ConsensusMessages []transaction.Msg
+
+	// IsGenesis indicates if this block is the first block of the chain.
+	IsGenesis bool
 }
 
 type BlockResponse struct {

runtime/v2/go.mod

@@ -50,7 +50,7 @@ require (
 	github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
 	github.com/cosmos/cosmos-db v1.0.2 // indirect
 	github.com/cosmos/cosmos-proto v1.0.0-beta.5 // indirect
-	github.com/cosmos/iavl v1.1.4 // indirect
+	github.com/cosmos/iavl v1.2.0 // indirect
 	github.com/cosmos/ics23/go v0.10.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/emicklei/dot v1.6.2 // indirect

runtime/v2/go.sum

@@ -42,8 +42,8 @@ github.com/cosmos/cosmos-proto v1.0.0-beta.5 h1:eNcayDLpip+zVLRLYafhzLvQlSmyab+R
 github.com/cosmos/cosmos-proto v1.0.0-beta.5/go.mod h1:hQGLpiIUloJBMdQMMWb/4wRApmI9hjHH05nefC0Ojec=
 github.com/cosmos/gogoproto v1.4.12 h1:vB6Lbe/rtnYGjQuFxkPiPYiCybqFT8QvLipDZP8JpFE=
 github.com/cosmos/gogoproto v1.4.12/go.mod h1:LnZob1bXRdUoqMMtwYlcR3wjiElmlC+FkjaZRv1/eLY=
-github.com/cosmos/iavl v1.1.4 h1:Z0cVVjeQqOUp78/nWt/uhQy83vYluWlAMGQ4zbH9G34=
-github.com/cosmos/iavl v1.1.4/go.mod h1:vCYmRQUJU1wwj0oRD3wMEtOM9sJNDP+GFMaXmIxZ/rU=
+github.com/cosmos/iavl v1.2.0 h1:kVxTmjTh4k0Dh1VNL046v6BXqKziqMDzxo93oh3kOfM=
+github.com/cosmos/iavl v1.2.0/go.mod h1:HidWWLVAtODJqFD6Hbne2Y0q3SdxByJepHUOeoH4LiI=
 github.com/cosmos/ics23/go v0.10.0 h1:iXqLLgp2Lp+EdpIuwXTYIQU+AiHj9mOC2X9ab++bZDM=
 github.com/cosmos/ics23/go v0.10.0/go.mod h1:ZfJSmng/TBNTBkFemHHHj5YY7VAU/MBU980F4VU1NG0=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=

server/v2/cometbft/abci.go

@@ -0,0 +1,596 @@
+package cometbft
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+
+	coreappmgr "cosmossdk.io/core/app"
+	"cosmossdk.io/core/comet"
+	"cosmossdk.io/core/event"
+	"cosmossdk.io/core/log"
+	"cosmossdk.io/core/store"
+	"cosmossdk.io/core/transaction"
+	errorsmod "cosmossdk.io/errors"
+	"cosmossdk.io/server/v2/appmanager"
+	"cosmossdk.io/server/v2/cometbft/handlers"
+	"cosmossdk.io/server/v2/cometbft/mempool"
+	"cosmossdk.io/server/v2/cometbft/types"
+	cometerrors "cosmossdk.io/server/v2/cometbft/types/errors"
+	"cosmossdk.io/server/v2/streaming"
+	"cosmossdk.io/store/v2/snapshots"
+	consensustypes "cosmossdk.io/x/consensus/types"
+)
+
+const (
+	QueryPathApp   = "app"
+	QueryPathP2P   = "p2p"
+	QueryPathStore = "store"
+)
+
+var _ abci.Application = (*Consensus[transaction.Tx])(nil)
+
+type Consensus[T transaction.Tx] struct {
+	app             *appmanager.AppManager[T]
+	cfg             Config
+	store           types.Store
+	logger          log.Logger
+	txCodec         transaction.Codec[T]
+	streaming       streaming.Manager
+	snapshotManager *snapshots.Manager
+	mempool         mempool.Mempool[T]
+
+	// this is only available after this node has committed a block (in FinalizeBlock),
+	// otherwise it will be empty and we will need to query the app for the last
+	// committed block. TODO(tip): check if concurrency is really needed
+	lastCommittedBlock atomic.Pointer[BlockData]
+
+	prepareProposalHandler handlers.PrepareHandler[T]
+	processProposalHandler handlers.ProcessHandler[T]
+	verifyVoteExt          handlers.VerifyVoteExtensionhandler
+	extendVote             handlers.ExtendVoteHandler
+
+	chainID string
+}
+
+func NewConsensus[T transaction.Tx](
+	app *appmanager.AppManager[T],
+	mp mempool.Mempool[T],
+	store types.Store,
+	cfg Config,
+	txCodec transaction.Codec[T],
+	logger log.Logger,
+) *Consensus[T] {
+	return &Consensus[T]{
+		mempool: mp,
+		store:   store,
+		app:     app,
+		cfg:     cfg,
+		txCodec: txCodec,
+		logger:  logger,
+	}
+}
+
+func (c *Consensus[T]) SetMempool(mp mempool.Mempool[T]) {
+	c.mempool = mp
+}
+
+func (c *Consensus[T]) SetStreamingManager(sm streaming.Manager) {
+	c.streaming = sm
+}
+
+// SetSnapshotManager sets the snapshot manager for the Consensus.
+// The snapshot manager is responsible for managing snapshots of the Consensus state.
+// It allows for creating, storing, and restoring snapshots of the Consensus state.
+// The provided snapshot manager will be used by the Consensus to handle snapshots.
+func (c *Consensus[T]) SetSnapshotManager(sm *snapshots.Manager) {
+	c.snapshotManager = sm
+}
+
+// RegisterExtensions registers the given extensions with the consensus module's snapshot manager.
+// It allows additional snapshotter implementations to be used for creating and restoring snapshots.
+func (c *Consensus[T]) RegisterExtensions(extensions ...snapshots.ExtensionSnapshotter) {
+	if err := c.snapshotManager.RegisterExtensions(extensions...); err != nil {
+		panic(fmt.Errorf("failed to register snapshot extensions: %w", err))
+	}
+}
+
+func (c *Consensus[T]) SetPrepareProposalHandler(handler handlers.PrepareHandler[T]) {
+	c.prepareProposalHandler = handler
+}
+
+func (c *Consensus[T]) SetProcessProposalHandler(handler handlers.ProcessHandler[T]) {
+	c.processProposalHandler = handler
+}
+
+func (c *Consensus[T]) SetExtendVoteExtension(handler handlers.ExtendVoteHandler) {
+	c.extendVote = handler
+}
+
+func (c *Consensus[T]) SetVerifyVoteExtension(handler handlers.VerifyVoteExtensionhandler) {
+	c.verifyVoteExt = handler
+}
+
+// BlockData is used to keep some data about the last committed block. Currently
+// we only use the height, the rest is not needed right now and might get removed
+// in the future.
+type BlockData struct {
+	Height       int64
+	Hash         []byte
+	StateChanges []store.StateChanges
+}
+
+// CheckTx implements types.Application.
+// It is called by cometbft to verify transaction validity
+func (c *Consensus[T]) CheckTx(ctx context.Context, req *abci.CheckTxRequest) (*abci.CheckTxResponse, error) {
+	decodedTx, err := c.txCodec.Decode(req.Tx)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.app.ValidateTx(ctx, decodedTx)
+	if err != nil {
+		return nil, err
+	}
+
+	cometResp := &abci.CheckTxResponse{
+		Code:      resp.Code,
+		GasWanted: uint64ToInt64(resp.GasWanted),
+		GasUsed:   uint64ToInt64(resp.GasUsed),
+		Events:    intoABCIEvents(resp.Events, c.cfg.IndexEvents),
+		Info:      resp.Info,
+		Data:      resp.Data,
+		Log:       resp.Log,
+		Codespace: resp.Codespace,
+	}
+	if resp.Error != nil {
+		cometResp.Code = 1
+		cometResp.Log = resp.Error.Error()
+	}
+	return cometResp, nil
+}
+
+// Info implements types.Application.
+func (c *Consensus[T]) Info(ctx context.Context, _ *abci.InfoRequest) (*abci.InfoResponse, error) {
+	version, _, err := c.store.StateLatest()
+	if err != nil {
+		return nil, err
+	}
+
+	// cp, err := c.GetConsensusParams(ctx)
+	// if err != nil {
+	//	return nil, err
+	// }
+
+	cid, err := c.store.LastCommitID()
+	if err != nil {
+		return nil, err
+	}
+
+	return &abci.InfoResponse{
+		Data:    c.cfg.Name,
+		Version: c.cfg.Version,
+		// AppVersion:       cp.GetVersion().App,
+		AppVersion:       0, // TODO fetch from store?
+		LastBlockHeight:  int64(version),
+		LastBlockAppHash: cid.Hash,
+	}, nil
+}
+
+// Query implements types.Application.
+// It is called by cometbft to query application state.
+func (c *Consensus[T]) Query(ctx context.Context, req *abci.QueryRequest) (*abci.QueryResponse, error) {
+	// follow the query path from here
+	decodedMsg, err := c.txCodec.Decode(req.Data)
+	protoMsg, ok := any(decodedMsg).(transaction.Msg)
+	if !ok {
+		return nil, fmt.Errorf("decoded type T %T must implement core/transaction.Msg", decodedMsg)
+	}
+
+	// if no error is returned then we can handle the query with the appmanager
+	// otherwise it is a KV store query
+	if err == nil {
+		res, err := c.app.Query(ctx, uint64(req.Height), protoMsg)
+		if err != nil {
+			return nil, err
+		}
+
+		return queryResponse(res)
+	}
+
+	// this error most probably means that we can't handle it with a proto message, so
+	// it must be an app/p2p/store query
+	path := splitABCIQueryPath(req.Path)
+	if len(path) == 0 {
+		return QueryResult(errorsmod.Wrap(cometerrors.ErrUnknownRequest, "no query path provided"), c.cfg.Trace), nil
+	}
+
+	var resp *abci.QueryResponse
+
+	switch path[0] {
+	case QueryPathApp:
+		resp, err = c.handlerQueryApp(ctx, path, req)
+
+	case QueryPathStore:
+		resp, err = c.handleQueryStore(path, c.store, req)
+
+	case QueryPathP2P:
+		resp, err = c.handleQueryP2P(path)
+
+	default:
+		resp = QueryResult(errorsmod.Wrap(cometerrors.ErrUnknownRequest, "unknown query path"), c.cfg.Trace)
+	}
+
+	if err != nil {
+		return QueryResult(err, c.cfg.Trace), nil
+	}
+
+	return resp, nil
+}
+
+// InitChain implements types.Application.
+func (c *Consensus[T]) InitChain(ctx context.Context, req *abci.InitChainRequest) (*abci.InitChainResponse, error) {
+	c.logger.Info("InitChain", "initialHeight", req.InitialHeight, "chainID", req.ChainId)
+
+	// store chainID to be used later on in execution
+	c.chainID = req.ChainId
+
+	// On a new chain, we consider the init chain block height as 0, even though
+	// req.InitialHeight is 1 by default.
+	// TODO
+
+	var consMessages []transaction.Msg
+	if req.ConsensusParams != nil {
+		consMessages = append(consMessages, &consensustypes.MsgUpdateParams{
+			Authority: c.cfg.ConsensusAuthority,
+			Block:     req.ConsensusParams.Block,
+			Evidence:  req.ConsensusParams.Evidence,
+			Validator: req.ConsensusParams.Validator,
+			Abci:      req.ConsensusParams.Abci,
+		})
+	}
+
+	br := &coreappmgr.BlockRequest[T]{
+		Height:            uint64(req.InitialHeight - 1),
+		Time:              req.Time,
+		Hash:              nil,
+		AppHash:           nil,
+		ChainId:           req.ChainId,
+		ConsensusMessages: consMessages,
+		IsGenesis:         true,
+	}
+
+	blockresponse, genesisState, err := c.app.InitGenesis(
+		ctx,
+		br,
+		req.AppStateBytes,
+		c.txCodec)
+	if err != nil {
+		return nil, fmt.Errorf("genesis state init failure: %w", err)
+	}
+
+	// TODO necessary? where should this WARN live if it all. helpful for testing
+	for _, txRes := range blockresponse.TxResults {
+		if txRes.Error != nil {
+			c.logger.Warn("genesis tx failed", "code", txRes.Code, "log", txRes.Log, "error", txRes.Error)
+		}
+	}
+
+	validatorUpdates := intoABCIValidatorUpdates(blockresponse.ValidatorUpdates)
+
+	stateChanges, err := genesisState.GetStateChanges()
+	if err != nil {
+		return nil, err
+	}
+	cs := &store.Changeset{
+		Changes: stateChanges,
+	}
+	stateRoot, err := c.store.Commit(cs)
+	if err != nil {
+		return nil, fmt.Errorf("unable to commit the changeset: %w", err)
+	}
+
+	return &abci.InitChainResponse{
+		ConsensusParams: req.ConsensusParams,
+		Validators:      validatorUpdates,
+		AppHash:         stateRoot,
+	}, nil
+}
+
+// PrepareProposal implements types.Application.
+// It is called by cometbft to prepare a proposal block.
+func (c *Consensus[T]) PrepareProposal(
+	ctx context.Context,
+	req *abci.PrepareProposalRequest,
+) (resp *abci.PrepareProposalResponse, err error) {
+	if req.Height < 1 {
+		return nil, errors.New("PrepareProposal called with invalid height")
+	}
+
+	decodedTxs := make([]T, len(req.Txs))
+	for _, tx := range req.Txs {
+		decTx, err := c.txCodec.Decode(tx)
+		if err != nil {
+			// TODO: vote extension meta data as a custom type to avoid possibly accepting invalid txs
+			// continue even if tx decoding fails
+			c.logger.Error("failed to decode tx", "err", err)
+		}
+		decodedTxs = append(decodedTxs, decTx)
+	}
+
+	ciCtx := contextWithCometInfo(ctx, comet.Info{
+		Evidence:        toCoreEvidence(req.Misbehavior),
+		ValidatorsHash:  req.NextValidatorsHash,
+		ProposerAddress: req.ProposerAddress,
+		LastCommit:      toCoreExtendedCommitInfo(req.LocalLastCommit),
+	})
+
+	txs, err := c.prepareProposalHandler(ciCtx, c.app, decodedTxs, req)
+	if err != nil {
+		return nil, err
+	}
+
+	encodedTxs := make([][]byte, len(txs))
+	for i, tx := range txs {
+		encodedTxs[i] = tx.Bytes()
+	}
+
+	return &abci.PrepareProposalResponse{
+		Txs: encodedTxs,
+	}, nil
+}
+
+// ProcessProposal implements types.Application.
+// It is called by cometbft to process/verify a proposal block.
+func (c *Consensus[T]) ProcessProposal(
+	ctx context.Context,
+	req *abci.ProcessProposalRequest,
+) (*abci.ProcessProposalResponse, error) {
+	decodedTxs := make([]T, len(req.Txs))
+	for _, tx := range req.Txs {
+		decTx, err := c.txCodec.Decode(tx)
+		if err != nil {
+			// TODO: vote extension meta data as a custom type to avoid possibly accepting invalid txs
+			// continue even if tx decoding fails
+			c.logger.Error("failed to decode tx", "err", err)
+		}
+		decodedTxs = append(decodedTxs, decTx)
+	}
+
+	ciCtx := contextWithCometInfo(ctx, comet.Info{
+		Evidence:        toCoreEvidence(req.Misbehavior),
+		ValidatorsHash:  req.NextValidatorsHash,
+		ProposerAddress: req.ProposerAddress,
+		LastCommit:      toCoreCommitInfo(req.ProposedLastCommit),
+	})
+
+	err := c.processProposalHandler(ciCtx, c.app, decodedTxs, req)
+	if err != nil {
+		c.logger.Error("failed to process proposal", "height", req.Height, "time", req.Time, "hash", fmt.Sprintf("%X", req.Hash), "err", err)
+		return &abci.ProcessProposalResponse{
+			Status: abci.PROCESS_PROPOSAL_STATUS_REJECT,
+		}, nil
+	}
+
+	return &abci.ProcessProposalResponse{
+		Status: abci.PROCESS_PROPOSAL_STATUS_ACCEPT,
+	}, nil
+}
+
+// FinalizeBlock implements types.Application.
+// It is called by cometbft to finalize a block.
+func (c *Consensus[T]) FinalizeBlock(
+	ctx context.Context,
+	req *abci.FinalizeBlockRequest,
+) (*abci.FinalizeBlockResponse, error) {
+	if err := c.validateFinalizeBlockHeight(req); err != nil {
+		return nil, err
+	}
+
+	if err := c.checkHalt(req.Height, req.Time); err != nil {
+		return nil, err
+	}
+
+	// TODO evaluate this approach vs. service using context.
+	// cometInfo := &consensustypes.MsgUpdateCometInfo{
+	//	Authority: c.cfg.ConsensusAuthority,
+	//	CometInfo: &consensustypes.CometInfo{
+	//		Evidence:        req.Misbehavior,
+	//		ValidatorsHash:  req.NextValidatorsHash,
+	//		ProposerAddress: req.ProposerAddress,
+	//		LastCommit:      req.DecidedLastCommit,
+	//	},
+	//}
+	//
+	// ctx = context.WithValue(ctx, corecontext.CometInfoKey, &comet.Info{
+	// 	Evidence:        sdktypes.ToSDKEvidence(req.Misbehavior),
+	// 	ValidatorsHash:  req.NextValidatorsHash,
+	// 	ProposerAddress: req.ProposerAddress,
+	// 	LastCommit:      sdktypes.ToSDKCommitInfo(req.DecidedLastCommit),
+	// })
+
+	// TODO(tip): can we expect some txs to not decode? if so, what we do in this case? this does not seem to be the case,
+	// considering that prepare and process always decode txs, assuming they're the ones providing txs we should never
+	// have a tx that fails decoding.
+	decodedTxs, err := decodeTxs(req.Txs, c.txCodec)
+	if err != nil {
+		return nil, err
+	}
+
+	cid, err := c.store.LastCommitID()
+	if err != nil {
+		return nil, err
+	}
+
+	blockReq := &coreappmgr.BlockRequest[T]{
+		Height:  uint64(req.Height),
+		Time:    req.Time,
+		Hash:    req.Hash,
+		AppHash: cid.Hash,
+		ChainId: c.chainID,
+		Txs:     decodedTxs,
+		// ConsensusMessages: []transaction.Msg{cometInfo},
+	}
+
+	ciCtx := contextWithCometInfo(ctx, comet.Info{
+		Evidence:        toCoreEvidence(req.Misbehavior),
+		ValidatorsHash:  req.NextValidatorsHash,
+		ProposerAddress: req.ProposerAddress,
+		LastCommit:      toCoreCommitInfo(req.DecidedLastCommit),
+	})
+
+	resp, newState, err := c.app.DeliverBlock(ciCtx, blockReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// after we get the changeset we can produce the commit hash,
+	// from the store.
+	stateChanges, err := newState.GetStateChanges()
+	if err != nil {
+		return nil, err
+	}
+	appHash, err := c.store.Commit(&store.Changeset{Changes: stateChanges})
+	if err != nil {
+		return nil, fmt.Errorf("unable to commit the changeset: %w", err)
+	}
+
+	var events []event.Event
+	events = append(events, resp.PreBlockEvents...)
+	events = append(events, resp.BeginBlockEvents...)
+	for _, tx := range resp.TxResults {
+		events = append(events, tx.Events...)
+	}
+	events = append(events, resp.EndBlockEvents...)
+
+	// listen to state streaming changes in accordance with the block
+	err = c.streamDeliverBlockChanges(ctx, req.Height, req.Txs, resp.TxResults, events, stateChanges)
+	if err != nil {
+		return nil, err
+	}
+
+	// remove txs from the mempool
+	err = c.mempool.Remove(decodedTxs)
+	if err != nil {
+		return nil, fmt.Errorf("unable to remove txs: %w", err)
+	}
+
+	c.lastCommittedBlock.Store(&BlockData{
+		Height:       req.Height,
+		Hash:         appHash,
+		StateChanges: stateChanges,
+	})
+
+	cp, err := c.GetConsensusParams(ctx) // we get the consensus params from the latest state because we committed state above
+	if err != nil {
+		return nil, err
+	}
+
+	return finalizeBlockResponse(resp, cp, appHash, c.cfg.IndexEvents)
+}
+
+// Commit implements types.Application.
+// It is called by cometbft to notify the application that a block was committed.
+func (c *Consensus[T]) Commit(ctx context.Context, _ *abci.CommitRequest) (*abci.CommitResponse, error) {
+	lastCommittedBlock := c.lastCommittedBlock.Load()
+
+	c.snapshotManager.SnapshotIfApplicable(lastCommittedBlock.Height)
+
+	cp, err := c.GetConsensusParams(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &abci.CommitResponse{
+		RetainHeight: c.GetBlockRetentionHeight(cp, lastCommittedBlock.Height),
+	}, nil
+}
+
+// Vote extensions
+// VerifyVoteExtension implements types.Application.
+func (c *Consensus[T]) VerifyVoteExtension(
+	ctx context.Context,
+	req *abci.VerifyVoteExtensionRequest,
+) (*abci.VerifyVoteExtensionResponse, error) {
+	// If vote extensions are not enabled, as a safety precaution, we return an
+	// error.
+	cp, err := c.GetConsensusParams(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	// Note: we verify votes extensions on VoteExtensionsEnableHeight+1. Check
+	// comment in ExtendVote and ValidateVoteExtensions for more details.
+	extsEnabled := cp.Abci != nil && req.Height >= cp.Abci.VoteExtensionsEnableHeight && cp.Abci.VoteExtensionsEnableHeight != 0
+	if !extsEnabled {
+		return nil, fmt.Errorf("vote extensions are not enabled; unexpected call to VerifyVoteExtension at height %d", req.Height)
+	}
+
+	if c.verifyVoteExt == nil {
+		return nil, fmt.Errorf("vote extensions are enabled but no verify function was set")
+	}
+
+	_, latestStore, err := c.store.StateLatest()
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.verifyVoteExt(ctx, latestStore, req)
+	if err != nil {
+		c.logger.Error("failed to verify vote extension", "height", req.Height, "err", err)
+		return &abci.VerifyVoteExtensionResponse{Status: abci.VERIFY_VOTE_EXTENSION_STATUS_REJECT}, nil
+	}
+
+	return resp, err
+}
+
+// ExtendVote implements types.Application.
+func (c *Consensus[T]) ExtendVote(ctx context.Context, req *abci.ExtendVoteRequest) (*abci.ExtendVoteResponse, error) {
+	// If vote extensions are not enabled, as a safety precaution, we return an
+	// error.
+	cp, err := c.GetConsensusParams(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	// Note: In this case, we do want to extend vote if the height is equal or
+	// greater than VoteExtensionsEnableHeight. This defers from the check done
+	// in ValidateVoteExtensions and PrepareProposal in which we'll check for
+	// vote extensions on VoteExtensionsEnableHeight+1.
+	extsEnabled := cp.Abci != nil && req.Height >= cp.Abci.VoteExtensionsEnableHeight && cp.Abci.VoteExtensionsEnableHeight != 0
+	if !extsEnabled {
+		return nil, fmt.Errorf("vote extensions are not enabled; unexpected call to ExtendVote at height %d", req.Height)
+	}
+
+	if c.verifyVoteExt == nil {
+		return nil, fmt.Errorf("vote extensions are enabled but no verify function was set")
+	}
+
+	_, latestStore, err := c.store.StateLatest()
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.extendVote(ctx, latestStore, req)
+	if err != nil {
+		c.logger.Error("failed to verify vote extension", "height", req.Height, "err", err)
+		return &abci.ExtendVoteResponse{}, nil
+	}
+
+	return resp, err
+}
+
+func decodeTxs[T transaction.Tx](rawTxs [][]byte, codec transaction.Codec[T]) ([]T, error) {
+	txs := make([]T, len(rawTxs))
+	for i, rawTx := range rawTxs {
+		tx, err := codec.Decode(rawTx)
+		if err != nil {
+			return nil, fmt.Errorf("unable to decode tx: %d: %w", i, err)
+		}
+		txs[i] = tx
+	}
+	return txs, nil
+}

server/v2/cometbft/client/grpc/cmtservice/autocli.go

@@ -0,0 +1,71 @@
+package cmtservice
+
+import (
+	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
+	cmtv1beta1 "cosmossdk.io/api/cosmos/base/tendermint/v1beta1"
+)
+
+var CometBFTAutoCLIDescriptor = &autocliv1.ServiceCommandDescriptor{
+	Service: cmtv1beta1.Service_ServiceDesc.ServiceName,
+	RpcCommandOptions: []*autocliv1.RpcCommandOptions{
+		{
+			RpcMethod: "GetNodeInfo",
+			Use:       "node-info",
+			Short:     "Query the current node info",
+		},
+		{
+			RpcMethod: "GetSyncing",
+			Use:       "syncing",
+			Short:     "Query node syncing status",
+		},
+		{
+			RpcMethod: "GetLatestBlock",
+			Use:       "block-latest",
+			Short:     "Query for the latest committed block",
+		},
+		{
+			RpcMethod:      "GetBlockByHeight",
+			Use:            "block-by-height [height]",
+			Short:          "Query for a committed block by height",
+			Long:           "Query for a specific committed block using the CometBFT RPC `block_by_height` method",
+			PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "height"}},
+		},
+		{
+			RpcMethod: "GetLatestValidatorSet",
+			Use:       "validator-set",
+			Alias:     []string{"validator-set-latest", "comet-validator-set", "cometbft-validator-set", "tendermint-validator-set"},
+			Short:     "Query for the latest validator set",
+		},
+		{
+			RpcMethod:      "GetValidatorSetByHeight",
+			Use:            "validator-set-by-height [height]",
+			Short:          "Query for a validator set by height",
+			PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "height"}},
+		},
+		{
+			RpcMethod: "ABCIQuery",
+			Skip:      true,
+		},
+	},
+}
+
+// NewCometBFTCommands is a fake `appmodule.Module` to be considered as a module
+// and be added in AutoCLI.
+func NewCometBFTCommands() *cometModule {
+	return &cometModule{}
+}
+
+type cometModule struct{}
+
+func (m cometModule) IsOnePerModuleType() {}
+func (m cometModule) IsAppModule()        {}
+
+func (m cometModule) Name() string {
+	return "comet"
+}
+
+func (m cometModule) AutoCLIOptions() *autocliv1.ModuleOptions {
+	return &autocliv1.ModuleOptions{
+		Query: CometBFTAutoCLIDescriptor,
+	}
+}

server/v2/cometbft/client/grpc/cmtservice/query.pb.gw.go

@@ -0,0 +1,669 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: cosmos/base/tendermint/v1beta1/query.proto
+
+/*
+Package cmtservice is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package cmtservice
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"github.com/golang/protobuf/descriptor"
+	"github.com/golang/protobuf/proto"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/grpc-ecosystem/grpc-gateway/utilities"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+)
+
+// Suppress "imported and not used" errors
+var _ codes.Code
+var _ io.Reader
+var _ status.Status
+var _ = runtime.String
+var _ = utilities.NewDoubleArray
+var _ = descriptor.ForMessage
+var _ = metadata.Join
+
+func request_Service_GetNodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeInfoRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.GetNodeInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetNodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetNodeInfoRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.GetNodeInfo(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Service_GetSyncing_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetSyncingRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.GetSyncing(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetSyncing_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetSyncingRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.GetSyncing(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Service_GetLatestBlock_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetLatestBlockRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.GetLatestBlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetLatestBlock_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetLatestBlockRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.GetLatestBlock(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Service_GetBlockByHeight_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetBlockByHeightRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	msg, err := client.GetBlockByHeight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetBlockByHeight_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetBlockByHeightRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	msg, err := server.GetBlockByHeight(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Service_GetLatestValidatorSet_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Service_GetLatestValidatorSet_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetLatestValidatorSetRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_GetLatestValidatorSet_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.GetLatestValidatorSet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetLatestValidatorSet_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetLatestValidatorSetRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_GetLatestValidatorSet_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.GetLatestValidatorSet(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Service_GetValidatorSetByHeight_0 = &utilities.DoubleArray{Encoding: map[string]int{"height": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Service_GetValidatorSetByHeight_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetValidatorSetByHeightRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_GetValidatorSetByHeight_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.GetValidatorSetByHeight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_GetValidatorSetByHeight_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq GetValidatorSetByHeightRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_GetValidatorSetByHeight_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.GetValidatorSetByHeight(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Service_ABCIQuery_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Service_ABCIQuery_0(ctx context.Context, marshaler runtime.Marshaler, client ServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ABCIQueryRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_ABCIQuery_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.ABCIQuery(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Service_ABCIQuery_0(ctx context.Context, marshaler runtime.Marshaler, server ServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq ABCIQueryRequest
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Service_ABCIQuery_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.ABCIQuery(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+// RegisterServiceHandlerServer registers the http handlers for service Service to "mux".
+// UnaryRPC     :call ServiceServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceHandlerFromEndpoint instead.
+func RegisterServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceServer) error {
+
+	mux.Handle("GET", pattern_Service_GetNodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetNodeInfo_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetNodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetSyncing_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetSyncing_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetSyncing_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetLatestBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetLatestBlock_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetLatestBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetBlockByHeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetBlockByHeight_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetBlockByHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetLatestValidatorSet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetLatestValidatorSet_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetLatestValidatorSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetValidatorSetByHeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_GetValidatorSetByHeight_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetValidatorSetByHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_ABCIQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Service_ABCIQuery_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_ABCIQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+// RegisterServiceHandlerFromEndpoint is same as RegisterServiceHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+	conn, err := grpc.Dial(endpoint, opts...)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+			return
+		}
+		go func() {
+			<-ctx.Done()
+			if cerr := conn.Close(); cerr != nil {
+				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+			}
+		}()
+	}()
+
+	return RegisterServiceHandler(ctx, mux, conn)
+}
+
+// RegisterServiceHandler registers the http handlers for service Service to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+	return RegisterServiceHandlerClient(ctx, mux, NewServiceClient(conn))
+}
+
+// RegisterServiceHandlerClient registers the http handlers for service Service
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "ServiceClient" to call the correct interceptors.
+func RegisterServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceClient) error {
+
+	mux.Handle("GET", pattern_Service_GetNodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetNodeInfo_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetNodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetSyncing_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetSyncing_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetSyncing_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetLatestBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetLatestBlock_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetLatestBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetBlockByHeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetBlockByHeight_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetBlockByHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetLatestValidatorSet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetLatestValidatorSet_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetLatestValidatorSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_GetValidatorSetByHeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_GetValidatorSetByHeight_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_GetValidatorSetByHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Service_ABCIQuery_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Service_ABCIQuery_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Service_ABCIQuery_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	return nil
+}
+
+var (
+	pattern_Service_GetNodeInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmos", "base", "tendermint", "v1beta1", "node_info"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_GetSyncing_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmos", "base", "tendermint", "v1beta1", "syncing"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_GetLatestBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"cosmos", "base", "tendermint", "v1beta1", "blocks", "latest"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_GetBlockByHeight_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "base", "tendermint", "v1beta1", "blocks", "height"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_GetLatestValidatorSet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"cosmos", "base", "tendermint", "v1beta1", "validatorsets", "latest"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_GetValidatorSetByHeight_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "base", "tendermint", "v1beta1", "validatorsets", "height"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Service_ABCIQuery_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmos", "base", "tendermint", "v1beta1", "abci_query"}, "", runtime.AssumeColonVerbOpt(false)))
+)
+
+var (
+	forward_Service_GetNodeInfo_0 = runtime.ForwardResponseMessage
+
+	forward_Service_GetSyncing_0 = runtime.ForwardResponseMessage
+
+	forward_Service_GetLatestBlock_0 = runtime.ForwardResponseMessage
+
+	forward_Service_GetBlockByHeight_0 = runtime.ForwardResponseMessage
+
+	forward_Service_GetLatestValidatorSet_0 = runtime.ForwardResponseMessage
+
+	forward_Service_GetValidatorSetByHeight_0 = runtime.ForwardResponseMessage
+
+	forward_Service_ABCIQuery_0 = runtime.ForwardResponseMessage
+)

server/v2/cometbft/client/grpc/cmtservice/service.go

@@ -0,0 +1,312 @@
+package cmtservice
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	coretypes "github.com/cometbft/cometbft/rpc/core/types"
+	gogogrpc "github.com/cosmos/gogoproto/grpc"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"cosmossdk.io/server/v2/cometbft/client/rpc"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	qtypes "github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/cosmos/cosmos-sdk/version"
+)
+
+var (
+	_ ServiceServer                      = queryServer{}
+	_ codectypes.UnpackInterfacesMessage = &GetLatestValidatorSetResponse{}
+)
+
+type (
+	abciQueryFn = func(context.Context, *abci.QueryRequest) (*abci.QueryResponse, error)
+
+	queryServer struct {
+		client  rpc.CometRPC
+		queryFn abciQueryFn
+	}
+)
+
+// NewQueryServer creates a new CometBFT query server.
+func NewQueryServer(
+	client rpc.CometRPC,
+	queryFn abciQueryFn,
+) ServiceServer {
+	return queryServer{
+		queryFn: queryFn,
+		client:  client,
+	}
+}
+
+// GetNodeStatus returns the status of the node.
+func (s queryServer) GetNodeStatus(ctx context.Context) (*coretypes.ResultStatus, error) {
+	return s.client.Status(ctx)
+}
+
+// GetSyncing implements ServiceServer.GetSyncing
+func (s queryServer) GetSyncing(ctx context.Context, _ *GetSyncingRequest) (*GetSyncingResponse, error) {
+	status, err := s.client.Status(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetSyncingResponse{
+		Syncing: status.SyncInfo.CatchingUp,
+	}, nil
+}
+
+// GetLatestBlock implements ServiceServer.GetLatestBlock
+func (s queryServer) GetLatestBlock(ctx context.Context, _ *GetLatestBlockRequest) (*GetLatestBlockResponse, error) {
+	block, err := s.client.Block(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	protoBlockID := block.BlockID.ToProto()
+	protoBlock, err := block.Block.ToProto()
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetLatestBlockResponse{
+		BlockId:  &protoBlockID,
+		Block:    protoBlock,
+		SdkBlock: convertBlock(protoBlock),
+	}, nil
+}
+
+// GetBlockByHeight implements ServiceServer.GetBlockByHeight
+func (s queryServer) GetBlockByHeight(
+	ctx context.Context,
+	req *GetBlockByHeightRequest,
+) (*GetBlockByHeightResponse, error) {
+	nodeStatus, err := s.client.Status(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	blockHeight := nodeStatus.SyncInfo.LatestBlockHeight
+
+	if req.Height > blockHeight {
+		return nil, status.Error(codes.InvalidArgument, "requested block height is bigger then the chain length")
+	}
+
+	b, err := s.client.Block(ctx, &req.Height)
+	if err != nil {
+		return nil, err
+	}
+
+	protoBlockID := b.BlockID.ToProto()
+	protoBlock, err := b.Block.ToProto()
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetBlockByHeightResponse{
+		BlockId:  &protoBlockID,
+		Block:    protoBlock,
+		SdkBlock: convertBlock(protoBlock),
+	}, nil
+}
+
+// GetLatestValidatorSet implements ServiceServer.GetLatestValidatorSet
+func (s queryServer) GetLatestValidatorSet(
+	ctx context.Context,
+	req *GetLatestValidatorSetRequest,
+) (*GetLatestValidatorSetResponse, error) {
+	page, limit, err := qtypes.ParsePagination(req.Pagination)
+	if err != nil {
+		return nil, err
+	}
+
+	return ValidatorsOutput(ctx, s.client, nil, page, limit)
+}
+
+func (m *GetLatestValidatorSetResponse) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
+	var pubKey cryptotypes.PubKey
+	for _, val := range m.Validators {
+		err := unpacker.UnpackAny(val.PubKey, &pubKey)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// GetValidatorSetByHeight implements ServiceServer.GetValidatorSetByHeight
+func (s queryServer) GetValidatorSetByHeight(
+	ctx context.Context,
+	req *GetValidatorSetByHeightRequest,
+) (*GetValidatorSetByHeightResponse, error) {
+	page, limit, err := qtypes.ParsePagination(req.Pagination)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeStatus, err := s.client.Status(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	blockHeight := nodeStatus.SyncInfo.LatestBlockHeight
+
+	if req.Height > blockHeight {
+		return nil, status.Error(codes.InvalidArgument, "requested block height is bigger then the chain length")
+	}
+
+	r, err := ValidatorsOutput(ctx, s.client, &req.Height, page, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GetValidatorSetByHeightResponse{
+		BlockHeight: r.BlockHeight,
+		Validators:  r.Validators,
+		Pagination:  r.Pagination,
+	}, nil
+}
+
+func ValidatorsOutput(
+	ctx context.Context,
+	client rpc.CometRPC,
+	height *int64,
+	page, limit int,
+) (*GetLatestValidatorSetResponse, error) {
+	vs, err := client.Validators(ctx, height, &page, &limit)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := GetLatestValidatorSetResponse{
+		BlockHeight: vs.BlockHeight,
+		Validators:  make([]*Validator, len(vs.Validators)),
+		Pagination: &qtypes.PageResponse{
+			Total: uint64(vs.Total),
+		},
+	}
+
+	for i, v := range vs.Validators {
+		pk, err := cryptocodec.FromCmtPubKeyInterface(v.PubKey)
+		if err != nil {
+			return nil, err
+		}
+		anyPub, err := codectypes.NewAnyWithValue(pk)
+		if err != nil {
+			return nil, err
+		}
+
+		resp.Validators[i] = &Validator{
+			Address:          sdk.ConsAddress(v.Address).String(),
+			ProposerPriority: v.ProposerPriority,
+			PubKey:           anyPub,
+			VotingPower:      v.VotingPower,
+		}
+	}
+
+	return &resp, nil
+}
+
+// GetNodeInfo implements ServiceServer.GetNodeInfo
+func (s queryServer) GetNodeInfo(ctx context.Context, _ *GetNodeInfoRequest) (*GetNodeInfoResponse, error) {
+	nodeStatus, err := s.client.Status(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	protoNodeInfo := nodeStatus.NodeInfo.ToProto()
+	nodeInfo := version.NewInfo()
+
+	deps := make([]*Module, len(nodeInfo.BuildDeps))
+
+	for i, dep := range nodeInfo.BuildDeps {
+		deps[i] = &Module{
+			Path:    dep.Path,
+			Sum:     dep.Sum,
+			Version: dep.Version,
+		}
+	}
+
+	resp := GetNodeInfoResponse{
+		DefaultNodeInfo: protoNodeInfo,
+		ApplicationVersion: &VersionInfo{
+			AppName:          nodeInfo.AppName,
+			Name:             nodeInfo.Name,
+			GitCommit:        nodeInfo.GitCommit,
+			GoVersion:        nodeInfo.GoVersion,
+			Version:          nodeInfo.Version,
+			BuildTags:        nodeInfo.BuildTags,
+			BuildDeps:        deps,
+			CosmosSdkVersion: nodeInfo.CosmosSdkVersion,
+		},
+	}
+	return &resp, nil
+}
+
+func (s queryServer) ABCIQuery(ctx context.Context, req *ABCIQueryRequest) (*ABCIQueryResponse, error) {
+	if s.queryFn == nil {
+		return nil, status.Error(codes.Internal, "ABCI Query handler undefined")
+	}
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+	if len(req.Path) == 0 {
+		return nil, status.Error(codes.InvalidArgument, "empty query path")
+	}
+
+	if path := SplitABCIQueryPath(req.Path); len(path) > 0 {
+		switch path[0] {
+		case "app", "store", "p2p", "custom": // TODO: check if we can use the ones from abci.go without having circular deps.
+			return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("ABCI query path not yet implemented: %s", req.Path))
+
+		default:
+			// Otherwise, error as to prevent either valid gRPC service requests or
+			// bogus ABCI queries.
+			return nil, status.Errorf(codes.InvalidArgument, "unsupported ABCI query path: %s", req.Path)
+		}
+	}
+
+	res, err := s.queryFn(ctx, req.ToABCIRequestQuery())
+	if err != nil {
+		return nil, err
+	}
+	return FromABCIResponseQuery(res), nil
+}
+
+// RegisterTendermintService registers the CometBFT queries on the gRPC router.
+func RegisterTendermintService(
+	client rpc.CometRPC,
+	server gogogrpc.Server,
+	queryFn abciQueryFn,
+) {
+	RegisterServiceServer(server, NewQueryServer(client, queryFn))
+}
+
+// RegisterGRPCGatewayRoutes mounts the CometBFT service's GRPC-gateway routes on the
+// given Mux.
+func RegisterGRPCGatewayRoutes(clientConn gogogrpc.ClientConn, mux *runtime.ServeMux) {
+	_ = RegisterServiceHandlerClient(context.Background(), mux, NewServiceClient(clientConn))
+}
+
+// SplitABCIQueryPath splits a string path using the delimiter '/'.
+//
+// e.g. "this/is/funny" becomes []string{"this", "is", "funny"}
+func SplitABCIQueryPath(requestPath string) (path []string) {
+	path = strings.Split(requestPath, "/")
+
+	// first element is empty string
+	if len(path) > 0 && path[0] == "" {
+		path = path[1:]
+	}
+
+	return path
+}

server/v2/cometbft/client/grpc/cmtservice/types.go

@@ -0,0 +1,47 @@
+package cmtservice
+
+import (
+	abci "github.com/cometbft/cometbft/abci/types"
+)
+
+// ToABCIRequestQuery converts a gRPC ABCIQueryRequest type to an ABCI
+// RequestQuery type.
+func (req *ABCIQueryRequest) ToABCIRequestQuery() *abci.QueryRequest {
+	return &abci.QueryRequest{
+		Data:   req.Data,
+		Path:   req.Path,
+		Height: req.Height,
+		Prove:  req.Prove,
+	}
+}
+
+// FromABCIResponseQuery converts an ABCI ResponseQuery type to a gRPC
+// ABCIQueryResponse type.
+func FromABCIResponseQuery(res *abci.QueryResponse) *ABCIQueryResponse {
+	var proofOps *ProofOps
+
+	if res.ProofOps != nil {
+		proofOps = &ProofOps{
+			Ops: make([]ProofOp, len(res.ProofOps.Ops)),
+		}
+		for i, proofOp := range res.ProofOps.Ops {
+			proofOps.Ops[i] = ProofOp{
+				Type: proofOp.Type,
+				Key:  proofOp.Key,
+				Data: proofOp.Data,
+			}
+		}
+	}
+
+	return &ABCIQueryResponse{
+		Code:      res.Code,
+		Log:       res.Log,
+		Info:      res.Info,
+		Index:     res.Index,
+		Key:       res.Key,
+		Value:     res.Value,
+		ProofOps:  proofOps,
+		Height:    res.Height,
+		Codespace: res.Codespace,
+	}
+}

server/v2/cometbft/client/grpc/cmtservice/util.go

@@ -0,0 +1,39 @@
+package cmtservice
+
+import (
+	cmtprototypes "github.com/cometbft/cometbft/api/cometbft/types/v1"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// convertHeader converts CometBFT header to sdk header
+func convertHeader(h cmtprototypes.Header) Header {
+	return Header{
+		Version:            h.Version,
+		ChainID:            h.ChainID,
+		Height:             h.Height,
+		Time:               h.Time,
+		LastBlockId:        h.LastBlockId,
+		ValidatorsHash:     h.ValidatorsHash,
+		NextValidatorsHash: h.NextValidatorsHash,
+		ConsensusHash:      h.ConsensusHash,
+		AppHash:            h.AppHash,
+		DataHash:           h.DataHash,
+		EvidenceHash:       h.EvidenceHash,
+		LastResultsHash:    h.LastResultsHash,
+		LastCommitHash:     h.LastCommitHash,
+		ProposerAddress:    sdk.ConsAddress(h.ProposerAddress).String(),
+	}
+}
+
+// convertBlock converts CometBFT block to sdk block
+func convertBlock(cmtblock *cmtprototypes.Block) *Block {
+	b := new(Block)
+
+	b.Header = convertHeader(cmtblock.Header)
+	b.LastCommit = cmtblock.LastCommit
+	b.Data = cmtblock.Data
+	b.Evidence = cmtblock.Evidence
+
+	return b
+}

server/v2/cometbft/client/rpc/block.go

@@ -0,0 +1,103 @@
+package rpc
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+
+	v11 "buf.build/gen/go/cometbft/cometbft/protocolbuffers/go/cometbft/types/v1"
+
+	abciv1beta1 "cosmossdk.io/api/cosmos/base/abci/v1beta1"
+)
+
+// GetChainHeight returns the current blockchain height.
+func GetChainHeight(ctx context.Context, rpcClient CometRPC) (int64, error) {
+	status, err := rpcClient.Status(ctx)
+	if err != nil {
+		return -1, err
+	}
+
+	height := status.SyncInfo.LatestBlockHeight
+	return height, nil
+}
+
+// QueryBlocks performs a search for blocks based on BeginBlock and EndBlock
+// events via the CometBFT RPC. A custom query may be passed as described below:
+//
+// To tell which events you want, you need to provide a query. query is a
+// string, which has a form: "condition AND condition ..." (no OR at the
+// 	moment). condition has a form: "key operation operand". key is a string with
+// 	a restricted set of possible symbols ( \t\n\r\\()"'=>< are not allowed).
+// 	operation can be "=", "<", "<=", ">", ">=", "CONTAINS" AND "EXISTS". operand
+// 	can be a string (escaped with single quotes), number, date or time.
+
+//	Examples:
+//		  tm.event = 'NewBlock'               # new blocks
+//		  tm.event = 'CompleteProposal'       # node got a complete proposal
+//		  tm.event = 'Tx' AND tx.hash = 'XYZ' # single transaction
+//		  tm.event = 'Tx' AND tx.height = 5   # all txs of the fifth block
+//		  tx.height = 5                       # all txs of the fifth block
+//
+// For more information, see the /subscribe CometBFT RPC endpoint documentation
+func QueryBlocks(ctx context.Context, rpcClient CometRPC, page, limit int, query, orderBy string) (*abciv1beta1.SearchBlocksResult, error) {
+	resBlocks, err := rpcClient.BlockSearch(ctx, query, &page, &limit, orderBy)
+	if err != nil {
+		return nil, err
+	}
+
+	blocks, err := formatBlockResults(resBlocks.Blocks)
+	if err != nil {
+		return nil, err
+	}
+
+	result := NewSearchBlocksResult(int64(resBlocks.TotalCount), int64(len(blocks)), int64(page), int64(limit), blocks)
+
+	return result, nil
+}
+
+// get block by height
+func GetBlockByHeight(ctx context.Context, rpcClient CometRPC, height *int64) (*v11.Block, error) {
+	// header -> BlockchainInfo
+	// header, tx -> Block
+	// results -> BlockResults
+	resBlock, err := rpcClient.Block(ctx, height)
+	if err != nil {
+		return nil, err
+	}
+
+	out, err := NewResponseResultBlock(resBlock)
+	if err != nil {
+		return nil, err
+	}
+	if out == nil {
+		return nil, fmt.Errorf("unable to create response block from comet result block: %v", resBlock)
+	}
+
+	return out, nil
+}
+
+func GetBlockByHash(ctx context.Context, rpcClient CometRPC, hashHexString string) (*v11.Block, error) {
+	hash, err := hex.DecodeString(hashHexString)
+	if err != nil {
+		return nil, err
+	}
+
+	resBlock, err := rpcClient.BlockByHash(ctx, hash)
+
+	if err != nil {
+		return nil, err
+	} else if resBlock.Block == nil {
+		return nil, fmt.Errorf("block not found with hash: %s", hashHexString)
+	}
+
+	// TODO: Also move NewResponseResultBlock somewhere around this package
+	out, err := NewResponseResultBlock(resBlock)
+	if err != nil {
+		return nil, err
+	}
+	if out == nil {
+		return nil, fmt.Errorf("unable to create response block from comet result block: %v", resBlock)
+	}
+
+	return out, nil
+}

server/v2/cometbft/client/rpc/client.go

@@ -0,0 +1,36 @@
+package rpc
+
+import (
+	"context"
+
+	rpcclient "github.com/cometbft/cometbft/rpc/client"
+	coretypes "github.com/cometbft/cometbft/rpc/core/types"
+)
+
+// CometRPC defines the interface of a CometBFT RPC client needed for
+// queries and transaction handling.
+type CometRPC interface {
+	rpcclient.ABCIClient
+
+	Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error)
+	Status(context.Context) (*coretypes.ResultStatus, error)
+	Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error)
+	BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error)
+	BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error)
+	BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error)
+	Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error)
+	Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error)
+	TxSearch(
+		ctx context.Context,
+		query string,
+		prove bool,
+		page, perPage *int,
+		orderBy string,
+	) (*coretypes.ResultTxSearch, error)
+	BlockSearch(
+		ctx context.Context,
+		query string,
+		page, perPage *int,
+		orderBy string,
+	) (*coretypes.ResultBlockSearch, error)
+}

server/v2/cometbft/client/rpc/utils.go

@@ -0,0 +1,75 @@
+package rpc
+
+import (
+	"fmt"
+
+	v11 "buf.build/gen/go/cometbft/cometbft/protocolbuffers/go/cometbft/types/v1"
+	coretypes "github.com/cometbft/cometbft/rpc/core/types"
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	protov2 "google.golang.org/protobuf/proto"
+
+	abciv1beta1 "cosmossdk.io/api/cosmos/base/abci/v1beta1"
+)
+
+// formatBlockResults parses the indexed blocks into a slice of BlockResponse objects.
+func formatBlockResults(resBlocks []*coretypes.ResultBlock) ([]*v11.Block, error) {
+	var (
+		err error
+		out = make([]*v11.Block, len(resBlocks))
+	)
+	for i := range resBlocks {
+		out[i], err = NewResponseResultBlock(resBlocks[i])
+		if err != nil {
+			return nil, fmt.Errorf("unable to create response block from comet result block: %v: %w", resBlocks[i], err)
+		}
+		if out[i] == nil {
+			return nil, fmt.Errorf("unable to create response block from comet result block: %v", resBlocks[i])
+		}
+	}
+
+	return out, nil
+}
+
+func NewSearchBlocksResult(totalCount, count, page, limit int64, blocks []*v11.Block) *abciv1beta1.SearchBlocksResult {
+	totalPages := calcTotalPages(totalCount, limit)
+	return &abciv1beta1.SearchBlocksResult{
+		TotalCount: totalCount,
+		Count:      count,
+		PageNumber: page,
+		PageTotal:  totalPages,
+		Limit:      limit,
+		Blocks:     blocks,
+	}
+}
+
+// NewResponseResultBlock returns a BlockResponse given a ResultBlock from CometBFT
+func NewResponseResultBlock(res *coretypes.ResultBlock) (*v11.Block, error) {
+	blkProto, err := res.Block.ToProto()
+	if err != nil {
+		return nil, err
+	}
+	blkBz, err := gogoproto.Marshal(blkProto)
+	if err != nil {
+		return nil, err
+	}
+
+	blk := &v11.Block{}
+	err = protov2.Unmarshal(blkBz, blk)
+	if err != nil {
+		return nil, err
+	}
+	return blk, nil
+}
+
+// calculate total pages in an overflow safe manner
+func calcTotalPages(totalCount, limit int64) int64 {
+	totalPages := int64(0)
+	if totalCount != 0 && limit != 0 {
+		if totalCount%limit > 0 {
+			totalPages = totalCount/limit + 1
+		} else {
+			totalPages = totalCount / limit
+		}
+	}
+	return totalPages
+}

server/v2/cometbft/commands.go

@@ -0,0 +1,414 @@
+package cometbft
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+
+	cmtcfg "github.com/cometbft/cometbft/config"
+	cmtjson "github.com/cometbft/cometbft/libs/json"
+	"github.com/cometbft/cometbft/node"
+	"github.com/cometbft/cometbft/p2p"
+	pvm "github.com/cometbft/cometbft/privval"
+	rpchttp "github.com/cometbft/cometbft/rpc/client/http"
+	"github.com/cometbft/cometbft/rpc/client/local"
+	cmtversion "github.com/cometbft/cometbft/version"
+	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/encoding/protojson"
+	"sigs.k8s.io/yaml"
+
+	"cosmossdk.io/server/v2/cometbft/client/rpc"
+	"cosmossdk.io/server/v2/cometbft/flags"
+	auth "cosmossdk.io/x/auth/client/cli"
+
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/cosmos/cosmos-sdk/version"
+)
+
+func (s *CometBFTServer[T]) rpcClient() (rpc.CometRPC, error) {
+	if s.config.Standalone {
+		client, err := rpchttp.New(s.config.CmtConfig.RPC.ListenAddress)
+		if err != nil {
+			return nil, err
+		}
+		return client, nil
+	}
+
+	return local.New(s.Node), nil
+}
+
+// StatusCommand returns the command to return the status of the network.
+func (s *CometBFTServer[T]) StatusCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "status",
+		Short: "Query remote node for status",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			rpcclient, err := s.rpcClient()
+			if err != nil {
+				return err
+			}
+
+			status, err := rpcclient.Status(cmd.Context())
+			if err != nil {
+				return err
+			}
+
+			output, err := cmtjson.Marshal(status)
+			if err != nil {
+				return err
+			}
+
+			cmd.Println(string(output))
+
+			// TODO: figure out yaml and json output
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP(flags.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+	cmd.Flags().StringP(flags.FlagOutput, "o", "json", "Output format (text|json)")
+
+	return cmd
+}
+
+// ShowNodeIDCmd - ported from CometBFT, dump node ID to stdout
+func (s *CometBFTServer[T]) ShowNodeIDCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "show-node-id",
+		Short: "Show this node's ID",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			nodeKey, err := p2p.LoadNodeKey(s.config.CmtConfig.NodeKeyFile())
+			if err != nil {
+				return err
+			}
+
+			cmd.Println(nodeKey.ID())
+			return nil
+		},
+	}
+}
+
+// ShowValidatorCmd - ported from CometBFT, show this node's validator info
+func (s *CometBFTServer[T]) ShowValidatorCmd() *cobra.Command {
+	cmd := cobra.Command{
+		Use:   "show-validator",
+		Short: "Show this node's CometBFT validator info",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg := s.config.CmtConfig
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+			pk, err := privValidator.GetPubKey()
+			if err != nil {
+				return err
+			}
+
+			sdkPK, err := cryptocodec.FromCmtPubKeyInterface(pk)
+			if err != nil {
+				return err
+			}
+
+			cmd.Println(sdkPK) // TODO: figure out if we need the codec here or not, see below
+
+			// clientCtx := client.GetClientContextFromCmd(cmd)
+			// bz, err := clientCtx.Codec.MarshalInterfaceJSON(sdkPK)
+			// if err != nil {
+			// 	return err
+			// }
+
+			// cmd.Println(string(bz))
+			return nil
+		},
+	}
+
+	return &cmd
+}
+
+// ShowAddressCmd - show this node's validator address
+func (s *CometBFTServer[T]) ShowAddressCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "show-address",
+		Short: "Shows this node's CometBFT validator consensus address",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg := s.config.CmtConfig
+			privValidator := pvm.LoadFilePV(cfg.PrivValidatorKeyFile(), cfg.PrivValidatorStateFile())
+			// TODO: use address codec?
+			valConsAddr := (sdk.ConsAddress)(privValidator.GetAddress())
+
+			cmd.Println(valConsAddr.String())
+			return nil
+		},
+	}
+
+	return cmd
+}
+
+// VersionCmd prints CometBFT and ABCI version numbers.
+func (s *CometBFTServer[T]) VersionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Print CometBFT libraries' version",
+		Long:  "Print protocols' and libraries' version numbers against which this app has been compiled.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			bs, err := yaml.Marshal(&struct {
+				CometBFT      string
+				ABCI          string
+				BlockProtocol uint64
+				P2PProtocol   uint64
+			}{
+				CometBFT:      cmtversion.CMTSemVer,
+				ABCI:          cmtversion.ABCIVersion,
+				BlockProtocol: cmtversion.BlockProtocol,
+				P2PProtocol:   cmtversion.P2PProtocol,
+			})
+			if err != nil {
+				return err
+			}
+
+			cmd.Println(string(bs))
+			return nil
+		},
+	}
+}
+
+// QueryBlocksCmd returns a command to search through blocks by events.
+func (s *CometBFTServer[T]) QueryBlocksCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "blocks",
+		Short: "Query for paginated blocks that match a set of events",
+		Long: `Search for blocks that match the exact given events where results are paginated.
+The events query is directly passed to CometBFT's RPC BlockSearch method and must
+conform to CometBFT's query syntax.
+Please refer to each module's documentation for the full set of events to query
+for. Each module documents its respective events under 'xx_events.md'.
+`,
+		Example: fmt.Sprintf(
+			"$ %s query blocks --query \"message.sender='cosmos1...' AND block.height > 7\" --page 1 --limit 30 --order-by ASC",
+			version.AppName,
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			rpcclient, err := s.rpcClient()
+			if err != nil {
+				return err
+			}
+
+			query, _ := cmd.Flags().GetString(auth.FlagQuery)
+			page, _ := cmd.Flags().GetInt(flags.FlagPage)
+			limit, _ := cmd.Flags().GetInt(flags.FlagLimit)
+			orderBy, _ := cmd.Flags().GetString(auth.FlagOrderBy)
+
+			blocks, err := rpc.QueryBlocks(cmd.Context(), rpcclient, page, limit, query, orderBy)
+			if err != nil {
+				return err
+			}
+
+			// return clientCtx.PrintProto(blocks) // TODO: previously we had this, but I think it can be replaced with a simple json marshal.
+			// We are missing YAML output tho.
+			bz, err := protojson.Marshal(blocks)
+			if err != nil {
+				return err
+			}
+
+			_, err = cmd.OutOrStdout().Write(bz)
+			return err
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	cmd.Flags().Int(flags.FlagPage, query.DefaultPage, "Query a specific page of paginated results")
+	cmd.Flags().Int(flags.FlagLimit, query.DefaultLimit, "Query number of transactions results per page returned")
+	cmd.Flags().String(auth.FlagQuery, "", "The blocks events query per CometBFT's query semantics")
+	cmd.Flags().String(auth.FlagOrderBy, "", "The ordering semantics (asc|dsc)")
+	_ = cmd.MarkFlagRequired(auth.FlagQuery)
+
+	return cmd
+}
+
+// QueryBlockCmd implements the default command for a Block query.
+func (s *CometBFTServer[T]) QueryBlockCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "block --type=[height|hash] [height|hash]",
+		Short: "Query for a committed block by height, hash, or event(s)",
+		Long:  "Query for a specific committed block using the CometBFT RPC `block` and `block_by_hash` method",
+		Example: strings.TrimSpace(fmt.Sprintf(`
+$ %s query block --%s=%s <height>
+$ %s query block --%s=%s <hash>
+`,
+			version.AppName, auth.FlagType, auth.TypeHeight,
+			version.AppName, auth.FlagType, auth.TypeHash)),
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			typ, _ := cmd.Flags().GetString(auth.FlagType)
+
+			rpcclient, err := s.rpcClient()
+			if err != nil {
+				return err
+			}
+
+			switch typ {
+			case auth.TypeHeight:
+				if args[0] == "" {
+					return fmt.Errorf("argument should be a block height")
+				}
+
+				// optional height
+				var height *int64
+				if len(args) > 0 {
+					height, err = parseOptionalHeight(args[0])
+					if err != nil {
+						return err
+					}
+				}
+
+				output, err := rpc.GetBlockByHeight(cmd.Context(), rpcclient, height)
+				if err != nil {
+					return err
+				}
+
+				if output.Header.Height == 0 {
+					return fmt.Errorf("no block found with height %s", args[0])
+				}
+
+				// return clientCtx.PrintProto(output)
+
+				bz, err := json.Marshal(output)
+				if err != nil {
+					return err
+				}
+
+				_, err = cmd.OutOrStdout().Write(bz)
+				return err
+
+			case auth.TypeHash:
+
+				if args[0] == "" {
+					return fmt.Errorf("argument should be a tx hash")
+				}
+
+				// If hash is given, then query the tx by hash.
+				output, err := rpc.GetBlockByHash(cmd.Context(), rpcclient, args[0])
+				if err != nil {
+					return err
+				}
+
+				if output.Header.AppHash == nil {
+					return fmt.Errorf("no block found with hash %s", args[0])
+				}
+
+				// return clientCtx.PrintProto(output)
+				bz, err := json.Marshal(output)
+				if err != nil {
+					return err
+				}
+
+				_, err = cmd.OutOrStdout().Write(bz)
+				return err
+
+			default:
+				return fmt.Errorf("unknown --%s value %s", auth.FlagType, typ)
+			}
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	cmd.Flags().String(auth.FlagType, auth.TypeHash, fmt.Sprintf("The type to be used when querying tx, can be one of \"%s\", \"%s\"", auth.TypeHeight, auth.TypeHash))
+
+	return cmd
+}
+
+// QueryBlockResultsCmd implements the default command for a BlockResults query.
+func (s *CometBFTServer[T]) QueryBlockResultsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "block-results [height]",
+		Short: "Query for a committed block's results by height",
+		Long:  "Query for a specific committed block's results using the CometBFT RPC `block_results` method",
+		Args:  cobra.RangeArgs(0, 1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// clientCtx, err := client.GetClientQueryContext(cmd)
+			// if err != nil {
+			// 	return err
+			// }
+
+			// TODO: we should be able to do this without using client context
+
+			node, err := s.rpcClient()
+			if err != nil {
+				return err
+			}
+
+			// optional height
+			var height *int64
+			if len(args) > 0 {
+				height, err = parseOptionalHeight(args[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			blockRes, err := node.BlockResults(cmd.Context(), height)
+			if err != nil {
+				return err
+			}
+
+			// coretypes.ResultBlockResults doesn't implement proto.Message interface
+			// so we can't print it using clientCtx.PrintProto
+			// we choose to serialize it to json and print the json instead
+			blockResStr, err := json.Marshal(blockRes)
+			if err != nil {
+				return err
+			}
+
+			cmd.Println(string(blockResStr))
+
+			// TODO: figure out yaml and json output
+			return nil
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
+func parseOptionalHeight(heightStr string) (*int64, error) {
+	h, err := strconv.Atoi(heightStr)
+	if err != nil {
+		return nil, err
+	}
+
+	if h == 0 {
+		return nil, nil
+	}
+
+	tmp := int64(h)
+
+	return &tmp, nil
+}
+
+func (s *CometBFTServer[T]) BootstrapStateCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "bootstrap-state",
+		Short: "Bootstrap CometBFT state at an arbitrary block height using a light client",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			height, err := cmd.Flags().GetUint64("height")
+			if err != nil {
+				return err
+			}
+			if height == 0 {
+				height, err = s.App.store.GetLatestVersion()
+				if err != nil {
+					return err
+				}
+			}
+
+			// TODO genensis doc provider and apphash
+			return node.BootstrapState(cmd.Context(), s.config.CmtConfig, cmtcfg.DefaultDBProvider, nil, height, nil)
+		},
+	}
+
+	cmd.Flags().Int64("height", 0, "Block height to bootstrap state at, if not provided it uses the latest block height in app state")
+
+	return cmd
+}

server/v2/cometbft/config.go

@@ -0,0 +1,37 @@
+package cometbft
+
+import (
+	cmtcfg "github.com/cometbft/cometbft/config"
+
+	"cosmossdk.io/server/v2/api/grpc"
+	"cosmossdk.io/server/v2/cometbft/types"
+)
+
+// Config is the configuration for the CometBFT application
+type Config struct {
+	// app.toml config options
+	Name            string              `mapstructure:"name" toml:"name"`
+	Version         string              `mapstructure:"version" toml:"version"`
+	InitialHeight   uint64              `mapstructure:"initial_height" toml:"initial_height"`
+	MinRetainBlocks uint64              `mapstructure:"min_retain_blocks" toml:"min_retain_blocks"`
+	IndexEvents     map[string]struct{} `mapstructure:"index_events" toml:"index_events"`
+	HaltHeight      uint64              `mapstructure:"halt_height" toml:"halt_height"`
+	HaltTime        uint64              `mapstructure:"halt_time" toml:"halt_time"`
+	// end of app.toml config options
+
+	AddrPeerFilter types.PeerFilter // filter peers by address and port
+	IdPeerFilter   types.PeerFilter // filter peers by node ID
+
+	Transport  string `mapstructure:"transport" toml:"transport"`
+	Addr       string `mapstructure:"addr" toml:"addr"`
+	Standalone bool   `mapstructure:"standalone" toml:"standalone"`
+	Trace      bool   `mapstructure:"trace" toml:"trace"`
+
+	GrpcConfig grpc.Config
+
+	// MempoolConfig
+	CmtConfig *cmtcfg.Config
+
+	// Must be set by the application to grant authority to the consensus engine to send messages to the consensus module
+	ConsensusAuthority string
+}

server/v2/cometbft/flags/flags.go

@@ -0,0 +1,79 @@
+package flags
+
+import "github.com/spf13/cobra"
+
+const (
+	FlagQuery   = "query"
+	FlagType    = "type"
+	FlagOrderBy = "order_by"
+)
+
+const (
+	FlagHome             = "home"
+	FlagKeyringDir       = "keyring-dir"
+	FlagUseLedger        = "ledger"
+	FlagChainID          = "chain-id"
+	FlagNode             = "node"
+	FlagGRPC             = "grpc-addr"
+	FlagGRPCInsecure     = "grpc-insecure"
+	FlagHeight           = "height"
+	FlagGasAdjustment    = "gas-adjustment"
+	FlagFrom             = "from"
+	FlagName             = "name"
+	FlagAccountNumber    = "account-number"
+	FlagSequence         = "sequence"
+	FlagNote             = "note"
+	FlagFees             = "fees"
+	FlagGas              = "gas"
+	FlagGasPrices        = "gas-prices"
+	FlagBroadcastMode    = "broadcast-mode"
+	FlagDryRun           = "dry-run"
+	FlagGenerateOnly     = "generate-only"
+	FlagOffline          = "offline"
+	FlagOutputDocument   = "output-document" // inspired by wget -O
+	FlagSkipConfirmation = "yes"
+	FlagProve            = "prove"
+	FlagKeyringBackend   = "keyring-backend"
+	FlagPage             = "page"
+	FlagLimit            = "limit"
+	FlagSignMode         = "sign-mode"
+	FlagPageKey          = "page-key"
+	FlagOffset           = "offset"
+	FlagCountTotal       = "count-total"
+	FlagTimeoutHeight    = "timeout-height"
+	FlagUnordered        = "unordered"
+	FlagKeyAlgorithm     = "algo"
+	FlagKeyType          = "key-type"
+	FlagFeePayer         = "fee-payer"
+	FlagFeeGranter       = "fee-granter"
+	FlagReverse          = "reverse"
+	FlagTip              = "tip"
+	FlagAux              = "aux"
+	FlagInitHeight       = "initial-height"
+	// FlagOutput is the flag to set the output format.
+	// This differs from FlagOutputDocument that is used to set the output file.
+	FlagOutput = "output"
+	// Logging flags
+	FlagLogLevel   = "log_level"
+	FlagLogFormat  = "log_format"
+	FlagLogNoColor = "log_no_color"
+)
+
+// List of supported output formats
+const (
+	OutputFormatJSON = "json"
+	OutputFormatText = "text"
+)
+
+// AddQueryFlagsToCmd adds common flags to a module query command.
+func AddQueryFlagsToCmd(cmd *cobra.Command) {
+	cmd.Flags().String(FlagNode, "tcp://localhost:26657", "<host>:<port> to CometBFT RPC interface for this chain")
+	cmd.Flags().String(FlagGRPC, "", "the gRPC endpoint to use for this chain")
+	cmd.Flags().Bool(FlagGRPCInsecure, false, "allow gRPC over insecure channels, if not the server must use TLS")
+	cmd.Flags().Int64(FlagHeight, 0, "Use a specific height to query state at (this can error if the node is pruning state)")
+	cmd.Flags().StringP(FlagOutput, "o", "text", "Output format (text|json)")
+
+	// some base commands does not require chainID e.g `simd testnet` while subcommands do
+	// hence the flag should not be required for those commands
+	_ = cmd.MarkFlagRequired(FlagChainID)
+}

server/v2/cometbft/go.mod

@@ -0,0 +1,190 @@
+module cosmossdk.io/server/v2/cometbft
+
+go 1.22.2
+
+replace (
+	cosmossdk.io/api => ../../../api
+	cosmossdk.io/core => ../../../core
+	cosmossdk.io/depinject => ../../../depinject
+	cosmossdk.io/log => ../../../log
+	cosmossdk.io/runtime/v2 => ../../../runtime/v2
+	cosmossdk.io/server/v2 => ../
+	cosmossdk.io/server/v2/appmanager => ../appmanager
+	cosmossdk.io/server/v2/stf => ../stf
+	cosmossdk.io/store/v2 => ../../../store/v2
+	cosmossdk.io/x/accounts => ../../../x/accounts
+	cosmossdk.io/x/auth => ../../../x/auth
+	cosmossdk.io/x/bank => ../../../x/bank
+	cosmossdk.io/x/consensus => ../../../x/consensus
+	cosmossdk.io/x/staking => ../../../x/staking
+	cosmossdk.io/x/tx => ../../../x/tx
+	github.com/cosmos/cosmos-sdk => ../../../
+)
+
+require (
+	buf.build/gen/go/cometbft/cometbft/protocolbuffers/go v1.34.1-20240312114316-c0d3497e35d6.1
+	cosmossdk.io/api v0.7.5
+	cosmossdk.io/core v0.12.1-0.20231114100755-569e3ff6a0d7
+	cosmossdk.io/errors v1.0.1
+	cosmossdk.io/server/v2 v2.0.0-00010101000000-000000000000
+	cosmossdk.io/server/v2/appmanager v0.0.0-00010101000000-000000000000
+	cosmossdk.io/store/v2 v2.0.0-00010101000000-000000000000
+	cosmossdk.io/x/auth v0.0.0-00010101000000-000000000000
+	cosmossdk.io/x/consensus v0.0.0-00010101000000-000000000000
+	github.com/cometbft/cometbft v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08
+	github.com/cometbft/cometbft/api v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08
+	github.com/cosmos/cosmos-proto v1.0.0-beta.5
+	github.com/cosmos/cosmos-sdk v0.51.0
+	github.com/cosmos/gogoproto v1.4.12
+	github.com/golang/protobuf v1.5.4
+	github.com/grpc-ecosystem/grpc-gateway v1.16.0
+	github.com/spf13/cobra v1.8.0
+	github.com/spf13/pflag v1.0.5
+	google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237
+	google.golang.org/grpc v1.64.0
+	google.golang.org/protobuf v1.34.1
+	sigs.k8s.io/yaml v1.4.0
+)
+
+require (
+	buf.build/gen/go/cosmos/gogo-proto/protocolbuffers/go v1.34.1-20240130113600-88ef6483f90f.1 // indirect
+	cosmossdk.io/collections v0.4.0 // indirect
+	cosmossdk.io/depinject v1.0.0-alpha.4 // indirect
+	cosmossdk.io/log v1.3.1 // indirect
+	cosmossdk.io/math v1.3.0 // indirect
+	cosmossdk.io/store v1.1.1-0.20240418092142-896cdf1971bc // indirect
+	cosmossdk.io/x/accounts v0.0.0-20240226161501-23359a0b6d91 // indirect
+	cosmossdk.io/x/bank v0.0.0-20240226161501-23359a0b6d91 // indirect
+	cosmossdk.io/x/staking v0.0.0-00010101000000-000000000000 // indirect
+	cosmossdk.io/x/tx v0.13.3 // indirect
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect
+	github.com/99designs/keyring v1.2.2 // indirect
+	github.com/DataDog/datadog-go v4.8.3+incompatible // indirect
+	github.com/DataDog/zstd v1.5.5 // indirect
+	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.3.3 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cockroachdb/errors v1.11.1 // indirect
+	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
+	github.com/cockroachdb/pebble v1.1.0 // indirect
+	github.com/cockroachdb/redact v1.1.5 // indirect
+	github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
+	github.com/cometbft/cometbft-db v0.12.0 // indirect
+	github.com/cosmos/btcutil v1.0.5 // indirect
+	github.com/cosmos/cosmos-db v1.0.2 // indirect
+	github.com/cosmos/crypto v0.0.0-20240309083813-82ed2537802e // indirect
+	github.com/cosmos/go-bip39 v1.0.0 // indirect
+	github.com/cosmos/gogogateway v1.2.0 // indirect
+	github.com/cosmos/iavl v1.2.0 // indirect
+	github.com/cosmos/ics23/go v0.10.0 // indirect
+	github.com/cosmos/ledger-cosmos-go v0.13.3 // indirect
+	github.com/danieljoos/wincred v1.2.1 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect
+	github.com/dgraph-io/badger/v4 v4.2.0 // indirect
+	github.com/dgraph-io/ristretto v0.1.1 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/dvsekhvalnov/jose2go v1.6.0 // indirect
+	github.com/emicklei/dot v1.6.2 // indirect
+	github.com/fatih/color v1.17.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/getsentry/sentry-go v0.27.0 // indirect
+	github.com/go-kit/kit v0.13.0 // indirect
+	github.com/go-kit/log v0.2.1 // indirect
+	github.com/go-logfmt/logfmt v0.6.0 // indirect
+	github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect
+	github.com/gofrs/uuid v4.4.0+incompatible // indirect
+	github.com/gogo/googleapis v1.4.1 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/glog v1.2.0 // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/btree v1.1.2 // indirect
+	github.com/google/flatbuffers v2.0.8+incompatible // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/orderedcode v0.0.1 // indirect
+	github.com/gorilla/handlers v1.5.2 // indirect
+	github.com/gorilla/mux v1.8.1 // indirect
+	github.com/gorilla/websocket v1.5.1 // indirect
+	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect
+	github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect
+	github.com/hashicorp/go-hclog v1.6.3 // indirect
+	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
+	github.com/hashicorp/go-metrics v0.5.3 // indirect
+	github.com/hashicorp/go-plugin v1.6.1 // indirect
+	github.com/hashicorp/golang-lru v1.0.2 // indirect
+	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/hashicorp/yamux v0.1.1 // indirect
+	github.com/hdevalence/ed25519consensus v0.2.0 // indirect
+	github.com/huandu/skiplist v1.2.0 // indirect
+	github.com/iancoleman/strcase v0.3.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/jmhodges/levigo v1.0.0 // indirect
+	github.com/klauspost/compress v1.17.8 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/lib/pq v1.10.9 // indirect
+	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
+	github.com/linxGnu/grocksdb v1.8.14 // indirect
+	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/minio/highwayhash v1.0.2 // indirect
+	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mtibben/percent v0.2.1 // indirect
+	github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect
+	github.com/oklog/run v1.1.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/petermattis/goid v0.0.0-20240327183114-c42a807a84ba // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/prometheus/client_golang v1.19.1 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.53.0 // indirect
+	github.com/prometheus/procfs v0.14.0 // indirect
+	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
+	github.com/rs/cors v1.11.0 // indirect
+	github.com/rs/zerolog v1.33.0 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sasha-s/go-deadlock v0.3.1 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
+	github.com/spf13/viper v1.18.2 // indirect
+	github.com/stretchr/testify v1.9.0 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/supranational/blst v0.3.11 // indirect
+	github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect
+	github.com/tendermint/go-amino v0.16.0 // indirect
+	github.com/tidwall/btree v1.7.0 // indirect
+	github.com/zondax/hid v0.9.2 // indirect
+	github.com/zondax/ledger-go v0.14.3 // indirect
+	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect
+	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect
+	go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
+	golang.org/x/mod v0.17.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/term v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	golang.org/x/tools v0.21.0 // indirect
+	google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240515191416-fc5f0ca64291 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gotest.tools/v3 v3.5.1 // indirect
+	pgregory.net/rapid v1.1.0 // indirect
+)

server/v2/cometbft/go.sum

@@ -0,0 +1,694 @@
+buf.build/gen/go/cometbft/cometbft/protocolbuffers/go v1.34.1-20240312114316-c0d3497e35d6.1 h1:lBlYy54lX1iBjFhbkd13bWlH7dMnoiyENzZ0Wok1YH4=
+buf.build/gen/go/cometbft/cometbft/protocolbuffers/go v1.34.1-20240312114316-c0d3497e35d6.1/go.mod h1:fYP6DZCfO5Ex4U+Xq1PqQwB8NQQhW5Y+Qbyzd/7dw7o=
+buf.build/gen/go/cosmos/gogo-proto/protocolbuffers/go v1.34.1-20240130113600-88ef6483f90f.1 h1:MfK7sTqm7NFqM/GOuuKOOemQzW8P7z07YQIW0vsYr38=
+buf.build/gen/go/cosmos/gogo-proto/protocolbuffers/go v1.34.1-20240130113600-88ef6483f90f.1/go.mod h1:RigkrxrsA6FPZontmsidcr0WGWF8zNFYleIktv6XdLc=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cosmossdk.io/collections v0.4.0 h1:PFmwj2W8szgpD5nOd8GWH6AbYNi1f2J6akWXJ7P5t9s=
+cosmossdk.io/collections v0.4.0/go.mod h1:oa5lUING2dP+gdDquow+QjlF45eL1t4TJDypgGd+tv0=
+cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0=
+cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U=
+cosmossdk.io/math v1.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
+cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
+cosmossdk.io/store v1.1.1-0.20240418092142-896cdf1971bc h1:R9O9d75e0qZYUsVV0zzi+D7cNLnX2JrUOQNoIPaF0Bg=
+cosmossdk.io/store v1.1.1-0.20240418092142-896cdf1971bc/go.mod h1:amTTatOUV3u1PsKmNb87z6/galCxrRbz9kRdJkL0DyU=
+cosmossdk.io/x/accounts/defaults/lockup v0.0.0-20240417181816-5e7aae0db1f5 h1:eb0kcGyaYHSS0do7+MIWg7UKlskSH01biRNENbm/zDA=
+cosmossdk.io/x/accounts/defaults/lockup v0.0.0-20240417181816-5e7aae0db1f5/go.mod h1:drzY4oVisyWvSgpsM7ccQ7IX3efMuVIvd9Eij1Gm/6o=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 h1:/vQbFIOMbk2FiG/kXiLl8BRyzTWDw7gX/Hz7Dd5eDMs=
+github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4/go.mod h1:hN7oaIRCjzsZ2dE+yG5k+rsdt3qcwykqK6HVGcKwsw4=
+github.com/99designs/keyring v1.2.2 h1:pZd3neh/EmUzWONb35LxQfvuY7kiSXAq3HQd97+XBn0=
+github.com/99designs/keyring v1.2.2/go.mod h1:wes/FrByc8j7lFOAGLGSNEg8f/PaI3cgTBqhFkHUrPk=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DataDog/datadog-go v4.8.3+incompatible h1:fNGaYSuObuQb5nzeTQqowRAd9bpDIRRV4/gUtIBjh8Q=
+github.com/DataDog/datadog-go v4.8.3+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ=
+github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk=
+github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/adlio/schema v1.3.6 h1:k1/zc2jNfeiZBA5aFTRy37jlBIuCkXCm0XmvpzCKI9I=
+github.com/adlio/schema v1.3.6/go.mod h1:qkxwLgPBd1FgLRHYVCmQT/rrBr3JH38J9LjmVzWNudg=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 h1:41iFGWnSlI2gVpmOtVTJZNodLdLQLn/KsJqFvXwnd/s=
+github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/btcsuite/btcd/btcec/v2 v2.3.3 h1:6+iXlDKE8RMtKsvK0gshlXIuPbyWM/h84Ensb7o3sC0=
+github.com/btcsuite/btcd/btcec/v2 v2.3.3/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
+github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=
+github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/bufbuild/protocompile v0.4.0 h1:LbFKd2XowZvQ/kajzguUp2DC9UEIQhIq77fZZlaQsNA=
+github.com/bufbuild/protocompile v0.4.0/go.mod h1:3v93+mbWn/v3xzN+31nwkJfrEpAUwp+BagBSZWx+TP8=
+github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
+github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
+github.com/cockroachdb/errors v1.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8=
+github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/pebble v1.1.0 h1:pcFh8CdCIt2kmEpK0OIatq67Ln9uGDYY3d5XnE0LJG4=
+github.com/cockroachdb/pebble v1.1.0/go.mod h1:sEHm5NOXxyiAoKWhoFxT8xMgd/f3RA6qUqQ1BXKrh2E=
+github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=
+github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
+github.com/cometbft/cometbft v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08 h1:xW0les/5Lr+4qVsOYDDwl5Utj8uouvv69hEtiavHJ2M=
+github.com/cometbft/cometbft v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08/go.mod h1:8uXGKqp5yPmNSbU81K/669E3rfO3H+juGkYKCPTnAtY=
+github.com/cometbft/cometbft-db v0.12.0 h1:v77/z0VyfSU7k682IzZeZPFZrQAKiQwkqGN0QzAjMi0=
+github.com/cometbft/cometbft-db v0.12.0/go.mod h1:aX2NbCrjNVd2ZajYxt1BsiFf/Z+TQ2MN0VxdicheYuw=
+github.com/cometbft/cometbft/api v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08 h1:BNUwBnVEBiRUGfLIqbKPKHEiR6VCOjWarDgy2dcbys4=
+github.com/cometbft/cometbft/api v1.0.0-alpha.2.0.20240530055211-ae27f7eb3c08/go.mod h1:NDFKiBBD8HJC6QQLAoUI99YhsiRZtg2+FJWfk6A6m6o=
+github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg=
+github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/cosmos/btcutil v1.0.5 h1:t+ZFcX77LpKtDBhjucvnOH8C2l2ioGsBNEQ3jef8xFk=
+github.com/cosmos/btcutil v1.0.5/go.mod h1:IyB7iuqZMJlthe2tkIFL33xPyzbFYP0XVdS8P5lUPis=
+github.com/cosmos/cosmos-db v1.0.2 h1:hwMjozuY1OlJs/uh6vddqnk9j7VamLv+0DBlbEXbAKs=
+github.com/cosmos/cosmos-db v1.0.2/go.mod h1:Z8IXcFJ9PqKK6BIsVOB3QXtkKoqUOp1vRvPT39kOXEA=
+github.com/cosmos/cosmos-proto v1.0.0-beta.5 h1:eNcayDLpip+zVLRLYafhzLvQlSmyab+RC5W7ZfmxJLA=
+github.com/cosmos/cosmos-proto v1.0.0-beta.5/go.mod h1:hQGLpiIUloJBMdQMMWb/4wRApmI9hjHH05nefC0Ojec=
+github.com/cosmos/crypto v0.0.0-20240309083813-82ed2537802e h1:Zk4OsfLBN+0WOfH15Hg/aAYsSP7IuZQC6RZjewPuITw=
+github.com/cosmos/crypto v0.0.0-20240309083813-82ed2537802e/go.mod h1:0KOK/XVzL5lj9x+NyJ7lWuJYl6F0Wd7JMVYM06bVQsc=
+github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY=
+github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw=
+github.com/cosmos/gogogateway v1.2.0 h1:Ae/OivNhp8DqBi/sh2A8a1D0y638GpL3tkmLQAiKxTE=
+github.com/cosmos/gogogateway v1.2.0/go.mod h1:iQpLkGWxYcnCdz5iAdLcRBSw3h7NXeOkZ4GUkT+tbFI=
+github.com/cosmos/gogoproto v1.4.2/go.mod h1:cLxOsn1ljAHSV527CHOtaIP91kK6cCrZETRBrkzItWU=
+github.com/cosmos/gogoproto v1.4.12 h1:vB6Lbe/rtnYGjQuFxkPiPYiCybqFT8QvLipDZP8JpFE=
+github.com/cosmos/gogoproto v1.4.12/go.mod h1:LnZob1bXRdUoqMMtwYlcR3wjiElmlC+FkjaZRv1/eLY=
+github.com/cosmos/iavl v1.2.0 h1:kVxTmjTh4k0Dh1VNL046v6BXqKziqMDzxo93oh3kOfM=
+github.com/cosmos/iavl v1.2.0/go.mod h1:HidWWLVAtODJqFD6Hbne2Y0q3SdxByJepHUOeoH4LiI=
+github.com/cosmos/ics23/go v0.10.0 h1:iXqLLgp2Lp+EdpIuwXTYIQU+AiHj9mOC2X9ab++bZDM=
+github.com/cosmos/ics23/go v0.10.0/go.mod h1:ZfJSmng/TBNTBkFemHHHj5YY7VAU/MBU980F4VU1NG0=
+github.com/cosmos/ledger-cosmos-go v0.13.3 h1:7ehuBGuyIytsXbd4MP43mLeoN2LTOEnk5nvue4rK+yM=
+github.com/cosmos/ledger-cosmos-go v0.13.3/go.mod h1:HENcEP+VtahZFw38HZ3+LS3Iv5XV6svsnkk9vdJtLr8=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/danieljoos/wincred v1.2.1 h1:dl9cBrupW8+r5250DYkYxocLeZ1Y4vB1kxgtjxw8GQs=
+github.com/danieljoos/wincred v1.2.1/go.mod h1:uGaFL9fDn3OLTvzCGulzE+SzjEe5NGlh5FdCcyfPwps=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
+github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/dgraph-io/badger/v4 v4.2.0 h1:kJrlajbXXL9DFTNuhhu9yCx7JJa4qpYWxtE8BzuWsEs=
+github.com/dgraph-io/badger/v4 v4.2.0/go.mod h1:qfCqhPoWDFJRx1gp5QwwyGo8xk1lbHUxvK9nK0OGAak=
+github.com/dgraph-io/ristretto v0.1.1 h1:6CWw5tJNgpegArSHpNHJKldNeq03FQCwYvfMVWajOK8=
+github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
+github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
+github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/dvsekhvalnov/jose2go v1.6.0 h1:Y9gnSnP4qEI0+/uQkHvFXeD2PLPJeXEL+ySMEA2EjTY=
+github.com/dvsekhvalnov/jose2go v1.6.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU=
+github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A=
+github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
+github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=
+github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
+github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
+github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
+github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0=
+github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
+github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/gogo/googleapis v1.4.1-0.20201022092350-68b0159b7869/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c=
+github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0=
+github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68=
+github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU=
+github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/flatbuffers v2.0.8+incompatible h1:ivUb1cGomAB101ZM1T0nOiWz9pSrTMoa9+EiY7igmkM=
+github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/orderedcode v0.0.1 h1:UzfcAexk9Vhv8+9pNOgRu41f16lHq725vPwnSeiG/Us=
+github.com/google/orderedcode v0.0.1/go.mod h1:iVyU4/qPKHY5h/wSd6rZZCDcLJNxiWO6dvsYES2Sb20=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE=
+github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
+github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI=
+github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU=
+github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k=
+github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
+github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-metrics v0.5.3 h1:M5uADWMOGCTUNU1YuC4hfknOeHNaX54LDm4oYSucoNE=
+github.com/hashicorp/go-metrics v0.5.3/go.mod h1:KEjodfebIOuBYSAe/bHTm+HChmKSxAOXPBieMLYozDE=
+github.com/hashicorp/go-plugin v1.6.1 h1:P7MR2UP6gNKGPp+y7EZw2kOiq4IR9WiqLvp0XOsVdwI=
+github.com/hashicorp/go-plugin v1.6.1/go.mod h1:XPHFku2tFo3o3QKFgSYo+cghcUhw1NA1hZyMK0PWAw0=
+github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
+github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
+github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hashicorp/yamux v0.1.1 h1:yrQxtgseBDrq9Y652vSRDvsKCJKOUD+GzTS4Y0Y8pvE=
+github.com/hashicorp/yamux v0.1.1/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ=
+github.com/hdevalence/ed25519consensus v0.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU=
+github.com/hdevalence/ed25519consensus v0.2.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c=
+github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
+github.com/huandu/skiplist v1.2.0 h1:gox56QD77HzSC0w+Ws3MH3iie755GBJU1OER3h5VsYw=
+github.com/huandu/skiplist v1.2.0/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXMrPiHF9w=
+github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
+github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/jhump/protoreflect v1.15.3 h1:6SFRuqU45u9hIZPJAoZ8c28T3nK64BNdp9w6jFonzls=
+github.com/jhump/protoreflect v1.15.3/go.mod h1:4ORHmSBmlCW8fh3xHmJMGyul1zNqZK4Elxc8qKP+p1k=
+github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
+github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
+github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
+github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
+github.com/linxGnu/grocksdb v1.8.14 h1:HTgyYalNwBSG/1qCQUIott44wU5b2Y9Kr3z7SK5OfGQ=
+github.com/linxGnu/grocksdb v1.8.14/go.mod h1:QYiYypR2d4v63Wj1adOOfzglnoII0gLj3PNh4fZkcFA=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
+github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
+github.com/mitchellh/go-testing-interface v1.14.1 h1:jrgshOhYAUVNMAJiKbEu7EqAwgJJ2JqpQmpLJOu07cU=
+github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs=
+github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a h1:dlRvE5fWabOchtH7znfiFCcOvmIYgOeAS5ifBXBlh9Q=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s=
+github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA=
+github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro=
+github.com/onsi/gomega v1.28.1 h1:MijcGUbfYuznzK/5R4CPNoUP/9Xvuo20sXfEm6XxoTA=
+github.com/onsi/gomega v1.28.1/go.mod h1:9sxs+SwGrKI0+PWe4Fxa9tFQQBG5xSsSbMXOI8PPpoQ=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0-rc5 h1:Ygwkfw9bpDvs+c9E34SdgGOj41dX/cbdlwvlWt0pnFI=
+github.com/opencontainers/image-spec v1.1.0-rc5/go.mod h1:X4pATf0uXsnn3g5aiGIsVnJBR4mxhKzfwmvK/B2NTm8=
+github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss=
+github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/ory/dockertest v3.3.5+incompatible h1:iLLK6SQwIhcbrG783Dghaaa3WPzGc+4Emza6EbVUUGA=
+github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs=
+github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
+github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o=
+github.com/petermattis/goid v0.0.0-20240327183114-c42a807a84ba h1:3jPgmsFGBID1wFfU2AbYocNcN4wqU68UaHSdMjiw/7U=
+github.com/petermattis/goid v0.0.0-20240327183114-c42a807a84ba/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
+github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/common v0.53.0 h1:U2pL9w9nmJwJDa4qqLQ3ZaePJ6ZTwt7cMD3AG3+aLCE=
+github.com/prometheus/common v0.53.0/go.mod h1:BrxBKv3FWBIGXw89Mg1AeBq7FSyRzXWI3l3e7W3RN5U=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.14.0 h1:Lw4VdGGoKEZilJsayHf0B+9YgLGREba2C6xr+Fdfq6s=
+github.com/prometheus/procfs v0.14.0/go.mod h1:XL+Iwz8k8ZabyZfMFHPiilCniixqQarAy5Mu67pHlNQ=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rs/cors v1.11.0 h1:0B9GE/r9Bc2UxRMMtymBkHTenPkHDv0CW4Y98GBY+po=
+github.com/rs/cors v1.11.0/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/sasha-s/go-deadlock v0.3.1 h1:sqv7fDNShgjcaxkO0JNcOAlr8B9+cV5Ey/OB71efZx0=
+github.com/sasha-s/go-deadlock v0.3.1/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
+github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ=
+github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=
+github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d h1:vfofYNRScrDdvS342BElfbETmL1Aiz3i2t0zfRj16Hs=
+github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48=
+github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E=
+github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME=
+github.com/tidwall/btree v1.7.0 h1:L1fkJH/AuEh5zBnnBbmTwQ5Lt+bRJ5A8EWecslvo9iI=
+github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EUQ2cKY=
+github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/zondax/hid v0.9.2 h1:WCJFnEDMiqGF64nlZz28E9qLVZ0KSJ7xpc5DLEyma2U=
+github.com/zondax/hid v0.9.2/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM=
+github.com/zondax/ledger-go v0.14.3 h1:wEpJt2CEcBJ428md/5MgSLsXLBos98sBOyxNmCjfUCw=
+github.com/zondax/ledger-go v0.14.3/go.mod h1:IKKaoxupuB43g4NxeQmbLXv7T9AlQyie1UpHb342ycI=
+gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA=
+gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8=
+gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q=
+gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02/go.mod h1:JTnUj0mpYiAsuZLmKjTx/ex3AtMowcCgnE7YNyCEP0I=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 h1:qxen9oVGzDdIRP6ejyAJc760RwW4SnVDiTYTzwnXuxo=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5/go.mod h1:eW0HG9/oHQhvRCvb1/pIXW4cOvtDqeQK+XSi3TnwaXY=
+go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
+go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220315194320-039c03cc5b86/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.21.0 h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=
+golang.org/x/tools v0.21.0/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20220314164441-57ef72a4c106/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
+google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de h1:F6qOa9AZTYJXOUEr4jDysRDLrm4PHePlge4v4TGAlxY=
+google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:VUhTRKeHn9wwcdrk73nvdC9gF178Tzhmt/qyaFcPLSo=
+google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237 h1:RFiFrvy37/mpSpdySBDrUdipW/dHwsRwh3J3+A9VgT4=
+google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237/go.mod h1:Z5Iiy3jtmioajWHDGFk7CeugTyHtPvMHA4UTmUkyalE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240515191416-fc5f0ca64291 h1:AgADTJarZTBqgjiUzRgfaBchgYB3/WFTC80GPwsMcRI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240515191416-fc5f0ca64291/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
+google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY=
+google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
+gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+pgregory.net/rapid v1.1.0 h1:CMa0sjHSru3puNx+J0MIAuiiEV4N0qj8/cMWGBBCsjw=
+pgregory.net/rapid v1.1.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04=
+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=

server/v2/cometbft/handlers/defaults.go

@@ -0,0 +1,186 @@
+package handlers
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/gogoproto/proto"
+
+	consensusv1 "cosmossdk.io/api/cosmos/consensus/v1"
+	appmanager "cosmossdk.io/core/app"
+	"cosmossdk.io/core/store"
+	"cosmossdk.io/core/transaction"
+	"cosmossdk.io/server/v2/cometbft/mempool"
+)
+
+type AppManager[T transaction.Tx] interface {
+	ValidateTx(ctx context.Context, tx T) (appmanager.TxResult, error)
+	Query(ctx context.Context, version uint64, request transaction.Msg) (response transaction.Msg, err error)
+}
+
+type DefaultProposalHandler[T transaction.Tx] struct {
+	mempool    mempool.Mempool[T]
+	txSelector TxSelector[T]
+}
+
+func NewDefaultProposalHandler[T transaction.Tx](mp mempool.Mempool[T]) *DefaultProposalHandler[T] {
+	return &DefaultProposalHandler[T]{
+		mempool:    mp,
+		txSelector: NewDefaultTxSelector[T](),
+	}
+}
+
+func (h *DefaultProposalHandler[T]) PrepareHandler() PrepareHandler[T] {
+	return func(ctx context.Context, app AppManager[T], txs []T, req proto.Message) ([]T, error) {
+		abciReq, ok := req.(*abci.PrepareProposalRequest)
+		if !ok {
+			return nil, fmt.Errorf("expected abci.PrepareProposalRequest, invalid request type: %T,", req)
+		}
+
+		var maxBlockGas uint64
+
+		res, err := app.Query(ctx, 0, &consensusv1.QueryParamsRequest{})
+		if err != nil {
+			return nil, err
+		}
+
+		paramsResp, ok := res.(*consensusv1.QueryParamsResponse)
+		if !ok {
+			return nil, fmt.Errorf("unexpected consensus params response type; expected: %T, got: %T", &consensusv1.QueryParamsResponse{}, res)
+		}
+
+		if b := paramsResp.GetParams().Block; b != nil {
+			maxBlockGas = uint64(b.MaxGas)
+		}
+
+		defer h.txSelector.Clear()
+
+		// If the mempool is nil or NoOp we simply return the transactions
+		// requested from CometBFT, which, by default, should be in FIFO order.
+		//
+		// Note, we still need to ensure the transactions returned respect req.MaxTxBytes.
+		_, isNoOp := h.mempool.(mempool.NoOpMempool[T])
+		if h.mempool == nil || isNoOp {
+			for _, tx := range txs {
+				stop := h.txSelector.SelectTxForProposal(ctx, uint64(abciReq.MaxTxBytes), maxBlockGas, tx)
+				if stop {
+					break
+				}
+			}
+
+			return h.txSelector.SelectedTxs(ctx), nil
+		}
+
+		iterator := h.mempool.Select(ctx, txs)
+		for iterator != nil {
+			memTx := iterator.Tx()
+
+			// NOTE: Since transaction verification was already executed in CheckTx,
+			// which calls mempool.Insert, in theory everything in the pool should be
+			// valid. But some mempool implementations may insert invalid txs, so we
+			// check again.
+			_, err := app.ValidateTx(ctx, memTx)
+			if err != nil {
+				err := h.mempool.Remove([]T{memTx})
+				if err != nil && !errors.Is(err, mempool.ErrTxNotFound) {
+					return nil, err
+				}
+			} else {
+				stop := h.txSelector.SelectTxForProposal(ctx, uint64(abciReq.MaxTxBytes), maxBlockGas, memTx)
+				if stop {
+					break
+				}
+			}
+
+			iterator = iterator.Next()
+		}
+
+		return h.txSelector.SelectedTxs(ctx), nil
+	}
+}
+
+func (h *DefaultProposalHandler[T]) ProcessHandler() ProcessHandler[T] {
+	return func(ctx context.Context, app AppManager[T], txs []T, req proto.Message) error {
+		// If the mempool is nil we simply return ACCEPT,
+		// because PrepareProposal may have included txs that could fail verification.
+		_, isNoOp := h.mempool.(mempool.NoOpMempool[T])
+		if h.mempool == nil || isNoOp {
+			return nil
+		}
+
+		_, ok := req.(*abci.PrepareProposalRequest)
+		if !ok {
+			return fmt.Errorf("invalid request type: %T", req)
+		}
+
+		res, err := app.Query(ctx, 0, &consensusv1.QueryParamsRequest{})
+		if err != nil {
+			return err
+		}
+
+		paramsResp, ok := res.(*consensusv1.QueryParamsResponse)
+		if !ok {
+			return fmt.Errorf("unexpected consensus params response type; expected: %T, got: %T", &consensusv1.QueryParamsResponse{}, res)
+		}
+
+		var maxBlockGas uint64
+		if b := paramsResp.GetParams().Block; b != nil {
+			maxBlockGas = uint64(b.MaxGas)
+		}
+
+		var totalTxGas uint64
+		for _, tx := range txs {
+			_, err := app.ValidateTx(ctx, tx)
+			if err != nil {
+				return fmt.Errorf("failed to validate tx: %w", err)
+			}
+
+			if maxBlockGas > 0 {
+				gaslimit, err := tx.GetGasLimit()
+				if err != nil {
+					return fmt.Errorf("failed to get gas limit")
+				}
+				totalTxGas += gaslimit
+				if totalTxGas > maxBlockGas {
+					return fmt.Errorf("total tx gas %d exceeds max block gas %d", totalTxGas, maxBlockGas)
+				}
+			}
+		}
+
+		return nil
+	}
+}
+
+// NoOpPrepareProposal defines a no-op PrepareProposal handler. It will always
+// return the transactions sent by the client's request.
+func NoOpPrepareProposal[T transaction.Tx]() PrepareHandler[T] {
+	return func(ctx context.Context, app AppManager[T], txs []T, req proto.Message) ([]T, error) {
+		return txs, nil
+	}
+}
+
+// NoOpProcessProposal defines a no-op ProcessProposal Handler. It will always
+// return ACCEPT.
+func NoOpProcessProposal[T transaction.Tx]() ProcessHandler[T] {
+	return func(context.Context, AppManager[T], []T, proto.Message) error {
+		return nil
+	}
+}
+
+// NoOpExtendVote defines a no-op ExtendVote handler. It will always return an
+// empty byte slice as the vote extension.
+func NoOpExtendVote() ExtendVoteHandler {
+	return func(context.Context, store.ReaderMap, *abci.ExtendVoteRequest) (*abci.ExtendVoteResponse, error) {
+		return &abci.ExtendVoteResponse{VoteExtension: []byte{}}, nil
+	}
+}
+
+// NoOpVerifyVoteExtensionHandler defines a no-op VerifyVoteExtension handler. It
+// will always return an ACCEPT status with no error.
+func NoOpVerifyVoteExtensionHandler() VerifyVoteExtensionhandler {
+	return func(context.Context, store.ReaderMap, *abci.VerifyVoteExtensionRequest) (*abci.VerifyVoteExtensionResponse, error) {
+		return &abci.VerifyVoteExtensionResponse{Status: abci.VERIFY_VOTE_EXTENSION_STATUS_ACCEPT}, nil
+	}
+}

server/v2/cometbft/handlers/handlers.go

@@ -0,0 +1,31 @@
+package handlers
+
+import (
+	"context"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/gogoproto/proto"
+
+	"cosmossdk.io/core/store"
+	"cosmossdk.io/core/transaction"
+)
+
+type (
+	// PrepareHandler passes in the list of Txs that are being proposed. The app can then do stateful operations
+	// over the list of proposed transactions. It can return a modified list of txs to include in the proposal.
+	PrepareHandler[T transaction.Tx] func(context.Context, AppManager[T], []T, proto.Message) ([]T, error)
+
+	// ProcessHandler is a function that takes a list of transactions and returns a boolean and an error.
+	// If the verification of a transaction fails, the boolean is false and the error is non-nil.
+	ProcessHandler[T transaction.Tx] func(context.Context, AppManager[T], []T, proto.Message) error
+
+	// VerifyVoteExtensionhandler is a function type that handles the verification of a vote extension request.
+	// It takes a context, a store reader map, and a request to verify a vote extension.
+	// It returns a response to verify the vote extension and an error if any.
+	VerifyVoteExtensionhandler func(context.Context, store.ReaderMap, *abci.VerifyVoteExtensionRequest) (*abci.VerifyVoteExtensionResponse, error)
+
+	// ExtendVoteHandler is a function type that handles the extension of a vote.
+	// It takes a context, a store reader map, and a request to extend a vote.
+	// It returns a response to extend the vote and an error if any.
+	ExtendVoteHandler func(context.Context, store.ReaderMap, *abci.ExtendVoteRequest) (*abci.ExtendVoteResponse, error)
+)

server/v2/cometbft/handlers/tx_selector.go

@@ -0,0 +1,76 @@
+package handlers
+
+import (
+	"context"
+
+	cmttypes "github.com/cometbft/cometbft/types"
+
+	"cosmossdk.io/core/transaction"
+)
+
+// TxSelector defines a helper type that assists in selecting transactions during
+// mempool transaction selection in PrepareProposal. It keeps track of the total
+// number of bytes and total gas of the selected transactions. It also keeps
+// track of the selected transactions themselves.
+type TxSelector[T transaction.Tx] interface {
+	// SelectedTxs should return a copy of the selected transactions.
+	SelectedTxs(ctx context.Context) []T
+
+	// Clear should clear the TxSelector, nulling out all relevant fields.
+	Clear()
+
+	// SelectTxForProposal should attempt to select a transaction for inclusion in
+	// a proposal based on inclusion criteria defined by the TxSelector. It must
+	// return <true> if the caller should halt the transaction selection loop
+	// (typically over a mempool) or <false> otherwise.
+	SelectTxForProposal(ctx context.Context, maxTxBytes, maxBlockGas uint64, tx T) bool
+}
+
+type defaultTxSelector[T transaction.Tx] struct {
+	totalTxBytes uint64
+	totalTxGas   uint64
+	selectedTxs  []T
+}
+
+func NewDefaultTxSelector[T transaction.Tx]() TxSelector[T] {
+	return &defaultTxSelector[T]{}
+}
+
+func (ts *defaultTxSelector[T]) SelectedTxs(_ context.Context) []T {
+	txs := make([]T, len(ts.selectedTxs))
+	copy(txs, ts.selectedTxs)
+	return txs
+}
+
+func (ts *defaultTxSelector[T]) Clear() {
+	ts.totalTxBytes = 0
+	ts.totalTxGas = 0
+	ts.selectedTxs = nil
+}
+
+func (ts *defaultTxSelector[T]) SelectTxForProposal(_ context.Context, maxTxBytes, maxBlockGas uint64, tx T) bool {
+	txSize := uint64(cmttypes.ComputeProtoSizeForTxs([]cmttypes.Tx{tx.Bytes()}))
+	txGasLimit, err := tx.GetGasLimit()
+	if err != nil {
+		return false
+	}
+
+	// only add the transaction to the proposal if we have enough capacity
+	if (txSize + ts.totalTxBytes) <= maxTxBytes {
+		// If there is a max block gas limit, add the tx only if the limit has
+		// not been met.
+		if maxBlockGas > 0 {
+			if (txGasLimit + ts.totalTxGas) <= maxBlockGas {
+				ts.totalTxGas += txGasLimit
+				ts.totalTxBytes += txSize
+				ts.selectedTxs = append(ts.selectedTxs, tx)
+			}
+		} else {
+			ts.totalTxBytes += txSize
+			ts.selectedTxs = append(ts.selectedTxs, tx)
+		}
+	}
+
+	// check if we've reached capacity; if so, we cannot select any more transactions
+	return ts.totalTxBytes >= maxTxBytes || (maxBlockGas > 0 && (ts.totalTxGas >= maxBlockGas))
+}

server/v2/cometbft/log/logger.go

@@ -0,0 +1,23 @@
+package log
+
+import (
+	cmtlog "github.com/cometbft/cometbft/libs/log"
+
+	"cosmossdk.io/core/log"
+)
+
+var _ cmtlog.Logger = (*CometLoggerWrapper)(nil)
+
+// CometLoggerWrapper provides a wrapper around a cosmossdk.io/log instance.
+// It implements CometBFT's Logger interface.
+type CometLoggerWrapper struct {
+	log.Logger
+}
+
+// With returns a new wrapped logger with additional context provided by a set
+// of key/value tuples. The number of tuples must be even and the key of the
+// tuple must be a string.
+func (cmt CometLoggerWrapper) With(keyVals ...interface{}) cmtlog.Logger {
+	logger := cmt.Logger.With(keyVals...)
+	return CometLoggerWrapper{logger}
+}

server/v2/cometbft/mempool/config.go

@@ -0,0 +1,11 @@
+package mempool
+
+// Config defines the configurations for the SDK built-in app-side mempool
+// implementations.
+type Config struct {
+	// MaxTxs defines the behavior of the mempool. A negative value indicates
+	// the mempool is disabled entirely, zero indicates that the mempool is
+	// unbounded in how many txs it may contain, and a positive value indicates
+	// the maximum amount of txs it may contain.
+	MaxTxs int `mapstructure:"max-txs"`
+}

server/v2/cometbft/mempool/doc.go

@@ -0,0 +1,6 @@
+/*
+The mempool package defines a few mempool services which can be used in conjunction with your consensus implementation
+
+*/
+
+package mempool

server/v2/cometbft/mempool/mempool.go

@@ -0,0 +1,41 @@
+package mempool
+
+import (
+	"context"
+	"errors"
+
+	"cosmossdk.io/core/transaction"
+)
+
+var (
+	ErrTxNotFound           = errors.New("tx not found in mempool")
+	ErrMempoolTxMaxCapacity = errors.New("pool reached max tx capacity")
+)
+
+// Mempool defines the required methods of an application's mempool.
+type Mempool[T transaction.Tx] interface {
+	// Insert attempts to insert a Tx into the app-side mempool returning
+	// an error upon failure.
+	Insert(context.Context, T) error
+
+	// Select returns an Iterator over the app-side mempool. If txs are specified,
+	// then they shall be incorporated into the Iterator. The Iterator must be
+	// closed by the caller.
+	Select(context.Context, []T) Iterator[T]
+
+	// Remove attempts to remove a transaction from the mempool, returning an error
+	// upon failure.
+	Remove([]T) error
+}
+
+// Iterator defines an app-side mempool iterator interface that is as minimal as
+// possible. The order of iteration is determined by the app-side mempool
+// implementation.
+type Iterator[T transaction.Tx] interface {
+	// Next returns the next transaction from the mempool. If there are no more
+	// transactions, it returns nil.
+	Next() Iterator[T]
+
+	// Tx returns the transaction at the current position of the iterator.
+	Tx() T
+}

server/v2/cometbft/mempool/noop.go

@@ -0,0 +1,22 @@
+package mempool
+
+import (
+	"context"
+
+	"cosmossdk.io/core/transaction"
+)
+
+var _ Mempool[transaction.Tx] = (*NoOpMempool[transaction.Tx])(nil)
+
+// NoOpMempool 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 NoOpMempool[T transaction.Tx] struct{}
+
+func (NoOpMempool[T]) Insert(context.Context, T) error         { return nil }
+func (NoOpMempool[T]) Select(context.Context, []T) Iterator[T] { return nil }
+func (NoOpMempool[T]) CountTx() int                            { return 0 }
+func (NoOpMempool[T]) Remove([]T) error                        { return nil }

server/v2/cometbft/query.go

@@ -0,0 +1,130 @@
+package cometbft
+
+import (
+	"context"
+	"strings"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	crypto "github.com/cometbft/cometbft/api/cometbft/crypto/v1"
+
+	errorsmod "cosmossdk.io/errors"
+	"cosmossdk.io/server/v2/cometbft/types"
+	cometerrors "cosmossdk.io/server/v2/cometbft/types/errors"
+)
+
+func (c *Consensus[T]) handleQueryP2P(path []string) (*abci.QueryResponse, error) {
+	// "/p2p" prefix for p2p queries
+	if len(path) < 4 {
+		return nil, errorsmod.Wrap(cometerrors.ErrUnknownRequest, "path should be p2p filter <addr|id> <parameter>")
+	}
+
+	cmd, typ, arg := path[1], path[2], path[3]
+	if cmd == "filter" {
+		if typ == "addr" {
+			if c.cfg.AddrPeerFilter != nil {
+				return c.cfg.AddrPeerFilter(arg)
+			}
+		} else if typ == "id" {
+			if c.cfg.IdPeerFilter != nil {
+				return c.cfg.IdPeerFilter(arg)
+			}
+		}
+	}
+
+	return nil, errorsmod.Wrap(cometerrors.ErrUnknownRequest, "expected second parameter to be 'filter'")
+}
+
+// handlerQueryApp handles the query requests for the application.
+// It expects the path parameter to have at least two elements.
+// The second element of the path can be either 'simulate' or 'version'.
+// If the second element is 'simulate', it decodes the request data into a transaction,
+// simulates the transaction using the application, and returns the simulation result.
+// If the second element is 'version', it returns the version of the application.
+// If the second element is neither 'simulate' nor 'version', it returns an error indicating an unknown query.
+func (c *Consensus[T]) handlerQueryApp(ctx context.Context, path []string, req *abci.QueryRequest) (*abci.QueryResponse, error) {
+	if len(path) < 2 {
+		return nil, errorsmod.Wrap(
+			cometerrors.ErrUnknownRequest,
+			"expected second parameter to be either 'simulate' or 'version', neither was present",
+		)
+	}
+
+	switch path[1] {
+	case "simulate":
+		tx, err := c.txCodec.Decode(req.Data)
+		if err != nil {
+			return nil, errorsmod.Wrap(err, "failed to decode tx")
+		}
+
+		txResult, _, err := c.app.Simulate(ctx, tx)
+		if err != nil {
+			return nil, errorsmod.Wrap(err, "failed to simulate tx")
+		}
+
+		bz, err := intoABCISimulationResponse(txResult, c.cfg.IndexEvents)
+		if err != nil {
+			return nil, errorsmod.Wrap(err, "failed to marshal txResult")
+		}
+
+		return &abci.QueryResponse{
+			Codespace: cometerrors.RootCodespace,
+			Value:     bz,
+			Height:    req.Height,
+		}, nil
+
+	case "version":
+		return &abci.QueryResponse{
+			Codespace: cometerrors.RootCodespace,
+			Value:     []byte(c.cfg.Version),
+			Height:    req.Height,
+		}, nil
+	}
+
+	return nil, errorsmod.Wrapf(cometerrors.ErrUnknownRequest, "unknown query: %s", path)
+}
+
+func (c *Consensus[T]) handleQueryStore(path []string, _ types.Store, req *abci.QueryRequest) (*abci.QueryResponse, error) {
+	req.Path = "/" + strings.Join(path[1:], "/")
+	if req.Height <= 1 && req.Prove {
+		return nil, errorsmod.Wrap(
+			cometerrors.ErrInvalidRequest,
+			"cannot query with proof when height <= 1; please provide a valid height",
+		)
+	}
+
+	// "/store/<storeName>" for store queries
+	storeName := path[1]
+	storeNameBz := []byte(storeName) // TODO fastpath?
+	qRes, err := c.store.Query(storeNameBz, uint64(req.Height), req.Data, req.Prove)
+	if err != nil {
+		return nil, err
+	}
+
+	res := &abci.QueryResponse{
+		Codespace: cometerrors.RootCodespace,
+		Height:    int64(qRes.Version),
+		Key:       qRes.Key,
+		Value:     qRes.Value,
+	}
+
+	if req.Prove {
+		for _, proof := range qRes.ProofOps {
+			bz, err := proof.Proof.Marshal()
+			if err != nil {
+				return nil, errorsmod.Wrap(err, "failed to marshal proof")
+			}
+
+			res.ProofOps = &crypto.ProofOps{
+				Ops: []crypto.ProofOp{
+					{
+						Type: proof.Type,
+						Key:  proof.Key,
+						Data: bz,
+					},
+				},
+			}
+		}
+	}
+
+	return res, nil
+}

server/v2/cometbft/server.go

@@ -0,0 +1,225 @@
+package cometbft
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+
+	abciserver "github.com/cometbft/cometbft/abci/server"
+	cmtcmd "github.com/cometbft/cometbft/cmd/cometbft/commands"
+	cmtcfg "github.com/cometbft/cometbft/config"
+	"github.com/cometbft/cometbft/node"
+	"github.com/cometbft/cometbft/p2p"
+	pvm "github.com/cometbft/cometbft/privval"
+	"github.com/cometbft/cometbft/proxy"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"cosmossdk.io/core/log"
+	"cosmossdk.io/core/transaction"
+	serverv2 "cosmossdk.io/server/v2"
+	"cosmossdk.io/server/v2/appmanager"
+	"cosmossdk.io/server/v2/cometbft/handlers"
+	cometlog "cosmossdk.io/server/v2/cometbft/log"
+	"cosmossdk.io/server/v2/cometbft/mempool"
+	"cosmossdk.io/server/v2/cometbft/types"
+	"cosmossdk.io/store/v2/snapshots"
+
+	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
+)
+
+const (
+	flagWithComet     = "with-comet"
+	flagAddress       = "address"
+	flagTransport     = "transport"
+	flagTraceStore    = "trace-store"
+	flagCPUProfile    = "cpu-profile"
+	FlagMinGasPrices  = "minimum-gas-prices"
+	FlagQueryGasLimit = "query-gas-limit"
+	FlagHaltHeight    = "halt-height"
+	FlagHaltTime      = "halt-time"
+	FlagTrace         = "trace"
+)
+
+var _ serverv2.ServerModule = (*CometBFTServer[transaction.Tx])(nil)
+
+type CometBFTServer[T transaction.Tx] struct {
+	Node   *node.Node
+	App    *Consensus[T]
+	logger log.Logger
+
+	config    Config
+	cleanupFn func()
+}
+
+// App is an interface that represents an application in the CometBFT server.
+// It provides methods to access the app manager, logger, and store.
+type App[T transaction.Tx] interface {
+	GetApp() *appmanager.AppManager[T]
+	GetLogger() log.Logger
+	GetStore() types.Store
+}
+
+func NewCometBFTServer[T transaction.Tx](
+	app *appmanager.AppManager[T],
+	store types.Store,
+	logger log.Logger,
+	cfg Config,
+	txCodec transaction.Codec[T],
+) *CometBFTServer[T] {
+	logger = logger.With("module", "cometbft-server")
+
+	// create noop mempool
+	mempool := mempool.NoOpMempool[T]{}
+
+	// create consensus
+	consensus := NewConsensus[T](app, mempool, store, cfg, txCodec, logger)
+
+	consensus.SetPrepareProposalHandler(handlers.NoOpPrepareProposal[T]())
+	consensus.SetProcessProposalHandler(handlers.NoOpProcessProposal[T]())
+	consensus.SetVerifyVoteExtension(handlers.NoOpVerifyVoteExtensionHandler())
+	consensus.SetExtendVoteExtension(handlers.NoOpExtendVote())
+
+	// TODO: set these; what is the appropriate presence of the Store interface here?
+	var ss snapshots.StorageSnapshotter
+	var sc snapshots.CommitSnapshotter
+
+	snapshotStore, err := GetSnapshotStore(cfg.CmtConfig.RootDir)
+	if err != nil {
+		panic(err)
+	}
+
+	sm := snapshots.NewManager(snapshotStore, snapshots.SnapshotOptions{}, sc, ss, nil, logger) // TODO: set options somehow
+	consensus.SetSnapshotManager(sm)
+
+	return &CometBFTServer[T]{
+		logger: logger,
+		App:    consensus,
+		config: cfg,
+	}
+}
+
+func (s *CometBFTServer[T]) Name() string {
+	return "cometbft"
+}
+
+func (s *CometBFTServer[T]) Start(ctx context.Context) error {
+	wrappedLogger := cometlog.CometLoggerWrapper{Logger: s.logger}
+	if s.config.Standalone {
+		svr, err := abciserver.NewServer(s.config.Addr, s.config.Transport, s.App)
+		if err != nil {
+			return fmt.Errorf("error creating listener: %w", err)
+		}
+
+		svr.SetLogger(wrappedLogger)
+
+		return svr.Start()
+	}
+
+	nodeKey, err := p2p.LoadOrGenNodeKey(s.config.CmtConfig.NodeKeyFile())
+	if err != nil {
+		return err
+	}
+
+	s.Node, err = node.NewNode(
+		ctx,
+		s.config.CmtConfig,
+		pvm.LoadOrGenFilePV(s.config.CmtConfig.PrivValidatorKeyFile(), s.config.CmtConfig.PrivValidatorStateFile()),
+		nodeKey,
+		proxy.NewLocalClientCreator(s.App),
+		getGenDocProvider(s.config.CmtConfig),
+		cmtcfg.DefaultDBProvider,
+		node.DefaultMetricsProvider(s.config.CmtConfig.Instrumentation),
+		wrappedLogger,
+	)
+	if err != nil {
+		return err
+	}
+
+	s.cleanupFn = func() {
+		if s.Node != nil && s.Node.IsRunning() {
+			_ = s.Node.Stop()
+		}
+	}
+
+	return s.Node.Start()
+}
+
+func (s *CometBFTServer[T]) Stop(_ context.Context) error {
+	defer s.cleanupFn()
+	if s.Node != nil {
+		return s.Node.Stop()
+	}
+	return nil
+}
+
+// returns a function which returns the genesis doc from the genesis file.
+func getGenDocProvider(cfg *cmtcfg.Config) func() (node.ChecksummedGenesisDoc, error) {
+	return func() (node.ChecksummedGenesisDoc, error) {
+		appGenesis, err := genutiltypes.AppGenesisFromFile(cfg.GenesisFile())
+		if err != nil {
+			return node.ChecksummedGenesisDoc{
+				Sha256Checksum: []byte{},
+			}, err
+		}
+
+		gen, err := appGenesis.ToGenesisDoc()
+		if err != nil {
+			return node.ChecksummedGenesisDoc{
+				Sha256Checksum: []byte{},
+			}, err
+		}
+		genbz, err := gen.AppState.MarshalJSON()
+		if err != nil {
+			return node.ChecksummedGenesisDoc{
+				Sha256Checksum: []byte{},
+			}, err
+		}
+
+		bz, err := json.Marshal(genbz)
+		if err != nil {
+			return node.ChecksummedGenesisDoc{
+				Sha256Checksum: []byte{},
+			}, err
+		}
+		sum := sha256.Sum256(bz)
+
+		return node.ChecksummedGenesisDoc{
+			GenesisDoc:     gen,
+			Sha256Checksum: sum[:],
+		}, nil
+	}
+}
+
+func (s *CometBFTServer[T]) StartCmdFlags() pflag.FlagSet {
+	flags := *pflag.NewFlagSet("cometbft", pflag.ExitOnError)
+	flags.Bool(flagWithComet, true, "Run abci app embedded in-process with CometBFT")
+	flags.String(flagAddress, "tcp://127.0.0.1:26658", "Listen address")
+	flags.String(flagTransport, "socket", "Transport protocol: socket, grpc")
+	flags.String(flagTraceStore, "", "Enable KVStore tracing to an output file")
+	flags.String(FlagMinGasPrices, "", "Minimum gas prices to accept for transactions; Any fee in a tx must meet this minimum (e.g. 0.01photino;0.0001stake)")
+	flags.Uint64(FlagQueryGasLimit, 0, "Maximum gas a Rest/Grpc query can consume. Blank and 0 imply unbounded.")
+	flags.Uint64(FlagHaltHeight, 0, "Block height at which to gracefully halt the chain and shutdown the node")
+	flags.Uint64(FlagHaltTime, 0, "Minimum block time (in Unix seconds) at which to gracefully halt the chain and shutdown the node")
+	flags.String(flagCPUProfile, "", "Enable CPU profiling and write to the provided file")
+	flags.Bool(FlagTrace, false, "Provide full stack traces for errors in ABCI Log")
+	return flags
+}
+
+func (s *CometBFTServer[T]) CLICommands() serverv2.CLIConfig {
+	return serverv2.CLIConfig{
+		Commands: []*cobra.Command{
+			s.StatusCommand(),
+			s.ShowNodeIDCmd(),
+			s.ShowValidatorCmd(),
+			s.ShowAddressCmd(),
+			s.VersionCmd(),
+			s.QueryBlockCmd(),
+			s.QueryBlocksCmd(),
+			s.QueryBlockResultsCmd(),
+			cmtcmd.ResetAllCmd,
+			cmtcmd.ResetStateCmd,
+		},
+	}
+}

server/v2/cometbft/service.go

@@ -0,0 +1,70 @@
+package cometbft
+
+import (
+	"context"
+
+	abci "github.com/cometbft/cometbft/api/cometbft/abci/v1"
+
+	"cosmossdk.io/core/comet"
+	corecontext "cosmossdk.io/core/context"
+)
+
+func contextWithCometInfo(ctx context.Context, info comet.Info) context.Context {
+	return context.WithValue(ctx, corecontext.CometInfoKey, info)
+}
+
+// toCoreEvidence takes comet evidence and returns sdk evidence
+func toCoreEvidence(ev []abci.Misbehavior) []comet.Evidence {
+	evidence := make([]comet.Evidence, len(ev))
+	for i, e := range ev {
+		evidence[i] = comet.Evidence{
+			Type:             comet.MisbehaviorType(e.Type),
+			Height:           e.Height,
+			Time:             e.Time,
+			TotalVotingPower: e.TotalVotingPower,
+			Validator: comet.Validator{
+				Address: e.Validator.Address,
+				Power:   e.Validator.Power,
+			},
+		}
+	}
+	return evidence
+}
+
+// toCoreCommitInfo takes comet commit info and returns sdk commit info
+func toCoreCommitInfo(commit abci.CommitInfo) comet.CommitInfo {
+	ci := comet.CommitInfo{
+		Round: commit.Round,
+	}
+
+	for _, v := range commit.Votes {
+		ci.Votes = append(ci.Votes, comet.VoteInfo{
+			Validator: comet.Validator{
+				Address: v.Validator.Address,
+				Power:   v.Validator.Power,
+			},
+			BlockIDFlag: comet.BlockIDFlag(v.BlockIdFlag),
+		})
+	}
+	return ci
+}
+
+// toCoreExtendedCommitInfo takes comet extended commit info and returns sdk commit info
+func toCoreExtendedCommitInfo(commit abci.ExtendedCommitInfo) comet.CommitInfo {
+	ci := comet.CommitInfo{
+		Round: commit.Round,
+		Votes: make([]comet.VoteInfo, len(commit.Votes)),
+	}
+
+	for i, v := range commit.Votes {
+		ci.Votes[i] = comet.VoteInfo{
+			Validator: comet.Validator{
+				Address: v.Validator.Address,
+				Power:   v.Validator.Power,
+			},
+			BlockIDFlag: comet.BlockIDFlag(v.BlockIdFlag),
+		}
+	}
+
+	return ci
+}

server/v2/cometbft/snapshots.go

@@ -0,0 +1,192 @@
+package cometbft
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/gogoproto/proto"
+
+	"cosmossdk.io/store/v2/snapshots"
+	snapshottypes "cosmossdk.io/store/v2/snapshots/types"
+)
+
+// GetSnapshotStore returns a snapshot store for the given application options.
+// It creates a directory for storing snapshots if it doesn't exist.
+// It initializes a GoLevelDB database for storing metadata of the snapshots.
+// The snapshot store is then created using the initialized database and directory.
+// If any error occurs during the process, it is returned along with a nil snapshot store.
+func GetSnapshotStore(rootDir string) (*snapshots.Store, error) {
+	snapshotDir := filepath.Join(rootDir, "data", "snapshots")
+	if err := os.MkdirAll(snapshotDir, 0o750); err != nil {
+		return nil, fmt.Errorf("failed to create snapshots directory: %w", err)
+	}
+
+	snapshotStore, err := snapshots.NewStore(snapshotDir)
+	if err != nil {
+		return nil, err
+	}
+
+	return snapshotStore, nil
+}
+
+// ApplySnapshotChunk implements types.Application.
+func (c *Consensus[T]) ApplySnapshotChunk(_ context.Context, req *abci.ApplySnapshotChunkRequest) (*abci.ApplySnapshotChunkResponse, error) {
+	if c.snapshotManager == nil {
+		c.logger.Error("snapshot manager not configured")
+		return &abci.ApplySnapshotChunkResponse{Result: abci.APPLY_SNAPSHOT_CHUNK_RESULT_ABORT}, nil
+	}
+
+	_, err := c.snapshotManager.RestoreChunk(req.Chunk)
+	switch {
+	case err == nil:
+		return &abci.ApplySnapshotChunkResponse{Result: abci.APPLY_SNAPSHOT_CHUNK_RESULT_ACCEPT}, nil
+
+	case errors.Is(err, snapshottypes.ErrChunkHashMismatch):
+		c.logger.Error(
+			"chunk checksum mismatch; rejecting sender and requesting refetch",
+			"chunk", req.Index,
+			"sender", req.Sender,
+			"err", err,
+		)
+		return &abci.ApplySnapshotChunkResponse{
+			Result:        abci.APPLY_SNAPSHOT_CHUNK_RESULT_RETRY,
+			RefetchChunks: []uint32{req.Index},
+			RejectSenders: []string{req.Sender},
+		}, nil
+
+	default:
+		c.logger.Error("failed to restore snapshot", "err", err)
+		return &abci.ApplySnapshotChunkResponse{Result: abci.APPLY_SNAPSHOT_CHUNK_RESULT_ABORT}, nil
+	}
+}
+
+// ListSnapshots implements types.Application.
+func (c *Consensus[T]) ListSnapshots(_ context.Context, ctx *abci.ListSnapshotsRequest) (*abci.ListSnapshotsResponse, error) {
+	if c.snapshotManager == nil {
+		return nil, nil
+	}
+
+	snapshots, err := c.snapshotManager.List()
+	if err != nil {
+		c.logger.Error("failed to list snapshots", "err", err)
+		return nil, err
+	}
+
+	resp := &abci.ListSnapshotsResponse{}
+	for _, snapshot := range snapshots {
+		abciSnapshot, err := snapshotToABCI(snapshot)
+		if err != nil {
+			c.logger.Error("failed to convert ABCI snapshots", "err", err)
+			return nil, err
+		}
+
+		resp.Snapshots = append(resp.Snapshots, &abciSnapshot)
+	}
+
+	return resp, nil
+}
+
+// LoadSnapshotChunk implements types.Application.
+func (c *Consensus[T]) LoadSnapshotChunk(_ context.Context, req *abci.LoadSnapshotChunkRequest) (*abci.LoadSnapshotChunkResponse, error) {
+	if c.snapshotManager == nil {
+		return &abci.LoadSnapshotChunkResponse{}, nil
+	}
+
+	chunk, err := c.snapshotManager.LoadChunk(req.Height, req.Format, req.Chunk)
+	if err != nil {
+		c.logger.Error(
+			"failed to load snapshot chunk",
+			"height", req.Height,
+			"format", req.Format,
+			"chunk", req.Chunk,
+			"err", err,
+		)
+		return nil, err
+	}
+
+	return &abci.LoadSnapshotChunkResponse{Chunk: chunk}, nil
+}
+
+// OfferSnapshot implements types.Application.
+func (c *Consensus[T]) OfferSnapshot(_ context.Context, req *abci.OfferSnapshotRequest) (*abci.OfferSnapshotResponse, error) {
+	if c.snapshotManager == nil {
+		c.logger.Error("snapshot manager not configured")
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_ABORT}, nil
+	}
+
+	if req.Snapshot == nil {
+		c.logger.Error("received nil snapshot")
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_REJECT}, nil
+	}
+
+	snapshot, err := snapshotFromABCI(req.Snapshot)
+	if err != nil {
+		c.logger.Error("failed to decode snapshot metadata", "err", err)
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_REJECT}, nil
+	}
+
+	err = c.snapshotManager.Restore(snapshot)
+	switch {
+	case err == nil:
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_ACCEPT}, nil
+
+	case errors.Is(err, snapshottypes.ErrUnknownFormat):
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_REJECT_FORMAT}, nil
+
+	case errors.Is(err, snapshottypes.ErrInvalidMetadata):
+		c.logger.Error(
+			"rejecting invalid snapshot",
+			"height", req.Snapshot.Height,
+			"format", req.Snapshot.Format,
+			"err", err,
+		)
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_REJECT}, nil
+
+	default:
+		c.logger.Error(
+			"failed to restore snapshot",
+			"height", req.Snapshot.Height,
+			"format", req.Snapshot.Format,
+			"err", err,
+		)
+
+		// We currently don't support resetting the IAVL stores and retrying a
+		// different snapshot, so we ask CometBFT to abort all snapshot restoration.
+		return &abci.OfferSnapshotResponse{Result: abci.OFFER_SNAPSHOT_RESULT_ABORT}, nil
+	}
+}
+
+// Converts an ABCI snapshot to a snapshot. Mainly to decode the SDK metadata.
+func snapshotFromABCI(in *abci.Snapshot) (snapshottypes.Snapshot, error) {
+	snapshot := snapshottypes.Snapshot{
+		Height: in.Height,
+		Format: in.Format,
+		Chunks: in.Chunks,
+		Hash:   in.Hash,
+	}
+	err := proto.Unmarshal(in.Metadata, &snapshot.Metadata)
+	if err != nil {
+		return snapshottypes.Snapshot{}, fmt.Errorf("failed to unmarshal snapshot metadata: %w", err)
+	}
+	return snapshot, nil
+}
+
+// Converts a Snapshot to its ABCI representation. Mainly to encode the SDK metadata.
+func snapshotToABCI(s *snapshottypes.Snapshot) (abci.Snapshot, error) {
+	out := abci.Snapshot{
+		Height: s.Height,
+		Format: s.Format,
+		Chunks: s.Chunks,
+		Hash:   s.Hash,
+	}
+	var err error
+	out.Metadata, err = proto.Marshal(&s.Metadata)
+	if err != nil {
+		return abci.Snapshot{}, fmt.Errorf("failed to marshal snapshot metadata: %w", err)
+	}
+	return out, nil
+}

server/v2/cometbft/streaming.go

@@ -0,0 +1,77 @@
+package cometbft
+
+import (
+	"context"
+
+	coreappmgr "cosmossdk.io/core/app"
+	"cosmossdk.io/core/event"
+	"cosmossdk.io/core/store"
+	"cosmossdk.io/server/v2/streaming"
+)
+
+// streamDeliverBlockChanges will stream all the changes happened during deliver block.
+func (c *Consensus[T]) streamDeliverBlockChanges(
+	ctx context.Context,
+	height int64,
+	txs [][]byte,
+	txResults []coreappmgr.TxResult,
+	events []event.Event,
+	stateChanges []store.StateChanges,
+) error {
+	// convert txresults to streaming txresults
+	streamingTxResults := make([]*streaming.ExecTxResult, len(txResults))
+	for i, txResult := range txResults {
+		streamingTxResults[i] = &streaming.ExecTxResult{
+			Code:      txResult.Code,
+			Data:      txResult.Data,
+			Log:       txResult.Log,
+			Info:      txResult.Info,
+			GasWanted: uint64ToInt64(txResult.GasWanted),
+			GasUsed:   uint64ToInt64(txResult.GasUsed),
+			Events:    streaming.IntoStreamingEvents(txResult.Events),
+			Codespace: txResult.Codespace,
+		}
+	}
+
+	for _, streamingListener := range c.streaming.Listeners {
+		if err := streamingListener.ListenDeliverBlock(ctx, streaming.ListenDeliverBlockRequest{
+			BlockHeight: height,
+			Txs:         txs,
+			TxResults:   streamingTxResults,
+			Events:      streaming.IntoStreamingEvents(events),
+		}); err != nil {
+			c.logger.Error("ListenDeliverBlock listening hook failed", "height", height, "err", err)
+		}
+
+		if err := streamingListener.ListenStateChanges(ctx, intoStreamingKVPairs(stateChanges)); err != nil {
+			c.logger.Error("ListenStateChanges listening hook failed", "height", height, "err", err)
+		}
+	}
+	return nil
+}
+
+func intoStreamingKVPairs(stateChanges []store.StateChanges) []*streaming.StoreKVPair {
+	// Calculate the total number of KV pairs to preallocate the slice with the required capacity.
+	totalKvPairs := 0
+	for _, accounts := range stateChanges {
+		totalKvPairs += len(accounts.StateChanges)
+	}
+
+	// Preallocate the slice with the required capacity.
+	streamKvPairs := make([]*streaming.StoreKVPair, 0, totalKvPairs)
+
+	for _, accounts := range stateChanges {
+		// Reducing the scope of address variable.
+		address := accounts.Actor
+
+		for _, kv := range accounts.StateChanges {
+			streamKvPairs = append(streamKvPairs, &streaming.StoreKVPair{
+				Address: address,
+				Key:     kv.Key,
+				Value:   kv.Value,
+				Delete:  kv.Remove,
+			})
+		}
+	}
+	return streamKvPairs
+}

server/v2/cometbft/types/errors/errors.go

@@ -0,0 +1,17 @@
+package errors
+
+import (
+	errorsmod "cosmossdk.io/errors"
+)
+
+// RootCodespace is the codespace for all errors defined in this package
+const RootCodespace = "cometbft-sdk"
+
+var (
+	// ErrUnknownRequest to doc
+	ErrUnknownRequest = errorsmod.Register(RootCodespace, 1, "unknown request")
+
+	// ErrInvalidRequest defines an ABCI typed error where the request contains
+	// invalid data.
+	ErrInvalidRequest = errorsmod.Register(RootCodespace, 2, "invalid request")
+)

server/v2/cometbft/types/peer.go

@@ -0,0 +1,6 @@
+package types
+
+import abci "github.com/cometbft/cometbft/abci/types"
+
+// PeerFilter responds to p2p filtering queries from Tendermint
+type PeerFilter func(info string) (*abci.QueryResponse, error)

server/v2/cometbft/types/store.go

@@ -0,0 +1,32 @@
+package types
+
+import (
+	"cosmossdk.io/core/store"
+	storev2 "cosmossdk.io/store/v2"
+	"cosmossdk.io/store/v2/proof"
+)
+
+type Store interface {
+	// GetLatestVersion returns the latest version that consensus has been made on
+	GetLatestVersion() (uint64, error)
+	// StateLatest returns a readonly view over the latest
+	// committed state of the store. Alongside the version
+	// associated with it.
+	StateLatest() (uint64, store.ReaderMap, error)
+
+	// Commit commits the provided changeset and returns
+	// the new state root of the state.
+	Commit(*store.Changeset) (store.Hash, error)
+
+	// Query is a key/value query directly to the underlying database. This skips the appmanager
+	Query(storeKey []byte, version uint64, key []byte, prove bool) (storev2.QueryResult, error)
+
+	// LastCommitID returns a CommitID pertaining to the last commitment.
+	LastCommitID() (proof.CommitID, error)
+
+	// GetStateStorage returns the SS backend.
+	GetStateStorage() storev2.VersionedDatabase
+
+	// GetStateCommitment returns the SC backend.
+	GetStateCommitment() storev2.Committer
+}

server/v2/cometbft/types/vote.go

@@ -0,0 +1,13 @@
+package types
+
+import (
+	"context"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+)
+
+// VoteExtensionsHandler defines how to implement vote extension handlers
+type VoteExtensionsHandler interface {
+	ExtendVote(context.Context, *abci.ExtendVoteRequest) (*abci.ExtendVoteResponse, error)
+	VerifyVoteExtension(context.Context, *abci.VerifyVoteExtensionRequest) (*abci.VerifyVoteExtensionResponse, error)
+}

server/v2/cometbft/utils.go

@@ -0,0 +1,414 @@
+package cometbft
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	abciv1 "buf.build/gen/go/cometbft/cometbft/protocolbuffers/go/cometbft/abci/v1"
+	abci "github.com/cometbft/cometbft/abci/types"
+	cmtproto "github.com/cometbft/cometbft/api/cometbft/types/v1"
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	gogoany "github.com/cosmos/gogoproto/types/any"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/types/known/anypb"
+
+	v1beta1 "cosmossdk.io/api/cosmos/base/abci/v1beta1"
+	appmanager "cosmossdk.io/core/app"
+	appmodulev2 "cosmossdk.io/core/appmodule/v2"
+	"cosmossdk.io/core/comet"
+	"cosmossdk.io/core/event"
+	"cosmossdk.io/core/transaction"
+	errorsmod "cosmossdk.io/errors"
+	consensus "cosmossdk.io/x/consensus/types"
+)
+
+func queryResponse(res transaction.Msg) (*abci.QueryResponse, error) {
+	// TODO(kocu): we are tightly coupled go gogoproto here, is this problem?
+	bz, err := gogoproto.Marshal(res)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: how do I reply? I suppose we need to different replies depending of the query
+	return &abci.QueryResponse{
+		Code:  0,
+		Log:   "",
+		Info:  "",
+		Index: 0,
+		Key:   []byte{},
+		Value: bz,
+		// ProofOps:  &cmtcrypto.ProofOps{},
+		Height:    0,
+		Codespace: "",
+	}, nil
+}
+
+// responseExecTxResultWithEvents returns an ABCI ExecTxResult object with fields
+// filled in from the given error, gas values and events.
+func responseExecTxResultWithEvents(err error, gw, gu uint64, events []abci.Event, debug bool) *abci.ExecTxResult {
+	space, code, log := errorsmod.ABCIInfo(err, debug)
+	return &abci.ExecTxResult{
+		Codespace: space,
+		Code:      code,
+		Log:       log,
+		GasWanted: int64(gw),
+		GasUsed:   int64(gu),
+		Events:    events,
+	}
+}
+
+// splitABCIQueryPath splits a string path using the delimiter '/'.
+//
+// e.g. "this/is/funny" becomes []string{"this", "is", "funny"}
+func splitABCIQueryPath(requestPath string) (path []string) {
+	path = strings.Split(requestPath, "/")
+
+	// first element is empty string
+	if len(path) > 0 && path[0] == "" {
+		path = path[1:]
+	}
+
+	return path
+}
+
+func finalizeBlockResponse(
+	in *appmanager.BlockResponse,
+	cp *cmtproto.ConsensusParams,
+	appHash []byte,
+	indexSet map[string]struct{},
+) (*abci.FinalizeBlockResponse, error) {
+	allEvents := append(in.BeginBlockEvents, in.EndBlockEvents...)
+
+	resp := &abci.FinalizeBlockResponse{
+		Events:                intoABCIEvents(allEvents, indexSet),
+		TxResults:             intoABCITxResults(in.TxResults, indexSet),
+		ValidatorUpdates:      intoABCIValidatorUpdates(in.ValidatorUpdates),
+		AppHash:               appHash,
+		ConsensusParamUpdates: cp,
+	}
+	return resp, nil
+}
+
+func intoABCIValidatorUpdates(updates []appmodulev2.ValidatorUpdate) []abci.ValidatorUpdate {
+	valsetUpdates := make([]abci.ValidatorUpdate, len(updates))
+
+	for i, v := range updates {
+		valsetUpdates[i] = abci.ValidatorUpdate{
+			PubKeyBytes: v.PubKey,
+			PubKeyType:  v.PubKeyType,
+			Power:       v.Power,
+		}
+	}
+
+	return valsetUpdates
+}
+
+func intoABCITxResults(results []appmanager.TxResult, indexSet map[string]struct{}) []*abci.ExecTxResult {
+	res := make([]*abci.ExecTxResult, len(results))
+	for i := range results {
+		if results[i].Error == nil {
+			res[i] = responseExecTxResultWithEvents(
+				results[i].Error,
+				results[i].GasWanted,
+				results[i].GasUsed,
+				intoABCIEvents(results[i].Events, indexSet),
+				false,
+			)
+			continue
+		}
+
+		// TODO: handle properly once the we decide on the type of TxResult.Resp
+	}
+
+	return res
+}
+
+func intoABCIEvents(events []event.Event, indexSet map[string]struct{}) []abci.Event {
+	indexAll := len(indexSet) == 0
+	abciEvents := make([]abci.Event, len(events))
+	for i, e := range events {
+		abciEvents[i] = abci.Event{
+			Type:       e.Type,
+			Attributes: make([]abci.EventAttribute, len(e.Attributes)),
+		}
+
+		for j, attr := range e.Attributes {
+			_, index := indexSet[fmt.Sprintf("%s.%s", e.Type, attr.Key)]
+			abciEvents[i].Attributes[j] = abci.EventAttribute{
+				Key:   attr.Key,
+				Value: attr.Value,
+				Index: index || indexAll,
+			}
+		}
+	}
+	return abciEvents
+}
+
+func intoABCISimulationResponse(txRes appmanager.TxResult, indexSet map[string]struct{}) ([]byte, error) {
+	indexAll := len(indexSet) == 0
+	abciEvents := make([]*abciv1.Event, len(txRes.Events))
+	for i, e := range txRes.Events {
+		abciEvents[i] = &abciv1.Event{
+			Type:       e.Type,
+			Attributes: make([]*abciv1.EventAttribute, len(e.Attributes)),
+		}
+
+		for j, attr := range e.Attributes {
+			_, index := indexSet[fmt.Sprintf("%s.%s", e.Type, attr.Key)]
+			abciEvents[i].Attributes[j] = &abciv1.EventAttribute{
+				Key:   attr.Key,
+				Value: attr.Value,
+				Index: index || indexAll,
+			}
+		}
+	}
+
+	msgResponses := make([]*anypb.Any, len(txRes.Resp))
+	for i, resp := range txRes.Resp {
+		// use this hack to maintain the protov2 API here for now
+		anyMsg, err := gogoany.NewAnyWithCacheWithValue(resp)
+		if err != nil {
+			return nil, err
+		}
+		msgResponses[i] = &anypb.Any{TypeUrl: anyMsg.TypeUrl, Value: anyMsg.Value}
+	}
+
+	res := &v1beta1.SimulationResponse{
+		GasInfo: &v1beta1.GasInfo{
+			GasWanted: txRes.GasWanted,
+			GasUsed:   txRes.GasUsed,
+		},
+		Result: &v1beta1.Result{
+			Data:         []byte{},
+			Log:          txRes.Error.Error(),
+			Events:       abciEvents,
+			MsgResponses: msgResponses,
+		},
+	}
+
+	return protojson.Marshal(res)
+}
+
+// ToSDKEvidence takes comet evidence and returns sdk evidence
+func ToSDKEvidence(ev []abci.Misbehavior) []*comet.Evidence {
+	evidence := make([]*comet.Evidence, len(ev))
+	for i, e := range ev {
+		evidence[i] = &comet.Evidence{
+			Type:             comet.MisbehaviorType(e.Type),
+			Height:           e.Height,
+			Time:             e.Time,
+			TotalVotingPower: e.TotalVotingPower,
+			Validator: comet.Validator{
+				Address: e.Validator.Address,
+				Power:   e.Validator.Power,
+			},
+		}
+	}
+	return evidence
+}
+
+// ToSDKDecidedCommitInfo takes comet commit info and returns sdk commit info
+func ToSDKCommitInfo(commit abci.CommitInfo) *comet.CommitInfo {
+	ci := comet.CommitInfo{
+		Round: commit.Round,
+	}
+
+	for _, v := range commit.Votes {
+		ci.Votes = append(ci.Votes, comet.VoteInfo{
+			Validator: comet.Validator{
+				Address: v.Validator.Address,
+				Power:   v.Validator.Power,
+			},
+			BlockIDFlag: comet.BlockIDFlag(v.BlockIdFlag),
+		})
+	}
+	return &ci
+}
+
+// ToSDKExtendedCommitInfo takes comet extended commit info and returns sdk commit info
+func ToSDKExtendedCommitInfo(commit abci.ExtendedCommitInfo) comet.CommitInfo {
+	ci := comet.CommitInfo{
+		Round: commit.Round,
+	}
+
+	for _, v := range commit.Votes {
+		ci.Votes = append(ci.Votes, comet.VoteInfo{
+			Validator: comet.Validator{
+				Address: v.Validator.Address,
+				Power:   v.Validator.Power,
+			},
+			BlockIDFlag: comet.BlockIDFlag(v.BlockIdFlag),
+		})
+	}
+
+	return ci
+}
+
+// QueryResult returns a ResponseQuery from an error. It will try to parse ABCI
+// info from the error.
+func QueryResult(err error, debug bool) *abci.QueryResponse {
+	space, code, log := errorsmod.ABCIInfo(err, debug)
+	return &abci.QueryResponse{
+		Codespace: space,
+		Code:      code,
+		Log:       log,
+	}
+}
+
+func (c *Consensus[T]) validateFinalizeBlockHeight(req *abci.FinalizeBlockRequest) error {
+	if req.Height < 1 {
+		return fmt.Errorf("invalid height: %d", req.Height)
+	}
+
+	lastBlockHeight, _, err := c.store.StateLatest()
+	if err != nil {
+		return err
+	}
+
+	// expectedHeight holds the expected height to validate
+	var expectedHeight uint64
+	if lastBlockHeight == 0 && c.cfg.InitialHeight > 1 {
+		// In this case, we're validating the first block of the chain, i.e no
+		// previous commit. The height we're expecting is the initial height.
+		expectedHeight = c.cfg.InitialHeight
+	} else {
+		// This case can mean two things:
+		//
+		// - Either there was already a previous commit in the store, in which
+		// case we increment the version from there.
+		// - Or there was no previous commit, in which case we start at version 1.
+		expectedHeight = lastBlockHeight + 1
+	}
+
+	if req.Height != int64(expectedHeight) {
+		return fmt.Errorf("invalid height: %d; expected: %d", req.Height, expectedHeight)
+	}
+
+	return nil
+}
+
+// GetConsensusParams makes a query to the consensus module in order to get the latest consensus
+// parameters from committed state
+func (c *Consensus[T]) GetConsensusParams(ctx context.Context) (*cmtproto.ConsensusParams, error) {
+	latestVersion, err := c.store.GetLatestVersion()
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := c.app.Query(ctx, latestVersion, &consensus.QueryParamsRequest{})
+	if err != nil {
+		return nil, err
+	}
+
+	if r, ok := res.(*consensus.QueryParamsResponse); !ok {
+		return nil, fmt.Errorf("failed to query consensus params")
+	} else {
+		// convert our params to cometbft params
+		evidenceMaxDuration := r.Params.Evidence.MaxAgeDuration
+		cs := &cmtproto.ConsensusParams{
+			Block: &cmtproto.BlockParams{
+				MaxBytes: r.Params.Block.MaxBytes,
+				MaxGas:   r.Params.Block.MaxGas,
+			},
+			Evidence: &cmtproto.EvidenceParams{
+				MaxAgeNumBlocks: r.Params.Evidence.MaxAgeNumBlocks,
+				MaxAgeDuration:  evidenceMaxDuration,
+			},
+			Validator: &cmtproto.ValidatorParams{
+				PubKeyTypes: r.Params.Validator.PubKeyTypes,
+			},
+			Version: &cmtproto.VersionParams{
+				App: r.Params.Version.App,
+			},
+		}
+		if r.Params.Abci != nil {
+			cs.Abci = &cmtproto.ABCIParams{ // nolint:staticcheck // deprecated type still supported for now
+				VoteExtensionsEnableHeight: r.Params.Abci.VoteExtensionsEnableHeight,
+			}
+		}
+		return cs, nil
+	}
+}
+
+func (c *Consensus[T]) GetBlockRetentionHeight(cp *cmtproto.ConsensusParams, commitHeight int64) int64 {
+	// pruning is disabled if minRetainBlocks is zero
+	if c.cfg.MinRetainBlocks == 0 {
+		return 0
+	}
+
+	minNonZero := func(x, y int64) int64 {
+		switch {
+		case x == 0:
+			return y
+
+		case y == 0:
+			return x
+
+		case x < y:
+			return x
+
+		default:
+			return y
+		}
+	}
+
+	// Define retentionHeight as the minimum value that satisfies all non-zero
+	// constraints. All blocks below (commitHeight-retentionHeight) are pruned
+	// from CometBFT.
+	var retentionHeight int64
+
+	// Define the number of blocks needed to protect against misbehaving validators
+	// which allows light clients to operate safely. Note, we piggy back of the
+	// evidence parameters instead of computing an estimated number of blocks based
+	// on the unbonding period and block commitment time as the two should be
+	// equivalent.
+	if cp.Evidence != nil && cp.Evidence.MaxAgeNumBlocks > 0 {
+		retentionHeight = commitHeight - cp.Evidence.MaxAgeNumBlocks
+	}
+
+	if c.snapshotManager != nil {
+		snapshotRetentionHeights := c.snapshotManager.GetSnapshotBlockRetentionHeights()
+		if snapshotRetentionHeights > 0 {
+			retentionHeight = minNonZero(retentionHeight, commitHeight-snapshotRetentionHeights)
+		}
+	}
+
+	v := commitHeight - int64(c.cfg.MinRetainBlocks)
+	retentionHeight = minNonZero(retentionHeight, v)
+
+	if retentionHeight <= 0 {
+		// prune nothing in the case of a non-positive height
+		return 0
+	}
+
+	return retentionHeight
+}
+
+// checkHalt checks if height or time exceeds halt-height or halt-time respectively.
+func (c *Consensus[T]) checkHalt(height int64, time time.Time) error {
+	var halt bool
+	switch {
+	case c.cfg.HaltHeight > 0 && uint64(height) > c.cfg.HaltHeight:
+		halt = true
+
+	case c.cfg.HaltTime > 0 && time.Unix() > int64(c.cfg.HaltTime):
+		halt = true
+	}
+
+	if halt {
+		return fmt.Errorf("halt per configuration height %d time %d", c.cfg.HaltHeight, c.cfg.HaltTime)
+	}
+
+	return nil
+}
+
+// uint64ToInt64 converts a uint64 to an int64, returning math.MaxInt64 if the uint64 is too large.
+func uint64ToInt64(u uint64) int64 {
+	if u > uint64(math.MaxInt64) {
+		return math.MaxInt64
+	}
+	return int64(u)
+}

tools/cosmovisor/go.mod

@@ -6,7 +6,9 @@ require (
 	cosmossdk.io/log v1.3.1
 	cosmossdk.io/x/upgrade v0.1.2
 	github.com/otiai10/copy v1.14.0
+	github.com/pelletier/go-toml/v2 v2.2.2
 	github.com/spf13/cobra v1.8.0
+	github.com/spf13/viper v1.18.2
 	github.com/stretchr/testify v1.9.0
 )
 
@@ -125,7 +127,6 @@ require (
 	github.com/mtibben/percent v0.2.1 // indirect
 	github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect
 	github.com/oklog/run v1.1.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/petermattis/goid v0.0.0-20240327183114-c42a807a84ba // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
@@ -144,7 +145,6 @@ require (
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/spf13/viper v1.18.2 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect
 	github.com/tendermint/go-amino v0.16.0 // indirect