fix build

plugin/dapp/paracross/executor/action.go

@@ -113,7 +113,7 @@ func makeCommitReceipt(addr string, commit *pt.ParacrossCommitAction, prev, curr
 	return &types.Receipt{
 		Ty: types.ExecOk,
 		KV: []*types.KeyValue{
-			{key, types.Encode(current)},
+			{Key: key, Value: types.Encode(current)},
 		},
 		Logs: []*types.ReceiptLog{
 			{
@@ -163,7 +163,7 @@ func makeDoneReceipt(addr string, commit *pt.ParacrossCommitAction, current *pt.
 	return &types.Receipt{
 		Ty: types.ExecOk,
 		KV: []*types.KeyValue{
-			{key, types.Encode(stat)},
+			{Key: key, Value: types.Encode(stat)},
 		},
 		Logs: []*types.ReceiptLog{
 			{

plugin/dapp/privacy/rpc/rpc.go

@@ -92,7 +92,7 @@ func (c *Jrpc) ShowPrivacyAccountInfo(in *pty.ReqPPrivacyAccount, result *json.R
 	if err != nil {
 		return err
 	}
-	*result, err = types.PBToJson(reply)
+	*result, err = types.PBToJSON(reply)
 	return err
 }
 
@@ -108,7 +108,7 @@ func (c *Jrpc) ShowPrivacyAccountSpend(in *pty.ReqPrivBal4AddrToken, result *jso
 		log.Info("ShowPrivacyAccountSpend", "return err info", err)
 		return err
 	}
-	*result, err = types.PBToJson(reply)
+	*result, err = types.PBToJSON(reply)
 	return err
 }
 
@@ -118,7 +118,7 @@ func (c *Jrpc) ShowPrivacykey(in *types.ReqString, result *json.RawMessage) erro
 	if err != nil {
 		return err
 	}
-	*result, err = types.PBToJson(reply)
+	*result, err = types.PBToJSON(reply)
 	return err
 }
 
@@ -192,7 +192,7 @@ func (c *Jrpc) RescanUtxos(in *pty.ReqRescanUtxos, result *json.RawMessage) erro
 	if err != nil {
 		return err
 	}
-	*result, err = types.PBToJson(reply)
+	*result, err = types.PBToJSON(reply)
 	return err
 }
 
@@ -202,7 +202,7 @@ func (c *Jrpc) EnablePrivacy(in *pty.ReqEnablePrivacy, result *json.RawMessage)
 	if err != nil {
 		return err
 	}
-	*result, err = types.PBToJson(reply)
+	*result, err = types.PBToJSON(reply)
 	return err
 }
 

plugin/dapp/privacy/types/jsonout.go

-// Copyright Fuzamei Corp. 2018 All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-/*
-func buildPrivacyInputResult(l *rpctypes.ReceiptLogResult) interface{} {
-	data, _ := common.FromHex(l.RawLog)
-	srcInput := &pty.PrivacyInput{}
-	dstInput := &PrivacyInput{}
-	if proto.Unmarshal(data, srcInput) != nil {
-		return dstInput
-	}
-	for _, srcKeyInput := range srcInput.Keyinput {
-		var dstUtxoGlobalIndex []*UTXOGlobalIndex
-		for _, srcUTXOGlobalIndex := range srcKeyInput.UtxoGlobalIndex {
-			dstUtxoGlobalIndex = append(dstUtxoGlobalIndex, &UTXOGlobalIndex{
-				Outindex: srcUTXOGlobalIndex.GetOutindex(),
-				Txhash:   common.ToHex(srcUTXOGlobalIndex.GetTxhash()),
-			})
-		}
-		dstKeyInput := &KeyInput{
-			Amount:          strconv.FormatFloat(float64(srcKeyInput.GetAmount())/float64(types.Coin), 'f', 4, 64),
-			UtxoGlobalIndex: dstUtxoGlobalIndex,
-			KeyImage:        common.ToHex(srcKeyInput.GetKeyImage()),
-		}
-		dstInput.Keyinput = append(dstInput.Keyinput, dstKeyInput)
-	}
-	return dstInput
-}
-
-func buildPrivacyOutputResult(l *rpctypes.ReceiptLogResult) interface{} {
-	data, _ := common.FromHex(l.RawLog)
-	srcOutput := &pty.ReceiptPrivacyOutput{}
-	dstOutput := &ReceiptPrivacyOutput{}
-	if proto.Unmarshal(data, srcOutput) != nil {
-		return dstOutput
-	}
-	dstOutput.Token = srcOutput.Token
-	for _, srcKeyoutput := range srcOutput.Keyoutput {
-		dstKeyoutput := &KeyOutput{
-			Amount:        strconv.FormatFloat(float64(srcKeyoutput.GetAmount())/float64(types.Coin), 'f', 4, 64),
-			Onetimepubkey: common.ToHex(srcKeyoutput.Onetimepubkey),
-		}
-		dstOutput.Keyoutput = append(dstOutput.Keyoutput, dstKeyoutput)
-	}
-	return dstOutput
-}
-
-func decodePrivInput(input *pty.PrivacyInput) *PrivacyInput {
-	inputResult := &PrivacyInput{}
-	for _, value := range input.Keyinput {
-		amt := float64(value.Amount) / float64(types.Coin)
-		amtResult := strconv.FormatFloat(amt, 'f', 4, 64)
-		var ugis []*UTXOGlobalIndex
-		for _, u := range value.UtxoGlobalIndex {
-			ugis = append(ugis, &UTXOGlobalIndex{Outindex: u.Outindex, Txhash: common.ToHex(u.Txhash)})
-		}
-		kin := &KeyInput{
-			Amount:          amtResult,
-			KeyImage:        common.ToHex(value.KeyImage),
-			UtxoGlobalIndex: ugis,
-		}
-		inputResult.Keyinput = append(inputResult.Keyinput, kin)
-	}
-	return inputResult
-}
-
-func decodePrivOutput(output *pty.PrivacyOutput) *PrivacyOutput {
-	outputResult := &PrivacyOutput{RpubKeytx: common.ToHex(output.RpubKeytx)}
-	for _, value := range output.Keyoutput {
-		amt := float64(value.Amount) / float64(types.Coin)
-		amtResult := strconv.FormatFloat(amt, 'f', 4, 64)
-		kout := &KeyOutput{
-			Amount:        amtResult,
-			Onetimepubkey: common.ToHex(value.Onetimepubkey),
-		}
-		outputResult.Keyoutput = append(outputResult.Keyoutput, kout)
-	}
-	return outputResult
-}
-*/

plugin/dapp/privacy/wallet/privacy.go

@@ -177,7 +177,7 @@ func (policy *privacyPolicy) createUTXOsByPub2Priv(priv crypto.PrivKey, reqCreat
 		To:      address.ExecAddress(privacytypes.PrivacyX),
 	}
 	txSize := types.Size(tx) + types.SignatureSize
-	realFee := int64((txSize+1023)>>types.Size_1K_shiftlen) * types.GInt("MinFee")
+	realFee := int64((txSize+1023)>>types.Size1Kshiftlen) * types.GInt("MinFee")
 	tx.Fee = realFee
 	tx.Sign(int32(operater.GetSignType()), priv)
 
@@ -610,7 +610,7 @@ func (policy *privacyPolicy) createPublic2PrivacyTx(req *types.ReqCreateTransact
 	}
 
 	txSize := types.Size(tx) + types.SignatureSize
-	realFee := int64((txSize+1023)>>types.Size_1K_shiftlen) * types.GInt("MinFee")
+	realFee := int64((txSize+1023)>>types.Size1Kshiftlen) * types.GInt("MinFee")
 	tx.Fee = realFee
 	return tx, nil
 }
@@ -1024,7 +1024,7 @@ func (policy *privacyPolicy) transPub2PriV2(priv crypto.PrivKey, reqPub2Pri *pri
 	}
 	tx.SetExpire(time.Duration(reqPub2Pri.GetExpire()))
 	txSize := types.Size(tx) + types.SignatureSize
-	realFee := int64((txSize+1023)>>types.Size_1K_shiftlen) * types.GInt("MinFee")
+	realFee := int64((txSize+1023)>>types.Size1Kshiftlen) * types.GInt("MinFee")
 	tx.Fee = realFee
 	tx.Sign(int32(operater.GetSignType()), priv)
 

vendor/github.com/33cn/chain33/CHANGELOG.md

+# Changelog
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+## [6.0.1]
+### Changed
+- Update configuration files from p2p/verMix to p2p/verMin from[@libangzhu](https://github.com/libangzhu).
+- Update p2p version Logic(if you do not fill in the range of p2p version,then verMin=version,verMax=verMin+1) from[@libangzhu](https://github.com/libangzhu).
+
+
+

vendor/github.com/33cn/chain33/blockchain/pushseq.go

+package blockchain
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io/ioutil"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/33cn/chain33/types"
+)
+
+type pushNotify struct {
+	cb  chan *types.BlockSeqCB
+	seq chan int64
+}
+
+//push seq data to out
+type pushseq struct {
+	store  *BlockStore
+	cmds   map[string]pushNotify
+	mu     sync.Mutex
+	client *http.Client
+}
+
+func newpushseq(store *BlockStore) *pushseq {
+	cmds := make(map[string]pushNotify)
+	return &pushseq{store: store, cmds: cmds, client: &http.Client{}}
+}
+
+//初始化: 从数据库读出seq的数目
+func (p *pushseq) init() {
+	cbs, err := p.store.listSeqCB()
+	if err != nil {
+		chainlog.Error("listSeqCB", "err", err)
+		return
+	}
+	for _, cb := range cbs {
+		p.addTask(cb)
+	}
+}
+
+func (p *pushseq) updateLastSeq() {
+	last, err := p.store.LoadBlockLastSequence()
+	if err != nil {
+		chainlog.Error("listSeqCB", "err", err)
+		return
+	}
+	p.updateSeq(last)
+}
+
+//每个name 有一个task
+func (p *pushseq) addTask(cb *types.BlockSeqCB) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if notify, ok := p.cmds[cb.Name]; ok {
+		notify.cb <- cb
+		if cb.URL == "" {
+			delete(p.cmds, cb.Name)
+		}
+		return
+	}
+	p.cmds[cb.Name] = pushNotify{
+		cb:  make(chan *types.BlockSeqCB, 10),
+		seq: make(chan int64, 10),
+	}
+	p.cmds[cb.Name].cb <- cb
+	p.runTask(p.cmds[cb.Name])
+	//更新最新的seq
+	p.updateLastSeq()
+}
+
+func (p *pushseq) updateSeq(seq int64) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	for _, notify := range p.cmds {
+		notify.seq <- seq
+	}
+}
+
+func (p *pushseq) trigeRun(run chan struct{}, sleep time.Duration) {
+	go func() {
+		if sleep > 0 {
+			time.Sleep(sleep)
+		}
+		select {
+		case run <- struct{}{}:
+		default:
+		}
+	}()
+}
+
+func (p *pushseq) runTask(input pushNotify) {
+	go func(in pushNotify) {
+		var lastseq int64 = -1
+		var maxseq int64 = -1
+		var cb *types.BlockSeqCB
+		var run = make(chan struct{}, 10)
+		for {
+			select {
+			case cb = <-in.cb:
+				if cb.URL == "" {
+					return
+				}
+				p.trigeRun(run, 0)
+			case maxseq = <-in.seq:
+				p.trigeRun(run, 0)
+			case <-run:
+				if cb == nil {
+					p.trigeRun(run, time.Second)
+					continue
+				}
+				if lastseq == -1 {
+					lastseq = p.store.getSeqCBLastNum([]byte(cb.Name))
+				}
+				if lastseq >= maxseq {
+					p.trigeRun(run, 100*time.Millisecond)
+					continue
+				}
+				data, err := p.getDataBySeq(lastseq + 1)
+				if err != nil {
+					chainlog.Error("getDataBySeq", "err", err)
+					p.trigeRun(run, 1000*time.Millisecond)
+					continue
+				}
+				err = p.postData(cb, data)
+				if err != nil {
+					chainlog.Error("postdata", "err", err)
+					//sleep 10s
+					p.trigeRun(run, 10000*time.Millisecond)
+					continue
+				}
+				//update seqid
+				lastseq = lastseq + 1
+				p.trigeRun(run, 0)
+			}
+		}
+	}(input)
+}
+
+func (p *pushseq) postData(cb *types.BlockSeqCB, data *types.BlockSeq) (err error) {
+	var postdata []byte
+	if cb.Encode == "json" {
+		postdata, err = types.PBToJSON(data)
+		if err != nil {
+			return err
+		}
+	} else {
+		postdata = types.Encode(data)
+	}
+	//post data in body
+	var buf bytes.Buffer
+	g := gzip.NewWriter(&buf)
+	if _, err = g.Write(postdata); err != nil {
+		return err
+	}
+	if err = g.Close(); err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest("POST", cb.URL, &buf)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "text/plain")
+	req.Header.Set("Content-Encoding", "gzip")
+	resp, err := p.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	if string(body) != "ok" && string(body) != "OK" {
+		return types.ErrPushSeqPostData
+	}
+	p.store.setSeqCBLastNum([]byte(cb.Name), data.Num)
+	return nil
+}
+
+func (p *pushseq) getDataBySeq(seq int64) (*types.BlockSeq, error) {
+	seqdata, err := p.store.GetBlockSequence(seq)
+	if err != nil {
+		return nil, err
+	}
+	detail, err := p.store.LoadBlockBySequence(seq)
+	if err != nil {
+		return nil, err
+	}
+	return &types.BlockSeq{Num: seq, Seq: seqdata, Detail: detail}, nil
+}

vendor/github.com/33cn/chain33/build/util/token.cnyy.sh

+#!/usr/bin/env bash
+percreate="$(../chain33-cli token precreate -s CNYY -n "CNY Coins" -i "" -p 0.000001 -t 1000000000 -a 1MY4pMgjpS2vWiaSDZasRhN47pcwEire32 -f 0.001)"
+finish="$(../chain33-cli token finish -f 0.001 -a 1MY4pMgjpS2vWiaSDZasRhN47pcwEire32 -s CNYY)"
+echo "cli wallet sign -d $percreate -a 1JmFaA6unrCFYEWPGRi7uuXY1KthTJxJEP  -e 1h > d:/a.txt"
+echo "cli wallet sign -d $finish -a 1JmFaA6unrCFYEWPGRi7uuXY1KthTJxJEP -e 1h >> d:/a.txt"

vendor/github.com/33cn/chain33/cmd/tools/strategy/createplugin.go

+//Copyright Fuzamei Corp. 2018 All Rights Reserved.
+//Use of this source code is governed by a BSD-style
+//license that can be found in the LICENSE file.
+
+package strategy
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/33cn/chain33/util"
+
+	"github.com/33cn/chain33/cmd/tools/tasks"
+	"github.com/33cn/chain33/cmd/tools/types"
+	"github.com/pkg/errors"
+)
+
+// createPluginStrategy 根據模板配置文件，創建一個完整的項目工程
+type createPluginStrategy struct {
+	strategyBasic
+
+	gopath          string
+	projName        string // 项目名称
+	execName        string // 项目中实现的执行器名称
+	execNameFB      string
+	className       string
+	classTypeName   string
+	classActionName string
+	outRootPath     string // 项目生成的根目录
+	projectPath     string // 生成的项目路径,是绝对路径
+
+}
+
+func (c *createPluginStrategy) Run() error {
+	fmt.Println("Begin run chain33 create plugin project mode.")
+	defer fmt.Println("Run chain33 create plugin project mode finish.")
+	if err := c.initMember(); err != nil {
+		return err
+	}
+	return c.rumImpl()
+}
+
+func (c *createPluginStrategy) initMember() error {
+	gopath := os.Getenv("GOPATH")
+	if len(gopath) <= 0 {
+		return errors.New("Can't find GOPATH")
+	}
+	c.gopath = gopath
+	c.outRootPath = filepath.Join(gopath, "/src/github.com/33cn")
+	c.projName, _ = c.getParam(types.KeyProjectName)
+	c.execName, _ = c.getParam(types.KeyExecutorName)
+	c.className, _ = c.getParam(types.KeyClassName)
+	c.projectPath = fmt.Sprintf("%s/%s", c.outRootPath, c.projName)
+	c.execNameFB, _ = util.MakeStringToUpper(c.execName, 0, 1)
+	c.classTypeName = c.execNameFB + "Type"
+	c.classActionName = c.execNameFB + "Action"
+	return nil
+}
+
+func (c *createPluginStrategy) rumImpl() error {
+	var err error
+	tasks := c.buildTask()
+	for _, task := range tasks {
+		err = task.Execute()
+		if err != nil {
+			mlog.Error("Execute command failed.", "error", err, "taskname", task.GetName())
+			break
+		}
+	}
+	return err
+}
+
+func (c *createPluginStrategy) buildTask() []tasks.Task {
+	// 获取项目相对于gopath/src中的目录路径
+	goprojpath := strings.Replace(c.projectPath, c.gopath+"/src/", "", -1)
+	taskSlice := make([]tasks.Task, 0)
+	taskSlice = append(taskSlice,
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_MAIN_GO,
+			OutputFile: fmt.Sprintf("%s/main.go", c.projectPath),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+				types.TagProjectPath: goprojpath,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_CFG_TOML,
+			OutputFile: fmt.Sprintf("%s/%s.toml", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:     CPFT_RUNMAIN,
+			BlockStrBegin: CPFT_RUNMAIN_BLOCK + "`",
+			BlockStrEnd:   "`",
+			OutputFile:    fmt.Sprintf("%s/%s.go", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_MAKEFILE,
+			OutputFile: fmt.Sprintf("%s/Makefile", c.projectPath),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+				types.TagProjectPath: goprojpath,
+				types.TagGoPath:      c.gopath,
+				types.TagExecName:    c.execName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_TRAVIS_YML,
+			OutputFile: fmt.Sprintf("%s/.travis.yml", c.projectPath),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_PLUGIN_TOML,
+			OutputFile: fmt.Sprintf("%s/plugin/plugin.toml", c.projectPath),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_CLI_MAIN,
+			OutputFile: fmt.Sprintf("%s/cli/main.go", c.projectPath),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+				types.TagProjectPath: goprojpath,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_DAPP_COMMANDS,
+			OutputFile: fmt.Sprintf("%s/plugin/dapp/%s/commands/cmd.go", c.projectPath, c.execName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_DAPP_PLUGIN,
+			OutputFile: fmt.Sprintf("%s/plugin/dapp/%s/plugin.go", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+				types.TagExecNameFB:  c.execNameFB,
+				types.TagProjectPath: goprojpath,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_DAPP_EXEC,
+			OutputFile: fmt.Sprintf("%s/plugin/dapp/%s/executor/%s.go", c.projectPath, c.projName, c.execName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagProjectName: c.projName,
+				types.TagExecName:    c.execName,
+				types.TagClassName:   c.className,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:       CPFT_DAPP_CREATEPB,
+			OutputFile:      fmt.Sprintf("%s/plugin/dapp/%s/proto/create_protobuf.sh", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:       CPFT_DAPP_MAKEFILE,
+			OutputFile:      fmt.Sprintf("%s/plugin/dapp/%s/proto/Makefile", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_DAPP_PROTO,
+			OutputFile: fmt.Sprintf("%s/plugin/dapp/%s/proto/%s.proto", c.projectPath, c.projName, c.execName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagActionName: c.classActionName,
+			},
+		},
+		&tasks.CreateFileFromStrTemplateTask{
+			SourceStr:  CPFT_DAPP_TYPEFILE,
+			OutputFile: fmt.Sprintf("%s/plugin/dapp/%s/types/types.go", c.projectPath, c.projName),
+			ReplaceKeyPairs: map[string]string{
+				types.TagExecNameFB:    c.execNameFB,
+				types.TagExecName:      c.execName,
+				types.TagClassTypeName: c.classTypeName,
+				types.TagActionName:    c.classActionName,
+			},
+		},
+		// 需要将所有的go文件格式化以下
+		&tasks.FormatDappSourceTask{
+			OutputFolder: fmt.Sprintf("%s/%s/", c.outRootPath, c.projName),
+		},
+	)
+	return taskSlice
+}

vendor/github.com/33cn/chain33/cmd/tools/tasks/create_file_from_str_template_task.go

+/*
+ * Copyright Fuzamei Corp. 2018 All Rights Reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+package tasks
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/33cn/chain33/util"
+)
+
+// CreateFileFromStrTemplateTask 从指定的模板字符串中创建目标文件的任务
+type CreateFileFromStrTemplateTask struct {
+	TaskBase
+	SourceStr       string
+	OutputFile      string
+	BlockStrBegin   string // Block会将SourceStr包含在内部
+	BlockStrEnd     string
+	ReplaceKeyPairs map[string]string
+	fileContent     string
+}
+
+//GetName 获取name
+func (c *CreateFileFromStrTemplateTask) GetName() string {
+	return "CreateFileFromStrTemplateTask"
+}
+
+//Execute 执行
+func (c *CreateFileFromStrTemplateTask) Execute() error {
+	if len(c.BlockStrBegin) > 0 && len(c.BlockStrEnd) > 0 {
+		c.SourceStr = fmt.Sprintf("%s%s%s", c.BlockStrBegin, c.SourceStr, c.BlockStrEnd)
+	}
+	c.fileContent = c.SourceStr
+	for key, value := range c.ReplaceKeyPairs {
+		c.fileContent = strings.Replace(c.fileContent, key, value, -1)
+	}
+	if err := util.MakeDir(c.OutputFile); err != nil {
+		return err
+	}
+	util.DeleteFile(c.OutputFile)
+	len, err := util.WriteStringToFile(c.OutputFile, c.fileContent)
+	if err == nil {
+		mlog.Info("Create file success.", "file", c.OutputFile, "file len", len)
+	} else {
+		mlog.Info("Create file falied.", "error", err)
+	}
+	return err
+}

vendor/github.com/33cn/chain33/golinter.sh

+#!/bin/bash
+# shellcheck disable=SC2207
+set +e
+
+OP="${1}"
+path="${2}"
+
+function filterLinter() {
+    res=$(gometalinter.v2 -t --sort=linter --enable-gc --deadline=2m --disable-all \
+        --enable=gofmt \
+        --enable=gosimple \
+        --enable=deadcode \
+        --enable=unconvert \
+        --enable=interfacer \
+        --enable=varcheck \
+        --enable=structcheck \
+        --enable=goimports \
+        --enable=misspell \
+        --vendor ./...)
+    #	    --enable=staticcheck \
+    #	    --enable=gocyclo \
+    #	    --enable=staticcheck \
+    #	    --enable=golint \
+    #	    --enable=unused \
+    #	    --enable=gotype \
+    #	    --enable=gotypex \
+
+    if [[ ${#res} -gt "0" ]]; then
+        resNoSpace=$(echo "${res}" | tr ' ' '@')
+        array=($(echo "${resNoSpace}" | tr '\n' '\n'))
+        str=""
+        for var in ${array[*]}; do
+            if ! [[ $var =~ "underscores" ]]; then
+                str="${str}""${var}""\\n"
+            fi
+        done
+        res=""
+        res=$(echo "${str}" | tr '@' ' ')
+    fi
+    if [[ ${#res} -gt "0" ]]; then
+        echo -e "${res}"
+        exit 1
+    fi
+}
+
+function testLinter() {
+    cd "${path}" >/dev/null || exit
+    gometalinter.v2 -t --sort=linter --enable-gc --deadline=2m --disable-all \
+        --enable=gofmt \
+        --enable=gosimple \
+        --enable=deadcode \
+        --enable=unconvert \
+        --enable=interfacer \
+        --enable=varcheck \
+        --enable=structcheck \
+        --enable=goimports \
+        --enable=vet \
+        --enable=golint \
+        --enable=ineffassign \
+        --vendor ./...
+    cd - >/dev/null || exit
+}
+
+function main() {
+    if [ "${OP}" == "filter" ]; then
+        filterLinter
+    elif [ "${OP}" == "test" ]; then
+        testLinter
+    fi
+}
+
+# run script
+main

vendor/github.com/33cn/chain33/wallet/walletbizpolicy.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of policy source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package wallet
+
+import (
+	"sync"
+
+	"github.com/33cn/chain33/common/crypto"
+	"github.com/33cn/chain33/common/db"
+	"github.com/33cn/chain33/types"
+	wcom "github.com/33cn/chain33/wallet/common"
+)
+
+const (
+	walletBizPolicyX = "walletBizPolicy"
+)
+
+func init() {
+	wcom.RegisterPolicy(walletBizPolicyX, newPolicy())
+}
+
+func newPolicy() wcom.WalletBizPolicy {
+	ret := &walletBizPlicy{
+		mtx: &sync.Mutex{},
+	}
+	return ret
+}
+
+// 默认的钱包业务实现
+type walletBizPlicy struct {
+	mtx           *sync.Mutex
+	walletOperate wcom.WalletOperate
+}
+
+func (policy *walletBizPlicy) Init(walletBiz wcom.WalletOperate, sub []byte) {
+	policy.setWalletOperate(walletBiz)
+}
+
+func (policy *walletBizPlicy) setWalletOperate(walletBiz wcom.WalletOperate) {
+	policy.mtx.Lock()
+	defer policy.mtx.Unlock()
+	policy.walletOperate = walletBiz
+}
+
+func (policy *walletBizPlicy) getWalletOperate() wcom.WalletOperate {
+	policy.mtx.Lock()
+	defer policy.mtx.Unlock()
+	return policy.walletOperate
+}
+
+func (policy *walletBizPlicy) OnAddBlockTx(block *types.BlockDetail, tx *types.Transaction, index int32, dbbatch db.Batch) *types.WalletTxDetail {
+	return nil
+}
+
+func (policy *walletBizPlicy) OnDeleteBlockTx(block *types.BlockDetail, tx *types.Transaction, index int32, dbbatch db.Batch) *types.WalletTxDetail {
+	return nil
+}
+
+func (policy *walletBizPlicy) SignTransaction(key crypto.PrivKey, req *types.ReqSignRawTx) (needSysSign bool, signtx string, err error) {
+	needSysSign = true
+	return
+}
+
+func (policy *walletBizPlicy) OnCreateNewAccount(acc *types.Account) {
+	wg := policy.getWalletOperate().GetWaitGroup()
+	wg.Add(1)
+	go policy.rescanReqTxDetailByAddr(acc.Addr, wg)
+}
+
+func (policy *walletBizPlicy) OnImportPrivateKey(acc *types.Account) {
+	wg := policy.getWalletOperate().GetWaitGroup()
+	wg.Add(1)
+	go policy.rescanReqTxDetailByAddr(acc.Addr, wg)
+}
+
+func (policy *walletBizPlicy) OnWalletLocked() {
+}
+
+func (policy *walletBizPlicy) OnWalletUnlocked(WalletUnLock *types.WalletUnLock) {
+}
+
+func (policy *walletBizPlicy) OnAddBlockFinish(block *types.BlockDetail) {
+}
+
+func (policy *walletBizPlicy) OnDeleteBlockFinish(block *types.BlockDetail) {
+}
+
+func (policy *walletBizPlicy) OnClose() {
+}
+
+func (policy *walletBizPlicy) OnSetQueueClient() {
+}
+
+func (policy *walletBizPlicy) Call(funName string, in types.Message) (ret types.Message, err error) {
+	err = types.ErrNotSupport
+	return
+}
+
+//从blockchain模块同步addr参与的所有交易详细信息
+func (policy *walletBizPlicy) rescanReqTxDetailByAddr(addr string, wg *sync.WaitGroup) {
+	defer wg.Done()
+	policy.reqTxDetailByAddr(addr)
+}
+
+//从blockchain模块同步addr参与的所有交易详细信息
+func (policy *walletBizPlicy) reqTxDetailByAddr(addr string) {
+	if len(addr) == 0 {
+		walletlog.Error("reqTxDetailByAddr input addr is nil!")
+		return
+	}
+	var txInfo types.ReplyTxInfo
+
+	i := 0
+	operater := policy.getWalletOperate()
+	for {
+		//首先从blockchain模块获取地址对应的所有交易hashs列表,从最新的交易开始获取
+		var ReqAddr types.ReqAddr
+		ReqAddr.Addr = addr
+		ReqAddr.Flag = 0
+		ReqAddr.Direction = 0
+		ReqAddr.Count = int32(MaxTxHashsPerTime)
+		if i == 0 {
+			ReqAddr.Height = -1
+			ReqAddr.Index = 0
+		} else {
+			ReqAddr.Height = txInfo.GetHeight()
+			ReqAddr.Index = txInfo.GetIndex()
+		}
+		i++
+		ReplyTxInfos, err := operater.GetAPI().GetTransactionByAddr(&ReqAddr)
+		if err != nil {
+			walletlog.Error("reqTxDetailByAddr", "GetTransactionByAddr error", err, "addr", addr)
+			return
+		}
+		if ReplyTxInfos == nil {
+			walletlog.Info("reqTxDetailByAddr ReplyTxInfos is nil")
+			return
+		}
+		txcount := len(ReplyTxInfos.TxInfos)
+
+		var ReqHashes types.ReqHashes
+		ReqHashes.Hashes = make([][]byte, len(ReplyTxInfos.TxInfos))
+		for index, ReplyTxInfo := range ReplyTxInfos.TxInfos {
+			ReqHashes.Hashes[index] = ReplyTxInfo.GetHash()
+			txInfo.Hash = ReplyTxInfo.GetHash()
+			txInfo.Height = ReplyTxInfo.GetHeight()
+			txInfo.Index = ReplyTxInfo.GetIndex()
+		}
+		operater.GetTxDetailByHashs(&ReqHashes)
+		if txcount < int(MaxTxHashsPerTime) {
+			return
+		}
+	}
+}

vendor/gopkg.in/go-playground/webhooks.v5/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2015 Dean Karn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/gopkg.in/go-playground/webhooks.v5/github/github.go

+package github
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+)
+
+// parse errors
+var (
+	ErrEventNotSpecifiedToParse  = errors.New("no Event specified to parse")
+	ErrInvalidHTTPMethod         = errors.New("invalid HTTP Method")
+	ErrMissingGithubEventHeader  = errors.New("missing X-GitHub-Event Header")
+	ErrMissingHubSignatureHeader = errors.New("missing X-Hub-Signature Header")
+	ErrEventNotFound             = errors.New("event not defined to be parsed")
+	ErrParsingPayload            = errors.New("error parsing payload")
+	ErrHMACVerificationFailed    = errors.New("HMAC verification failed")
+)
+
+// Event defines a GitHub hook event type
+type Event string
+
+// GitHub hook types
+const (
+	CommitCommentEvent            Event = "commit_comment"
+	CreateEvent                   Event = "create"
+	DeleteEvent                   Event = "delete"
+	DeploymentEvent               Event = "deployment"
+	DeploymentStatusEvent         Event = "deployment_status"
+	ForkEvent                     Event = "fork"
+	GollumEvent                   Event = "gollum"
+	InstallationEvent             Event = "installation"
+	IntegrationInstallationEvent  Event = "integration_installation"
+	IssueCommentEvent             Event = "issue_comment"
+	IssuesEvent                   Event = "issues"
+	LabelEvent                    Event = "label"
+	MemberEvent                   Event = "member"
+	MembershipEvent               Event = "membership"
+	MilestoneEvent                Event = "milestone"
+	OrganizationEvent             Event = "organization"
+	OrgBlockEvent                 Event = "org_block"
+	PageBuildEvent                Event = "page_build"
+	PingEvent                     Event = "ping"
+	ProjectCardEvent              Event = "project_card"
+	ProjectColumnEvent            Event = "project_column"
+	ProjectEvent                  Event = "project"
+	PublicEvent                   Event = "public"
+	PullRequestEvent              Event = "pull_request"
+	PullRequestReviewEvent        Event = "pull_request_review"
+	PullRequestReviewCommentEvent Event = "pull_request_review_comment"
+	PushEvent                     Event = "push"
+	ReleaseEvent                  Event = "release"
+	RepositoryEvent               Event = "repository"
+	StatusEvent                   Event = "status"
+	TeamEvent                     Event = "team"
+	TeamAddEvent                  Event = "team_add"
+	WatchEvent                    Event = "watch"
+)
+
+// EventSubtype defines a GitHub Hook Event subtype
+type EventSubtype string
+
+// GitHub hook event subtypes
+const (
+	NoSubtype     EventSubtype = ""
+	BranchSubtype EventSubtype = "branch"
+	TagSubtype    EventSubtype = "tag"
+	PullSubtype   EventSubtype = "pull"
+	IssueSubtype  EventSubtype = "issues"
+)
+
+// Option is a configuration option for the webhook
+type Option func(*Webhook) error
+
+// Options is a namespace var for configuration options
+var Options = WebhookOptions{}
+
+// WebhookOptions is a namespace for configuration option methods
+type WebhookOptions struct{}
+
+// Secret registers the GitHub secret
+func (WebhookOptions) Secret(secret string) Option {
+	return func(hook *Webhook) error {
+		hook.secret = secret
+		return nil
+	}
+}
+
+// Webhook instance contains all methods needed to process events
+type Webhook struct {
+	secret string
+}
+
+// New creates and returns a WebHook instance denoted by the Provider type
+func New(options ...Option) (*Webhook, error) {
+	hook := new(Webhook)
+	for _, opt := range options {
+		if err := opt(hook); err != nil {
+			return nil, errors.New("Error applying Option")
+		}
+	}
+	return hook, nil
+}
+
+// Parse verifies and parses the events specified and returns the payload object or an error
+func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {
+	defer func() {
+		_, _ = io.Copy(ioutil.Discard, r.Body)
+		_ = r.Body.Close()
+	}()
+
+	if len(events) == 0 {
+		return nil, ErrEventNotSpecifiedToParse
+	}
+	if r.Method != http.MethodPost {
+		return nil, ErrInvalidHTTPMethod
+	}
+
+	event := r.Header.Get("X-GitHub-Event")
+	if event == "" {
+		return nil, ErrMissingGithubEventHeader
+	}
+	gitHubEvent := Event(event)
+
+	var found bool
+	for _, evt := range events {
+		if evt == gitHubEvent {
+			found = true
+			break
+		}
+	}
+	// event not defined to be parsed
+	if !found {
+		return nil, ErrEventNotFound
+	}
+
+	payload, err := ioutil.ReadAll(r.Body)
+	if err != nil || len(payload) == 0 {
+		return nil, ErrParsingPayload
+	}
+
+	// If we have a Secret set, we should check the MAC
+	if len(hook.secret) > 0 {
+		signature := r.Header.Get("X-Hub-Signature")
+		if len(signature) == 0 {
+			return nil, ErrMissingHubSignatureHeader
+		}
+		mac := hmac.New(sha1.New, []byte(hook.secret))
+		_, _ = mac.Write(payload)
+		expectedMAC := hex.EncodeToString(mac.Sum(nil))
+
+		if !hmac.Equal([]byte(signature[5:]), []byte(expectedMAC)) {
+			return nil, ErrHMACVerificationFailed
+		}
+	}
+
+	switch gitHubEvent {
+	case CommitCommentEvent:
+		var pl CommitCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case CreateEvent:
+		var pl CreatePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case DeleteEvent:
+		var pl DeletePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case DeploymentEvent:
+		var pl DeploymentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case DeploymentStatusEvent:
+		var pl DeploymentStatusPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case ForkEvent:
+		var pl ForkPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case GollumEvent:
+		var pl GollumPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case InstallationEvent, IntegrationInstallationEvent:
+		var pl InstallationPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case IssueCommentEvent:
+		var pl IssueCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case IssuesEvent:
+		var pl IssuesPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case LabelEvent:
+		var pl LabelPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case MemberEvent:
+		var pl MemberPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case MembershipEvent:
+		var pl MembershipPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case MilestoneEvent:
+		var pl MilestonePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case OrganizationEvent:
+		var pl OrganizationPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case OrgBlockEvent:
+		var pl OrgBlockPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PageBuildEvent:
+		var pl PageBuildPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PingEvent:
+		var pl PingPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case ProjectCardEvent:
+		var pl ProjectCardPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case ProjectColumnEvent:
+		var pl ProjectColumnPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case ProjectEvent:
+		var pl ProjectPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PublicEvent:
+		var pl PublicPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PullRequestEvent:
+		var pl PullRequestPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PullRequestReviewEvent:
+		var pl PullRequestReviewPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PullRequestReviewCommentEvent:
+		var pl PullRequestReviewCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case PushEvent:
+		var pl PushPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case ReleaseEvent:
+		var pl ReleasePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case RepositoryEvent:
+		var pl RepositoryPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case StatusEvent:
+		var pl StatusPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case TeamEvent:
+		var pl TeamPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case TeamAddEvent:
+		var pl TeamAddPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	case WatchEvent:
+		var pl WatchPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	default:
+		return nil, fmt.Errorf("unknown event %s", gitHubEvent)
+	}
+}