fix(tm2): Fix the endpoint /tx?hash= to make it work

tm2/pkg/bft/rpc/lib/server/handlers.go

@@ -3,6 +3,7 @@
 import (
 	"bytes"
 	"context"
+	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -332,130 +333,59 @@
 	}
 }
 
+var reInt = regexp.MustCompile(`^-?[0-9]+$`)
+
 // Convert an http query to a list of properly typed values.
 // To be properly decoded the arg must be a concrete type from tendermint (if its an interface).
 func httpParamsToArgs(rpcFunc *RPCFunc, r *http.Request) ([]reflect.Value, error) {
-	// skip types.Context
 	const argsOffset = 1
 
-	values := make([]reflect.Value, len(rpcFunc.argNames))
-
-	for i, name := range rpcFunc.argNames {
-		argType := rpcFunc.args[i+argsOffset]
-
-		values[i] = reflect.Zero(argType) // set default for that type
-
-		arg := GetParam(r, name)
-		// log.Notice("param to arg", "argType", argType, "name", name, "arg", arg)
-
+	paramsMap := make(map[string]json.RawMessage)
+	for _, argName := range rpcFunc.argNames {
+		arg := GetParam(r, argName)
 		if arg == "" {
 			continue
 		}
 
-		v, err, ok := nonJSONStringToArg(argType, arg)
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			values[i] = v
-			continue
-		}
+		// Handle hex string
+		if strings.HasPrefix(arg, "0x") {
+			decoded, err := hex.DecodeString(arg[2:])
+			if err != nil {
+				return nil, errors.Wrap(err, "error decoding hex string")
+			}
 
-		values[i], err = jsonStringToArg(argType, arg)
-		if err != nil {
-			return nil, err
-		}
-	}
+			data, err := amino.MarshalJSON(decoded)
+			if err != nil {
+				return nil, errors.Wrap(err, "error marshaling argument to JSON")
+			}
 
-	return values, nil
-}
+			paramsMap[argName] = data
 
-func jsonStringToArg(rt reflect.Type, arg string) (reflect.Value, error) {
-	rv := reflect.New(rt)
-	err := amino.UnmarshalJSON([]byte(arg), rv.Interface())
-	if err != nil {
-		return rv, err
-	}
-	rv = rv.Elem()
-	return rv, nil
-}
-
-func nonJSONStringToArg(rt reflect.Type, arg string) (reflect.Value, error, bool) {
-	if rt.Kind() == reflect.Ptr {
-		rv_, err, ok := nonJSONStringToArg(rt.Elem(), arg)
-		switch {
-		case err != nil:
-			return reflect.Value{}, err, false
-		case ok:
-			rv := reflect.New(rt.Elem())
-			rv.Elem().Set(rv_)
-			return rv, nil, true
-		default:
-			return reflect.Value{}, nil, false
+			continue
 		}
-	} else {
-		return _nonJSONStringToArg(rt, arg)
-	}
-}
 
-var reInt = regexp.MustCompile(`^-?[0-9]+$`)
-
-// NOTE: rt.Kind() isn't a pointer.
-func _nonJSONStringToArg(rt reflect.Type, arg string) (reflect.Value, error, bool) {
-	isIntString := reInt.Match([]byte(arg))
-	isQuotedString := strings.HasPrefix(arg, `"`) && strings.HasSuffix(arg, `"`)
-	isHexString := strings.HasPrefix(strings.ToLower(arg), "0x")
-
-	var expectingString, expectingByteSlice, expectingInt bool
-	switch rt.Kind() {
-	case reflect.Int, reflect.Uint, reflect.Int8, reflect.Uint8, reflect.Int16, reflect.Uint16, reflect.Int32, reflect.Uint32, reflect.Int64, reflect.Uint64:
-		expectingInt = true
-	case reflect.String:
-		expectingString = true
-	case reflect.Slice:
-		expectingByteSlice = rt.Elem().Kind() == reflect.Uint8
-	}
-
-	if isIntString && expectingInt {
-		qarg := `"` + arg + `"`
-		// jsonStringToArg
-		rv, err := jsonStringToArg(rt, qarg)
-		if err != nil {
-			return rv, err, false
-		}
+		// Handle base64 string
+		if decoded, err := base64.StdEncoding.DecodeString(arg); err == nil {
+			data, err := amino.MarshalJSON(decoded)
+			if err != nil {
+				return nil, errors.Wrap(err, "error marshaling argument to JSON")
+			}
 
-		return rv, nil, true
-	}
+			paramsMap[argName] = data
 
-	if isHexString {
-		if !expectingString && !expectingByteSlice {
-			err := errors.New("got a hex string arg, but expected '%s'",
-				rt.Kind().String())
-			return reflect.ValueOf(nil), err, false
+			continue
 		}
 
-		var value []byte
-		value, err := hex.DecodeString(arg[2:])
-		if err != nil {
-			return reflect.ValueOf(nil), err, false
-		}
-		if rt.Kind() == reflect.String {
-			return reflect.ValueOf(string(value)), nil, true
+		// Handle int string
+		if reInt.Match([]byte(arg)) {
+			arg = fmt.Sprintf("%q", arg)
 		}
-		return reflect.ValueOf(value), nil, true
-	}
 
-	if isQuotedString && expectingByteSlice {
-		v := reflect.New(reflect.TypeOf(""))
-		err := amino.UnmarshalJSON([]byte(arg), v.Interface())
-		if err != nil {
-			return reflect.ValueOf(nil), err, false
-		}
-		v = v.Elem()
-		return reflect.ValueOf([]byte(v.String())), nil, true
+		// Default: treat the argument as a JSON raw message
+		paramsMap[argName] = json.RawMessage([]byte(arg))
 	}
 
-	return reflect.ValueOf(nil), nil, false
+	return mapParamsToArgs(rpcFunc, paramsMap, argsOffset)
 }
 
 // rpc.http

tm2/pkg/bft/rpc/lib/server/parse_test.go

@@ -1,9 +1,13 @@
 package rpcserver
 
 import (
+	"bytes"
+	"encoding/base64"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"net/url"
 	"strconv"
 	"testing"
 
@@ -175,44 +179,118 @@ func TestParseJSONRPC(t *testing.T) {
 	}
 }
 
-func TestParseURI(t *testing.T) {
+func TestParseURINonJSON(t *testing.T) {
 	t.Parallel()
 
-	demo := func(ctx *types.Context, height int, name string) {}
-	call := NewRPCFunc(demo, "height,name")
+	// Define a demo RPC function
+	demo := func(ctx *types.Context, height int, name string, hash []byte) {}
+	call := NewRPCFunc(demo, "height,name,hash")
 
-	cases := []struct {
+	// Helper function to decode input base64 string to []byte
+	decodeBase64 := func(input string) []byte {
+		decoded, _ := base64.StdEncoding.DecodeString(input)
+		return decoded
+	}
+
+	// Helper function to decode input hex string to []byte
+	decodeHex := func(input string) []byte {
+		decoded, _ := hex.DecodeString(input[2:])
+		return decoded
+	}
+
+	// Test cases for non-JSON encoded parameters
+	nonJSONCases := []struct {
 		raw    []string
 		height int64
 		name   string
+		hash   []byte
 		fail   bool
 	}{
 		// can parse numbers unquoted and strings quoted
-		{[]string{"7", `"flew"`}, 7, "flew", false},
-		{[]string{"22", `"john"`}, 22, "john", false},
-		{[]string{"-10", `"bob"`}, -10, "bob", false},
+		{[]string{"7", `"flew"`, "rnpVPFlGJlauMNiL43Dmcl1U9loOBlib4L9OQAQ29tI="}, 7, "flew", decodeBase64("rnpVPFlGJlauMNiL43Dmcl1U9loOBlib4L9OQAQ29tI="), false},
+		{[]string{"22", `"john"`, "E+oc1Imd8g5W62tYntw6DjEI/5Lygsx9wJEwc4/oNWI="}, 22, "john", decodeBase64("E+oc1Imd8g5W62tYntw6DjEI/5Lygsx9wJEwc4/oNWI="), false},
+		{[]string{"-10", `"bob"`, "VAmm+RUvpjL3SAGG5gHNzo9ZWo2w3E15iyQB7DN0uF8="}, -10, "bob", decodeBase64("VAmm+RUvpjL3SAGG5gHNzo9ZWo2w3E15iyQB7DN0uF8="), false},
 		// can parse numbers quoted, too
-		{[]string{`"7"`, `"flew"`}, 7, "flew", false},
-		{[]string{`"-10"`, `"bob"`}, -10, "bob", false},
-		// cant parse strings uquoted
-		{[]string{`"-10"`, `bob`}, -10, "bob", true},
+		{[]string{`"7"`, `"flew"`, "0x486173682076616c7565"}, 7, "flew", decodeHex("0x486173682076616c7565"), false}, // Testing hex encoded data
+		{[]string{`"-10"`, `"bob"`, "0x6578616d706c65"}, -10, "bob", decodeHex("0x6578616d706c65"), false},           // Testing hex encoded data
+		// can't parse strings unquoted
+		{[]string{`"-10"`, `bob`, "invalid_encoded_data"}, -10, "bob", []byte("invalid_encoded_data"), true}, // Invalid encoded data format
 	}
-	for idx, tc := range cases {
+
+	// Iterate over test cases for non-JSON encoded parameters
+	for idx, tc := range nonJSONCases {
 		i := strconv.Itoa(idx)
-		// data := []byte(tc.raw)
-		url := fmt.Sprintf(
-			"test.com/method?height=%v&name=%v",
-			tc.raw[0], tc.raw[1])
+		url := fmt.Sprintf("test.com/method?height=%v&name=%v&hash=%v", tc.raw[0], tc.raw[1], url.QueryEscape(tc.raw[2]))
 		req, err := http.NewRequest("GET", url, nil)
+
 		assert.NoError(t, err)
+
+		// Invoke httpParamsToArgs to parse the request and convert to reflect.Values
 		vals, err := httpParamsToArgs(call, req)
+
+		// Check for expected errors or successful parsing
 		if tc.fail {
 			assert.NotNil(t, err, i)
 		} else {
 			assert.Nil(t, err, "%s: %+v", i, err)
-			if assert.Equal(t, 2, len(vals), i) {
+			// Assert the parsed values match the expected height, name, and data
+
+			if assert.Equal(t, 3, len(vals), i) {
 				assert.Equal(t, tc.height, vals[0].Int(), i)
 				assert.Equal(t, tc.name, vals[1].String(), i)
+				assert.Equal(t, len(tc.hash), len(vals[2].Bytes()), i)
+				assert.True(t, bytes.Equal(tc.hash, vals[2].Bytes()), i)
+			}
+		}
+	}
+}
+
+func TestParseURIJSON(t *testing.T) {
+	t.Parallel()
+
+	type Data struct {
+		Key string `json:"key"`
+	}
+
+	// Define a demo RPC function
+	demo := func(ctx *types.Context, data Data) {}
+	call := NewRPCFunc(demo, "data")
+
+	// Test cases for JSON encoded parameters
+	jsonCases := []struct {
+		raw  string
+		data Data
+		fail bool
+	}{
+		// Valid JSON encoded values
+		{`{"key": "value"}`, Data{Key: "value"}, false},
+		{`{"id": 123}`, Data{}, false},         // Invalid field "id" (not in struct)
+		{`{"list": [1, 2, 3]}`, Data{}, false}, // Invalid field "list" (not in struct)
+		// Invalid JSON encoded values
+		{`"string_data"`, Data{}, true},                // Invalid JSON format (not an object)
+		{`12345`, Data{}, true},                        // Invalid JSON format (not an object)
+		{`{"key": true}`, Data{}, true},                // Invalid field "key" type (expected string)
+		{`{"key": {"nested": "value"}}`, Data{}, true}, // Invalid field "key" type (nested object)
+	}
+
+	// Iterate over test cases for JSON encoded parameters
+	for idx, tc := range jsonCases {
+		i := strconv.Itoa(idx)
+		url := fmt.Sprintf("test.com/method?data=%v", url.PathEscape(tc.raw))
+		req, err := http.NewRequest("GET", url, nil)
+		assert.NoError(t, err)
+
+		// Invoke httpParamsToArgs to parse the request and convert to reflect.Values
+		vals, err := httpParamsToArgs(call, req)
+
+		// Check for expected errors or successful parsing
+		if tc.fail {
+			assert.NotNil(t, err, i)
+		} else {
+			assert.Nil(t, err, "%s: %+v", i, err)
+			// Assert the parsed values match the expected data
+			if assert.Equal(t, 1, len(vals), i) {
+				assert.Equal(t, tc.data, vals[0].Interface(), i)
 			}
 		}
 	}