handle error cases

app/ante.go

@@ -124,7 +124,6 @@ func NewAnteHandlerAndDepGenerator(options HandlerOptions) (sdk.AnteHandler, sdk
 		sdk.DefaultWrappedAnteDecorator(evmante.NewGasLimitDecorator(options.EVMKeeper)),
 	}
 	evmAnteHandler, evmAnteDepGenerator := sdk.ChainAnteDecorators(evmAnteDecorators...)
-	evmAnteHandler = evmante.NewAnteErrorHandler(evmAnteHandler, options.EVMKeeper).Handle
 
 	router := evmante.NewEVMRouterDecorator(anteHandler, evmAnteHandler, anteDepGenerator, evmAnteDepGenerator)
 

app/ante_test.go

@@ -259,7 +259,9 @@ func TestEvmAnteErrorHandler(t *testing.T) {
 	require.NotEqual(t, 0, res.Code)
 	testkeeper.EVMTestApp.EvmKeeper.SetTxResults([]*abci.ExecTxResult{{
 		Code: res.Code,
+		Log:  "nonce too high",
 	}})
+	testkeeper.EVMTestApp.EvmKeeper.SetMsgs([]*evmtypes.MsgEVMTransaction{req})
 	deferredInfo := testkeeper.EVMTestApp.EvmKeeper.GetEVMTxDeferredInfo(ctx)
 	require.Equal(t, 1, len(deferredInfo))
 	require.Contains(t, deferredInfo[0].Error, "nonce too high")

app/app.go

@@ -1529,6 +1529,7 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 	beginBlockResp := app.BeginBlock(ctx, beginBlockReq)
 	events = append(events, beginBlockResp.Events...)
 
+	evmTxs := make([]*evmtypes.MsgEVMTransaction, len(txs)) // nil for non-EVM txs
 	txResults := make([]*abci.ExecTxResult, len(txs))
 	typedTxs := app.DecodeTransactionsConcurrently(ctx, txs)
 
@@ -1538,6 +1539,11 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 	prioritizedResults, ctx := app.ExecuteTxsConcurrently(ctx, prioritizedTxs, prioritizedTypedTxs, prioritizedIndices)
 	for relativePrioritizedIndex, originalIndex := range prioritizedIndices {
 		txResults[originalIndex] = prioritizedResults[relativePrioritizedIndex]
+		if emsg := evmtypes.GetEVMTransactionMessage(prioritizedTypedTxs[relativePrioritizedIndex]); emsg != nil {
+			evmTxs[originalIndex] = emsg
+		} else {
+			evmTxs[originalIndex] = nil
+		}
 	}
 
 	// Finalize all Bank Module Transfers here so that events are included for prioritiezd txs
@@ -1550,8 +1556,14 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 	otherResults, ctx := app.ExecuteTxsConcurrently(ctx, otherTxs, otherTypedTxs, otherIndices)
 	for relativeOtherIndex, originalIndex := range otherIndices {
 		txResults[originalIndex] = otherResults[relativeOtherIndex]
+		if emsg := evmtypes.GetEVMTransactionMessage(otherTypedTxs[relativeOtherIndex]); emsg != nil {
+			evmTxs[originalIndex] = emsg
+		} else {
+			evmTxs[originalIndex] = nil
+		}
 	}
 	app.EvmKeeper.SetTxResults(txResults)
+	app.EvmKeeper.SetMsgs(evmTxs)
 
 	// Finalize all Bank Module Transfers here so that events are included
 	lazyWriteEvents := app.BankKeeper.WriteDeferredBalances(ctx)

x/evm/keeper/deferred.go

@@ -13,23 +13,34 @@ import (
 
 func (k *Keeper) GetEVMTxDeferredInfo(ctx sdk.Context) (res []*types.DeferredInfo) {
 	store := prefix.NewStore(ctx.TransientStore(k.tStoreKey), types.DeferredInfoPrefix)
-	iter := store.Iterator(nil, nil)
-	defer iter.Close()
-	for ; iter.Valid(); iter.Next() {
-		key := binary.BigEndian.Uint64(iter.Key())
-		if key >= uint64(len(k.txResults)) {
-			ctx.Logger().Error(fmt.Sprintf("getting invalid tx index in EVM deferred info: %d, num of txs: %d", key, len(k.txResults)))
+	for txIdx, msg := range k.msgs {
+		if msg == nil {
 			continue
 		}
-		val := &types.DeferredInfo{}
-		if err := val.Unmarshal(iter.Value()); err != nil {
-			// unable to unmarshal deferred info is serious, because it could cause
-			// balance surplus to be mishandled and thus affect total supply
-			panic(err)
-		}
-		// cast is safe here because of the check above
-		if k.txResults[int(key)].Code == 0 || val.Error != "" {
-			res = append(res, val)
+		txRes := k.txResults[txIdx]
+		key := make([]byte, 8)
+		binary.BigEndian.PutUint64(key, uint64(txIdx))
+		val := store.Get(key)
+		if val == nil {
+			// this means the transaction got reverted during execution, either in ante handler
+			// or due to a panic in msg server
+			etx, _ := msg.AsTransaction()
+			if txRes.Code == 0 {
+				ctx.Logger().Error(fmt.Sprintf("transaction %s has code 0 but no deferred info", etx.Hash().Hex()))
+			}
+			res = append(res, &types.DeferredInfo{
+				TxIndex: uint32(txIdx),
+				TxHash:  etx.Hash().Bytes(),
+				Error:   txRes.Log,
+			})
+		} else {
+			info := &types.DeferredInfo{}
+			if err := info.Unmarshal(val); err != nil {
+				// unable to unmarshal deferred info is serious, because it could cause
+				// balance surplus to be mishandled and thus affect total supply
+				panic(err)
+			}
+			res = append(res, info)
 		}
 	}
 	return
@@ -52,20 +63,3 @@ func (k *Keeper) AppendToEvmTxDeferredInfo(ctx sdk.Context, bloom ethtypes.Bloom
 	}
 	prefix.NewStore(ctx.TransientStore(k.tStoreKey), types.DeferredInfoPrefix).Set(key, bz)
 }
-
-func (k *Keeper) AppendErrorToEvmTxDeferredInfo(ctx sdk.Context, txHash common.Hash, err string) {
-	key := make([]byte, 8)
-	binary.BigEndian.PutUint64(key, uint64(ctx.TxIndex()))
-	val := &types.DeferredInfo{
-		TxIndex: uint32(ctx.TxIndex()),
-		TxHash:  txHash[:],
-		Error:   err,
-	}
-	bz, e := val.Marshal()
-	if e != nil {
-		// unable to marshal deferred info is serious, because it could cause
-		// balance surplus to be mishandled and thus affect total supply
-		panic(e)
-	}
-	prefix.NewStore(ctx.TransientStore(k.tStoreKey), types.DeferredInfoPrefix).Set(key, bz)
-}

x/evm/keeper/keeper.go

@@ -45,6 +45,7 @@ type Keeper struct {
 	Paramstore paramtypes.Subspace
 
 	txResults []*abci.ExecTxResult
+	msgs      []*types.MsgEVMTransaction
 
 	bankKeeper     bankkeeper.Keeper
 	accountKeeper  *authkeeper.AccountKeeper
@@ -348,6 +349,10 @@ func (k *Keeper) SetTxResults(txResults []*abci.ExecTxResult) {
 	k.txResults = txResults
 }
 
+func (k *Keeper) SetMsgs(msgs []*types.MsgEVMTransaction) {
+	k.msgs = msgs
+}
+
 // Test use only
 func (k *Keeper) GetPendingTxs() map[string][]*PendingTx {
 	return k.pendingTxs