Use go-ethereum in compiler

Author: jemilezzet

solc/compiler.go

@@ -2,74 +2,25 @@ package solc
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
+
+	"github.com/ethereum/go-ethereum/common/compiler"
 )
 
 var versionRegexp = regexp.MustCompile(`([0-9]+)\.([0-9]+)\.([0-9]+)`)
 
-// Contract contains information about a compiled contract, alongside its code and runtime code.
-type Contract struct {
-	Code        string            `json:"code"`
-	RuntimeCode string            `json:"runtime-code"`
-	Info        ContractInfo      `json:"info"`
-	Hashes      map[string]string `json:"hashes"`
-}
-
-// ContractInfo contains information about a compiled contract, including access
-// to the ABI definition, source mapping, user and developer docs, and metadata.
-//
-// Depending on the source, language version, compiler version, and compiler
-// options will provide information about how the contract was compiled.
-type ContractInfo struct {
-	Source          string      `json:"source"`
-	Language        string      `json:"language"`
-	LanguageVersion string      `json:"languageVersion"`
-	CompilerVersion string      `json:"compilerVersion"`
-	CompilerOptions string      `json:"compilerOptions"`
-	SrcMap          interface{} `json:"srcMap"`
-	SrcMapRuntime   string      `json:"srcMapRuntime"`
-	AbiDefinition   interface{} `json:"abiDefinition"`
-	UserDoc         interface{} `json:"userDoc"`
-	DeveloperDoc    interface{} `json:"developerDoc"`
-	Metadata        string      `json:"metadata"`
-}
 
 // Solidity contains information about the solidity compiler.
 type Solidity struct {
 	Path, Version, FullVersion string
 	Major, Minor, Patch        int
 }
 
-// --combined-output format
-type solcOutput struct {
-	Contracts map[string]struct {
-		BinRuntime                                  string `json:"bin-runtime"`
-		SrcMapRuntime                               string `json:"srcmap-runtime"`
-		Bin, SrcMap, Abi, Devdoc, Userdoc, Metadata string
-		Hashes                                      map[string]string
-	}
-	Version string
-}
-
-// solidity v.0.8 changes the way ABI, Devdoc and Userdoc are serialized
-type solcOutputV8 struct {
-	Contracts map[string]struct {
-		BinRuntime            string `json:"bin-runtime"`
-		SrcMapRuntime         string `json:"srcmap-runtime"`
-		Bin, SrcMap, Metadata string
-		Abi                   interface{}
-		Devdoc                interface{}
-		Userdoc               interface{}
-		Hashes                map[string]string
-	}
-	Version string
-}
 
 func (s *Solidity) makeArgs() []string {
 	p := []string{
@@ -113,7 +64,7 @@ func SolidityVersion(solc string) (*Solidity, error) {
 }
 
 // compileSolidityString builds and returns all the contracts contained within a source string.
-func compileSolidityString(solc, source string) (map[string]*Contract, error) {
+func compileSolidityString(solc, source string) (map[string]*compiler.Contract, error) {
 	if len(source) == 0 {
 		return nil, errors.New("solc: empty source string")
 	}
@@ -127,93 +78,13 @@ func compileSolidityString(solc, source string) (map[string]*Contract, error) {
 	return s.run(cmd, source)
 }
 
-func (s *Solidity) run(cmd *exec.Cmd, source string) (map[string]*Contract, error) {
+func (s *Solidity) run(cmd *exec.Cmd, source string) (map[string]*compiler.Contract, error) {
 	var stderr, stdout bytes.Buffer
 	cmd.Stderr = &stderr
 	cmd.Stdout = &stdout
 	if err := cmd.Run(); err != nil {
 		return nil, fmt.Errorf("solc: %v\n%s", err, stderr.Bytes())
 	}
-	return ParseCombinedJSON(stdout.Bytes(), source, s.Version, s.Version, strings.Join(s.makeArgs(), " "))
+	return compiler.ParseCombinedJSON(stdout.Bytes(), source, s.Version, s.Version, strings.Join(s.makeArgs(), " "))
 }
 
-// ParseCombinedJSON takes the direct output of a solc --combined-output run and
-// parses it into a map of string contract name to Contract structs. The
-// provided source, language and compiler version, and compiler options are all
-// passed through into the Contract structs.
-//
-// The solc output is expected to contain ABI, source mapping, user docs, and dev docs.
-//
-// Returns an error if the JSON is malformed or missing data, or if the JSON
-// embedded within the JSON is malformed.
-func ParseCombinedJSON(combinedJSON []byte, source string, languageVersion string, compilerVersion string, compilerOptions string) (map[string]*Contract, error) {
-	var output solcOutput
-	if err := json.Unmarshal(combinedJSON, &output); err != nil {
-		// Try to parse the output with the new solidity v.0.8.0 rules
-		return parseCombinedJSONV8(combinedJSON, source, languageVersion, compilerVersion, compilerOptions)
-	}
-	// Compilation succeeded, assemble and return the contracts.
-	contracts := make(map[string]*Contract)
-	for name, info := range output.Contracts {
-		// Parse the individual compilation results.
-		var abi interface{}
-		if err := json.Unmarshal([]byte(info.Abi), &abi); err != nil {
-			return nil, fmt.Errorf("solc: error reading abi definition (%v)", err)
-		}
-		var userdoc, devdoc interface{}
-		json.Unmarshal([]byte(info.Userdoc), &userdoc)
-		json.Unmarshal([]byte(info.Devdoc), &devdoc)
-
-		contracts[name] = &Contract{
-			Code:        "0x" + info.Bin,
-			RuntimeCode: "0x" + info.BinRuntime,
-			Hashes:      info.Hashes,
-			Info: ContractInfo{
-				Source:          source,
-				Language:        "Solidity",
-				LanguageVersion: languageVersion,
-				CompilerVersion: compilerVersion,
-				CompilerOptions: compilerOptions,
-				SrcMap:          info.SrcMap,
-				SrcMapRuntime:   info.SrcMapRuntime,
-				AbiDefinition:   abi,
-				UserDoc:         userdoc,
-				DeveloperDoc:    devdoc,
-				Metadata:        info.Metadata,
-			},
-		}
-	}
-	return contracts, nil
-}
-
-// parseCombinedJSONV8 parses the direct output of solc --combined-output
-// and parses it using the rules from solidity v.0.8.0 and later.
-func parseCombinedJSONV8(combinedJSON []byte, source string, languageVersion string, compilerVersion string, compilerOptions string) (map[string]*Contract, error) {
-	var output solcOutputV8
-	if err := json.Unmarshal(combinedJSON, &output); err != nil {
-		return nil, err
-	}
-	// Compilation succeeded, assemble and return the contracts.
-	contracts := make(map[string]*Contract)
-	for name, info := range output.Contracts {
-		contracts[name] = &Contract{
-			Code:        "0x" + info.Bin,
-			RuntimeCode: "0x" + info.BinRuntime,
-			Hashes:      info.Hashes,
-			Info: ContractInfo{
-				Source:          source,
-				Language:        "Solidity",
-				LanguageVersion: languageVersion,
-				CompilerVersion: compilerVersion,
-				CompilerOptions: compilerOptions,
-				SrcMap:          info.SrcMap,
-				SrcMapRuntime:   info.SrcMapRuntime,
-				AbiDefinition:   info.Abi,
-				UserDoc:         info.Userdoc,
-				DeveloperDoc:    info.Devdoc,
-				Metadata:        info.Metadata,
-			},
-		}
-	}
-	return contracts, nil
-}

solc/solc.go

@@ -14,6 +14,7 @@ import (
 	"sort"
 
 	"github.com/Masterminds/semver/v3"
+	"github.com/ethereum/go-ethereum/common/compiler"
 	"github.com/shibukawa/configdir"
 	"github.com/withtally/synceth/parser"
 )
@@ -178,7 +179,7 @@ func resolve(vc *parser.VersionConstraint) (Build, error) {
 	return Build{}, fmt.Errorf("cant satisfy version constraint: %s", vc.String())
 }
 
-func CompileSolidityString(src string) (map[string]*Contract, error) {
+func CompileSolidityString(src string) (map[string]*compiler.Contract, error) {
 	c, err := parser.NewVersionConstraint(src)
 	if err != nil {
 		return nil, fmt.Errorf("parsing solidity version: %w", err)