remove change in context for tx and msg index

Author: thomas-nguy

CHANGELOG.md

@@ -60,7 +60,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
     * x/distribution can now utilize an externally managed community pool. NOTE: this will make the message handlers for FundCommunityPool and CommunityPoolSpend error, as well as the query handler for CommunityPool.
 * (client) [#18101](https://github.com/cosmos/cosmos-sdk/pull/18101) Add a `keyring-default-keyname` in `client.toml` for specifying a default key name, and skip the need to use the `--from` flag when signing transactions.
 * (x/gov) [#24355](https://github.com/cosmos/cosmos-sdk/pull/24355) Allow users to set a custom CalculateVoteResultsAndVotingPower function to be used in govkeeper.Tally.
-* (baseapp) [#24458](https://github.com/cosmos/cosmos-sdk/pull/24458) Add `TxExecutor` baseapp option, add `TxIndex`/`TxCount`/`MsgIndex`/`BlockGasUsed` fields to `Context, to support parallel execution, introduce incarnation cache for performance optimisation
+* (baseapp) [#24458](https://github.com/cosmos/cosmos-sdk/pull/24458) Add `TxExecutor` to support parallel execution and introduce incarnation cache for performance optimisation
 
 ### Improvements
 

baseapp/abci.go

@@ -791,11 +791,7 @@ func (app *BaseApp) internalFinalizeBlock(ctx context.Context, req *abci.Request
 
 	// Reset the gas meter so that the AnteHandlers aren't required to
 	gasMeter = app.getBlockGasMeter(app.finalizeBlockState.Context())
-	app.finalizeBlockState.SetContext(
-		app.finalizeBlockState.Context().
-			WithBlockGasMeter(gasMeter).
-			WithTxCount(len(req.Txs)),
-	)
+	app.finalizeBlockState.SetContext(app.finalizeBlockState.Context().WithBlockGasMeter(gasMeter))
 
 	// Iterate over all raw transactions in the proposal and attempt to execute
 	// them, gathering the execution results.
@@ -839,17 +835,17 @@ func (app *BaseApp) internalFinalizeBlock(ctx context.Context, req *abci.Request
 func (app *BaseApp) executeTxsWithExecutor(ctx context.Context, txs [][]byte) ([]*abci.ExecTxResult, error) {
 	if app.txExecutor != nil {
 		return app.txExecutor(ctx, txs, app.finalizeBlockState.ms, func(i int, memTx sdk.Tx, ms storetypes.MultiStore, incarnationCache map[string]any) *abci.ExecTxResult {
-			return app.deliverTxWithMultiStore(txs[i], i, ms, incarnationCache)
+			return app.deliverTxWithMultiStore(txs[i], ms, incarnationCache)
 		})
 	}
 
 	// Fallback to the default execution logic
 	txResults := make([]*abci.ExecTxResult, 0, len(txs))
-	for i, rawTx := range txs {
+	for _, rawTx := range txs {
 		var response *abci.ExecTxResult
 
 		if _, err := app.txDecoder(rawTx); err == nil {
-			response = app.deliverTx(rawTx, i)
+			response = app.deliverTx(rawTx)
 		} else {
 			// In the case where a transaction included in a block proposal is malformed,
 			// we still want to return a default response to comet. This is because comet

baseapp/baseapp.go

@@ -677,7 +677,7 @@ func (app *BaseApp) getBlockGasMeter(ctx sdk.Context) storetypes.GasMeter {
 }
 
 // retrieve the context for the tx w/ txBytes and other memoized values.
-func (app *BaseApp) getContextForTx(mode execMode, txBytes []byte, txIndex int) sdk.Context {
+func (app *BaseApp) getContextForTx(mode execMode, txBytes []byte) sdk.Context {
 	app.mu.Lock()
 	defer app.mu.Unlock()
 
@@ -687,8 +687,7 @@ func (app *BaseApp) getContextForTx(mode execMode, txBytes []byte, txIndex int)
 	}
 	ctx := modeState.Context().
 		WithTxBytes(txBytes).
-		WithGasMeter(storetypes.NewInfiniteGasMeter()).
-		WithTxIndex(txIndex)
+		WithGasMeter(storetypes.NewInfiniteGasMeter())
 	// WithVoteInfos(app.voteInfos) // TODO: identify if this is needed
 
 	ctx = ctx.WithIsSigverifyTx(app.sigverifyTx)
@@ -773,11 +772,11 @@ func (app *BaseApp) beginBlock(_ *abci.RequestFinalizeBlock) (sdk.BeginBlock, er
 	return resp, nil
 }
 
-func (app *BaseApp) deliverTx(tx []byte, txIndex int) *abci.ExecTxResult {
-	return app.deliverTxWithMultiStore(tx, txIndex, nil, nil)
+func (app *BaseApp) deliverTx(tx []byte) *abci.ExecTxResult {
+	return app.deliverTxWithMultiStore(tx, nil, nil)
 }
 
-func (app *BaseApp) deliverTxWithMultiStore(tx []byte, txIndex int, txMultiStore storetypes.MultiStore, incarnationCache map[string]any) *abci.ExecTxResult {
+func (app *BaseApp) deliverTxWithMultiStore(tx []byte, txMultiStore storetypes.MultiStore, incarnationCache map[string]any) *abci.ExecTxResult {
 	gInfo := sdk.GasInfo{}
 	resultStr := "successful"
 
@@ -790,7 +789,7 @@ func (app *BaseApp) deliverTxWithMultiStore(tx []byte, txIndex int, txMultiStore
 		telemetry.SetGauge(float32(gInfo.GasWanted), "tx", "gas", "wanted")
 	}()
 
-	gInfo, result, anteEvents, err := app.runTxWithMultiStore(execModeFinalize, tx, nil, txIndex, txMultiStore, incarnationCache)
+	gInfo, result, anteEvents, err := app.runTxWithMultiStore(execModeFinalize, tx, nil, txMultiStore, incarnationCache)
 	if err != nil {
 		resultStr = "failed"
 		resp = sdkerrors.ResponseExecTxResultWithEvents(
@@ -850,17 +849,19 @@ func (app *BaseApp) endBlock(_ context.Context) (sdk.EndBlock, error) {
 // both txbytes and the decoded tx are passed to runTx to avoid the state machine encoding the tx and decoding the transaction twice
 // passing the decoded tx to runTX is optional, it will be decoded if the tx is nil
 func (app *BaseApp) runTx(mode execMode, txBytes []byte, tx sdk.Tx) (gInfo sdk.GasInfo, result *sdk.Result, anteEvents []abci.Event, err error) {
-	return app.runTxWithMultiStore(mode, txBytes, tx, -1, nil, nil)
+	return app.runTxWithMultiStore(mode, txBytes, tx, nil, nil)
 }
 
-func (app *BaseApp) runTxWithMultiStore(mode execMode, txBytes []byte, tx sdk.Tx, txIndex int, txMultiStore storetypes.MultiStore, incarnationCache map[string]any) (gInfo sdk.GasInfo, result *sdk.Result, anteEvents []abci.Event, err error) {
+func (app *BaseApp) runTxWithMultiStore(mode execMode, txBytes []byte, tx sdk.Tx, txMultiStore storetypes.MultiStore, incarnationCache map[string]any) (gInfo sdk.GasInfo, result *sdk.Result, anteEvents []abci.Event, err error) {
 	// NOTE: GasWanted should be returned by the AnteHandler. GasUsed is
 	// determined by the GasMeter. We need access to the context to get the gas
 	// meter, so we initialize upfront.
 	var gasWanted uint64
 
-	ctx := app.getContextForTx(mode, txBytes, txIndex)
-	ctx = ctx.WithIncarnationCache(incarnationCache)
+	ctx := app.getContextForTx(mode, txBytes)
+	if incarnationCache != nil {
+		ctx = ctx.WithIncarnationCache(incarnationCache)
+	}
 	if txMultiStore != nil {
 		ctx = ctx.WithMultiStore(txMultiStore)
 	}
@@ -1056,8 +1057,6 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, msgsV2 []protov2.Me
 			break
 		}
 
-		ctx = ctx.WithMsgIndex(i)
-
 		handler := app.msgServiceRouter.Handler(msg)
 		if handler == nil {
 			return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "no message handler found for %T", msg)

baseapp/genesis.go

@@ -13,7 +13,7 @@ var _ genesis.TxHandler = (*BaseApp)(nil)
 // ExecuteGenesisTx implements genesis.GenesisState from
 // cosmossdk.io/core/genesis to set initial state in genesis
 func (ba *BaseApp) ExecuteGenesisTx(tx []byte) error {
-	res := ba.deliverTx(tx, -1)
+	res := ba.deliverTx(tx)
 
 	if res.Code != types.CodeTypeOK {
 		return errors.New(res.Log)

baseapp/test_helpers.go

@@ -77,9 +77,9 @@ func (app *BaseApp) NewUncachedContext(isCheckTx bool, header cmtproto.Header) s
 }
 
 func (app *BaseApp) GetContextForFinalizeBlock(txBytes []byte) sdk.Context {
-	return app.getContextForTx(execModeFinalize, txBytes, -1)
+	return app.getContextForTx(execModeFinalize, txBytes)
 }
 
 func (app *BaseApp) GetContextForCheckTx(txBytes []byte) sdk.Context {
-	return app.getContextForTx(execModeCheck, txBytes, -1)
+	return app.getContextForTx(execModeCheck, txBytes)
 }

baseapp/txexecutor.go

@@ -10,6 +10,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// TxExecutor function type for implementing custom execution logic, such as block-stm
 type TxExecutor func(
 	ctx context.Context,
 	block [][]byte,

types/context.go

@@ -66,10 +66,6 @@ type Context struct {
 	headerInfo           header.Info
 
 	// For block-stm
-	txIndex          int            // the index of the current tx in the block, -1 means not in finalize block context
-	msgIndex         int            // the index of the current msg in the tx, -1 means not in finalize block context
-	txCount          int            // the total number of transactions in current block
-	blockGasUsed     uint64         // sum the gas used by all the transactions in the current block, only accessible by end blocker
 	incarnationCache map[string]any // incarnationCache is shared between multiple incarnations of the same transaction, it must only cache stateless computation results that only depends on tx body and block level information that don't change during block execution, like the result of tx signature verification.
 }
 
@@ -99,10 +95,6 @@ func (c Context) TransientKVGasConfig() storetypes.GasConfig    { return c.trans
 func (c Context) StreamingManager() storetypes.StreamingManager { return c.streamingManager }
 func (c Context) CometInfo() comet.BlockInfo                    { return c.cometInfo }
 func (c Context) HeaderInfo() header.Info                       { return c.headerInfo }
-func (c Context) TxIndex() int                                  { return c.txIndex }
-func (c Context) MsgIndex() int                                 { return c.msgIndex }
-func (c Context) TxCount() int                                  { return c.txCount }
-func (c Context) BlockGasUsed() uint64                          { return c.blockGasUsed }
 func (c Context) IncarnationCache() map[string]any              { return c.incarnationCache }
 
 // BlockHeader returns the header by value.
@@ -150,8 +142,6 @@ func NewContext(ms storetypes.MultiStore, header cmtproto.Header, isCheckTx bool
 		eventManager:         NewEventManager(),
 		kvGasConfig:          storetypes.KVGasConfig(),
 		transientKVGasConfig: storetypes.TransientGasConfig(),
-		txIndex:              -1,
-		msgIndex:             -1,
 	}
 }
 
@@ -331,26 +321,6 @@ func (c Context) WithHeaderInfo(headerInfo header.Info) Context {
 	return c
 }
 
-func (c Context) WithTxIndex(txIndex int) Context {
-	c.txIndex = txIndex
-	return c
-}
-
-func (c Context) WithTxCount(txCount int) Context {
-	c.txCount = txCount
-	return c
-}
-
-func (c Context) WithMsgIndex(msgIndex int) Context {
-	c.msgIndex = msgIndex
-	return c
-}
-
-func (c Context) WithBlockGasUsed(gasUsed uint64) Context {
-	c.blockGasUsed = gasUsed
-	return c
-}
-
 // TODO: remove???
 func (c Context) IsZero() bool {
 	return c.ms == nil

x/auth/ante/sigverify.go

@@ -32,7 +32,7 @@ var (
 	simSecp256k1Pubkey = &secp256k1.PubKey{Key: key}
 	simSecp256k1Sig    [64]byte
 
-	// SigVerificationResultCacheKey key for incarnation cache
+	// SigVerificationResultCacheKey default key for incarnation cache
 	SigVerificationResultCacheKey = "ante:SigVerificationResult"
 )
 
@@ -261,6 +261,7 @@ func (svd SigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simul
 		}
 	} else {
 		err = svd.verify(ctx, tx, simulate)
+		// if enabled, use incarnation cache to store the result to improve performance for block-stm
 		ctx.SetIncarnationCache(SigVerificationResultCacheKey, err)
 	}
 	if err != nil {