fix: fix blockchain stop to produce blocks

baseapp/baseapp.go

@@ -703,6 +703,7 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte) (gInfo sdk.GasInfo, re
 		// performance benefits, but it'll be more difficult to get right.
 		anteCtx, msCache = app.cacheTxContext(ctx, txBytes)
 		anteCtx = anteCtx.WithEventManager(sdk.NewEventManager())
+		fmt.Println("AAAAAAAAAA current block time: ", anteCtx.BlockTime().UnixMilli(), " height:", anteCtx.BlockHeight(), " mode: ", mode)
 		newCtx, err := app.anteHandler(anteCtx, tx, mode == runTxModeSimulate)
 
 		if !newCtx.IsZero() {
@@ -882,10 +883,13 @@ func createEvents(events sdk.Events, msg sdk.Msg) sdk.Events {
 // PrepareProposal state internally will be discarded. <nil, err> will be
 // returned if the transaction cannot be encoded. <bz, nil> will be returned if
 // the transaction is valid, otherwise <bz, err> will be returned.
-func (app *BaseApp) PrepareProposalVerifyTx(tx sdk.Tx) ([]byte, error) {
-	bz, err := app.txEncoder(tx)
-	if err != nil {
-		return nil, err
+func (app *BaseApp) PrepareProposalVerifyTx(tx sdk.Tx, bz []byte) ([]byte, error) {
+	var err error
+	if bz == nil {
+		bz, err = app.txEncoder(tx)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	_, _, _, _, err = app.runTx(runTxPrepareProposal, bz) //nolint:dogsled
@@ -920,7 +924,7 @@ type (
 	// that any custom ABCI PrepareProposal and ProcessProposal handler can use
 	// to verify a transaction.
 	ProposalTxVerifier interface {
-		PrepareProposalVerifyTx(tx sdk.Tx) ([]byte, error)
+		PrepareProposalVerifyTx(tx sdk.Tx, txBz []byte) ([]byte, error)
 		ProcessProposalVerifyTx(txBz []byte) (sdk.Tx, error)
 	}
 
@@ -961,17 +965,33 @@ func NewDefaultProposalHandler(mp mempool.Mempool, txVerifier ProposalTxVerifier
 // FIFO order.
 func (h DefaultProposalHandler) PrepareProposalHandler() sdk.PrepareProposalHandler {
 	return func(ctx sdk.Context, req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
+		var (
+			selectedTxs  [][]byte
+			totalTxBytes int64
+		)
+
 		// If the mempool is nil or a no-op mempool, we simply return the transactions
 		// requested from CometBFT, which, by default, should be in FIFO order.
 		_, isNoOp := h.mempool.(mempool.NoOpMempool)
 		if h.mempool == nil || isNoOp {
-			return abci.ResponsePrepareProposal{Txs: req.Txs}
-		}
+			for _, txBz := range req.Txs {
+				bz, err := h.txVerifier.PrepareProposalVerifyTx(nil, txBz)
+				if err != nil {
+					continue
+				} else {
+					txSize := int64(len(bz))
+					if totalTxBytes += txSize; totalTxBytes <= req.MaxTxBytes {
+						selectedTxs = append(selectedTxs, bz)
+					} else {
+						// We've reached capacity per req.MaxTxBytes so we cannot select any
+						// more transactions.
+						break
+					}
+				}
 
-		var (
-			selectedTxs  [][]byte
-			totalTxBytes int64
-		)
+			}
+			return abci.ResponsePrepareProposal{Txs: selectedTxs}
+		}
 
 		iterator := h.mempool.Select(ctx, req.Txs)
 
@@ -982,7 +1002,7 @@ func (h DefaultProposalHandler) PrepareProposalHandler() sdk.PrepareProposalHand
 			// 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.
-			bz, err := h.txVerifier.PrepareProposalVerifyTx(memTx)
+			bz, err := h.txVerifier.PrepareProposalVerifyTx(memTx, nil)
 			if err != nil {
 				err := h.mempool.Remove(memTx)
 				if err != nil && !errors.Is(err, mempool.ErrTxNotFound) {