From cd96cd78506078066a6a38d636693bb9b1977d56 Mon Sep 17 00:00:00 2001 From: bai Date: Wed, 22 Aug 2018 10:50:35 +0800 Subject: [PATCH] accounts: fix unpack event error(#17477) --- accounts/abi/argument.go | 42 +++++++++++++++++++++--- accounts/abi/bind/bind.go | 64 ++++++------------------------------- accounts/abi/bind/topics.go | 2 +- accounts/abi/reflect.go | 2 +- 4 files changed, 49 insertions(+), 61 deletions(-) diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go index 93b513c346..e10986c1d5 100644 --- a/accounts/abi/argument.go +++ b/accounts/abi/argument.go @@ -277,14 +277,48 @@ func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) { return ret, nil } -// capitalise makes the first character of a string upper case, also removing any -// prefixing underscores from the variable names. -func capitalise(input string) string { +// Capitalise makes a camel-case string which starts with an upper case character. +func Capitalise(input string) string { for len(input) > 0 && input[0] == '_' { input = input[1:] } if len(input) == 0 { return "" } - return strings.ToUpper(input[:1]) + input[1:] + return toCamelCase(strings.ToUpper(input[:1]) + input[1:]) +} + +// Decapitalise makes a camel-case string which starts with a lower case character. +func Decapitalise(input string) string { + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } + return toCamelCase(strings.ToLower(input[:1]) + input[1:]) +} + +// toCamelCase converts an under-score string to a camel-case string +func toCamelCase(input string) string { + toupper := false + + result := "" + for k, v := range input { + switch { + case k == 0: + result = strings.ToUpper(string(input[0])) + + case toupper: + result += strings.ToUpper(string(v)) + toupper = false + + case v == '_': + toupper = true + + default: + result += string(v) + } + } + return result } diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 411177057b..d040475883 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -85,7 +85,7 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La copy(normalized.Outputs, original.Outputs) for j, output := range normalized.Outputs { if output.Name != "" { - normalized.Outputs[j].Name = capitalise(output.Name) + normalized.Outputs[j].Name = abi.Capitalise(output.Name) } } // Append the methods to the call or transact lists @@ -118,7 +118,7 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} } contracts[types[i]] = &tmplContract{ - Type: capitalise(types[i]), + Type: abi.Capitalise(types[i]), InputABI: strings.Replace(strippedABI, "\"", "\\\"", -1), InputBin: strings.TrimSpace(bytecodes[i]), Constructor: evmABI.Constructor, @@ -138,8 +138,8 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La "bindtype": bindType[lang], "bindtopictype": bindTopicType[lang], "namedtype": namedType[lang], - "capitalise": capitalise, - "decapitalise": decapitalise, + "capitalise": abi.Capitalise, + "decapitalise": abi.Decapitalise, } tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) if err := tmpl.Execute(buffer, data); err != nil { @@ -368,9 +368,9 @@ func namedTypeJava(javaKind string, solKind abi.Type) string { switch parts[2] { case "8", "16", "32", "64": if parts[3] == "" { - return capitalise(fmt.Sprintf("%sint%s", parts[1], parts[2])) + return abi.Capitalise(fmt.Sprintf("%sint%s", parts[1], parts[2])) } - return capitalise(fmt.Sprintf("%sint%ss", parts[1], parts[2])) + return abi.Capitalise(fmt.Sprintf("%sint%ss", parts[1], parts[2])) default: return javaKind @@ -381,54 +381,8 @@ func namedTypeJava(javaKind string, solKind abi.Type) string { // methodNormalizer is a name transformer that modifies Solidity method names to // conform to target language naming concentions. var methodNormalizer = map[Lang]func(string) string{ - LangGo: capitalise, - LangJava: decapitalise, -} - -// capitalise makes a camel-case string which starts with an upper case character. -func capitalise(input string) string { - for len(input) > 0 && input[0] == '_' { - input = input[1:] - } - if len(input) == 0 { - return "" - } - return toCamelCase(strings.ToUpper(input[:1]) + input[1:]) -} - -// decapitalise makes a camel-case string which starts with a lower case character. -func decapitalise(input string) string { - for len(input) > 0 && input[0] == '_' { - input = input[1:] - } - if len(input) == 0 { - return "" - } - return toCamelCase(strings.ToLower(input[:1]) + input[1:]) -} - -// toCamelCase converts an under-score string to a camel-case string -func toCamelCase(input string) string { - toupper := false - - result := "" - for k, v := range input { - switch { - case k == 0: - result = strings.ToUpper(string(input[0])) - - case toupper: - result += strings.ToUpper(string(v)) - toupper = false - - case v == '_': - toupper = true - - default: - result += string(v) - } - } - return result + LangGo: abi.Capitalise, + LangJava: abi.Decapitalise, } // structured checks whether a list of ABI data types has enough information to @@ -445,7 +399,7 @@ func structured(args abi.Arguments) bool { } // If the field name is empty when normalized or collides (var, Var, _var, _Var), // we can't organize into a struct - field := capitalise(out.Name) + field := abi.Capitalise(out.Name) if field == "" || exists[field] { return false } diff --git a/accounts/abi/bind/topics.go b/accounts/abi/bind/topics.go index 600dfcda97..f7f463bdda 100644 --- a/accounts/abi/bind/topics.go +++ b/accounts/abi/bind/topics.go @@ -117,7 +117,7 @@ func parseTopics(out interface{}, fields abi.Arguments, topics []common.Hash) er if !arg.Indexed { return errors.New("non-indexed field in topic reconstruction") } - field := reflect.ValueOf(out).Elem().FieldByName(capitalise(arg.Name)) + field := reflect.ValueOf(out).Elem().FieldByName(abi.Capitalise(arg.Name)) // Try to parse the topic back into the fields based on primitive types switch field.Kind() { diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go index 0193517a42..7ba7220be5 100644 --- a/accounts/abi/reflect.go +++ b/accounts/abi/reflect.go @@ -171,7 +171,7 @@ func mapAbiToStructFields(args Arguments, value reflect.Value) (map[string]strin for _, arg := range args { abiFieldName := arg.Name - structFieldName := capitalise(abiFieldName) + structFieldName := Capitalise(abiFieldName) if structFieldName == "" { return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct")