cmd/abigen, accounts/abi/bind: implement abigen version 2

accounts/abi/bind/bind.go → accounts/abi/abigen/bind.go

@@ -14,11 +14,11 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-// Package bind generates Ethereum contract Go bindings.
+// Package abigen generates Ethereum contract Go bindings.
 //
 // Detailed usage document and tutorial available on the go-ethereum Wiki page:
-// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
-package bind
+// https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings
+package abigen
 
 import (
 	"bytes"
@@ -33,13 +33,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// Lang is a target programming language selector to generate bindings for.
-type Lang int
-
-const (
-	LangGo Lang = iota
-)
-
 func isKeyWord(arg string) bool {
 	switch arg {
 	case "break":
@@ -81,7 +74,7 @@ func isKeyWord(arg string) bool {
 // to be used as is in client code, but rather as an intermediate struct which
 // enforces compile time type safety and naming convention as opposed to having to
 // manually maintain hard coded strings that break on runtime.
-func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) {
+func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) {
 	var (
 		// contracts is the map of each individual contract requested binding
 		contracts = make(map[string]*tmplContract)
@@ -125,14 +118,14 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 
 		for _, input := range evmABI.Constructor.Inputs {
 			if hasStruct(input.Type) {
-				bindStructType[lang](input.Type, structs)
+				bindStructType(input.Type, structs)
 			}
 		}
 
 		for _, original := range evmABI.Methods {
 			// Normalize the method for capital cases and non-anonymous inputs/outputs
 			normalized := original
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+			normalizedName := abi.ToCamelCase(alias(aliases, original.Name))
 			// Ensure there is no duplicated identifier
 			var identifiers = callIdentifiers
 			if !original.IsConstant() {
@@ -159,17 +152,17 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
 				}
 				if hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
+					bindStructType(input.Type, structs)
 				}
 			}
 			normalized.Outputs = make([]abi.Argument, len(original.Outputs))
 			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.ToCamelCase(output.Name)
 				}
 				if hasStruct(output.Type) {
-					bindStructType[lang](output.Type, structs)
+					bindStructType(output.Type, structs)
 				}
 			}
 			// Append the methods to the call or transact lists
@@ -188,7 +181,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			normalized := original
 
 			// Ensure there is no duplicated identifier
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+			normalizedName := abi.ToCamelCase(alias(aliases, original.Name))
 			// Name shouldn't start with a digit. It will make the generated code invalid.
 			if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) {
 				normalizedName = fmt.Sprintf("E%s", normalizedName)
@@ -213,14 +206,14 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 				// Event is a bit special, we need to define event struct in binding,
 				// ensure there is no camel-case-style name conflict.
 				for index := 0; ; index++ {
-					if !used[capitalise(normalized.Inputs[j].Name)] {
-						used[capitalise(normalized.Inputs[j].Name)] = true
+					if !used[abi.ToCamelCase(normalized.Inputs[j].Name)] {
+						used[abi.ToCamelCase(normalized.Inputs[j].Name)] = true
 						break
 					}
 					normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index)
 				}
 				if hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
+					bindStructType(input.Type, structs)
 				}
 			}
 			// Append the event to the accumulator list
@@ -233,8 +226,9 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		if evmABI.HasReceive() {
 			receive = &tmplMethod{Original: evmABI.Receive}
 		}
+
 		contracts[types[i]] = &tmplContract{
-			Type:        capitalise(types[i]),
+			Type:        abi.ToCamelCase(types[i]),
 			InputABI:    strings.ReplaceAll(strippedABI, "\"", "\\\""),
 			InputBin:    strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"),
 			Constructor: evmABI.Constructor,
@@ -245,6 +239,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			Events:      events,
 			Libraries:   make(map[string]string),
 		}
+
 		// Function 4-byte signatures are stored in the same sequence
 		// as types, if available.
 		if len(fsigs) > i {
@@ -270,6 +265,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		_, ok := isLib[types[i]]
 		contracts[types[i]].Library = ok
 	}
+
 	// Generate the contract template data content and render it
 	data := &tmplData{
 		Package:   pkg,
@@ -280,36 +276,25 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 	buffer := new(bytes.Buffer)
 
 	funcs := map[string]interface{}{
-		"bindtype":      bindType[lang],
-		"bindtopictype": bindTopicType[lang],
-		"namedtype":     namedType[lang],
-		"capitalise":    capitalise,
+		"bindtype":      bindType,
+		"bindtopictype": bindTopicType,
+		"capitalise":    abi.ToCamelCase,
 		"decapitalise":  decapitalise,
 	}
-	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang]))
+	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource))
 	if err := tmpl.Execute(buffer, data); err != nil {
 		return "", err
 	}
-	// For Go bindings pass the code through gofmt to clean it up
-	if lang == LangGo {
-		code, err := format.Source(buffer.Bytes())
-		if err != nil {
-			return "", fmt.Errorf("%v\n%s", err, buffer)
-		}
-		return string(code), nil
+	// Pass the code through gofmt to clean it up
+	code, err := format.Source(buffer.Bytes())
+	if err != nil {
+		return "", fmt.Errorf("%v\n%s", err, buffer)
 	}
-	// For all others just return as is for now
-	return buffer.String(), nil
-}
-
-// bindType is a set of type binders that convert Solidity types to some supported
-// programming language types.
-var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo: bindTypeGo,
+	return string(code), nil
 }
 
-// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go ones.
-func bindBasicTypeGo(kind abi.Type) string {
+// bindBasicType converts basic solidity types(except array, slice and tuple) to Go ones.
+func bindBasicType(kind abi.Type) string {
 	switch kind.T {
 	case abi.AddressTy:
 		return "common.Address"
@@ -332,32 +317,26 @@ func bindBasicTypeGo(kind abi.Type) string {
 	}
 }
 
-// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping
+// bindType converts solidity types to Go ones. Since there is no clear mapping
 // from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
 // mapped will use an upscaled type (e.g. BigDecimal).
-func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+func bindType(kind abi.Type, structs map[string]*tmplStruct) string {
 	switch kind.T {
 	case abi.TupleTy:
 		return structs[kind.TupleRawName+kind.String()].Name
 	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs)
+		return fmt.Sprintf("[%d]", kind.Size) + bindType(*kind.Elem, structs)
 	case abi.SliceTy:
-		return "[]" + bindTypeGo(*kind.Elem, structs)
+		return "[]" + bindType(*kind.Elem, structs)
 	default:
-		return bindBasicTypeGo(kind)
+		return bindBasicType(kind)
 	}
 }
 
-// bindTopicType is a set of type binders that convert Solidity types to some
-// supported programming language topic types.
-var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo: bindTopicTypeGo,
-}
-
-// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same
+// bindTopicType converts a Solidity topic type to a Go one. It is almost the same
 // functionality as for simple types, but dynamic types get converted to hashes.
-func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
-	bound := bindTypeGo(kind, structs)
+func bindTopicType(kind abi.Type, structs map[string]*tmplStruct) string {
+	bound := bindType(kind, structs)
 
 	// todo(rjl493456442) according solidity documentation, indexed event
 	// parameters that are not value types i.e. arrays and structs are not
@@ -371,16 +350,10 @@ func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 	return bound
 }
 
-// bindStructType is a set of type binders that convert Solidity tuple types to some supported
-// programming language struct definition.
-var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo: bindStructTypeGo,
-}
-
-// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping
-// in the given map.
-// Notably, this function will resolve and record nested struct recursively.
-func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+// bindStructType converts a Solidity tuple type to a Go one and records the mapping
+// in the given map. Notably, this function will resolve and record nested struct
+// recursively.
+func bindStructType(kind abi.Type, structs map[string]*tmplStruct) string {
 	switch kind.T {
 	case abi.TupleTy:
 		// We compose a raw struct name and a canonical parameter expression
@@ -398,37 +371,35 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 			fields []*tmplField
 		)
 		for i, elem := range kind.TupleElems {
-			name := capitalise(kind.TupleRawNames[i])
+			name := abi.ToCamelCase(kind.TupleRawNames[i])
 			name = abi.ResolveNameConflict(name, func(s string) bool { return names[s] })
 			names[name] = true
-			fields = append(fields, &tmplField{Type: bindStructTypeGo(*elem, structs), Name: name, SolKind: *elem})
+			fields = append(fields, &tmplField{
+				Type:    bindStructType(*elem, structs),
+				Name:    name,
+				SolKind: *elem,
+			})
 		}
 		name := kind.TupleRawName
 		if name == "" {
 			name = fmt.Sprintf("Struct%d", len(structs))
 		}
-		name = capitalise(name)
+		name = abi.ToCamelCase(name)
 
 		structs[id] = &tmplStruct{
 			Name:   name,
 			Fields: fields,
 		}
 		return name
 	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs)
+		return fmt.Sprintf("[%d]", kind.Size) + bindStructType(*kind.Elem, structs)
 	case abi.SliceTy:
-		return "[]" + bindStructTypeGo(*kind.Elem, structs)
+		return "[]" + bindStructType(*kind.Elem, structs)
 	default:
-		return bindBasicTypeGo(kind)
+		return bindBasicType(kind)
 	}
 }
 
-// namedType is a set of functions that transform language specific types to
-// named versions that may be used inside method names.
-var namedType = map[Lang]func(string, abi.Type) string{
-	LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") },
-}
-
 // alias returns an alias of the given string based on the aliasing rules
 // or returns itself if no rule is matched.
 func alias(aliases map[string]string, n string) string {
@@ -438,21 +409,11 @@ func alias(aliases map[string]string, n string) string {
 	return n
 }
 
-// methodNormalizer is a name transformer that modifies Solidity method names to
-// conform to target language naming conventions.
-var methodNormalizer = map[Lang]func(string) string{
-	LangGo: abi.ToCamelCase,
-}
-
-// capitalise makes a camel-case string which starts with an upper case character.
-var capitalise = abi.ToCamelCase
-
 // decapitalise makes a camel-case string which starts with a lower case character.
 func decapitalise(input string) string {
 	if len(input) == 0 {
 		return input
 	}
-
 	goForm := abi.ToCamelCase(input)
 	return strings.ToLower(goForm[:1]) + goForm[1:]
 }
@@ -471,7 +432,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.ToCamelCase(out.Name)
 		if field == "" || exists[field] {
 			return false
 		}

accounts/abi/bind/bind_test.go → accounts/abi/abigen/bind_test.go

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-package bind
+package abigen
 
 import (
 	"fmt"
@@ -2072,20 +2072,22 @@ var bindTests = []struct {
 
 // Tests that packages generated by the binder can be successfully compiled and
 // the requested tester run against it.
-func TestGolangBindings(t *testing.T) {
+func TestBindings(t *testing.T) {
 	t.Parallel()
 	// Skip the test if no Go command can be found
 	gocmd := runtime.GOROOT() + "/bin/go"
 	if !common.FileExist(gocmd) {
 		t.Skip("go sdk not found for testing")
 	}
-	// Create a temporary workspace for the test suite
-	ws := t.TempDir()
 
+	// Create a temporary workspace for the test suite
+	ws, _ := os.MkdirTemp("", "abigen")
 	pkg := filepath.Join(ws, "bindtest")
 	if err := os.MkdirAll(pkg, 0700); err != nil {
 		t.Fatalf("failed to create package: %v", err)
 	}
+	t.Log("tmpdir", pkg)
+
 	// Generate the test suite for all the contracts
 	for i, tt := range bindTests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -2096,7 +2098,7 @@ func TestGolangBindings(t *testing.T) {
 				types = []string{tt.name}
 			}
 			// Generate the binding and create a Go source file in the workspace
-			bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", LangGo, tt.libs, tt.aliases)
+			bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", tt.libs, tt.aliases)
 			if err != nil {
 				t.Fatalf("test %d: failed to generate binding: %v", i, err)
 			}