feat(keeper): handle JSON arguments in MsgCall

gno.land/pkg/sdk/vm/convert_json.go

@@ -0,0 +1,38 @@
+package vm
+
+import (
+	"encoding/json"
+	"reflect"
+
+	"github.com/gnolang/gno/gnovm/pkg/gnolang"
+	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
+	"github.com/gnolang/gno/tm2/pkg/amino"
+)
+
+func UnmarshalJSON(alloc *gno.Allocator, store gno.Store, b []byte, t gno.Type) (tv gno.TypedValue, err error) {
+	tv.T = t
+	gvalue := gnolang.Gno2GoValue(&tv, reflect.Value{})
+	v := reflect.New(gvalue.Type())
+	if err := amino.UnmarshalJSON(b, v.Interface()); err != nil {
+		return tv, err
+	}
+
+	return gnolang.Go2GnoValue(alloc, store, v.Elem()), nil
+}
+
+func UnmarshalNativeValueJSON(alloc *gno.Allocator, b []byte, t gno.Type) (tv gno.TypedValue, err error) {
+	tv.T = t
+	gvalue := gnolang.Gno2GoValue(&tv, reflect.Value{})
+	v := reflect.New(gvalue.Type())
+	if err = amino.UnmarshalJSON(b, v.Interface()); err != nil {
+		return tv, err
+	}
+
+	return gnolang.Go2GnoNativeValue(alloc, v.Elem()), nil
+}
+
+func MarshalJSON(tv *gno.TypedValue) ([]byte, error) {
+	rv := gnolang.Gno2GoValue(tv, reflect.Value{})
+	// XXX: use amino
+	return json.Marshal(rv.Interface())
+}

gno.land/pkg/sdk/vm/keeper.go

@@ -208,6 +208,7 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 	pkgPath := msg.PkgPath // to import
 	fnc := msg.Func
 	store := vm.getGnoStore(ctx)
+
 	// Get the package and function type.
 	pv := store.GetPackage(pkgPath, false)
 	pl := gno.PackageNodeLocation(pkgPath)
@@ -217,16 +218,44 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 	mpn := gno.NewPackageNode("main", "main", nil)
 	mpn.Define("pkg", gno.TypedValue{T: &gno.PackageType{}, V: pv})
 	mpv := mpn.NewPackage()
-	// Parse expression.
+
+	if len(msg.Args) != len(ft.Params) {
+		return "", fmt.Errorf("wrong number of arguments in call to %s: want %d got %d", fnc, len(ft.Params), len(msg.Args))
+	}
+
+	request := make([]gno.TypedValue, len(ft.Params))
+	for i, arg := range msg.Args {
+		pt := ft.Params[i].Type
+		arg = strings.TrimSpace(arg)
+		if len(arg) > 2 &&
+			((arg[0] == '{' && arg[len(arg)-1] == '}') ||
+				(arg[0] == '[' && arg[len(arg)-1] == ']')) {
+			// Handle JSON argument
+			request[i], err = UnmarshalJSON(store.GetAllocator(), store, []byte(arg), pt)
+			if err != nil {
+				return "", fmt.Errorf("unable to unmarshal arg#%d: %w", err)
+			}
+
+			continue
+		}
+
+		request[i] = convertArgToGno(arg, pt)
+
+	}
+
+	// Create expresion
 	argslist := ""
-	for i := range msg.Args {
+	for i := range ft.Params {
 		if i > 0 {
 			argslist += ","
 		}
 		argslist += fmt.Sprintf("arg%d", i)
 	}
+
 	expr := fmt.Sprintf(`pkg.%s(%s)`, fnc, argslist)
+	fmt.Printf("expr%v\r\n", expr)
 	xn := gno.MustParseExpr(expr)
+
 	// Send send-coins to pkg from caller.
 	pkgAddr := gno.DerivePkgAddr(pkgPath)
 	caller := msg.Caller
@@ -235,21 +264,19 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 	if err != nil {
 		return "", err
 	}
+
 	// Convert Args to gno values.
 	cx := xn.(*gno.CallExpr)
 	if cx.Varg {
 		panic("variadic calls not yet supported")
 	}
-	if len(msg.Args) != len(ft.Params) {
-		panic(fmt.Sprintf("wrong number of arguments in call to %s: want %d got %d", fnc, len(ft.Params), len(msg.Args)))
-	}
-	for i, arg := range msg.Args {
-		argType := ft.Params[i].Type
-		atv := convertArgToGno(arg, argType)
+
+	for i, arg := range request {
 		cx.Args[i] = &gno.ConstExpr{
-			TypedValue: atv,
+			TypedValue: arg,
 		}
 	}
+
 	// Make context.
 	// NOTE: if this is too expensive,
 	// could it be safely partially memoized?
@@ -283,15 +310,64 @@ func (vm *VMKeeper) Call(ctx sdk.Context, msg MsgCall) (res string, err error) {
 		}
 		m.Release()
 	}()
+
 	rtvs := m.Eval(xn)
-	ctx.Logger().Info("CPUCYCLES call", "num-cycles", m.Cycles)
-	for i, rtv := range rtvs {
-		res = res + rtv.String()
-		if i < len(rtvs)-1 {
-			res += "\n"
+
+	// Result
+
+	// Iterate through params
+	var response gno.TypedValue
+	{
+		var sv gno.StructValue
+		var st gno.StructType
+
+		// Generate result Typed Valye
+		result := gno.TypedValue{
+			V: &gno.ArrayValue{
+				List: rtvs,
+			},
+			T: &gno.ArrayType{
+				Elt: &gno.InterfaceType{},
+				Len: len(rtvs),
+			},
+		}
+
+		// Define response fields
+		responseFS := []gno.FieldType{
+			gno.FieldType{
+				Name: gno.Name("Result"),
+				Type: result.T,
+			},
+			gno.FieldType{
+				Name: gno.Name("CPUCycles"),
+				Type: gno.Int64Type,
+			},
 		}
+		responseTV := make([]gno.TypedValue, 0, len(responseFS))
+
+		// Add result value
+		responseTV = append(responseTV, result)
+
+		// Add cpucycle to responses
+		cycle := gno.TypedValue{T: gno.Int64Type}
+		cycle.SetInt64(m.Cycles)
+		responseTV = append(responseTV, cycle)
+
+		st.PkgPath = mpn.PkgPath
+		st.Fields = responseFS
+		sv.Fields = responseTV
+
+		response.T = &st
+		response.V = &sv
 	}
-	return res, nil
+
+	ctx.Logger().Info("CPUCYCLES call", "num-cycles", m.Cycles)
+	resraw, err := MarshalJSON(&response)
+	if err != nil {
+		return "", fmt.Errorf("unable to unarmsahll result: %w", err)
+	}
+
+	return string(resraw), nil
 	// TODO pay for gas? TODO see context?
 }
 

gnovm/pkg/gnolang/gonative.go

@@ -1203,6 +1203,12 @@ func gno2GoValue(tv *TypedValue, rv reflect.Value) (ret reflect.Value) {
 			if ftv.IsUndefined() {
 				continue
 			}
+
+			// Skip unexported field
+			if rt.Field(i).PkgPath != "" {
+				continue
+			}
+
 			gno2GoValue(ftv, rv.Field(i))
 		}
 	case *MapType: