Merge pull request #694 from axone-protocol/fix/out-of-gas-catch

Improve `ErrorOutOfGas` handling in predicate execution

Author: bdeneux

x/logic/keeper/grpc_query_ask_test.go

@@ -17,8 +17,10 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/testutil"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	bankypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 
 	"github.com/axone-protocol/axoned/v8/x/logic"
@@ -137,16 +139,18 @@ func TestGRPCAsk(t *testing.T) {
 				maxGas:        1000,
 				expectedError: "out of gas: logic <ReadPerByte> (1018/1000): limit exceeded",
 			},
+			{
+				query:         "bank_balances(X, Y).",
+				maxGas:        3000,
+				expectedError: "out of gas: logic <panic: {ValuePerByte}> (4204/3000): limit exceeded",
+			},
 			{
 				query:  "block_height(X).",
 				maxGas: 3000,
 				predicateCosts: map[string]uint64{
 					"block_height/1": 10000,
 				},
-				expectedAnswer: &types.Answer{
-					Variables: []string{"X"},
-					Results:   []types.Result{{Error: "error(resource_error(gas(block_height/1,12353,3000)),block_height/1)"}},
-				},
+				expectedError: "out of gas: logic <block_height/1> (12353/3000): limit exceeded",
 			},
 			{
 				program: "father(bob, 'élodie').",
@@ -325,6 +329,11 @@ foo(a4).
 					bankKeeper := logictestutil.NewMockBankKeeper(ctrl)
 					fsProvider := logictestutil.NewMockFS(ctrl)
 
+					bankKeeper.EXPECT().GetAccountsBalances(gomock.Any()).Do(func(ctx gocontext.Context) []bankypes.Balance {
+						sdk.UnwrapSDKContext(ctx).GasMeter().ConsumeGas(2000, "ValuePerByte")
+						return nil
+					}).AnyTimes()
+
 					logicKeeper := keeper.NewKeeper(
 						encCfg.Codec,
 						key,

x/logic/keeper/interpreter.go

@@ -66,7 +66,7 @@ func (k Keeper) execute(
 
 	answer, err := k.queryInterpreter(ctx, i, query, sdkmath.MinUint(solutionsLimit, *limits.MaxResultCount))
 	if err != nil {
-		return nil, errorsmod.Wrapf(types.InvalidArgument, "error executing query: %v", err.Error())
+		return nil, err
 	}
 
 	return &types.QueryServiceAskResponse{
@@ -107,17 +107,17 @@ func (k Keeper) newInterpreter(ctx context.Context) (*prolog.Interpreter, fmt.St
 
 			defer func() {
 				if r := recover(); r != nil {
-					if gasError, ok := r.(storetypes.ErrorOutOfGas); ok {
-						err = engine.ResourceError(prolog2.ResourceGas(gasError.Descriptor, gasMeter.GasConsumed(), gasMeter.Limit()), env)
-						return
+					switch rType := r.(type) {
+					case storetypes.ErrorOutOfGas:
+						err = errorsmod.Wrapf(
+							types.LimitExceeded, "out of gas: %s <%s> (%d/%d)",
+							types.ModuleName, rType.Descriptor, sdkctx.GasMeter().GasConsumed(), sdkctx.GasMeter().Limit())
+					default:
+						panic(r)
 					}
-
-					panic(r)
 				}
 			}()
-
 			gasMeter.ConsumeGas(cost, predicate)
-
 			return err
 		}
 	}

x/logic/prolog/error.go

@@ -2,8 +2,6 @@ package prolog
 
 import (
 	"github.com/ichiban/prolog/engine"
-
-	"cosmossdk.io/store/types"
 )
 
 var (
@@ -82,8 +80,6 @@ var (
 	// The module resource is the representation of the module with which the interaction is made.
 	// The module resource is denoted as a compound with the name of the module.
 	AtomResourceModule = engine.NewAtom("resource_module")
-	// AtomResourceGas is the atom denoting the "gas" resource.
-	AtomResourceGas = engine.NewAtom("gas")
 )
 
 // ResourceContext returns a term representing the context resource.
@@ -96,12 +92,6 @@ func ResourceModule(module string) engine.Term {
 	return AtomResourceModule.Apply(engine.NewAtom(module))
 }
 
-// ResourceGas returns a term representing the gas resource with the given descriptor, consumed and limit at the
-// given context.
-func ResourceGas(descriptor string, consumed types.Gas, limit types.Gas) engine.Term {
-	return AtomResourceGas.Apply(engine.NewAtom(descriptor), engine.Integer(int64(consumed)), engine.Integer(int64(limit)))
-}
-
 var (
 	AtomOperationInput   = engine.NewAtom("input")
 	AtomOperationExecute = engine.NewAtom("execute")

x/logic/util/prolog.go

@@ -2,14 +2,18 @@ package util
 
 import (
 	"context"
+	"errors"
 	"strings"
 
 	"github.com/ichiban/prolog"
 	"github.com/ichiban/prolog/engine"
 	"github.com/samber/lo"
 
+	errorsmod "cosmossdk.io/errors"
 	sdkmath "cosmossdk.io/math"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	"github.com/axone-protocol/axoned/v8/x/logic/types"
 )
 
@@ -24,7 +28,7 @@ func QueryInterpreter(
 	p := engine.NewParser(&i.VM, strings.NewReader(query))
 	t, err := p.Term()
 	if err != nil {
-		return nil, err
+		return nil, errorsmod.Wrapf(types.InvalidArgument, "error executing query: %v", err.Error())
 	}
 
 	var env *engine.Env
@@ -42,13 +46,24 @@ func QueryInterpreter(
 
 	results, err := envsToResults(envs, p.Vars, i)
 	if err != nil {
-		return nil, err
+		return nil, errorsmod.Wrapf(types.InvalidArgument, "error executing query: %v", err.Error())
 	}
 
 	if callErr != nil {
 		if sdkmath.NewUint(uint64(len(results))).LT(solutionsLimit) {
 			// error is not part of the look-ahead and should be included in the solutions
-			results = append(results, types.Result{Error: callErr.Error()})
+			sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+			switch {
+			case errors.Is(callErr, types.LimitExceeded):
+				return nil, callErr
+			case sdkCtx.GasMeter().IsOutOfGas():
+				return nil, errorsmod.Wrapf(
+					types.LimitExceeded, "out of gas: %s <%s> (%d/%d)",
+					types.ModuleName, callErr.Error(), sdkCtx.GasMeter().GasConsumed(), sdkCtx.GasMeter().Limit())
+			default:
+				results = append(results, types.Result{Error: callErr.Error()})
+			}
 		} else {
 			// error is part of the look-ahead, so let's consider that there's one more solution
 			count = count.Incr()