Go语言打造以太坊智能合约测试框架（level3）

时间 2019-12-10

标签语言打造以太智能合约测试框架 level3 level 繁體版

原文原文链接

传送门: 柏链项目学院html

第三课智能合约自动化测试

以前课程回顾

咱们以前介绍了go语言调用exec处理命令行，介绍了toml配置文件的处理，以及awk处理文本文件得到ABI信息。咱们的代码算是完成了从智能合约到go语言的自动编译，同时也能够自动提取到ABI信息。git

具体能够参考：github

第一课 go语言与智能合约调用的前因后果编程

第二课智能合约自动化编译json

本节主要工做

go语言模版编程
目标代码生成
目标代码的调用代码生成
配置文件的自动化生成

原有代码优化

想要自动化生成测试代码，首先你要知道目标代码长什么样儿，也就是以前咱们写的部署合约，调用合约的代码。仔细思考，其实会发现分了两层内容，第一层内容就是针对每个合约函数都要有一个调用函数生成，假设合约函数为X，咱们把调用该函数的函数叫CallX，咱们想要完成测试，又须要在main函数内能找到调用CallX的入口。先一步一步来，先完成一个小目标，那就是生成这些个CallX，
再来梳理一下咱们以前调用合约的代码。app

const keydata = `{"address":"791443d21a76e16cc510b6b1684344d2a5ce751c","crypto":{"cipher":"aes-128-ctr","ciphertext":"bbccbf9deb8c907d9f245767fffb57880c4cfd265dde9372d7278a8e963043bd","cipherparams":{"iv":"95e8f925fe0f3460f0ca3ccebc481b14"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"2036300fae07d954a10e70a2f87876fa198b310dc16a72f3fab3265978e7d798"},"mac":"009ce0ecd11d5f563d2f7bd41eb957f1ca3b517f31653dd18fac20e77b7feb5c"},"id":"7f42641c-580a-4398-b00c-74ef2710bcae","version":3}`

func CallDeploy() error {
    //连接到以太坊,cli就是backend
    cli, err := ethclient.Dial("http://localhost:8545")
    if err != nil {
        fmt.Println("failed to dial ", err)
        return err
    }
    //建立身份,须要私钥= pass+keystore文件
    auth, err := bind.NewTransactor(strings.NewReader(keydata), "123")
    if err != nil {
        fmt.Println("failed to NewTransactor auth", err)
        return err
    }
    auth.GasLimit = 400000
    addr, ts, pd, err := DeployPdbank(auth, cli, "yekai233")
    if err != nil {
        fmt.Println("failed to DeployPdbank", err)
        return err
    }
    bkname, _ := pd.BankName(nil)
    fmt.Println("addr=", addr.Hex(), "bkname=", bkname, "hash=", ts.Hash().Hex())
    return err
}

对于keydata来讲，咱们不能写死了，须要从keystore文件读取这部分数据。http://localhost:8545这样的链接地址最好经过配置文件来搞定，但思路要清楚的是，咱们这个代码是未来要执行的，这个代码它须要一个本身的配置文件，并不是是咱们当前工程的配置文件，直白一点的说就是咱们须要给将来的代码宝宝们自动的生成一个配置文件。记得有这么回事儿，咱们先无论这一点，先以能完成任务为前提。框架

咱们仍是来单独造成一个函数，用于专门造成签名，它须要读取keystore文件，这个文件能够根据对应的帐户地址到以太坊keystore目录获得，这样就容易多了！ide

//设置签名
func MakeAuth(addr, pass string) (*bind.TransactOpts, error) {
    keystorePath  :=  "{{.Keydir}}"
    fileName, err := GetFileName(string([]rune(addr)[2:]), keystorePath)
    if err != nil {
        fmt.Println("failed to GetFileName", err)
        return nil, err
    }

    file, err := os.Open(keystorePath + "/" + fileName)
    if err != nil {
        fmt.Println("failed to open file ", err)
        return nil, err
    }
    auth, err := bind.NewTransactor(file, pass)
    if err != nil {
        fmt.Println("failed to NewTransactor  ", err)
        return nil, err
    }
    return auth, err
}
func GetFileName(address, dirname string) (string, error) {

    data, err := ioutil.ReadDir(dirname)
    if err != nil {
        fmt.Println("read dir err", err)
        return "", err
    }
    for _, v := range data {
        if strings.Index(v.Name(), address) > 0 {
            //表明找到文件
            return v.Name(), nil
        }
    }

    return "", nil
}

因而，咱们将原来写的测试代码进行完善一下！函数

此外，链接这里也规范一下，使用init函数来搞定！测试

var testclient *ethclient.Client

func init() {
    cli, err := CreateCli("http://localhost:8545")
    if err != nil {
        log.Panic("failed to connect to eth", err)
    }
    testclient = cli
}

func CallBankName() (error) {
    instance, err := NewPdbank(common.HexToAddress("0xD55E88D9156355C584982Db2C96dD1C2c63788C2"), testclient)
    if err != nil {
        fmt.Println("failed to get contract instance", err)
        return err
    }
    data,err := instance.BankName(nil)
    if err != nil {
        fmt.Println("failed to get Balances", err)
        return err
    }
    fmt.Println(data,err)
    return nil
}


func CallWithdraw(addr, pass string) (*types.Transaction, error) {

    instance, err := NewPdbank(common.HexToAddress("0xD55E88D9156355C584982Db2C96dD1C2c63788C2"), testclient)
    if err != nil {
        fmt.Println("failed to get contract instance", err)
        return nil, err
    }
    auth, err := MakeAuth(addr, pass)
    if err != nil {
        fmt.Println("failed to makeAuth", err)
        return nil, err
    }
    auth.Value = big.NewInt(0)
    ts,err := instance.Withdraw(auth,big.NewInt(10000))
    if err != nil {
        fmt.Println("failed to call ", err)
        return nil, err
    }
    fmt.Println(ts.ChainId(), ts.Hash().Hex(), ts.Nonce())
    return ts , err
}

这样代码看上去舒服多了，接下来考虑目标代码的生成办法。

go语言与模版编程

go语言模版编程须要用到template包，go语言的模版呢实际上也提供了两大类模版处理。一类是文本的，一类是html的。鉴于咱们的目标代码是go语言，因此本次使用基于文本的模版处理。

下面是一个最简单的模版处理的例子，{{.Count}}和{{.Material}}至关因而这个模版要填的两个空。

type Inventory struct {
    Material string
    Count    uint
}
sweaters := Inventory{"wool", 17}
tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
if err != nil { panic(err) }
err = tmpl.Execute(os.Stdout, sweaters)
if err != nil { panic(err) }

New 方法建立一个模版
Parse 是指定模版的内容
Execute 是执行，两个参数分别是写入的方向以及模版实例化的内容

一个复杂一些的例子

// Define a template.
const letter = `
Dear {{.Name}},
{{if .Attended}}
It was a pleasure to see you at the wedding.{{else}}
It is a shame you couldn't make it to the wedding.{{end}}
{{with .Gift}}Thank you for the lovely {{.}}.
{{end}}
Best wishes,
Josie
`

// Prepare some data to insert into the template.
type Recipient struct {
    Name, Gift string
    Attended   bool
}
var recipients = []Recipient{
    {"Aunt Mildred", "bone china tea set", true},
    {"Uncle John", "moleskin pants", false},
    {"Cousin Rodney", "", false},
}

// Create a new template and parse the letter into it.
t := template.Must(template.New("letter").Parse(letter))

// Execute the template for each recipient.
for _, r := range recipients {
    err := t.Execute(os.Stdout, r)
    if err != nil {
        log.Println("executing template:", err)
    }
}

咱们能够发现一些特色：

{{.Name}}这样的pipeline（官方学名）必定能在结构体中找到这个名字
可使用if和with作流程处理

因而把咱们的目标代码，能够制做成定制化的模版！

建立一个用于存放模版定义的文件,template_code.go

package templates

const Main_tmpl = `package main

import (
    "fmt"
    "log"
    "os"

    "gosol/contracts"
    "io/ioutil"
    "math/big"
    "strings"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethclient"
)

var testclient *ethclient.Client

func init() {
    cli, err := CreateCli("{{.Connstr}}")
    if err != nil {
        log.Panic("failed to connect to eth", err)
    }
    testclient = cli
}

func GetFileName(address, dirname string) (string, error) {

    data, err := ioutil.ReadDir(dirname)
    if err != nil {
        fmt.Println("read dir err", err)
        return "", err
    }
    for _, v := range data {
        if strings.Index(v.Name(), address) > 0 {
            //表明找到文件
            return v.Name(), nil
        }
    }

    return "", nil
}

//建立连接
func CreateCli(connstr string) (*ethclient.Client, error) {
    cli, err := ethclient.Dial(connstr)
    if err != nil {
        fmt.Println("failed to dial provide", err)
        return nil, err
    }
    return cli, err
}

//设置签名
func MakeAuth(addr, pass string) (*bind.TransactOpts, error) {
    keystorePath  :=  "{{.Keydir}}"
    fileName, err := GetFileName(string([]rune(addr)[2:]), keystorePath)
    if err != nil {
        fmt.Println("failed to GetFileName", err)
        return nil, err
    }

    file, err := os.Open(keystorePath + "/" + fileName)
    if err != nil {
        fmt.Println("failed to open file ", err)
        return nil, err
    }
    auth, err := bind.NewTransactor(file, pass)
    if err != nil {
        fmt.Println("failed to NewTransactor  ", err)
        return nil, err
    }
    return auth, err
}
`

const Deploy_sol_tmpl = `
func Deploy{{.ContractName}}() (common.Address, error) {
    auth, err := MakeAuth("{{.FromAddr}}", "{{.Pass}}")
    if err != nil {
        fmt.Println("failed to makeAuth", err)
        return common.HexToAddress(""), err
    }

    //common.Address, *types.Transaction, *Pdbank, error
    contractaddr, ts, _, err := contracts.{{.CallFunc}}
    if err != nil {
        fmt.Println("failed to deloy ",err)
        return common.HexToAddress(""), err
    }
    fmt.Println(ts.ChainId(), ts.Hash().Hex(), ts.Nonce())
    fmt.Println(contractaddr.Hex())
    return contractaddr, err
}

`

先搞定部署合约代码自动生成部分！

//1. 写到哪
    outfile, err := os.OpenFile("build/solcall.go", os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666)
    if err != nil {
        fmt.Println("failed to open file", err)
        return err
    }
    defer outfile.Close()
    //2. 写什么
    _, err = outfile.WriteString(test_main_temp)
    if err != nil {
        fmt.Println("failed to write ", err)
        return err
    }
    // 读取abi文件信息
    abiInfos, err := readAbi("contracts/pdbank.abi")
    if err != nil {
        fmt.Println("failed to read abi", err)
        return err
    }
    //fmt.Println(infos)

    //3. 写入部署合约代码
    //定义部署模版
    deploy_temp, err := template.New("deploy").Parse(test_deploy_temp)
    if err != nil {
        fmt.Println("failed to template deploy", err)
        return err
    }
    var deploy_data DeployContractParams
    deploy_data.DeployName = "DeployPdbank"
    
    for _, v := range abiInfos {
        v.Name = strings.Title(v.Name) //标题优化，首字母大写, hello world - > Hello World
        if v.Type == "constructor" {
            // 若是是构造函数-部署函数
            deploy_data.DeployParams = "(auth,testClient"
            for _, vv := range v.Inputs {
                //须要根据输入数据类型来判断如何处理:string,address,uint256
                if vv.Type == "address" {
                    deploy_data.DeployParams += ",common.HexToAddress(\"0xD55E88D9156355C584982Db2C96dD1C2c63788C2\")"
                } else if vv.Type == "uint256" {
                    deploy_data.DeployParams += ",big.NewInt(1000)"
                } else if vv.Type == "string" {
                    deploy_data.DeployParams += ",\"yekai\""
                }

            }
            deploy_data.DeployParams += ")"
            //模版的执行
            err = deploy_temp.Execute(outfile, &deploy_data)
            if err != nil {
                fmt.Println("failed to template Execute ", err)
                return err
            }
        }
    }

接下来的代码仍是相同的套路。
完整代码以下；

//temp_org.go
package templates

const test_main_temp = `
package main

import (
    "fmt"
    "gosolkit/contracts"
    "io/ioutil"
    "log"
    "math/big"
    "os"
    "strings"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

var testClient *ethclient.Client

func init() {
    cli, err := Connect("http://localhost:8545")
    if err != nil {
        log.Fatalln("failed to connect to eth", err)
    }
    testClient = cli
}

func Connect(connstr string) (*ethclient.Client, error) {
    return ethclient.Dial(connstr)
}

//签名函数
func MakeAuth(addr, pass string) (*bind.TransactOpts, error) {
    //1. 根据addr找到keystore目录下的文件
    keyDir := "/Users/yk/ethdev/data/keystore"
    infos, err := ioutil.ReadDir(keyDir)
    if err != nil {
        fmt.Println("failed to readdir", err)
        return nil, err
    }
    //UTC--2019-03-16T13-00-48.032030904Z--791443d21a76e16cc510b6b1684344d2a5ce751c
    //0x791443d21a76e16cc510b6b1684344d2a5ce751c
    strAddr := ([]rune(addr))[2:]
    for _, v := range infos {
        strVname := []rune(v.Name())
        if len(strVname) > len(strAddr) {
            strVname2 := strVname[len(strVname)-len(strAddr):]
            if strings.EqualFold(string(strAddr), string(strVname2)) {
                //找到了匹配的文件
                //fmt.Println(addr, v.Name())
                //2. 作签名
                reader, err := os.Open(keyDir + "/" + v.Name())
                if err != nil {
                    fmt.Println("failed to open file", err)
                    return nil, err
                }
                defer reader.Close()
                auth, err := bind.NewTransactor(reader, pass)
                if err != nil {
                    fmt.Println("failed to NewTransactor auth", err)
                    return nil, err
                }
                return auth, err
            }
        }
    }

    return nil, nil
}
`
const test_deploy_temp = `
func CallDeploy() error {
    //建立身份,须要私钥= pass+keystore文件
    auth, err := MakeAuth("0x791443d21a76e16cc510b6b1684344d2a5ce751c", "123")
    if err != nil {
        fmt.Println("failed to MakeAuth auth", err)
        return err
    }
    addr, ts, _, err := contracts.{{.DeployName}}{{.DeployParams}}
    if err != nil {
        fmt.Println("failed to DeployPdbank", err)
        return err
    }

    fmt.Println("addr=", addr.Hex(), "hash=", ts.Hash().Hex())
    return err
}
`

const test_nogas_temp = `
func Call{{.FuncName}}() error {

    //使用以前部署获得的合约地址
    instance, err := contracts.{{.NewContractName}}(common.HexToAddress("0xD55E88D9156355C584982Db2C96dD1C2c63788C2"), testClient)
    if err != nil {
        fmt.Println("failed to instance contract", err)
        return err
    }
    //调用合约函数
    {{.OutParams}} := instance.{{.FuncName}}{{.InputParams}}
    fmt.Println({{.OutParams}})

    return err
}
`

const test_gas_temp = `
func Call{{.FuncName}}() error {

    //2. 构造函数入口 - 合约对象
    instance, err := contracts.{{.NewContractName}}(common.HexToAddress("0xD55E88D9156355C584982Db2C96dD1C2c63788C2"), testClient)
    if err != nil {
        fmt.Println("failed to contract instance", err)
        return err
    }
    //3. 设置签名
    auth, err := MakeAuth("0x791443d21a76e16cc510b6b1684344d2a5ce751c", "123")
    if err != nil {
        fmt.Println("failed to MakeAuth auth", err)
        return err
    }
    //4. 函数调用
    auth.Value = big.NewInt(0)
    ts, err := instance.{{.FuncName}}{{.InputParams}}
    if err != nil {
        fmt.Println("failed to Deposit ", err)
        return err
    }
    fmt.Println(ts.Hash().Hex())
    return err
}
`

//temp_main.go
package templates

const test_run_main_temp = `
package main
import (
    "fmt"
    "os"
)
var funcNames = []string{%s}
`

//1. 提供一个命令行帮助
const test_build_main_temp = `
func Usage() {
    fmt.Printf("%s 1 -- deploy\n", os.Args[0])
    num := 2
    for _, v := range funcNames {
        fmt.Printf("%s %d -- %s\n", os.Args[0], num, v)
        num++
    }
}
func main() {
    if len(os.Args) < 2 {
        Usage()
        os.Exit(0)
    }
    if os.Args[1] == "1" {
        CallDeploy()
    }{{range.}} else if os.Args[1] == "{{.Num}}" {
        Call{{.FuncName}}()
    } {{end}}
}
`

//temp_impl.go
package templates

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
    "strings"
    "text/template"
)

type DeployContractParams struct {
    DeployName   string
    DeployParams string
}

//无gas函数调用
type FuncNoGasParams struct {
    FuncName        string
    NewContractName string
    OutParams       string
    InputParams     string
}

//有gas函数调用
type FuncGasParams struct {
    FuncName        string
    NewContractName string
    InputParams     string
}

type InputsOutPuts struct {
    Name string
    Type string
}

type FuncInfo struct {
    FuncName string
    Num      int
}

type AbiInfo struct {
    Constant        bool
    Inputs          []InputsOutPuts
    Name            string
    Outputs         []InputsOutPuts
    Payable         bool
    StateMutability string
    Type            string
}

func readAbi(abifile string) ([]AbiInfo, error) {
    file, err := os.Open(abifile)
    if err != nil {
        fmt.Println("failed to open file ", err)
        return nil, err
    }
    data, err := ioutil.ReadAll(file)
    if err != nil {
        fmt.Println("failed to read abi", err)
        return nil, err
    }
    var abiInfos []AbiInfo
    strdata := strings.Replace(string(data), "\\", "", -1)
    err = json.Unmarshal([]byte(strdata), &abiInfos)
    if err != nil {
        fmt.Println("failed to Unmarshal abi", err)
        return nil, err
    }
    return abiInfos, err
}

func Impl_run_code() error {
    //1. 写到哪
    outfile, err := os.OpenFile("build/solcall.go", os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666)
    if err != nil {
        fmt.Println("failed to open file", err)
        return err
    }
    defer outfile.Close()
    //2. 写什么
    _, err = outfile.WriteString(test_main_temp)
    if err != nil {
        fmt.Println("failed to write ", err)
        return err
    }
    // 读取abi文件信息
    abiInfos, err := readAbi("contracts/pdbank.abi")
    if err != nil {
        fmt.Println("failed to read abi", err)
        return err
    }
    //fmt.Println(infos)

    //3. 写入部署合约代码
    //定义部署模版
    deploy_temp, err := template.New("deploy").Parse(test_deploy_temp)
    if err != nil {
        fmt.Println("failed to template deploy", err)
        return err
    }
    var deploy_data DeployContractParams
    deploy_data.DeployName = "DeployPdbank"

    //定义nogas函数的模版
    nogas_temp, err := template.New("nogas").Parse(test_nogas_temp)
    if err != nil {
        fmt.Println("failed to template nogas_temp", err)
        return err
    }

    var func_nogas_data FuncNoGasParams
    func_nogas_data.NewContractName = "NewPdbank"

    //定义有gas模版
    hasgas_temp, err := template.New("hasgas").Parse(test_gas_temp)
    if err != nil {
        fmt.Println("failed to template hasgas_temp", err)
        return err
    }

    var func_gas_data FuncGasParams
    func_gas_data.NewContractName = "NewPdbank"

    //对abi进行遍历处理
    for _, v := range abiInfos {
        v.Name = strings.Title(v.Name) //标题优化，首字母大写, hello world - > Hello World
        if v.Type == "constructor" {
            // 若是是构造函数-部署函数
            deploy_data.DeployParams = "(auth,testClient"
            for _, vv := range v.Inputs {
                //须要根据输入数据类型来判断如何处理:string,address,uint256
                if vv.Type == "address" {
                    deploy_data.DeployParams += ",common.HexToAddress(\"0xD55E88D9156355C584982Db2C96dD1C2c63788C2\")"
                } else if vv.Type == "uint256" {
                    deploy_data.DeployParams += ",big.NewInt(1000)"
                } else if vv.Type == "string" {
                    deploy_data.DeployParams += ",\"yekai\""
                }

            }
            deploy_data.DeployParams += ")"
            //模版的执行
            err = deploy_temp.Execute(outfile, &deploy_data)
            if err != nil {
                fmt.Println("failed to template Execute ", err)
                return err
            }
        } else {
            //处理其余函数
            if len(v.Outputs) > 0 {
                //不须要gas函数
                func_nogas_data.FuncName = v.Name

                func_nogas_data.InputParams = "(nil"
                for _, vv := range v.Inputs {
                    //须要根据输入数据类型来判断如何处理:string,address,uint256
                    if vv.Type == "address" {
                        func_nogas_data.InputParams += ",common.HexToAddress(\"0xD55E88D9156355C584982Db2C96dD1C2c63788C2\")"
                    } else if vv.Type == "uint256" {
                        func_nogas_data.InputParams += ",big.NewInt(1000)"
                    } else if vv.Type == "string" {
                        func_nogas_data.InputParams += ",\"yekai\""
                    }

                }
                func_nogas_data.InputParams += ")"
                //输入参数
                num := 0
                strOutPuts := ""
                for _, _ = range v.Outputs {
                    strOutPuts = fmt.Sprintf("%sdata%d,", strOutPuts, num)
                    num++
                }
                strOutPuts += "err"
                func_nogas_data.OutParams = strOutPuts

                //模版的执行
                err = nogas_temp.Execute(outfile, &func_nogas_data)
                if err != nil {
                    fmt.Println("failed to template nogas Execute ", err)
                    return err
                }
            } else {
                //须要消耗gas
                func_gas_data.FuncName = v.Name
                func_gas_data.InputParams = "(auth"
                for _, vv := range v.Inputs {
                    //须要根据输入数据类型来判断如何处理:string,address,uint256
                    if vv.Type == "address" {
                        func_gas_data.InputParams += ",common.HexToAddress(\"0xD55E88D9156355C584982Db2C96dD1C2c63788C2\")"
                    } else if vv.Type == "uint256" {
                        func_gas_data.InputParams += ",big.NewInt(1000)"
                    } else if vv.Type == "string" {
                        func_gas_data.InputParams += ",\"yekai\""
                    }

                }
                func_gas_data.InputParams += ")"
                //模版的执行
                err = hasgas_temp.Execute(outfile, &func_gas_data)
                if err != nil {
                    fmt.Println("failed to template hasgas Execute ", err)
                    return err
                }
            }
        }
    }

    return nil
}

func Impl_main_code() error {
    //1. 写到哪
    outfile, err := os.OpenFile("build/main.go", os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666)
    if err != nil {
        fmt.Println("failed to open file", err)
        return err
    }
    defer outfile.Close()
    // 读取abi文件信息
    abiInfos, err := readAbi("contracts/pdbank.abi")
    if err != nil {
        fmt.Println("failed to read abi", err)
        return err
    }
    funcNames := ""
    //"abc","def","
    num := 0
    var funcInfos []FuncInfo
    var funcInfo FuncInfo
    // 2- 第一个函数
    for _, v := range abiInfos {
        if v.Type != "constructor" {
            if num == 0 {
                //第一个
                funcNames += fmt.Sprintf(`"%s"`, v.Name)
            } else {
                funcNames += fmt.Sprintf(`,"%s"`, v.Name)
            }
            num++
            funcInfo.FuncName = strings.Title(v.Name)
            funcInfo.Num = num + 1
            funcInfos = append(funcInfos, funcInfo)
        }
    }
    main_str1 := fmt.Sprintf(test_run_main_temp, funcNames)
    _, err = outfile.WriteString(main_str1)
    if err != nil {
        fmt.Println("failed to write to main.go", err)
        return err
    }

    //创建一个模版，输出内容
    main_temp, err := template.New("main").Parse(test_build_main_temp)
    if err != nil {
        fmt.Println("failed to template main", err)
        return err
    }
    err = main_temp.Execute(outfile, funcInfos)
    if err != nil {
        fmt.Println("failed to Execute main", err)
        return err
    }
    return err
}

func Run() {
    Impl_run_code()
    Impl_main_code()
}

在main函数内增长此部分调用

package main

import (
    "fmt"
    "gosolkit/templates"
    "os"
)

func Usage() {
    fmt.Printf("%s 1  -- compiler code\n", os.Args[0])
    fmt.Printf("%s 2  -- build test code\n", os.Args[0])
}

func main() {
    if len(os.Args) < 2 {
        Usage()
        os.Exit(0)
    }
    if os.Args[1] == "1" {
        CompilerRun()
    } else if os.Args[1] == "2" {
        //build test code
        templates.Run()
    } else {
        Usage()
        os.Exit(0)
    }

}

若是以为代码看着太累，能够来看视频教程

Go语言打造以太坊智能合约开发框架