Support names in selector parser

(cherry picked from commit 9261c38)

Author: sobolev-igor

accounts/abi/selector_parser.go

@@ -17,7 +17,11 @@ func isDigit(c byte) bool {
 }
 
 func isAlpha(c byte) bool {
-	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == ' ')
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+func isSpace(c byte) bool {
+	return c == ' '
 }
 
 func isIdentifierSymbol(c byte) bool {
@@ -35,7 +39,7 @@ func parseToken(unescapedSelector string, isIdent bool) (string, string, error)
 	}
 	for position < len(unescapedSelector) {
 		char := unescapedSelector[position]
-		if !(isAlpha(char) || isDigit(char) || (isIdent && isIdentifierSymbol(char))) {
+		if !(isAlpha(char) || isDigit(char) || (isIdent && isIdentifierSymbol(char)) || (!isIdent && isSpace(char))) {
 			break
 		}
 		position++
@@ -48,6 +52,32 @@ func parseIdentifier(unescapedSelector string) (string, string, error) {
 }
 
 func parseElementaryType(unescapedSelector string) (parsedType string, rest string, err error) {
+	parsedType, rest, err = parseToken(unescapedSelector, false)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to parse elementary type: %v", err)
+	}
+	parts := strings.Split(parsedType, " ")
+	if len(parts) > 1 {
+		parsedType = parsedType[len(parts[0])+1:]
+	}
+	// handle arrays
+	for len(rest) > 0 && rest[0] == '[' {
+		parsedType = parsedType + string(rest[0])
+		rest = rest[1:]
+		for len(rest) > 0 && isDigit(rest[0]) {
+			parsedType = parsedType + string(rest[0])
+			rest = rest[1:]
+		}
+		if len(rest) == 0 || rest[0] != ']' {
+			return "", "", fmt.Errorf("failed to parse array: expected ']', got %c", unescapedSelector[0])
+		}
+		parsedType = parsedType + string(rest[0])
+		rest = rest[1:]
+	}
+	return parsedType, rest, nil
+}
+
+func parseElementaryTypeWithName(unescapedSelector string) (parsedType string, rest string, err error) {
 	parsedType, rest, err = parseToken(unescapedSelector, false)
 	if err != nil {
 		return "", "", fmt.Errorf("failed to parse elementary type: %v", err)
@@ -95,7 +125,77 @@ func parseCompositeType(unescapedSelector string) (result []interface{}, rest st
 	return result, rest[1:], nil
 }
 
+func parseCompositeTypeWithName(unescapedSelector string) (result []interface{}, rest string, err error) {
+	var name string
+	parts := strings.Split(unescapedSelector, " ")
+	if len(parts) < 2 {
+		return nil, "", fmt.Errorf("expected name in the beginning, got %s", unescapedSelector)
+	} else {
+		name = parts[0]
+		unescapedSelector = unescapedSelector[len(parts[0])+1:]
+	}
+	if len(unescapedSelector) == 0 || unescapedSelector[0] != '(' {
+		return nil, "", fmt.Errorf("expected '(...', got %s", unescapedSelector)
+	}
+	result = []interface{}{name}
+	var parsedType interface{}
+	var counter int64
+	parsedType, rest, err = parseTypeWithName(unescapedSelector[1:], counter)
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to parse type: %v", err)
+	}
+	result = append(result, parsedType)
+	for len(rest) > 0 && rest[0] != ')' {
+		counter += 1
+		parsedType, rest, err = parseTypeWithName(rest[1:], counter)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to parse type: %v", err)
+		}
+		result = append(result, parsedType)
+	}
+	if len(rest) == 0 || rest[0] != ')' {
+		return nil, "", fmt.Errorf("expected ')', got '%s'", rest)
+	}
+	if len(rest) >= 3 && rest[1] == '[' && rest[2] == ']' {
+		return append(result, "[]"), rest[3:], nil
+	}
+	return result, rest[1:], nil
+}
+
+func parseFunctionsArgs(unescapedSelector string) (result []interface{}, rest string, err error) {
+	if len(unescapedSelector) == 0 || unescapedSelector[0] != '(' {
+		return nil, "", fmt.Errorf("expected '(...', got %s", unescapedSelector)
+	}
+	var parsedType interface{}
+	var counter int64
+	parsedType, rest, err = parseTypeWithName(unescapedSelector[1:], counter)
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to parse type: %v", err)
+	}
+	result = []interface{}{parsedType}
+
+	for len(rest) > 0 && rest[0] != ')' {
+		counter += 1
+		parsedType, rest, err = parseTypeWithName(rest[1:], counter)
+		if err != nil {
+			return nil, "", fmt.Errorf("failed to parse type: %v", err)
+		}
+		result = append(result, parsedType)
+	}
+	if len(rest) == 0 || rest[0] != ')' {
+		return nil, "", fmt.Errorf("expected ')', got '%s'", rest)
+	}
+	if len(rest) >= 3 && rest[1] == '[' && rest[2] == ']' {
+		return append(result, "[]"), rest[3:], nil
+	}
+	return result, rest[1:], nil
+}
+
 func parseType(unescapedSelector string) (interface{}, string, error) {
+	parts := strings.Split(unescapedSelector, " ")
+	if len(parts) > 1 {
+		unescapedSelector = unescapedSelector[len(parts[0])+1:]
+	}
 	if len(unescapedSelector) == 0 {
 		return nil, "", errors.New("empty type")
 	}
@@ -106,22 +206,48 @@ func parseType(unescapedSelector string) (interface{}, string, error) {
 	}
 }
 
+func parseTypeWithName(unescapedSelector string, counter int64) (interface{}, string, error) {
+	name, rest, _ := parseIdentifier(unescapedSelector)
+	if len(rest) > 0 && rest[0] == ' ' {
+		unescapedSelector = unescapedSelector[len(name)+1:]
+	} else {
+		name = fmt.Sprintf("name%d", counter)
+	}
+	if len(unescapedSelector) == 0 {
+		return nil, "", errors.New("empty type")
+	}
+	if unescapedSelector[0] == '(' {
+		return parseCompositeTypeWithName(fmt.Sprintf("%v %v", name, unescapedSelector))
+	} else {
+		return parseElementaryTypeWithName(fmt.Sprintf("%v %v", name, unescapedSelector))
+	}
+}
+
 func assembleArgs(args []interface{}) (arguments []ArgumentMarshaling, err error) {
 	arguments = make([]ArgumentMarshaling, 0)
-	for i, arg := range args {
-		// generate dummy name to avoid unmarshal issues
-		name := fmt.Sprintf("name%d", i)
+	for _, arg := range args {
+		var name string
 		if s, ok := arg.(string); ok {
+			if s == "[]" {
+				arguments = append(arguments, ArgumentMarshaling{Name: name, Type: s, InternalType: s})
+				continue
+			}
 			parts := strings.Split(s, " ")
-			if len(parts) > 2 {
-				return nil, fmt.Errorf("more than 2 spaces in type declaration in selector %s", s)
-			} else if len(parts) == 2 {
+			if len(parts) < 2 {
+				return nil, fmt.Errorf("no name in arg %s", s)
+			} else {
 				name = parts[0]
-				s = parts[1]
+				s = s[len(name)+1:]
 			}
 			arguments = append(arguments, ArgumentMarshaling{Name: name, Type: s, InternalType: s})
 		} else if components, ok := arg.([]interface{}); ok {
 			var subArgs []ArgumentMarshaling
+			if len(components) < 2 {
+				return nil, fmt.Errorf("no name in components %s", components)
+			} else {
+				name = components[0].(string)
+				components = components[1:]
+			}
 			subArgs, err = assembleArgs(components)
 			if err != nil {
 				return nil, fmt.Errorf("failed to assemble components: %v", err)
@@ -153,7 +279,7 @@ func ParseSelector(unescapedSelector string) (m SelectorMarshaling, err error) {
 	if len(rest) >= 2 && rest[0] == '(' && rest[1] == ')' {
 		rest = rest[2:]
 	} else {
-		args, rest, err = parseCompositeType(rest)
+		args, rest, err = parseFunctionsArgs(rest)
 		if err != nil {
 			return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': %v", unescapedSelector, err)
 		}

accounts/abi/selector_parser_test.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"log"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -30,6 +31,11 @@ func TestParseSelector(t *testing.T) {
 		for i, typeOrComponents := range types {
 			name := fmt.Sprintf("name%d", i)
 			if typeName, ok := typeOrComponents.(string); ok {
+				names := strings.Split(typeName, " ")
+				if len(names) > 1 {
+					name = names[0]
+					typeName = typeName[len(name)+1:]
+				}
 				result = append(result, ArgumentMarshaling{name, typeName, typeName, nil, false})
 			} else if components, ok := typeOrComponents.([]ArgumentMarshaling); ok {
 				result = append(result, ArgumentMarshaling{name, "tuple", "tuple", components, false})
@@ -60,6 +66,10 @@ func TestParseSelector(t *testing.T) {
 			mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, "bytes32[]")},
 		{"singleArrayNestWithArrayAndArray((uint256[],address[2],uint8[4][][5])[],bytes32[])", "singleArrayNestWithArrayAndArray",
 			mkType([][]ArgumentMarshaling{mkType("uint256[]", "address[2]", "uint8[4][][5]")}, "bytes32[]")},
+		{"transfer(to address,amount uint256)", "transfer",
+			mkType("to address", "amount uint256")},
+		{"execute(((a address,c uint256,b uint8),(d uint8,e bytes)),(address,uint256),(uint8,(uint256,address),(uint256,address),address,address,bytes),(uint256,bytes),(uint256,bytes))", "execute",
+			mkType(mkType(mkType("a address", "c uint256", "b uint8"), mkType("d uint8", "e bytes")), mkType("address", "uint256"), mkType("uint8", mkType("uint256", "address"), mkType("uint256", "address"), "address", "address", "bytes"), mkType("uint256", "bytes"), mkType("uint256", "bytes"))},
 	}
 	for i, tt := range tests {
 		selector, err := ParseSelector(tt.input)