Add and test JSON object matcher

x/wasm/types/errors.go

@@ -72,6 +72,18 @@ var (
 
 	//  error if an address does not belong to a contract (just for registration)
 	_ = sdkErrors.Register(DefaultCodespace, 22, "no such contract")
+
+	// ErrNotAJSONObject error if given data is not a JSON object
+	ErrNotAJSONObject = sdkErrors.Register(DefaultCodespace, 23, "not a JSON object")
+
+	// ErrNoTopLevelKey error if a JSON object has no top-level key
+	ErrNoTopLevelKey = sdkErrors.Register(DefaultCodespace, 24, "no top-level key")
+
+	// ErrMultipleTopLevelKeys error if a JSON object has more than one top-level key
+	ErrMultipleTopLevelKeys = sdkErrors.Register(DefaultCodespace, 25, "multiple top-level keys")
+
+	// ErrTopKevelKeyNotAllowed error if a JSON object has a top-level key that is not allowed
+	ErrTopKevelKeyNotAllowed = sdkErrors.Register(DefaultCodespace, 26, "top-level key is not allowed")
 )
 
 type ErrNoSuchContract struct {

x/wasm/types/json_matching.go

@@ -0,0 +1,36 @@
+package types
+
+import (
+	"encoding/json"
+
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// IsJSONObjectWithTopLevelKey checks if the given bytes are a valid JSON object
+// with exactly one top-level key that is contained in the list of allowed keys.
+func IsJSONObjectWithTopLevelKey(jsonBytes []byte, allowedKeys []string) error {
+	document := map[string]interface{}{}
+	if err := json.Unmarshal(jsonBytes, &document); err != nil {
+		return sdkerrors.Wrap(ErrNotAJSONObject, "failed to unmarshal JSON to map")
+	}
+
+	if len(document) == 0 {
+		return sdkerrors.Wrap(ErrNoTopLevelKey, "JSON object has no top-level key")
+	}
+
+	if len(document) > 1 {
+		return sdkerrors.Wrap(ErrMultipleTopLevelKeys, "JSON object has multiple top-level keys")
+	}
+
+	// Loop is executed exactly once
+	for topLevelKey := range document {
+		for _, allowedKey := range allowedKeys {
+			if allowedKey == topLevelKey {
+				return nil
+			}
+		}
+		return sdkerrors.Wrapf(ErrTopKevelKeyNotAllowed, "JSON object has a top-level key which is not allowed: '%s'", topLevelKey)
+	}
+
+	panic("Reached unreachable code. This is a bug.")
+}

x/wasm/types/json_matching_test.go

@@ -0,0 +1,115 @@
+package types
+
+import (
+	"testing"
+
+	// sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsJSONObjectWithTopLevelKey(t *testing.T) {
+	specs := map[string]struct {
+		src         []byte
+		allowedKeys []string
+		exp         error
+	}{
+		"happy": {
+			src:         []byte(`{"msg": {"foo":"bar"}}`),
+			allowedKeys: []string{"msg"},
+			exp:         nil,
+		},
+		"happy with many allowed keys 1": {
+			src:         []byte(`{"claim": {"foo":"bar"}}`),
+			allowedKeys: []string{"claim", "swap", "burn", "mint"},
+			exp:         nil,
+		},
+		"happy with many allowed keys 2": {
+			src:         []byte(`{"burn": {"foo":"bar"}}`),
+			allowedKeys: []string{"claim", "swap", "burn", "mint"},
+			exp:         nil,
+		},
+		"happy with many allowed keys 3": {
+			src:         []byte(`{"mint": {"foo":"bar"}}`),
+			allowedKeys: []string{"claim", "swap", "burn", "mint"},
+			exp:         nil,
+		},
+		"happy with number": {
+			src:         []byte(`{"msg": 123}`),
+			allowedKeys: []string{"msg"},
+			exp:         nil,
+		},
+		"happy with array": {
+			src:         []byte(`{"msg": [1, 2, 3, 4]}`),
+			allowedKeys: []string{"msg"},
+			exp:         nil,
+		},
+		"happy with null": {
+			src:         []byte(`{"msg": null}`),
+			allowedKeys: []string{"msg"},
+			exp:         nil,
+		},
+		"happy with whitespace": {
+			src: []byte(`{
+				"msg":	null    }`),
+			allowedKeys: []string{"msg"},
+			exp:         nil,
+		},
+		"happy with excaped key": {
+			src:         []byte(`{"event\u2468thing": {"foo":"bar"}}`),
+			allowedKeys: []string{"event⑨thing"},
+			exp:         nil,
+		},
+
+		// Invalid JSON object
+		"errors for bytes that are no JSON": {
+			src:         []byte(`nope`),
+			allowedKeys: []string{"claim"},
+			exp:         ErrNotAJSONObject,
+		},
+		"errors for valid JSON (string)": {
+			src:         []byte(`"nope"`),
+			allowedKeys: []string{"claim"},
+			exp:         ErrNotAJSONObject,
+		},
+		"errors for valid JSON (array)": {
+			src:         []byte(`[1, 2, 3]`),
+			allowedKeys: []string{"claim"},
+			exp:         ErrNotAJSONObject,
+		},
+
+		// Not one top-level key
+		"errors for no top-level key": {
+			src:         []byte(`{}`),
+			allowedKeys: []string{"claim"},
+			exp:         ErrNoTopLevelKey,
+		},
+		"errors for multiple top-level keys": {
+			src:         []byte(`{"claim": {}, "and_swap": {}}`),
+			allowedKeys: []string{"claim"},
+			exp:         ErrMultipleTopLevelKeys,
+		},
+
+		// Wrong top-level key
+		"errors for wrong top-level key 1": {
+			src:         []byte(`{"claim": {}}`),
+			allowedKeys: []string{""},
+			exp:         ErrTopKevelKeyNotAllowed,
+		},
+		"errors for wrong top-level key 2": {
+			src:         []byte(`{"claim": {}}`),
+			allowedKeys: []string{"swap", "burn", "mint"},
+			exp:         ErrTopKevelKeyNotAllowed,
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			result := IsJSONObjectWithTopLevelKey(spec.src, spec.allowedKeys)
+			if spec.exp == nil {
+				require.NoError(t, result)
+			} else {
+				require.Error(t, result)
+				require.Contains(t, result.Error(), spec.exp.Error())
+			}
+		})
+	}
+}