287: messages := ctx.Value(types.CONTEXT_KEY_EXECUTE_REQUESTS).(*[]types.ExecuteRequest)
288: *messages = append(*messages, types.ExecuteRequest{
289: 	Caller: caller,
290: 	Msg:    sdkMsg,
291:
292: 	AllowFailure: executeCosmosArguments.Options.AllowFailure,
293: 	CallbackId:   executeCosmosArguments.Options.CallbackId,
294: })
347: // handle cosmos execute requests
348: requests := sdkCtx.Value(types.CONTEXT_KEY_EXECUTE_REQUESTS).(*[]types.ExecuteRequest)
349: if dispatchLogs, err := k.dispatchMessages(sdkCtx, *requests); err != nil {
350: 	return nil, nil, err
351: } else {
352: 	logs = append(logs, dispatchLogs...)
353: }
diff --git a/x/evm/contracts/counter/Counter.sol b/x/evm/contracts/counter/Counter.sol
index 2c5166e..d6a4930 100644
--- a/x/evm/contracts/counter/Counter.sol
+++ b/x/evm/contracts/counter/Counter.sol
@@ -81,10 +81,18 @@ contract Counter is IIBCAsyncCallback {
             return;
         }

-        COSMOS_CONTRACT.execute_cosmos(_recursive(n));

-        // to test branching
+        try this.nested(n) {
+            // do nothing
+        } catch {
+            // do nothing
+        }
+    }
+
+    function nested(uint64 n) external {
         COSMOS_CONTRACT.execute_cosmos(_recursive(n));
+
+        revert();
     }

     function _recursive(uint64 n) internal returns (string memory message) {
func Test_Recursive_Audit_ExecuteRequestsNotCleanedOnRevert(t *testing.T) {
	ctx, input := createDefaultTestInput(t)
	_, _, addr := keyPubAddr()

	counterBz, err := hexutil.Decode(counter.CounterBin)
	require.NoError(t, err)

	// deploy counter contract
	caller := common.BytesToAddress(addr.Bytes())
	retBz, contractAddr, _, err := input.EVMKeeper.EVMCreate(ctx, caller, counterBz, nil, nil)
	require.NoError(t, err)
	require.NotEmpty(t, retBz)
	require.Len(t, contractAddr, 20)

	// call recursive function
	parsed, err := counter.CounterMetaData.GetAbi()
	require.NoError(t, err)

	inputBz, err := parsed.Pack("recursive", uint64(1))
	require.NoError(t, err)

	_, logs, err := input.EVMKeeper.EVMCall(ctx, caller, contractAddr, inputBz, nil, nil)
	require.NoError(t, err)
	require.Len(t, logs, 2)

	// check logs
	log := logs[0]
	require.Equal(t, contractAddr.Hex(), log.Address)
	require.Equal(t, parsed.Events["recursive_called"].ID.Hex(), log.Topics[0])
	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000001", log.Data)

	log = logs[1]
	require.Equal(t, contractAddr.Hex(), log.Address)
	require.Equal(t, parsed.Events["recursive_called"].ID.Hex(), log.Topics[0])
	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000000", log.Data)
}
