From c344007e9252eeabbd164e8150ee965fab1f363c Mon Sep 17 00:00:00 2001
From: laizy <laizy@users.noreply.github.com>
Date: Wed, 5 Aug 2020 10:25:19 +0800
Subject: [PATCH 01/11] support propose offline witness in p2p (#1268)

* implement offline witness in p2p

* refactor local rpc

* add rpc api

* add license

* fix comments

* check self is gov node before vote
---
 go.mod                                        |   1 -
 go.sum                                        |   1 +
 http/base/rpc/result.go                       |   6 +-
 http/base/rpc/rpc.go                          |   5 +-
 http/{base/rpc => jsonrpc}/interfaces.go      | 257 +++++++++---------
 http/jsonrpc/rpc_server.go                    |  52 ++--
 .../rpc => localrpc}/local_interfaces.go      |  39 +--
 http/localrpc/local_server.go                 |  10 +-
 p2pserver/common/p2p_common.go                |   1 +
 p2pserver/message/types/message.go            |   2 +
 p2pserver/message/types/offline_witness.go    | 196 +++++++++++++
 p2pserver/net/netserver/nbr_peers.go          |   2 +-
 p2pserver/peer/peer.go                        |   4 +-
 p2pserver/protocols/msg_handler.go            |   4 +
 p2pserver/protocols/rpcapi.go                 |  54 ++++
 p2pserver/protocols/subnet/offline_witness.go | 241 ++++++++++++++++
 p2pserver/protocols/subnet/subnet.go          |  34 ++-
 p2pserver/protocols/utils/govnode_resolver.go |  74 ++++-
 .../service/native/utils/serialization.go     |   1 +
 19 files changed, 770 insertions(+), 214 deletions(-)
 rename http/{base/rpc => jsonrpc}/interfaces.go (65%)
 rename http/{base/rpc => localrpc}/local_interfaces.go (75%)
 create mode 100644 p2pserver/message/types/offline_witness.go
 create mode 100644 p2pserver/protocols/rpcapi.go
 create mode 100644 p2pserver/protocols/subnet/offline_witness.go

diff --git a/go.mod b/go.mod
index 07b455ec29..55fc4b2205 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,6 @@ require (
 	github.com/blang/semver v3.5.1+incompatible
 	github.com/emirpasic/gods v1.12.0 // indirect
 	github.com/ethereum/go-ethereum v1.9.13
-	github.com/gogo/protobuf v1.3.1 // indirect
 	github.com/gorilla/websocket v1.4.1
 	github.com/gosuri/uilive v0.0.3 // indirect
 	github.com/gosuri/uiprogress v0.0.1
diff --git a/go.sum b/go.sum
index 0e9c55686c..027004bb5e 100644
--- a/go.sum
+++ b/go.sum
@@ -75,6 +75,7 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9
 github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
 github.com/go-sourcemap/sourcemap v2.1.2+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
diff --git a/http/base/rpc/result.go b/http/base/rpc/result.go
index 89d7e66854..b091d13383 100644
--- a/http/base/rpc/result.go
+++ b/http/base/rpc/result.go
@@ -22,10 +22,10 @@ import (
 	Err "github.com/ontio/ontology/http/base/error"
 )
 
-func responseSuccess(result interface{}) map[string]interface{} {
-	return responsePack(Err.SUCCESS, result)
+func ResponseSuccess(result interface{}) map[string]interface{} {
+	return ResponsePack(Err.SUCCESS, result)
 }
-func responsePack(errcode int64, result interface{}) map[string]interface{} {
+func ResponsePack(errcode int64, result interface{}) map[string]interface{} {
 	resp := map[string]interface{}{
 		"error":  errcode,
 		"desc":   Err.ErrMap[errcode],
diff --git a/http/base/rpc/rpc.go b/http/base/rpc/rpc.go
index 491d16c5c1..f59dcb1a02 100644
--- a/http/base/rpc/rpc.go
+++ b/http/base/rpc/rpc.go
@@ -30,10 +30,11 @@ import (
 	"sync"
 
 	"github.com/ontio/ontology/common/log"
-	"github.com/ontio/ontology/http/base/common"
 	berr "github.com/ontio/ontology/http/base/error"
 )
 
+const MAX_REQUEST_BODY_SIZE = 1 << 20
+
 func init() {
 	mainMux.m = make(map[string]func([]interface{}) map[string]interface{})
 }
@@ -95,7 +96,7 @@ func Handle(w http.ResponseWriter, r *http.Request) {
 	}
 	request := make(map[string]interface{})
 	defer r.Body.Close()
-	decoder := json.NewDecoder(io.LimitReader(r.Body, common.MAX_REQUEST_BODY_SIZE))
+	decoder := json.NewDecoder(io.LimitReader(r.Body, MAX_REQUEST_BODY_SIZE))
 	err := decoder.Decode(&request)
 	if err != nil {
 		log.Error("HTTP JSON RPC Handle - json.Unmarshal: ", err)
diff --git a/http/base/rpc/interfaces.go b/http/jsonrpc/interfaces.go
similarity index 65%
rename from http/base/rpc/interfaces.go
rename to http/jsonrpc/interfaces.go
index 1ab41efec4..7a58b07b04 100644
--- a/http/base/rpc/interfaces.go
+++ b/http/jsonrpc/interfaces.go
@@ -16,7 +16,7 @@
  * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package rpc
+package jsonrpc
 
 import (
 	"encoding/hex"
@@ -31,13 +31,14 @@ import (
 	bactor "github.com/ontio/ontology/http/base/actor"
 	bcomn "github.com/ontio/ontology/http/base/common"
 	berr "github.com/ontio/ontology/http/base/error"
+	"github.com/ontio/ontology/http/base/rpc"
 	"github.com/ontio/ontology/smartcontract/service/native/utils"
 )
 
 //get best block hash
 func GetBestBlockHash(params []interface{}) map[string]interface{} {
 	hash := bactor.CurrentBlockHash()
-	return responseSuccess(hash.ToHexString())
+	return rpc.ResponseSuccess(hash.ToHexString())
 }
 
 // get block by height or hash
@@ -46,7 +47,7 @@ func GetBestBlockHash(params []interface{}) map[string]interface{} {
 //   {"jsonrpc": "2.0", "method": "getblock", "params": ["aabbcc.."], "id": 0}
 func GetBlock(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	var err error
 	var hash common.Uint256
@@ -56,40 +57,40 @@ func GetBlock(params []interface{}) map[string]interface{} {
 		index := uint32(params[0].(float64))
 		hash = bactor.GetBlockHashFromStore(index)
 		if hash == common.UINT256_EMPTY {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		// block hash
 	case string:
 		str := params[0].(string)
 		hash, err = common.Uint256FromHexString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	block, err := bactor.GetBlockFromStore(hash)
 	if err != nil {
-		return responsePack(berr.UNKNOWN_BLOCK, "unknown block")
+		return rpc.ResponsePack(berr.UNKNOWN_BLOCK, "unknown block")
 	}
 	if len(params) >= 2 {
 		switch (params[1]).(type) {
 		case float64:
 			json := uint32(params[1].(float64))
 			if json == 1 {
-				return responseSuccess(bcomn.GetBlockInfo(block))
+				return rpc.ResponseSuccess(bcomn.GetBlockInfo(block))
 			}
 		default:
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	}
-	return responseSuccess(common.ToHexString(block.ToArray()))
+	return rpc.ResponseSuccess(common.ToHexString(block.ToArray()))
 }
 
 //get block height
 func GetBlockCount(params []interface{}) map[string]interface{} {
 	height := bactor.GetCurrentBlockHeight()
-	return responseSuccess(height + 1)
+	return rpc.ResponseSuccess(height + 1)
 }
 
 //get block hash
@@ -97,25 +98,25 @@ func GetBlockCount(params []interface{}) map[string]interface{} {
 //   {"jsonrpc": "2.0", "method": "getblockhash", "params": [1], "id": 0}
 func GetBlockHash(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	switch params[0].(type) {
 	case float64:
 		height := uint32(params[0].(float64))
 		hash := bactor.GetBlockHashFromStore(height)
 		if hash == common.UINT256_EMPTY {
-			return responsePack(berr.UNKNOWN_BLOCK, "")
+			return rpc.ResponsePack(berr.UNKNOWN_BLOCK, "")
 		}
-		return responseSuccess(hash.ToHexString())
+		return rpc.ResponseSuccess(hash.ToHexString())
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 }
 
 //get node connection count
 func GetConnectionCount(params []interface{}) map[string]interface{} {
 	count := bactor.GetConnectionCnt()
-	return responseSuccess(count)
+	return rpc.ResponseSuccess(count)
 }
 
 //get node connection most height
@@ -123,10 +124,10 @@ func GetSyncStatus(params []interface{}) map[string]interface{} {
 	status, err := bcomn.GetSyncStatus()
 	if err != nil {
 		log.Errorf("GetSyncStatus error:%s", err)
-		return responsePack(berr.INTERNAL_ERROR, false)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, false)
 	}
 
-	return responseSuccess(status)
+	return rpc.ResponseSuccess(status)
 }
 
 func GetRawMemPool(params []interface{}) map[string]interface{} {
@@ -136,53 +137,53 @@ func GetRawMemPool(params []interface{}) map[string]interface{} {
 		txs = append(txs, bcomn.TransArryByteToHexString(t))
 	}
 	if len(txs) == 0 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
-	return responseSuccess(txs)
+	return rpc.ResponseSuccess(txs)
 }
 
 //get memory pool transaction count
 func GetMemPoolTxCount(params []interface{}) map[string]interface{} {
 	count, err := bactor.GetTxnCount()
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, nil)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, nil)
 	}
-	return responseSuccess(count)
+	return rpc.ResponseSuccess(count)
 }
 
 //get memory pool transaction hash
 func GetMemPoolTxHashList(params []interface{}) map[string]interface{} {
 	txHashList, err := bactor.GetTxnHashList()
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, nil)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, nil)
 	}
-	return responseSuccess(txHashList)
+	return rpc.ResponseSuccess(txHashList)
 }
 
 //get memory pool transaction state
 func GetMemPoolTxState(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	switch params[0].(type) {
 	case string:
 		str := params[0].(string)
 		hash, err := common.Uint256FromHexString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		txEntry, err := bactor.GetTxFromPool(hash)
 		if err != nil {
-			return responsePack(berr.UNKNOWN_TRANSACTION, "unknown transaction")
+			return rpc.ResponsePack(berr.UNKNOWN_TRANSACTION, "unknown transaction")
 		}
-		attrs := []bcomn.TXNAttrInfo{}
+		var attrs []bcomn.TXNAttrInfo
 		for _, t := range txEntry.Attrs {
 			attrs = append(attrs, bcomn.TXNAttrInfo{t.Height, int(t.Type), int(t.ErrCode)})
 		}
 		info := bcomn.TXNEntryInfo{attrs}
-		return responseSuccess(info)
+		return rpc.ResponseSuccess(info)
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 }
 
@@ -191,7 +192,7 @@ func GetMemPoolTxState(params []interface{}) map[string]interface{} {
 //   {"jsonrpc": "2.0", "method": "getrawtransaction", "params": ["transactioin hash in hex"], "id": 0}
 func GetRawTransaction(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	var tx *types.Transaction
 	var height uint32
@@ -200,16 +201,16 @@ func GetRawTransaction(params []interface{}) map[string]interface{} {
 		str := params[0].(string)
 		hash, err := common.Uint256FromHexString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		h, t, err := bactor.GetTxnWithHeightByTxHash(hash)
 		if err != nil {
-			return responsePack(berr.UNKNOWN_TRANSACTION, "unknown transaction")
+			return rpc.ResponsePack(berr.UNKNOWN_TRANSACTION, "unknown transaction")
 		}
 		height = h
 		tx = t
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 
 	if len(params) >= 2 {
@@ -219,21 +220,21 @@ func GetRawTransaction(params []interface{}) map[string]interface{} {
 			if json == 1 {
 				txinfo := bcomn.TransArryByteToHexString(tx)
 				txinfo.Height = height
-				return responseSuccess(txinfo)
+				return rpc.ResponseSuccess(txinfo)
 			}
 		default:
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	}
 
-	return responseSuccess(common.ToHexString(common.SerializeToBytes(tx)))
+	return rpc.ResponseSuccess(common.ToHexString(common.SerializeToBytes(tx)))
 }
 
 //get storage from contract
 //   {"jsonrpc": "2.0", "method": "getstorage", "params": ["code hash", "key"], "id": 0}
 func GetStorage(params []interface{}) map[string]interface{} {
 	if len(params) < 2 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 
 	var address common.Address
@@ -244,10 +245,10 @@ func GetStorage(params []interface{}) map[string]interface{} {
 		var err error
 		address, err = bcomn.GetAddress(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 
 	switch params[1].(type) {
@@ -255,20 +256,20 @@ func GetStorage(params []interface{}) map[string]interface{} {
 		str := params[1].(string)
 		hex, err := hex.DecodeString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		key = hex
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	value, err := bactor.GetStorageItem(address, key)
 	if err != nil {
 		if err == scom.ErrNotFound {
-			return responseSuccess(nil)
+			return rpc.ResponseSuccess(nil)
 		}
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responseSuccess(common.ToHexString(value))
+	return rpc.ResponseSuccess(common.ToHexString(value))
 }
 
 //send raw transaction
@@ -276,7 +277,7 @@ func GetStorage(params []interface{}) map[string]interface{} {
 //   {"jsonrpc": "2.0", "method": "sendrawtransaction", "params": ["raw transactioin in hex"], "id": 0}
 func SendRawTransaction(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	var hash common.Uint256
 	switch params[0].(type) {
@@ -284,11 +285,11 @@ func SendRawTransaction(params []interface{}) map[string]interface{} {
 		str := params[0].(string)
 		raw, err := common.HexToBytes(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		txn, err := types.TransactionFromRawBytes(raw)
 		if err != nil {
-			return responsePack(berr.INVALID_TRANSACTION, "")
+			return rpc.ResponsePack(berr.INVALID_TRANSACTION, "")
 		}
 		hash = txn.Hash()
 		log.Debugf("SendRawTransaction recv %s", hash.ToHexString())
@@ -299,9 +300,9 @@ func SendRawTransaction(params []interface{}) map[string]interface{} {
 					result, err := bactor.PreExecuteContract(txn)
 					if err != nil {
 						log.Infof("PreExec: ", err)
-						return responsePack(berr.SMARTCODE_ERROR, err.Error())
+						return rpc.ResponsePack(berr.SMARTCODE_ERROR, err.Error())
 					}
-					return responseSuccess(bcomn.ConvertPreExecuteResult(result))
+					return rpc.ResponseSuccess(bcomn.ConvertPreExecuteResult(result))
 				}
 			}
 		}
@@ -309,29 +310,29 @@ func SendRawTransaction(params []interface{}) map[string]interface{} {
 		log.Debugf("SendRawTransaction send to txpool %s", hash.ToHexString())
 		if errCode, desc := bcomn.SendTxToPool(txn); errCode != ontErrors.ErrNoError {
 			log.Warnf("SendRawTransaction verified %s error: %s", hash.ToHexString(), desc)
-			return responsePack(int64(errCode), desc)
+			return rpc.ResponsePack(int64(errCode), desc)
 		}
 		log.Debugf("SendRawTransaction verified %s", hash.ToHexString())
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responseSuccess(hash.ToHexString())
+	return rpc.ResponseSuccess(hash.ToHexString())
 }
 
 //get node version
 func GetNodeVersion(params []interface{}) map[string]interface{} {
-	return responseSuccess(config.Version)
+	return rpc.ResponseSuccess(config.Version)
 }
 
 // get networkid
 func GetNetworkId(params []interface{}) map[string]interface{} {
-	return responseSuccess(config.DefConfig.P2PNode.NetworkId)
+	return rpc.ResponseSuccess(config.DefConfig.P2PNode.NetworkId)
 }
 
 //get contract state
 func GetContractState(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	var contract *payload.DeployCode
 	switch params[0].(type) {
@@ -339,39 +340,39 @@ func GetContractState(params []interface{}) map[string]interface{} {
 		str := params[0].(string)
 		address, err := bcomn.GetAddress(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		c, err := bactor.GetContractStateFromStore(address)
 		if err != nil {
-			return responsePack(berr.UNKNOWN_CONTRACT, berr.ErrMap[berr.UNKNOWN_CONTRACT])
+			return rpc.ResponsePack(berr.UNKNOWN_CONTRACT, berr.ErrMap[berr.UNKNOWN_CONTRACT])
 		}
 		contract = c
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	if len(params) >= 2 {
 		switch (params[1]).(type) {
 		case float64:
 			json := uint32(params[1].(float64))
 			if json == 1 {
-				return responseSuccess(bcomn.TransPayloadToHex(contract))
+				return rpc.ResponseSuccess(bcomn.TransPayloadToHex(contract))
 			}
 		default:
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	}
 	sink := common.NewZeroCopySink(nil)
 	contract.Serialization(sink)
-	return responseSuccess(common.ToHexString(sink.Bytes()))
+	return rpc.ResponseSuccess(common.ToHexString(sink.Bytes()))
 }
 
 //get smartconstract event
 func GetSmartCodeEvent(params []interface{}) map[string]interface{} {
 	if !config.DefConfig.Common.EnableEventLog {
-		return responsePack(berr.INVALID_METHOD, "")
+		return rpc.ResponsePack(berr.INVALID_METHOD, "")
 	}
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 
 	switch (params[0]).(type) {
@@ -381,42 +382,42 @@ func GetSmartCodeEvent(params []interface{}) map[string]interface{} {
 		eventInfos, err := bactor.GetEventNotifyByHeight(height)
 		if err != nil {
 			if err == scom.ErrNotFound {
-				return responseSuccess(nil)
+				return rpc.ResponseSuccess(nil)
 			}
-			return responsePack(berr.INTERNAL_ERROR, "")
+			return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 		}
 		eInfos := make([]*bcomn.ExecuteNotify, 0, len(eventInfos))
 		for _, eventInfo := range eventInfos {
 			_, notify := bcomn.GetExecuteNotify(eventInfo)
 			eInfos = append(eInfos, &notify)
 		}
-		return responseSuccess(eInfos)
+		return rpc.ResponseSuccess(eInfos)
 		//txhash
 	case string:
 		str := params[0].(string)
 		hash, err := common.Uint256FromHexString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		eventInfo, err := bactor.GetEventNotifyByTxHash(hash)
 		if err != nil {
 			if scom.ErrNotFound == err {
-				return responseSuccess(nil)
+				return rpc.ResponseSuccess(nil)
 			}
-			return responsePack(berr.INTERNAL_ERROR, "")
+			return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 		}
 		_, notify := bcomn.GetExecuteNotify(eventInfo)
-		return responseSuccess(notify)
+		return rpc.ResponseSuccess(notify)
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responsePack(berr.INVALID_PARAMS, "")
+	return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 }
 
 //get block height by transaction hash
 func GetBlockHeightByTxHash(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 
 	switch (params[0]).(type) {
@@ -425,129 +426,129 @@ func GetBlockHeightByTxHash(params []interface{}) map[string]interface{} {
 		str := params[0].(string)
 		hash, err := common.Uint256FromHexString(str)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		height, _, err := bactor.GetTxnWithHeightByTxHash(hash)
 		if err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
-		return responseSuccess(height)
+		return rpc.ResponseSuccess(height)
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responsePack(berr.INVALID_PARAMS, "")
+	return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 }
 
 //get balance of address
 func GetBalance(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	addrBase58, ok := params[0].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	address, err := common.AddressFromBase58(addrBase58)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	rsp, err := bcomn.GetBalance(address)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responseSuccess(rsp)
+	return rpc.ResponseSuccess(rsp)
 }
 
 //get allowance
 func GetAllowance(params []interface{}) map[string]interface{} {
 	if len(params) < 3 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	asset, ok := params[0].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	fromAddrStr, ok := params[1].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	fromAddr, err := bcomn.GetAddress(fromAddrStr)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	toAddrStr, ok := params[2].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	toAddr, err := bcomn.GetAddress(toAddrStr)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	rsp, err := bcomn.GetAllowance(asset, fromAddr, toAddr)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responseSuccess(rsp)
+	return rpc.ResponseSuccess(rsp)
 }
 
 //get merkle proof by transaction hash
 func GetMerkleProof(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	str, ok := params[0].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	hash, err := common.Uint256FromHexString(str)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	height, _, err := bactor.GetTxnWithHeightByTxHash(hash)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	header, err := bactor.GetHeaderByHeight(height)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 
 	curHeight := bactor.GetCurrentBlockHeight()
 	curHeader, err := bactor.GetHeaderByHeight(curHeight)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	proof, err := bactor.GetMerkleProof(uint32(height), uint32(curHeight))
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
 	var hashes []string
 	for _, v := range proof {
 		hashes = append(hashes, v.ToHexString())
 	}
-	return responseSuccess(bcomn.MerkleProof{"MerkleProof", header.TransactionsRoot.ToHexString(), height,
+	return rpc.ResponseSuccess(bcomn.MerkleProof{"MerkleProof", header.TransactionsRoot.ToHexString(), height,
 		curHeader.BlockRoot.ToHexString(), curHeight, hashes})
 }
 
 //get block transactions by height
 func GetBlockTxsByHeight(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	switch params[0].(type) {
 	case float64:
 		height := uint32(params[0].(float64))
 		hash := bactor.GetBlockHashFromStore(height)
 		if hash == common.UINT256_EMPTY {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 		block, err := bactor.GetBlockFromStore(hash)
 		if err != nil {
-			return responsePack(berr.UNKNOWN_BLOCK, "")
+			return rpc.ResponsePack(berr.UNKNOWN_BLOCK, "")
 		}
-		return responseSuccess(bcomn.GetBlockTransactions(block))
+		return rpc.ResponseSuccess(bcomn.GetBlockTransactions(block))
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 }
 
@@ -555,95 +556,95 @@ func GetBlockTxsByHeight(params []interface{}) map[string]interface{} {
 func GetGasPrice(params []interface{}) map[string]interface{} {
 	result, err := bcomn.GetGasPrice()
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
-	return responseSuccess(result)
+	return rpc.ResponseSuccess(result)
 }
 
 // get unbound ong of address
 func GetUnboundOng(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	str, ok := params[0].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	toAddr, err := common.AddressFromBase58(str)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	fromAddr := utils.OntContractAddress
 	rsp, err := bcomn.GetAllowance("ong", fromAddr, toAddr)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responseSuccess(rsp)
+	return rpc.ResponseSuccess(rsp)
 }
 
 // get grant ong of address
 func GetGrantOng(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	str, ok := params[0].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	toAddr, err := common.AddressFromBase58(str)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	rsp, err := bcomn.GetGrantOng(toAddr)
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
-	return responseSuccess(rsp)
+	return rpc.ResponseSuccess(rsp)
 }
 
 //get cross chain message by height
 func GetCrossChainMsg(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	height, ok := (params[0]).(float64)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	msg, err := bactor.GetCrossChainMsg(uint32(height))
 	if err != nil {
 		log.Errorf("GetCrossChainMsg, get cross chain msg from db error:%s", err)
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
 	header, err := bactor.GetHeaderByHeight(uint32(height) + 1)
 	if err != nil {
 		log.Errorf("GetCrossChainMsg, get block by height from db error:%s", err)
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
-	return responseSuccess(bcomn.TransferCrossChainMsg(msg, header.Bookkeepers))
+	return rpc.ResponseSuccess(bcomn.TransferCrossChainMsg(msg, header.Bookkeepers))
 }
 
 //get cross chain state proof
 func GetCrossStatesProof(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, nil)
+		return rpc.ResponsePack(berr.INVALID_PARAMS, nil)
 	}
 	height, ok := params[0].(float64)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	str, ok := params[1].(string)
 	if !ok {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	key, err := hex.DecodeString(str)
 	if err != nil {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	proof, err := bactor.GetCrossStatesProof(uint32(height), key)
 	if err != nil {
 		log.Errorf("GetCrossStatesProof, bactor.GetCrossStatesProof error:%s", err)
-		return responsePack(berr.INTERNAL_ERROR, "")
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, "")
 	}
-	return responseSuccess(bcomn.CrossStatesProof{"CrossStatesProof", hex.EncodeToString(proof)})
+	return rpc.ResponseSuccess(bcomn.CrossStatesProof{"CrossStatesProof", hex.EncodeToString(proof)})
 }
diff --git a/http/jsonrpc/rpc_server.go b/http/jsonrpc/rpc_server.go
index be207087fb..6e3eb20793 100644
--- a/http/jsonrpc/rpc_server.go
+++ b/http/jsonrpc/rpc_server.go
@@ -32,37 +32,37 @@ import (
 func StartRPCServer() error {
 	log.Debug()
 	http.HandleFunc("/", rpc.Handle)
-	rpc.HandleFunc("getbestblockhash", rpc.GetBestBlockHash)
-	rpc.HandleFunc("getblock", rpc.GetBlock)
-	rpc.HandleFunc("getblockcount", rpc.GetBlockCount)
-	rpc.HandleFunc("getblockhash", rpc.GetBlockHash)
-	rpc.HandleFunc("getconnectioncount", rpc.GetConnectionCount)
-	rpc.HandleFunc("getsyncstatus", rpc.GetSyncStatus)
+	rpc.HandleFunc("getbestblockhash", GetBestBlockHash)
+	rpc.HandleFunc("getblock", GetBlock)
+	rpc.HandleFunc("getblockcount", GetBlockCount)
+	rpc.HandleFunc("getblockhash", GetBlockHash)
+	rpc.HandleFunc("getconnectioncount", GetConnectionCount)
+	rpc.HandleFunc("getsyncstatus", GetSyncStatus)
 	//HandleFunc("getrawmempool", GetRawMemPool)
 
-	rpc.HandleFunc("getrawtransaction", rpc.GetRawTransaction)
-	rpc.HandleFunc("sendrawtransaction", rpc.SendRawTransaction)
-	rpc.HandleFunc("getstorage", rpc.GetStorage)
-	rpc.HandleFunc("getversion", rpc.GetNodeVersion)
-	rpc.HandleFunc("getnetworkid", rpc.GetNetworkId)
+	rpc.HandleFunc("getrawtransaction", GetRawTransaction)
+	rpc.HandleFunc("sendrawtransaction", SendRawTransaction)
+	rpc.HandleFunc("getstorage", GetStorage)
+	rpc.HandleFunc("getversion", GetNodeVersion)
+	rpc.HandleFunc("getnetworkid", GetNetworkId)
 
-	rpc.HandleFunc("getcontractstate", rpc.GetContractState)
-	rpc.HandleFunc("getmempooltxcount", rpc.GetMemPoolTxCount)
-	rpc.HandleFunc("getmempooltxstate", rpc.GetMemPoolTxState)
-	rpc.HandleFunc("getmempooltxhashlist", rpc.GetMemPoolTxHashList)
-	rpc.HandleFunc("getsmartcodeevent", rpc.GetSmartCodeEvent)
-	rpc.HandleFunc("getblockheightbytxhash", rpc.GetBlockHeightByTxHash)
+	rpc.HandleFunc("getcontractstate", GetContractState)
+	rpc.HandleFunc("getmempooltxcount", GetMemPoolTxCount)
+	rpc.HandleFunc("getmempooltxstate", GetMemPoolTxState)
+	rpc.HandleFunc("getmempooltxhashlist", GetMemPoolTxHashList)
+	rpc.HandleFunc("getsmartcodeevent", GetSmartCodeEvent)
+	rpc.HandleFunc("getblockheightbytxhash", GetBlockHeightByTxHash)
 
-	rpc.HandleFunc("getbalance", rpc.GetBalance)
-	rpc.HandleFunc("getallowance", rpc.GetAllowance)
-	rpc.HandleFunc("getmerkleproof", rpc.GetMerkleProof)
-	rpc.HandleFunc("getblocktxsbyheight", rpc.GetBlockTxsByHeight)
-	rpc.HandleFunc("getgasprice", rpc.GetGasPrice)
-	rpc.HandleFunc("getunboundong", rpc.GetUnboundOng)
-	rpc.HandleFunc("getgrantong", rpc.GetGrantOng)
+	rpc.HandleFunc("getbalance", GetBalance)
+	rpc.HandleFunc("getallowance", GetAllowance)
+	rpc.HandleFunc("getmerkleproof", GetMerkleProof)
+	rpc.HandleFunc("getblocktxsbyheight", GetBlockTxsByHeight)
+	rpc.HandleFunc("getgasprice", GetGasPrice)
+	rpc.HandleFunc("getunboundong", GetUnboundOng)
+	rpc.HandleFunc("getgrantong", GetGrantOng)
 
-	rpc.HandleFunc("getcrosschainmsg", rpc.GetCrossChainMsg)
-	rpc.HandleFunc("getcrossstatesproof", rpc.GetCrossStatesProof)
+	rpc.HandleFunc("getcrosschainmsg", GetCrossChainMsg)
+	rpc.HandleFunc("getcrossstatesproof", GetCrossStatesProof)
 
 	err := http.ListenAndServe(":"+strconv.Itoa(int(cfg.DefConfig.Rpc.HttpJsonPort)), nil)
 	if err != nil {
diff --git a/http/base/rpc/local_interfaces.go b/http/localrpc/local_interfaces.go
similarity index 75%
rename from http/base/rpc/local_interfaces.go
rename to http/localrpc/local_interfaces.go
index 5b23dceaa8..652f660b15 100644
--- a/http/base/rpc/local_interfaces.go
+++ b/http/localrpc/local_interfaces.go
@@ -16,34 +16,21 @@
  * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package rpc
+package localrpc
 
 import (
-	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/ontio/ontology/common/log"
 	bactor "github.com/ontio/ontology/http/base/actor"
 	"github.com/ontio/ontology/http/base/common"
 	berr "github.com/ontio/ontology/http/base/error"
+	"github.com/ontio/ontology/http/base/rpc"
 )
 
-const (
-	RANDBYTELEN = 4
-)
-
-func getCurrentDirectory() string {
-	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
-	if err != nil {
-		log.Fatal(err)
-	}
-	return dir
-}
-
 func GetNeighbor(params []interface{}) map[string]interface{} {
 	addr := bactor.GetNeighborAddrs()
-	return responseSuccess(addr)
+	return rpc.ResponseSuccess(addr)
 }
 
 func GetNodeState(params []interface{}) map[string]interface{} {
@@ -56,7 +43,7 @@ func GetNodeState(params []interface{}) map[string]interface{} {
 	height := bactor.GetCurrentBlockHeight()
 	txnCnt, err := bactor.GetTxnCount()
 	if err != nil {
-		return responsePack(berr.INTERNAL_ERROR, false)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, false)
 	}
 	n := common.NodeInfo{
 		NodeTime:    t,
@@ -68,35 +55,35 @@ func GetNodeState(params []interface{}) map[string]interface{} {
 		Height:      height,
 		TxnCnt:      txnCnt,
 	}
-	return responseSuccess(n)
+	return rpc.ResponseSuccess(n)
 }
 
 func StartConsensus(params []interface{}) map[string]interface{} {
 	if err := bactor.ConsensusSrvStart(); err != nil {
-		return responsePack(berr.INTERNAL_ERROR, false)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, false)
 	}
-	return responsePack(berr.SUCCESS, true)
+	return rpc.ResponsePack(berr.SUCCESS, true)
 }
 
 func StopConsensus(params []interface{}) map[string]interface{} {
 	if err := bactor.ConsensusSrvHalt(); err != nil {
-		return responsePack(berr.INTERNAL_ERROR, false)
+		return rpc.ResponsePack(berr.INTERNAL_ERROR, false)
 	}
-	return responsePack(berr.SUCCESS, true)
+	return rpc.ResponsePack(berr.SUCCESS, true)
 }
 
 func SetDebugInfo(params []interface{}) map[string]interface{} {
 	if len(params) < 1 {
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
 	switch params[0].(type) {
 	case float64:
 		level := params[0].(float64)
 		if err := log.Log().SetDebugLevel(int(level)); err != nil {
-			return responsePack(berr.INVALID_PARAMS, "")
+			return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 		}
 	default:
-		return responsePack(berr.INVALID_PARAMS, "")
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
 	}
-	return responsePack(berr.SUCCESS, true)
+	return rpc.ResponsePack(berr.SUCCESS, true)
 }
diff --git a/http/localrpc/local_server.go b/http/localrpc/local_server.go
index 9e93f3cf95..246232c635 100644
--- a/http/localrpc/local_server.go
+++ b/http/localrpc/local_server.go
@@ -38,11 +38,11 @@ func StartLocalServer() error {
 	log.Debug()
 	http.HandleFunc(LOCAL_DIR, rpc.Handle)
 
-	rpc.HandleFunc("getneighbor", rpc.GetNeighbor)
-	rpc.HandleFunc("getnodestate", rpc.GetNodeState)
-	rpc.HandleFunc("startconsensus", rpc.StartConsensus)
-	rpc.HandleFunc("stopconsensus", rpc.StopConsensus)
-	rpc.HandleFunc("setdebuginfo", rpc.SetDebugInfo)
+	rpc.HandleFunc("getneighbor", GetNeighbor)
+	rpc.HandleFunc("getnodestate", GetNodeState)
+	rpc.HandleFunc("startconsensus", StartConsensus)
+	rpc.HandleFunc("stopconsensus", StopConsensus)
+	rpc.HandleFunc("setdebuginfo", SetDebugInfo)
 
 	// TODO: only listen to local host
 	err := http.ListenAndServe(LOCAL_HOST+":"+strconv.Itoa(int(cfg.DefConfig.Rpc.HttpLocalPort)), nil)
diff --git a/p2pserver/common/p2p_common.go b/p2pserver/common/p2p_common.go
index 1adb2b8ce8..8a3e2880c5 100644
--- a/p2pserver/common/p2p_common.go
+++ b/p2pserver/common/p2p_common.go
@@ -117,6 +117,7 @@ const (
 
 	GET_SUBNET_MEMBERS_TYPE = "getmembers" // request subnet members
 	SUBNET_MEMBERS_TYPE     = "members"    // response subnet members
+	SUBNET_OFFLINE_TYPE     = "offline"    // offline witness message
 )
 
 //ParseIPAddr return ip address
diff --git a/p2pserver/message/types/message.go b/p2pserver/message/types/message.go
index ad16055650..3cc9279977 100644
--- a/p2pserver/message/types/message.go
+++ b/p2pserver/message/types/message.go
@@ -201,6 +201,8 @@ func makeEmptyMessage(cmdType string) Message {
 		return &SubnetMembersRequest{}
 	case common.SUBNET_MEMBERS_TYPE:
 		return &SubnetMembers{}
+	case common.SUBNET_OFFLINE_TYPE:
+		return &OfflineWitnessMsg{}
 	default:
 		return &UnknownMessage{Cmd: cmdType}
 	}
diff --git a/p2pserver/message/types/offline_witness.go b/p2pserver/message/types/offline_witness.go
new file mode 100644
index 0000000000..8811a7d5c6
--- /dev/null
+++ b/p2pserver/message/types/offline_witness.go
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2018 The ontology Authors
+ * This file is part of The ontology library.
+ *
+ * The ontology is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The ontology is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package types
+
+import (
+	"crypto/sha256"
+	"errors"
+	"math"
+
+	"github.com/ontio/ontology/account"
+	"github.com/ontio/ontology/common"
+	vconfig "github.com/ontio/ontology/consensus/vbft/config"
+	"github.com/ontio/ontology/core/signature"
+	common2 "github.com/ontio/ontology/p2pserver/common"
+)
+
+type OfflineWitnessMsg struct {
+	Timestamp   uint32   `json:"timestamp"`
+	View        uint32   `json:"view"`
+	NodePubKeys []string `json:"nodePubKeys"`
+	Proposer    string   `json:"proposer"`
+
+	ProposerSig []byte `json:"proposerSig"`
+
+	Voters []VoterMsg `json:"voters"`
+}
+
+type VoterMsg struct {
+	OfflineIndex []uint8 `json:"offlineIndex"`
+	PubKey       string  `json:"pubKey"`
+	Sig          []byte  `json:"sig"`
+}
+
+func (this *OfflineWitnessMsg) CmdType() string {
+	return common2.SUBNET_OFFLINE_TYPE
+}
+
+func (self *OfflineWitnessMsg) Serialization(sink *common.ZeroCopySink) {
+	self.serializeUnsigned(sink)
+	sink.WriteVarBytes(self.ProposerSig)
+
+	sink.WriteUint32(uint32(len(self.Voters)))
+	for _, val := range self.Voters {
+		sink.WriteVarBytes(val.OfflineIndex)
+		sink.WriteString(val.PubKey)
+		sink.WriteVarBytes(val.Sig)
+	}
+}
+
+func (self *OfflineWitnessMsg) Deserialization(source *common.ZeroCopySource) (err error) {
+	self.Timestamp, err = source.ReadUint32()
+	if err != nil {
+		return err
+	}
+	self.View, err = source.ReadUint32()
+	if err != nil {
+		return err
+	}
+	lenPubKeys, err := source.ReadUint32()
+	if err != nil {
+		return err
+	}
+	if lenPubKeys > math.MaxUint8 {
+		return errors.New("too many node keys")
+	}
+	for i := uint32(0); i < lenPubKeys; i++ {
+		key, err := source.ReadString()
+		if err != nil {
+			return err
+		}
+		self.NodePubKeys = append(self.NodePubKeys, key)
+	}
+
+	self.Proposer, err = source.ReadString()
+	if err != nil {
+		return err
+	}
+
+	lenVoters, err := source.ReadUint32()
+	if err != nil {
+		return err
+	}
+
+	for i := uint32(0); i < lenVoters; i++ {
+		index, err := source.ReadVarBytes()
+		if err != nil {
+			return err
+		}
+		for _, idx := range index {
+			if int(idx) >= len(self.NodePubKeys) {
+				return errors.New("vote index out of range")
+			}
+		}
+		pubKey, err := source.ReadString()
+		if err != nil {
+			return err
+		}
+		sig, err := source.ReadVarBytes()
+
+		self.Voters = append(self.Voters, VoterMsg{OfflineIndex: index, PubKey: pubKey, Sig: sig})
+	}
+
+	return self.VerifySigs()
+}
+
+func (self *OfflineWitnessMsg) serializeUnsigned(sink *common.ZeroCopySink) {
+	sink.WriteUint32(self.Timestamp)
+	sink.WriteUint32(self.View)
+	sink.WriteUint32(uint32(len(self.NodePubKeys)))
+	for _, key := range self.NodePubKeys {
+		sink.WriteString(key)
+	}
+	sink.WriteString(self.Proposer)
+}
+
+func (self *OfflineWitnessMsg) Hash() common.Uint256 {
+	sink := common.NewZeroCopySink(nil)
+	self.serializeUnsigned(sink)
+	hash := common.Uint256(sha256.Sum256(sink.Bytes()))
+
+	return hash
+}
+
+func (self *OfflineWitnessMsg) AddProposeSig(acct *account.Account) error {
+	hash := self.Hash()
+	sig, err := signature.Sign(acct, hash[:])
+	if err != nil {
+		return err
+	}
+	self.ProposerSig = sig
+
+	return nil
+}
+
+func (self *OfflineWitnessMsg) VoteFor(acct *account.Account, index []uint8) error {
+	sink := common.NewZeroCopySink(nil)
+	self.serializeUnsigned(sink)
+	sink.WriteVarBytes(index)
+	hash := common.Uint256(sha256.Sum256(sink.Bytes()))
+	sig, err := signature.Sign(acct, hash[:])
+	if err != nil {
+		return err
+	}
+	pubkey := vconfig.PubkeyID(acct.PublicKey)
+	self.Voters = append(self.Voters, VoterMsg{OfflineIndex: index, PubKey: pubkey, Sig: sig})
+
+	return nil
+}
+
+func (self *OfflineWitnessMsg) VerifySigs() error {
+	sink := common.NewZeroCopySink(nil)
+	self.serializeUnsigned(sink)
+	unsign := sink.Bytes()
+	data := sha256.Sum256(unsign)
+	prop, err := vconfig.Pubkey(self.Proposer)
+	if err != nil {
+		return err
+	}
+
+	err = signature.Verify(prop, data[:], self.ProposerSig)
+	if err != nil {
+		return err
+	}
+
+	for _, vote := range self.Voters {
+		sink = common.NewZeroCopySink(unsign)
+		sink.WriteVarBytes(vote.OfflineIndex)
+		data = sha256.Sum256(sink.Bytes())
+		key, err := vconfig.Pubkey(vote.PubKey)
+		if err != nil {
+			return err
+		}
+		err = signature.Verify(key, data[:], vote.Sig)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/p2pserver/net/netserver/nbr_peers.go b/p2pserver/net/netserver/nbr_peers.go
index cb09bde876..a4250bfe8e 100644
--- a/p2pserver/net/netserver/nbr_peers.go
+++ b/p2pserver/net/netserver/nbr_peers.go
@@ -92,7 +92,7 @@ func (this *NbrPeers) Broadcast(msg types.Message) {
 	defer this.RUnlock()
 	for _, node := range this.List {
 		if node.Peer.GetRelay() {
-			go node.Peer.SendRaw(msg.CmdType(), sink.Bytes())
+			go node.Peer.SendRaw(sink.Bytes())
 		}
 	}
 }
diff --git a/p2pserver/peer/peer.go b/p2pserver/peer/peer.go
index 260952eaf2..6b42b53969 100644
--- a/p2pserver/peer/peer.go
+++ b/p2pserver/peer/peer.go
@@ -140,7 +140,7 @@ func (this *Peer) GetPort() uint16 {
 }
 
 //SendTo call sync link to send buffer
-func (this *Peer) SendRaw(msgType string, msgPayload []byte) error {
+func (this *Peer) SendRaw(msgPayload []byte) error {
 	return this.Link.SendRaw(msgPayload)
 }
 
@@ -208,7 +208,7 @@ func (this *Peer) Send(msg types.Message) error {
 	sink := comm.NewZeroCopySink(nil)
 	types.WriteMessage(sink, msg)
 
-	return this.SendRaw(msg.CmdType(), sink.Bytes())
+	return this.SendRaw(sink.Bytes())
 }
 
 //GetHttpInfoPort return peer`s httpinfo port
diff --git a/p2pserver/protocols/msg_handler.go b/p2pserver/protocols/msg_handler.go
index 6033854762..f1b5d111c7 100644
--- a/p2pserver/protocols/msg_handler.go
+++ b/p2pserver/protocols/msg_handler.go
@@ -103,6 +103,8 @@ func (self *MsgHandler) start(net p2p.P2P) {
 	go self.heatBeat.Start()
 	go self.bootstrap.Start()
 	go self.subnet.Start(net)
+
+	RegisterProposeOfflineVote(self.subnet)
 }
 
 func (self *MsgHandler) stop() {
@@ -173,6 +175,8 @@ func (self *MsgHandler) HandlePeerMessage(ctx *p2p.Context, msg msgTypes.Message
 		self.subnet.OnMembersRequest(ctx, m)
 	case *msgTypes.SubnetMembers:
 		self.subnet.OnMembersResponse(ctx, m)
+	case *msgTypes.OfflineWitnessMsg:
+		self.subnet.OnOfflineWitnessMsg(ctx, m)
 	case *msgTypes.NotFound:
 		log.Debug("[p2p]receive notFound message, hash is ", m.Hash)
 	default:
diff --git a/p2pserver/protocols/rpcapi.go b/p2pserver/protocols/rpcapi.go
new file mode 100644
index 0000000000..8faddf57ff
--- /dev/null
+++ b/p2pserver/protocols/rpcapi.go
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2018 The ontology Authors
+ * This file is part of The ontology library.
+ *
+ * The ontology is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The ontology is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package protocols
+
+import (
+	"github.com/ontio/ontology/http/base/error"
+	"github.com/ontio/ontology/http/base/rpc"
+	"github.com/ontio/ontology/p2pserver/protocols/subnet"
+)
+
+func RegisterProposeOfflineVote(subnet *subnet.SubNet) {
+	// curl http://localhost:20337/local -v -d '{"method":"proposeOfflineVote", "params":["pubkey1", "pubkey2"]}'
+	rpc.HandleFunc("proposeOfflineVote", func(params []interface{}) map[string]interface{} {
+		var nodes []string
+		for _, key := range params {
+			switch pubKey := key.(type) {
+			case string:
+				nodes = append(nodes, pubKey)
+			default:
+				return rpc.ResponsePack(error.INVALID_PARAMS, "")
+			}
+		}
+
+		err := subnet.ProposeOffline(nodes)
+		if err != nil {
+			return rpc.ResponsePack(error.INTERNAL_ERROR, err.Error())
+		}
+
+		return rpc.ResponseSuccess(nil)
+	})
+
+	// curl http://localhost:20337/local -v -d '{"method":"getOfflineVotes", "params":[]}'
+	rpc.HandleFunc("getOfflineVotes", func(params []interface{}) map[string]interface{} {
+		votes := subnet.GetOfflineVotes()
+
+		return rpc.ResponseSuccess(votes)
+	})
+}
diff --git a/p2pserver/protocols/subnet/offline_witness.go b/p2pserver/protocols/subnet/offline_witness.go
new file mode 100644
index 0000000000..20aa98c3e3
--- /dev/null
+++ b/p2pserver/protocols/subnet/offline_witness.go
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2018 The ontology Authors
+ * This file is part of The ontology library.
+ *
+ * The ontology is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The ontology is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package subnet
+
+import (
+	"errors"
+	"math/rand"
+	"time"
+
+	common2 "github.com/ontio/ontology/common"
+	"github.com/ontio/ontology/common/log"
+	vconfig "github.com/ontio/ontology/consensus/vbft/config"
+	"github.com/ontio/ontology/p2pserver/common"
+	"github.com/ontio/ontology/p2pserver/message/types"
+	p2p "github.com/ontio/ontology/p2pserver/net/protocol"
+	"github.com/ontio/ontology/p2pserver/protocols/utils"
+)
+
+const MinProposeDuration = uint32(1 * time.Hour / time.Second)
+const ExpireOfflineMsgTime = uint32(2 * time.Hour / time.Second)
+const DelayUpdateMsgTime = 5 * time.Second
+
+func (self *SubNet) ProposeOffline(nodes []string) error {
+	if self.acct == nil {
+		return errors.New("only consensus node can propose offline witness")
+	}
+	key := vconfig.PubkeyID(self.acct.PublicKey)
+	role, view := self.gov.GetNodeRoleAndView(key)
+	if role != utils.ConsensusNode {
+		return errors.New("only consensus node can propose offline witness")
+	}
+	now := uint32(time.Now().Unix())
+	connected := make(map[string]bool)
+	for _, val := range self.GetMembersInfo() {
+		if val.Connected {
+			connected[val.PubKey] = true
+		}
+	}
+	var leftNodes []string
+	for _, node := range nodes {
+		if !self.gov.IsGovNode(node) {
+			continue
+		}
+		if !connected[node] {
+			leftNodes = append(leftNodes, node)
+		}
+	}
+
+	if len(leftNodes) == 0 {
+		log.Info("do not send offline witness proposal since all nodes are online")
+		return nil
+	}
+	msg := &types.OfflineWitnessMsg{
+		Timestamp:   now,
+		View:        view,
+		NodePubKeys: leftNodes,
+		Proposer:    key,
+	}
+	err := msg.AddProposeSig(self.acct)
+	if err != nil {
+		return err
+	}
+	err = self.addProposol(msg)
+	if err != nil {
+		return err
+	}
+
+	self.unparker.Unpark()
+	return nil
+}
+
+func (self *SubNet) sendOfflineWitness(net p2p.P2P) {
+	var msgs []struct {
+		status WitnessStatus
+		rawMsg []byte
+	}
+	var peerIds []common.PeerId
+	now := uint32(time.Now().Unix())
+	self.lock.RLock()
+	for hash, m := range self.offlineWitness {
+		if m.Msg.Timestamp+ExpireOfflineMsgTime < now {
+			delete(self.offlineWitness, hash)
+		}
+		if m.Status != UnchangedStatus {
+			rawMsg := common2.SerializeToBytes(m.Msg)
+			msgs = append(msgs, struct {
+				status WitnessStatus
+				rawMsg []byte
+			}{status: UnchangedStatus, rawMsg: rawMsg})
+		}
+	}
+	for _, p := range self.connected {
+		peerIds = append(peerIds, p.Id)
+	}
+	self.lock.RUnlock()
+
+	for _, msg := range msgs {
+		switch msg.status {
+		case NewStatus, UpdatedStatus:
+			for _, peerId := range peerIds {
+				if p := net.GetPeer(peerId); p != nil {
+					_ = p.SendRaw(msg.rawMsg)
+				}
+			}
+		}
+	}
+}
+
+func (self *SubNet) Broadcast(net p2p.P2P, msg types.Message) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	for _, p := range self.connected {
+		net.SendTo(p.Id, msg)
+	}
+}
+
+func (self *SubNet) OnOfflineWitnessMsg(ctx *p2p.Context, msg *types.OfflineWitnessMsg) {
+	status := self.processOfflineWitnessMsg(ctx, msg)
+	switch status {
+	case NewStatus:
+		self.unparker.Unpark()
+	case UpdatedStatus:
+		delay := int64(rand.Intn(1000)) * int64(DelayUpdateMsgTime) / 1000
+		time.Sleep(time.Duration(delay))
+		self.unparker.Unpark()
+	}
+}
+
+func (self *SubNet) processOfflineWitnessMsg(ctx *p2p.Context, msg *types.OfflineWitnessMsg) WitnessStatus {
+	now := uint32(time.Now().Unix())
+	hash := msg.Hash()
+	if msg.Timestamp+ExpireOfflineMsgTime < now {
+		self.logger.Infof("receive expired witness msg: %s", hash.ToHexString())
+		return UnchangedStatus
+	}
+	role, view := self.gov.GetNodeRoleAndView(msg.Proposer)
+	if role != utils.ConsensusNode || view != msg.View {
+		self.logger.Infof("receive expired witness msg: %s, {role: %d, view: %d}, current view: %d",
+			hash.ToHexString(), role, msg.View, view)
+		return UnchangedStatus
+	}
+
+	voters := make(map[string]types.VoterMsg)
+	for _, voter := range msg.Voters {
+		if !self.gov.IsGovNode(voter.PubKey) {
+			self.logger.Infof("receive witness msg: %s with wrong voter: %s", hash.ToHexString(), voter.PubKey)
+			return UnchangedStatus
+		}
+		voters[voter.PubKey] = voter
+	}
+
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	offline := self.offlineWitness[msg.Hash()]
+	if offline == nil {
+		govNode := self.acct != nil && self.gov.IsGovNodePubKey(self.acct.PublicKey)
+		if govNode {
+			err := msg.VoteFor(self.acct, self.collectOfflineIndexLocked(msg.NodePubKeys))
+			if err != nil {
+				self.logger.Infof("vote for witness msg error: %s", err)
+				return UnchangedStatus
+			}
+		}
+		offline = &Offline{Status: NewStatus, Msg: msg}
+		self.offlineWitness[msg.Hash()] = offline
+
+		return NewStatus
+	}
+	for _, vote := range offline.Msg.Voters {
+		delete(voters, vote.PubKey)
+	}
+	for _, voter := range voters {
+		offline.Msg.Voters = append(offline.Msg.Voters, voter)
+		offline.Status = UpdatedStatus
+	}
+	if len(voters) > 0 {
+		return UpdatedStatus
+	}
+
+	return UnchangedStatus
+}
+
+func (self *SubNet) collectOfflineIndexLocked(nodes []string) []uint8 {
+	connected := make(map[string]bool)
+	for _, val := range self.getMembersInfoLocked() {
+		if val.Connected {
+			connected[val.PubKey] = true
+		}
+	}
+	var leftNodes []uint8
+	for idx, node := range nodes {
+		if !connected[node] {
+			leftNodes = append(leftNodes, uint8(idx))
+		}
+	}
+
+	return leftNodes
+}
+
+func (self *SubNet) addProposol(msg *types.OfflineWitnessMsg) error {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	for _, m := range self.offlineWitness {
+		propose := m.Msg
+		if propose.Proposer == msg.Proposer && (msg.Timestamp < propose.Timestamp+MinProposeDuration) {
+			return errors.New("have already propose offline witness recently")
+		}
+	}
+
+	self.offlineWitness[msg.Hash()] = &Offline{Status: NewStatus, Msg: msg}
+	return nil
+}
+
+func (self *SubNet) GetOfflineVotes() []*types.OfflineWitnessMsg {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+
+	var voters []*types.OfflineWitnessMsg
+	for _, m := range self.offlineWitness {
+		msg := *m.Msg
+		voters = append(voters, &msg)
+	}
+
+	return voters
+}
diff --git a/p2pserver/protocols/subnet/subnet.go b/p2pserver/protocols/subnet/subnet.go
index 86a65457b2..0d2d4443ce 100644
--- a/p2pserver/protocols/subnet/subnet.go
+++ b/p2pserver/protocols/subnet/subnet.go
@@ -26,6 +26,7 @@ import (
 	"time"
 
 	"github.com/ontio/ontology/account"
+	common2 "github.com/ontio/ontology/common"
 	vconfig "github.com/ontio/ontology/consensus/vbft/config"
 	"github.com/ontio/ontology/p2pserver/common"
 	"github.com/ontio/ontology/p2pserver/message/types"
@@ -39,6 +40,17 @@ const MaxInactiveTime = 10 * time.Minute
 
 var RefreshDuration = 1 * time.Minute
 
+type WitnessStatus = byte
+
+const NewStatus WitnessStatus = 0
+const UpdatedStatus WitnessStatus = 1
+const UnchangedStatus WitnessStatus = 2
+
+type Offline struct {
+	Status WitnessStatus
+	Msg    *types.OfflineWitnessMsg
+}
+
 type SubNet struct {
 	acct     *account.Account // nil if conenesus is not enabled
 	seeds    *utils.HostsResolver
@@ -50,9 +62,10 @@ type SubNet struct {
 	seedNode uint32 // bool acturally
 	closed   bool
 
-	connected map[string]*peer.PeerInfo // connected seed or gov node, listen address --> PeerInfo
-	members   map[string]*MemberStatus  // gov node info, listen address --> pubkey hex string
-	logger    common.Logger
+	connected      map[string]*peer.PeerInfo    // connected seed/gov node, listenAddr --> PeerInfo
+	members        map[string]*MemberStatus     // gov node info, listenAddr --> pubkey hex string
+	offlineWitness map[common2.Uint256]*Offline // hash -> msg
+	logger         common.Logger
 }
 
 func NewSubNet(acc *account.Account, seeds *utils.HostsResolver,
@@ -64,8 +77,9 @@ func NewSubNet(acc *account.Account, seeds *utils.HostsResolver,
 		unparker: utils.NewParker(),
 		logger:   logger,
 
-		connected: make(map[string]*peer.PeerInfo),
-		members:   make(map[string]*MemberStatus),
+		connected:      make(map[string]*peer.PeerInfo),
+		members:        make(map[string]*MemberStatus),
+		offlineWitness: make(map[common2.Uint256]*Offline),
 	}
 }
 
@@ -356,10 +370,17 @@ func (self *SubNet) maintainLoop(net p2p.P2P) {
 		self.cleanInactiveGovNode()
 
 		if seedOrGov {
+			self.sendOfflineWitness(net)
+
 			self.sendMembersRequestToRandNodes(net)
 			members := self.GetMembersInfo()
 			buf, _ := json.Marshal(members)
 			self.logger.Infof("[subnet] current members: %s", string(buf))
+			votes := self.GetOfflineVotes()
+			if len(votes) != 0 {
+				buf, _ = json.Marshal(votes)
+				self.logger.Infof("[subnet] current offline votes: %s", string(buf))
+			}
 		}
 
 		parker.ParkTimeout(RefreshDuration)
@@ -386,7 +407,10 @@ func (self *SubNet) GetMaskAddrFilter() p2p.AddressFilter {
 func (self *SubNet) GetMembersInfo() []common.SubnetMemberInfo {
 	self.lock.RLock()
 	defer self.lock.RUnlock()
+	return self.getMembersInfoLocked()
+}
 
+func (self *SubNet) getMembersInfoLocked() []common.SubnetMemberInfo {
 	var members []common.SubnetMemberInfo
 	for addr, mem := range self.members {
 		connected := self.selfAddr == addr
diff --git a/p2pserver/protocols/utils/govnode_resolver.go b/p2pserver/protocols/utils/govnode_resolver.go
index dc20ffb5aa..1d7da29cf9 100644
--- a/p2pserver/protocols/utils/govnode_resolver.go
+++ b/p2pserver/protocols/utils/govnode_resolver.go
@@ -37,9 +37,18 @@ import (
 
 const GovNodeCacheTime = time.Minute * 10
 
+type NodeRole byte
+
+const (
+	SyncNode      NodeRole = iota
+	CandidateNode          = iota
+	ConsensusNode          = iota
+)
+
 type GovNodeResolver interface {
 	IsGovNodePubKey(key keypair.PublicKey) bool
 	IsGovNode(key string) bool
+	GetNodeRoleAndView(key string) (NodeRole, uint32)
 }
 
 type GovNodeMockResolver struct {
@@ -61,6 +70,15 @@ func (self *GovNodeMockResolver) IsGovNode(key string) bool {
 	return ok
 }
 
+func (self *GovNodeMockResolver) GetNodeRoleAndView(key string) (NodeRole, uint32) {
+	_, ok := self.govNode[key]
+	if ok {
+		return CandidateNode, 0
+	}
+
+	return SyncNode, 0
+}
+
 func (self *GovNodeMockResolver) IsGovNodePubKey(key keypair.PublicKey) bool {
 	pubKey := vconfig.PubkeyID(key)
 	_, ok := self.govNode[pubKey]
@@ -78,13 +96,13 @@ type GovCache struct {
 	view        uint32
 	refreshTime time.Time
 	govNodeNum  uint32
-	pubkeys     map[string]struct{}
+	pubkeys     map[string]bool
 }
 
 func NewGovNodeResolver(db *ledger.Ledger) *GovNodeLedgerResolver {
 	return &GovNodeLedgerResolver{
 		db:    db,
-		cache: unsafe.Pointer(&GovCache{pubkeys: make(map[string]struct{})}),
+		cache: unsafe.Pointer(&GovCache{pubkeys: make(map[string]bool)}),
 	}
 }
 
@@ -94,29 +112,46 @@ func (self *GovNodeLedgerResolver) IsGovNodePubKey(key keypair.PublicKey) bool {
 }
 
 func (self *GovNodeLedgerResolver) IsGovNode(pubKey string) bool {
+	role, _ := self.GetNodeRoleAndView(pubKey)
+
+	return role != SyncNode
+}
+
+func (self *GovNodeLedgerResolver) GetNodeRoleAndView(pubKey string) (NodeRole, uint32) {
 	view, err := GetGovernanceView(self.db)
 	if err != nil {
 		log.Warnf("[subnet] gov node resolver failed to load view from ledger, err: %v", err)
-		return false
+		return SyncNode, 0
 	}
 	cached := (*GovCache)(atomic.LoadPointer(&self.cache))
 	if cached != nil && view.View == cached.view && cached.refreshTime.Add(GovNodeCacheTime).After(time.Now()) {
-		_, ok := cached.pubkeys[pubKey]
-		return ok
+		cons, ok := cached.pubkeys[pubKey]
+		if !ok {
+			return SyncNode, 0
+		}
+		if cons {
+			return ConsensusNode, view.View
+		}
+
+		return CandidateNode, view.View
 	}
 
-	govNode := false
+	nodeRole := SyncNode
 	peers, count, err := GetPeersConfig(self.db, view.View)
 	if err != nil {
 		log.Warnf("[subnet] gov node resolver failed to load peers from ledger, err: %v", err)
-		return false
+		return SyncNode, view.View
 	}
 
-	pubkeys := make(map[string]struct{}, len(peers))
+	pubkeys := make(map[string]bool, len(peers))
 	for _, peer := range peers {
-		pubkeys[peer.PeerPubkey] = struct{}{}
+		pubkeys[peer.PeerPubkey] = peer.ConsNode
 		if peer.PeerPubkey == pubKey {
-			govNode = true
+			if peer.ConsNode {
+				nodeRole = ConsensusNode
+			} else {
+				nodeRole = CandidateNode
+			}
 		}
 	}
 
@@ -130,7 +165,7 @@ func (self *GovNodeLedgerResolver) IsGovNode(pubKey string) bool {
 		view:        view.View,
 	}))
 
-	return govNode
+	return nodeRole, view.View
 }
 
 func GetGovernanceView(backend *ledger.Ledger) (*governance.GovernanceView, error) {
@@ -146,7 +181,12 @@ func GetGovernanceView(backend *ledger.Ledger) (*governance.GovernanceView, erro
 	return governanceView, nil
 }
 
-func GetPeersConfig(backend *ledger.Ledger, view uint32) ([]*config.VBFTPeerStakeInfo, uint32, error) {
+type GovNodeInfo struct {
+	ConsNode bool
+	*config.VBFTPeerStakeInfo
+}
+
+func GetPeersConfig(backend *ledger.Ledger, view uint32) ([]*GovNodeInfo, uint32, error) {
 	viewBytes := governance.GetUint32Bytes(view)
 	key := append([]byte(governance.PEER_POOL), viewBytes...)
 	data, err := backend.GetStorageItem(utils.GovernanceContractAddress, key)
@@ -162,8 +202,9 @@ func GetPeersConfig(backend *ledger.Ledger, view uint32) ([]*config.VBFTPeerStak
 	}
 
 	govCount := uint32(0)
-	var peerstakes []*config.VBFTPeerStakeInfo
+	var peerstakes []*GovNodeInfo
 	for _, id := range peerMap.PeerPoolMap {
+		isConsensus := id.Status == governance.ConsensusStatus || id.Status == governance.QuitConsensusStatus
 		switch id.Status {
 		case governance.CandidateStatus, governance.ConsensusStatus, governance.QuitConsensusStatus:
 			conf := &config.VBFTPeerStakeInfo{
@@ -171,9 +212,12 @@ func GetPeersConfig(backend *ledger.Ledger, view uint32) ([]*config.VBFTPeerStak
 				PeerPubkey: id.PeerPubkey,
 				InitPos:    id.InitPos + id.TotalPos,
 			}
-			peerstakes = append(peerstakes, conf)
+			peerstakes = append(peerstakes, &GovNodeInfo{
+				ConsNode:          isConsensus,
+				VBFTPeerStakeInfo: conf,
+			})
 		}
-		if id.Status == governance.ConsensusStatus || id.Status == governance.QuitConsensusStatus {
+		if isConsensus {
 			govCount += 1
 		}
 	}
diff --git a/smartcontract/service/native/utils/serialization.go b/smartcontract/service/native/utils/serialization.go
index 8b5d123a2b..fd265e757c 100644
--- a/smartcontract/service/native/utils/serialization.go
+++ b/smartcontract/service/native/utils/serialization.go
@@ -45,6 +45,7 @@ func EncodeString(sink *common.ZeroCopySink, str string) (size uint64) {
 func EncodeBool(sink *common.ZeroCopySink, value bool) {
 	sink.WriteBool(value)
 }
+
 func DecodeVarUint(source *common.ZeroCopySource) (uint64, error) {
 	value, _, irregular, eof := source.NextVarBytes()
 	if eof {

From a19e704ceac3257fc4a68578a5e3db993d28cae7 Mon Sep 17 00:00:00 2001
From: siovanus <siovanus@126.com>
Date: Thu, 6 Aug 2020 11:32:13 +0800
Subject: [PATCH 02/11] update height and abi file (#1269)

---
 cmd/abi/native_abi_script/governance.json | 54 ++++++++++-------------
 common/constants/constants.go             |  2 +-
 2 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/cmd/abi/native_abi_script/governance.json b/cmd/abi/native_abi_script/governance.json
index e3b8725af9..ea5c04dd01 100644
--- a/cmd/abi/native_abi_script/governance.json
+++ b/cmd/abi/native_abi_script/governance.json
@@ -443,6 +443,29 @@
       ],
       "returnType":"Bool"
     },
+    {
+      "name":"setFeePercentage",
+      "parameters":
+      [
+        {
+          "name":"PeerPubkey",
+          "type":"String"
+        },
+        {
+          "name":"Address",
+          "type":"Address"
+        },
+        {
+          "name":"PeerCost",
+          "type":"Int"
+        },
+        {
+          "name":"StakeCost",
+          "type":"Int"
+        }
+      ],
+      "returnType":"Bool"
+    },
     {
       "name":"withdrawFee",
       "parameters":
@@ -556,38 +579,9 @@
         }
       ],
       "returnType":"Bool"
-    },
-    {
-      "name":"getPeerPool",
-      "parameters":
-      [
-      ],
-      "returnType":"ByteArray"
-    },
-    {
-      "name":"getPeerInfo",
-      "parameters":
-      [
-        {
-          "name":"PeerPublicKey",
-          "type":"String"
-        }
-      ],
-      "returnType":"ByteArray"
-    },
-    {
-      "name":"getPeerPoolByAddress",
-      "parameters":
-      [
-        {
-          "name":"Address",
-          "type":"Address"
-        }
-      ],
-      "returnType":"ByteArray"
     }
   ],
   "events":
   [
   ]
-}
+}
\ No newline at end of file
diff --git a/common/constants/constants.go b/common/constants/constants.go
index 87356efbb7..b26bdb4b80 100644
--- a/common/constants/constants.go
+++ b/common/constants/constants.go
@@ -94,4 +94,4 @@ const BLOCKHEIGHT_CC_POLARIS = 13130000
 
 //new node cost height
 const BLOCKHEIGHT_NEW_PEER_COST_MAINNET = 9400000
-const BLOCKHEIGHT_NEW_PEER_COST_POLARIS = 13360000
+const BLOCKHEIGHT_NEW_PEER_COST_POLARIS = 13440000

From 2b598edfecadb36b758f21369a53b5dccba267f8 Mon Sep 17 00:00:00 2001
From: siovanus <siovanus@126.com>
Date: Thu, 6 Aug 2020 19:32:18 +0800
Subject: [PATCH 03/11] fix bugs (#1270)

---
 common/constants/constants.go                     | 2 +-
 smartcontract/service/native/governance/method.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/constants/constants.go b/common/constants/constants.go
index b26bdb4b80..18ece8c507 100644
--- a/common/constants/constants.go
+++ b/common/constants/constants.go
@@ -94,4 +94,4 @@ const BLOCKHEIGHT_CC_POLARIS = 13130000
 
 //new node cost height
 const BLOCKHEIGHT_NEW_PEER_COST_MAINNET = 9400000
-const BLOCKHEIGHT_NEW_PEER_COST_POLARIS = 13440000
+const BLOCKHEIGHT_NEW_PEER_COST_POLARIS = 13400000
diff --git a/smartcontract/service/native/governance/method.go b/smartcontract/service/native/governance/method.go
index d0a07e140c..deaceff70a 100644
--- a/smartcontract/service/native/governance/method.go
+++ b/smartcontract/service/native/governance/method.go
@@ -1416,7 +1416,7 @@ func splitNodeFee(native *native.NativeService, contract common.Address, peerPub
 	}
 	var amount uint64
 	if native.Height > config.GetNewPeerCostHeight() {
-		stakeFee := new(big.Int).Sub(
+		stakeFee := new(big.Int).Div(
 			new(big.Int).Mul(new(big.Int).SetUint64(nodeAmount), new(big.Int).SetUint64(totalPos)),
 			new(big.Int).Add(new(big.Int).SetUint64(initPos), new(big.Int).SetUint64(totalPos))).Uint64()
 		nodeFee := nodeAmount - stakeFee

From 26cf1fa5dd473dcf3f7e29f7ca5e7b677d0c01b7 Mon Sep 17 00:00:00 2001
From: laizy <laizy@users.noreply.github.com>
Date: Wed, 12 Aug 2020 15:52:04 +0800
Subject: [PATCH 04/11] remove old gov node ip from members in subnet (#1271)

* remove old gov node ip from members in subnet

* fix testcase
---
 p2pserver/mock/subnet_test.go                 |  6 +--
 p2pserver/protocols/subnet/offline_witness.go |  2 +-
 p2pserver/protocols/subnet/subnet.go          | 53 ++++++++++++++-----
 3 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/p2pserver/mock/subnet_test.go b/p2pserver/mock/subnet_test.go
index 2c1b03aa3b..97ac7ca48c 100644
--- a/p2pserver/mock/subnet_test.go
+++ b/p2pserver/mock/subnet_test.go
@@ -65,7 +65,7 @@ func TestSubnetAllGovAreSeed(t *testing.T) {
 	net := NewNetwork()
 	var nodes []*netserver.NetServer
 	for i := 0; i < SG; i++ {
-		seedNode := NewSubnetNode(acct[0], seedList[i], seedList, gov, net, nil, "seedgov")
+		seedNode := NewSubnetNode(acct[i], seedList[i], seedList, gov, net, nil, "seedgov")
 		go seedNode.Start()
 		nodes = append(nodes, seedNode)
 	}
@@ -85,7 +85,7 @@ func TestSubnetAllGovAreSeed(t *testing.T) {
 	//need some time for seed node detected it's identity
 	time.Sleep(time.Second * 20)
 	for i := 0; i < SG; i++ {
-		assert.Equal(t, len(getSubnetMemberInfo(nodes[i].Protocol())), SG, i)
+		assert.Equal(t, SG, len(getSubnetMemberInfo(nodes[i].Protocol())), i)
 	}
 	for i := 0; i < T; i++ {
 		assert.Equal(t, uint32(T)-1, nodes[i].GetConnectionCnt(), i)
@@ -123,7 +123,7 @@ func TestSubnet(t *testing.T) {
 	net := NewNetwork()
 	var nodes []*netserver.NetServer
 	for i := 0; i < S; i++ {
-		seedNode := NewSubnetNode(acct[0], seedList[i], seedList, gov, net, nil, "seed")
+		seedNode := NewSubnetNode(acct[i], seedList[i], seedList, gov, net, nil, "seed")
 		go seedNode.Start()
 		nodes = append(nodes, seedNode)
 	}
diff --git a/p2pserver/protocols/subnet/offline_witness.go b/p2pserver/protocols/subnet/offline_witness.go
index 20aa98c3e3..e9e9951151 100644
--- a/p2pserver/protocols/subnet/offline_witness.go
+++ b/p2pserver/protocols/subnet/offline_witness.go
@@ -198,7 +198,7 @@ func (self *SubNet) processOfflineWitnessMsg(ctx *p2p.Context, msg *types.Offlin
 
 func (self *SubNet) collectOfflineIndexLocked(nodes []string) []uint8 {
 	connected := make(map[string]bool)
-	for _, val := range self.getMembersInfoLocked() {
+	for _, val := range self.cleanAndGetMembersInfoLocked() {
 		if val.Connected {
 			connected[val.PubKey] = true
 		}
diff --git a/p2pserver/protocols/subnet/subnet.go b/p2pserver/protocols/subnet/subnet.go
index 0d2d4443ce..5dcb32a86d 100644
--- a/p2pserver/protocols/subnet/subnet.go
+++ b/p2pserver/protocols/subnet/subnet.go
@@ -201,10 +201,11 @@ func (self *SubNet) OnMembersRequest(ctx *p2p.Context, msg *types.SubnetMembersR
 	}
 
 	self.lock.Lock()
-	members := make([]types.MemberInfo, 0, len(self.members))
+	memberInfos := self.cleanAndGetMembersInfoLocked()
+	members := make([]types.MemberInfo, 0, len(memberInfos))
 
-	for addr, status := range self.members {
-		members = append(members, types.MemberInfo{PubKey: status.PubKey, Addr: addr})
+	for _, info := range memberInfos {
+		members = append(members, types.MemberInfo{PubKey: info.PubKey, Addr: info.ListenAddr})
 	}
 
 	//update self.members
@@ -403,15 +404,10 @@ func (self *SubNet) GetMaskAddrFilter() p2p.AddressFilter {
 	}
 }
 
-//restful api
-func (self *SubNet) GetMembersInfo() []common.SubnetMemberInfo {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	return self.getMembersInfoLocked()
-}
-
-func (self *SubNet) getMembersInfoLocked() []common.SubnetMemberInfo {
-	var members []common.SubnetMemberInfo
+// some gov node may change its listen ip address,
+// this function will try to remove old address
+func (self *SubNet) cleanAndGetMembersInfoLocked() map[string]common.SubnetMemberInfo {
+	members := make(map[string]common.SubnetMemberInfo)
 	for addr, mem := range self.members {
 		connected := self.selfAddr == addr
 		height := uint64(0)
@@ -421,14 +417,43 @@ func (self *SubNet) getMembersInfoLocked() []common.SubnetMemberInfo {
 			height = p.Height()
 			version = p.SoftVersion
 		}
-		members = append(members, common.SubnetMemberInfo{
+
+		curr := common.SubnetMemberInfo{
 			PubKey:     mem.PubKey,
 			ListenAddr: addr,
 			Connected:  connected,
 			Height:     height,
 			Version:    version,
-		})
+		}
+
+		prev, ok := members[mem.PubKey]
+		if !ok {
+			members[mem.PubKey] = curr
+		} else { // already has one item
+			if connected && !prev.Connected { // delete prev if curr is connected, but prev is not
+				delete(self.members, prev.ListenAddr)
+				members[mem.PubKey] = curr
+			} else if prev.Connected && !connected { // delete curr if prev is connected, but curr is not
+				delete(self.members, addr)
+			}
+
+			// keep both if both not connected, (both connected is not possible because of p2p handshake)
+		}
 	}
 
 	return members
 }
+
+//restful api
+func (self *SubNet) GetMembersInfo() []common.SubnetMemberInfo {
+	self.lock.Lock()
+	members := self.cleanAndGetMembersInfoLocked()
+	self.lock.Unlock()
+
+	result := make([]common.SubnetMemberInfo, 0, len(members))
+	for _, info := range members {
+		result = append(result, info)
+	}
+
+	return result
+}

From fb3d61fdc12ec039620acfea6854b7ed0ab524f9 Mon Sep 17 00:00:00 2001
From: laizy <laizy@users.noreply.github.com>
Date: Mon, 17 Aug 2020 19:18:15 +0800
Subject: [PATCH 05/11] add sign hash based on chain id for transaction (#1273)

---
 core/types/transaction.go      | 22 ++++++++++++------
 core/types/transaction_test.go | 41 ++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 7 deletions(-)
 create mode 100644 core/types/transaction_test.go

diff --git a/core/types/transaction.go b/core/types/transaction.go
index d1aa28ddaf..100c6ee5b5 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -47,8 +47,9 @@ type Transaction struct {
 
 	Raw []byte // raw transaction data
 
-	hash       common.Uint256
-	SignedAddr []common.Address // this is assigned when passed signature verification
+	hashUnsigned common.Uint256
+	hash         common.Uint256
+	SignedAddr   []common.Address // this is assigned when passed signature verification
 
 	nonDirectConstracted bool // used to check literal construction like `tx := &Transaction{...}`
 }
@@ -78,8 +79,8 @@ func (tx *Transaction) Deserialization(source *common.ZeroCopySource) error {
 	lenUnsigned := pos - pstart
 	source.BackUp(lenUnsigned)
 	rawUnsigned, _ := source.NextBytes(lenUnsigned)
-	temp := sha256.Sum256(rawUnsigned)
-	tx.hash = common.Uint256(sha256.Sum256(temp[:]))
+	tx.hashUnsigned = sha256.Sum256(rawUnsigned)
+	tx.hash = common.Uint256(sha256.Sum256(tx.hashUnsigned[:]))
 
 	// tx sigs
 	length, _, irregular, eof := source.NextVarUint()
@@ -321,7 +322,14 @@ func (tx *Transaction) Hash() common.Uint256 {
 	return tx.hash
 }
 
-func (tx *Transaction) Verify() error {
-	panic("unimplemented ")
-	return nil
+// calculate a hash for another chain to sign.
+// and take the chain id of ontology as 0.
+func (tx *Transaction) SigHashForChain(id uint32) common.Uint256 {
+	sink := common.NewZeroCopySink(nil)
+	sink.WriteHash(tx.hashUnsigned)
+	if id != 0 {
+		sink.WriteUint32(id)
+	}
+
+	return common.Uint256(sha256.Sum256(sink.Bytes()))
 }
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
new file mode 100644
index 0000000000..1cb830cf97
--- /dev/null
+++ b/core/types/transaction_test.go
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2018 The ontology Authors
+ * This file is part of The ontology library.
+ *
+ * The ontology is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The ontology is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package types
+
+import (
+	"math"
+	"testing"
+
+	"github.com/ontio/ontology/core/payload"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTransaction_SigHashForChain(t *testing.T) {
+	mutable := &MutableTransaction{
+		TxType:  InvokeNeo,
+		Payload: &payload.InvokeCode{},
+	}
+
+	tx, err := mutable.IntoImmutable()
+	assert.Nil(t, err)
+
+	assert.Equal(t, tx.Hash(), tx.SigHashForChain(0))
+	assert.NotEqual(t, tx.Hash(), tx.SigHashForChain(1))
+	assert.NotEqual(t, tx.Hash(), tx.SigHashForChain(math.MaxUint32))
+}

From 591f7ce1009c02f5a358135d930dba2fc85df4a3 Mon Sep 17 00:00:00 2001
From: rongyi <rongyi@onchain.com>
Date: Thu, 27 Aug 2020 18:31:03 +0800
Subject: [PATCH 06/11] Add testmode check in initNodeInfo (#1275)

---
 main.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/main.go b/main.go
index ec4aeb3d28..863784c639 100644
--- a/main.go
+++ b/main.go
@@ -44,7 +44,6 @@ import (
 	"github.com/ontio/ontology/core/ledger"
 	"github.com/ontio/ontology/events"
 	bactor "github.com/ontio/ontology/http/base/actor"
-	hserver "github.com/ontio/ontology/http/base/actor"
 	"github.com/ontio/ontology/http/jsonrpc"
 	"github.com/ontio/ontology/http/localrpc"
 	"github.com/ontio/ontology/http/nodeinfo"
@@ -292,8 +291,8 @@ func initTxPool(ctx *cli.Context) (*proc.TXPoolServer, error) {
 	stfValidator, _ := stateful.NewValidator("stateful_validator")
 	stfValidator.Register(txPoolServer.GetPID(tc.VerifyRspActor))
 
-	hserver.SetTxnPoolPid(txPoolServer.GetPID(tc.TxPoolActor))
-	hserver.SetTxPid(txPoolServer.GetPID(tc.TxActor))
+	bactor.SetTxnPoolPid(txPoolServer.GetPID(tc.TxPoolActor))
+	bactor.SetTxPid(txPoolServer.GetPID(tc.TxActor))
 
 	log.Infof("TxPool init success")
 	return txPoolServer, nil
@@ -314,7 +313,7 @@ func initP2PNode(ctx *cli.Context, txpoolSvr *proc.TXPoolServer, acct *account.A
 	}
 	netreqactor.SetTxnPoolPid(txpoolSvr.GetPID(tc.TxActor))
 	txpoolSvr.Net = p2p.GetNetwork()
-	hserver.SetNetServer(p2p.GetNetwork())
+	bactor.SetNetServer(p2p.GetNetwork())
 	p2p.WaitForPeersStart()
 	log.Infof("P2P init success")
 	return p2p, p2p.GetNetwork(), nil
@@ -334,7 +333,7 @@ func initConsensus(ctx *cli.Context, net p2p.P2P, txpoolSvr *proc.TXPoolServer,
 	consensusService.Start()
 
 	netreqactor.SetConsensusPid(consensusService.GetPID())
-	hserver.SetConsensusPid(consensusService.GetPID())
+	bactor.SetConsensusPid(consensusService.GetPID())
 
 	log.Infof("Consensus init success")
 	return consensusService, nil
@@ -408,7 +407,8 @@ func initWs(ctx *cli.Context) {
 }
 
 func initNodeInfo(ctx *cli.Context, p2pSvr *p2pserver.P2PServer) {
-	if config.DefConfig.P2PNode.HttpInfoPort == 0 {
+	// testmode has no p2pserver(see function initP2PNode for detail), simply ignore httpInfoPort in testmode
+	if ctx.Bool(utils.GetFlagName(utils.EnableTestModeFlag)) || config.DefConfig.P2PNode.HttpInfoPort == 0 {
 		return
 	}
 	go nodeinfo.StartServer(p2pSvr.GetNetwork())

From e2351296e732444dd64a8bda0efcaaa2279a09d5 Mon Sep 17 00:00:00 2001
From: rongyi <rongyi@onchain.com>
Date: Wed, 2 Sep 2020 10:02:02 +0800
Subject: [PATCH 07/11] fix static check lint issue (#1277)

* Drop duplicate import

* Drop redundant return and break statement

* for true ==> for

* Fix bool cmp lint

should omit comparison to bool constant

* use or drop unused variables

* Drop empty branch

* Some fmt.Sprintf is useless, drop it

* should call self.quitWg.Add(1) before starting the goroutine to avoid a race

* drop for, using append

* Update cmd/tx_cmd.go

* Update consensus/vbft/node_sync.go

Co-authored-by: laizy <laizy@users.noreply.github.com>
---
 cmd/account.go                                | 12 +---
 cmd/common/notice.go                          |  3 -
 cmd/contract_cmd.go                           |  2 +-
 cmd/sig_tx_cmd.go                             |  6 ++
 cmd/tx_cmd.go                                 | 15 +++--
 cmd/utils/ont.go                              | 15 +++--
 common/config/config.go                       |  3 +
 consensus/dbft/block_signatures.go            |  4 ++
 consensus/dbft/consensus_message.go           |  4 ++
 consensus/dbft/dbft_service.go                |  6 +-
 consensus/dbft/prepare_request.go             |  7 +++
 consensus/vbft/block_pool.go                  |  7 +--
 consensus/vbft/chain_store.go                 |  6 +-
 consensus/vbft/node_sync.go                   | 17 ++----
 consensus/vbft/service.go                     | 59 +++++++++----------
 consensus/vbft/utils.go                       |  2 +-
 core/payload/deploy_code.go                   | 24 ++++++++
 core/program/program.go                       |  2 +-
 core/signature/signature.go                   |  2 +-
 core/store/ledgerstore/ledger_store.go        |  1 -
 core/store/ledgerstore/state_store.go         |  3 +
 core/store/overlaydb/iterator.go              | 14 ++---
 core/store/overlaydb/memdb.go                 |  1 -
 core/store/overlaydb/overlaydb.go             |  2 +-
 core/types/header.go                          | 33 +++++++++++
 core/types/transaction.go                     | 23 +++++++-
 core/validation/block_validator.go            |  4 +-
 core/validation/transaction_validator.go      |  2 +-
 errors/callstack.go                           |  2 +-
 http/restful/restful/router.go                | 12 ++--
 merkle/merkle_tree.go                         |  2 +-
 p2pserver/message/types/offline_witness.go    |  3 +
 .../service/native/governance/method.go       |  2 +-
 .../service/native/native_service.go          |  3 +-
 smartcontract/service/native/ong/ong.go       |  2 +-
 smartcontract/service/native/ont/ont.go       |  2 +-
 smartcontract/service/native/ontfs/app_sdk.go |  2 +-
 smartcontract/service/native/ontid/event.go   |  1 -
 smartcontract/service/native/ontid/init.go    |  1 -
 smartcontract/service/native/ontid/method.go  |  3 +
 .../service/native/utils/operation.go         |  2 +-
 smartcontract/service/neovm/runtime.go        |  3 +
 smartcontract/service/neovm/wasmvm.go         |  2 +-
 smartcontract/service/util/util.go            |  4 +-
 smartcontract/service/wasmvm/contract.go      |  3 +
 smartcontract/service/wasmvm/utils.go         |  2 +-
 smartcontract/service/wasmvm/wasm_service.go  |  2 +-
 smartcontract/states/contract.go              |  9 +++
 smartcontract/states/wasmContract.go          |  3 +
 txnpool/proc/txnpool_server.go                |  5 +-
 vm/crossvm_codec/notify_codec.go              |  2 +-
 vm/crossvm_codec/vmcall_codec.go              |  2 +-
 vm/neovm/executor.go                          |  2 +-
 vm/neovm/types/int_value.go                   | 22 +++----
 vm/neovm/types/neovm_value.go                 |  2 +-
 55 files changed, 238 insertions(+), 141 deletions(-)

diff --git a/cmd/account.go b/cmd/account.go
index fac1818216..d9aa660574 100644
--- a/cmd/account.go
+++ b/cmd/account.go
@@ -108,7 +108,7 @@ var schemeMap = map[string]schemeInfo{
 // wait for user to choose options
 func chooseKeyType(reader *bufio.Reader) string {
 	common.PrintNotice("key type")
-	for true {
+	for {
 		tmp, _ := reader.ReadString('\n')
 		tmp = strings.TrimSpace(tmp)
 		_, ok := keyTypeMap[tmp]
@@ -123,7 +123,7 @@ func chooseKeyType(reader *bufio.Reader) string {
 }
 func chooseScheme(reader *bufio.Reader) string {
 	common.PrintNotice("signature-scheme")
-	for true {
+	for {
 		tmp, _ := reader.ReadString('\n')
 		tmp = strings.TrimSpace(tmp)
 
@@ -139,7 +139,7 @@ func chooseScheme(reader *bufio.Reader) string {
 }
 func chooseCurve(reader *bufio.Reader) string {
 	common.PrintNotice("curve")
-	for true {
+	for {
 		tmp, _ := reader.ReadString('\n')
 		tmp = strings.TrimSpace(tmp)
 		_, ok := curveMap[tmp]
@@ -217,15 +217,12 @@ func checkCurve(ctx *cli.Context, reader *bufio.Reader, t *string) string {
 		} else {
 			c = chooseCurve(reader)
 		}
-		break
 	case "sm2":
 		fmt.Println("Use curve sm2p256v1 with key length of 256 bits.")
 		c = "SM2P256V1"
-		break
 	case "ed25519":
 		fmt.Println("Use curve 25519 with key length of 256 bits.")
 		c = "ED25519"
-		break
 	default:
 		return ""
 	}
@@ -247,15 +244,12 @@ func checkScheme(ctx *cli.Context, reader *bufio.Reader, t *string) string {
 		} else {
 			sch = chooseScheme(reader)
 		}
-		break
 	case "sm2":
 		fmt.Println("Use SM3withSM2 as the signature scheme.")
 		sch = "SM3withSM2"
-		break
 	case "ed25519":
 		fmt.Println("Use SHA512withEdDSA as the signature scheme.")
 		sch = "SHA512withEdDSA"
-		break
 	default:
 		return ""
 	}
diff --git a/cmd/common/notice.go b/cmd/common/notice.go
index f50f731fb9..1f5ac08ad0 100644
--- a/cmd/common/notice.go
+++ b/cmd/common/notice.go
@@ -32,7 +32,6 @@ Select a signature algorithm from the following:
   3  Ed25519
 
 [default is 1]: `)
-		break
 
 	case "curve":
 		fmt.Printf(`
@@ -46,7 +45,6 @@ Select a curve from the following:
   4 | P-521 | 521
 
 This determines the length of the private key [default is 2]: `)
-		break
 
 	case "signature-scheme":
 		fmt.Printf(`
@@ -63,7 +61,6 @@ Select a signature scheme from the following:
   9  RIPEMD160withECDSA
 
 This can be changed later [default is 2]: `)
-		break
 
 	default:
 	}
diff --git a/cmd/contract_cmd.go b/cmd/contract_cmd.go
index 03a8d483ea..1fd76127d2 100644
--- a/cmd/contract_cmd.go
+++ b/cmd/contract_cmd.go
@@ -156,7 +156,7 @@ func deployContract(ctx *cli.Context) error {
 		gasPrice = 0
 	}
 
-	cversion := fmt.Sprintf("%s", version)
+	cversion := version
 
 	if ctx.IsSet(utils.GetFlagName(utils.ContractPrepareDeployFlag)) {
 		preResult, err := utils.PrepareDeployContract(vmtype, code, name, cversion, author, email, desc)
diff --git a/cmd/sig_tx_cmd.go b/cmd/sig_tx_cmd.go
index b8ea22eb8c..14c6718308 100644
--- a/cmd/sig_tx_cmd.go
+++ b/cmd/sig_tx_cmd.go
@@ -93,6 +93,9 @@ func genMultiSigAddress(ctx *cli.Context) error {
 			continue
 		}
 		data, err := hex.DecodeString(pk)
+		if err != nil {
+			return err
+		}
 		pubKey, err := keypair.DeserializePublicKey(data)
 		if err != nil {
 			return fmt.Errorf("invalid pub key:%s", pk)
@@ -141,6 +144,9 @@ func multiSigToTx(ctx *cli.Context) error {
 			continue
 		}
 		data, err := hex.DecodeString(pk)
+		if err != nil {
+			return err
+		}
 		pubKey, err := keypair.DeserializePublicKey(data)
 		if err != nil {
 			return fmt.Errorf("invalid pub key:%s", pk)
diff --git a/cmd/tx_cmd.go b/cmd/tx_cmd.go
index df2bb7356b..60163a6b8f 100644
--- a/cmd/tx_cmd.go
+++ b/cmd/tx_cmd.go
@@ -205,10 +205,10 @@ func transferTx(ctx *cli.Context) error {
 	switch strings.ToLower(asset) {
 	case "ont":
 		amount = utils.ParseOnt(amountStr)
-		amountStr = utils.FormatOnt(amount)
+		// amountStr = utils.FormatOnt(amount)
 	case "ong":
 		amount = utils.ParseOng(amountStr)
-		amountStr = utils.FormatOng(amount)
+		// amountStr = utils.FormatOng(amount)
 	default:
 		return fmt.Errorf("unsupport asset:%s", asset)
 	}
@@ -277,10 +277,10 @@ func approveTx(ctx *cli.Context) error {
 	switch strings.ToLower(asset) {
 	case "ont":
 		amount = utils.ParseOnt(amountStr)
-		amountStr = utils.FormatOnt(amount)
+		// amountStr = utils.FormatOnt(amount)
 	case "ong":
 		amount = utils.ParseOng(amountStr)
-		amountStr = utils.FormatOng(amount)
+		// amountStr = utils.FormatOng(amount)
 	default:
 		return fmt.Errorf("unsupport asset:%s", asset)
 	}
@@ -363,10 +363,9 @@ func transferFromTx(ctx *cli.Context) error {
 	switch strings.ToLower(asset) {
 	case "ont":
 		amount = utils.ParseOnt(amountStr)
-		amountStr = utils.FormatOnt(amount)
 	case "ong":
 		amount = utils.ParseOng(amountStr)
-		amountStr = utils.FormatOng(amount)
+		// amountStr = utils.FormatOng(amount)
 	default:
 		return fmt.Errorf("unsupport asset:%s", asset)
 	}
@@ -425,13 +424,13 @@ func withdrawONGTx(ctx *cli.Context) error {
 		if amount <= 0 {
 			return fmt.Errorf("haven't unbound ong")
 		}
-		amountStr = utils.FormatOng(amount)
+		// amountStr = utils.FormatOng(amount)
 	} else {
 		amount = utils.ParseOng(amountStr)
 		if amount <= 0 {
 			return fmt.Errorf("haven't unbound ong")
 		}
-		amountStr = utils.FormatOng(amount)
+		// amountStr = utils.FormatOng(amount)
 	}
 
 	var payer common.Address
diff --git a/cmd/utils/ont.go b/cmd/utils/ont.go
index 2aba7b5b67..cda40a90cf 100644
--- a/cmd/utils/ont.go
+++ b/cmd/utils/ont.go
@@ -41,7 +41,6 @@ import (
 	"github.com/ontio/ontology/core/types"
 	cutils "github.com/ontio/ontology/core/utils"
 	httpcom "github.com/ontio/ontology/http/base/common"
-	rpccommon "github.com/ontio/ontology/http/base/common"
 	"github.com/ontio/ontology/smartcontract/service/native/ont"
 	"github.com/ontio/ontology/smartcontract/service/native/utils"
 )
@@ -454,12 +453,12 @@ func SendRawTransactionData(txData string) (string, error) {
 	return hexHash, nil
 }
 
-func PrepareSendRawTransaction(txData string) (*rpccommon.PreExecuteResult, error) {
+func PrepareSendRawTransaction(txData string) (*httpcom.PreExecuteResult, error) {
 	data, ontErr := sendRpcRequest("sendrawtransaction", []interface{}{txData, 1})
 	if ontErr != nil {
 		return nil, ontErr.Error
 	}
-	preResult := &rpccommon.PreExecuteResult{}
+	preResult := &httpcom.PreExecuteResult{}
 	err := json.Unmarshal(data, &preResult)
 	if err != nil {
 		return nil, fmt.Errorf("json.Unmarshal PreExecResult:%s error:%s", data, err)
@@ -468,7 +467,7 @@ func PrepareSendRawTransaction(txData string) (*rpccommon.PreExecuteResult, erro
 }
 
 //GetSmartContractEvent return smart contract event execute by invoke transaction by hex string code
-func GetSmartContractEvent(txHash string) (*rpccommon.ExecuteNotify, error) {
+func GetSmartContractEvent(txHash string) (*httpcom.ExecuteNotify, error) {
 	data, ontErr := sendRpcRequest("getsmartcodeevent", []interface{}{txHash})
 	if ontErr != nil {
 		switch ontErr.ErrorCode {
@@ -477,7 +476,7 @@ func GetSmartContractEvent(txHash string) (*rpccommon.ExecuteNotify, error) {
 		}
 		return nil, ontErr.Error
 	}
-	notifies := &rpccommon.ExecuteNotify{}
+	notifies := &httpcom.ExecuteNotify{}
 	err := json.Unmarshal(data, &notifies)
 	if err != nil {
 		return nil, fmt.Errorf("json.Unmarshal SmartContactEvent:%s error:%s", data, err)
@@ -714,7 +713,7 @@ func InvokeSmartContract(signer *account.Account, tx *types.MutableTransaction)
 func PrepareInvokeNeoVMContract(
 	contractAddress common.Address,
 	params []interface{},
-) (*rpccommon.PreExecuteResult, error) {
+) (*httpcom.PreExecuteResult, error) {
 	mutable, err := httpcom.NewNeovmInvokeTransaction(0, 0, contractAddress, params)
 	if err != nil {
 		return nil, err
@@ -729,7 +728,7 @@ func PrepareInvokeNeoVMContract(
 	return PrepareSendRawTransaction(txData)
 }
 
-func PrepareInvokeCodeNeoVMContract(code []byte) (*rpccommon.PreExecuteResult, error) {
+func PrepareInvokeCodeNeoVMContract(code []byte) (*httpcom.PreExecuteResult, error) {
 	mutable, err := httpcom.NewSmartContractTransaction(0, 0, code)
 	if err != nil {
 		return nil, err
@@ -743,7 +742,7 @@ func PrepareInvokeCodeNeoVMContract(code []byte) (*rpccommon.PreExecuteResult, e
 }
 
 //prepare invoke wasm
-func PrepareInvokeWasmVMContract(contractAddress common.Address, params []interface{}) (*rpccommon.PreExecuteResult, error) {
+func PrepareInvokeWasmVMContract(contractAddress common.Address, params []interface{}) (*httpcom.PreExecuteResult, error) {
 	mutable, err := cutils.NewWasmVMInvokeTransaction(0, 0, contractAddress, params)
 	if err != nil {
 		return nil, err
diff --git a/common/config/config.go b/common/config/config.go
index 4af797fe44..9809a1d441 100644
--- a/common/config/config.go
+++ b/common/config/config.go
@@ -731,6 +731,9 @@ func (this *OntologyConfig) GetBookkeepers() ([]keypair.PublicKey, error) {
 	pubKeys := make([]keypair.PublicKey, 0, len(bookKeepers))
 	for _, key := range bookKeepers {
 		pubKey, err := hex.DecodeString(key)
+		if err != nil {
+			return nil, err
+		}
 		k, err := keypair.DeserializePublicKey(pubKey)
 		if err != nil {
 			return nil, fmt.Errorf("Incorrectly book keepers key:%s", key)
diff --git a/consensus/dbft/block_signatures.go b/consensus/dbft/block_signatures.go
index 96cff06b96..21ba4001b8 100644
--- a/consensus/dbft/block_signatures.go
+++ b/consensus/dbft/block_signatures.go
@@ -62,6 +62,10 @@ func (self *BlockSignatures) Deserialization(source *common.ZeroCopySource) erro
 		sig := SignaturesData{}
 
 		sig.Signature, _, irregular, eof = source.NextVarBytes()
+		if eof {
+			return io.ErrUnexpectedEOF
+		}
+
 		if irregular {
 			return common.ErrIrregularData
 		}
diff --git a/consensus/dbft/consensus_message.go b/consensus/dbft/consensus_message.go
index 1833512dac..363d0e6bfc 100644
--- a/consensus/dbft/consensus_message.go
+++ b/consensus/dbft/consensus_message.go
@@ -98,6 +98,10 @@ func (cd *ConsensusMessageData) Deserialization(source *common.ZeroCopySource) e
 	var eof bool
 	var temp byte
 	temp, eof = source.NextByte()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	cd.Type = ConsensusMessageType(temp)
 	cd.ViewNumber, eof = source.NextByte()
 	if eof {
diff --git a/consensus/dbft/dbft_service.go b/consensus/dbft/dbft_service.go
index 4acdd5cb02..42a0dea775 100644
--- a/consensus/dbft/dbft_service.go
+++ b/consensus/dbft/dbft_service.go
@@ -96,7 +96,7 @@ func NewDbftService(bkAccount *account.Account, txpool *actor.PID, p2p p2p.P2P)
 }
 
 func (this *DbftService) Receive(context actor.Context) {
-	if _, ok := context.Message().(*actorTypes.StartConsensus); this.started == false && ok == false {
+	if _, ok := context.Message().(*actorTypes.StartConsensus); !this.started && !ok {
 		return
 	}
 
@@ -359,22 +359,18 @@ func (ds *DbftService) NewConsensusPayload(payload *p2pmsg.ConsensusPayload) {
 		if cv, ok := message.(*ChangeView); ok {
 			ds.ChangeViewReceived(payload, cv)
 		}
-		break
 	case PrepareRequestMsg:
 		if pr, ok := message.(*PrepareRequest); ok {
 			ds.PrepareRequestReceived(payload, pr)
 		}
-		break
 	case PrepareResponseMsg:
 		if pres, ok := message.(*PrepareResponse); ok {
 			ds.PrepareResponseReceived(payload, pres)
 		}
-		break
 	case BlockSignaturesMsg:
 		if blockSigs, ok := message.(*BlockSignatures); ok {
 			ds.BlockSignaturesReceived(payload, blockSigs)
 		}
-		break
 	default:
 		log.Warn("unknown consensus message type")
 	}
diff --git a/consensus/dbft/prepare_request.go b/consensus/dbft/prepare_request.go
index 28caed11f3..ec45b40ca2 100644
--- a/consensus/dbft/prepare_request.go
+++ b/consensus/dbft/prepare_request.go
@@ -62,9 +62,16 @@ func (pr *PrepareRequest) Deserialization(source *common.ZeroCopySource) error {
 	}
 	pr.Nonce = nonce
 	pr.NextBookkeeper, eof = source.NextAddress()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 
 	var length uint64
 	length, _, irregular, eof = source.NextVarUint()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
diff --git a/consensus/vbft/block_pool.go b/consensus/vbft/block_pool.go
index 1a990928b1..6a8651d295 100644
--- a/consensus/vbft/block_pool.go
+++ b/consensus/vbft/block_pool.go
@@ -111,9 +111,9 @@ func (pool *BlockPool) clean() {
 
 func (pool *BlockPool) getCandidateInfoLocked(blkNum uint32) *CandidateInfo {
 	// NOTE: call this function only when pool.lock locked
-	if candidate, present := pool.candidateBlocks[blkNum]; !present {
+	if _, present := pool.candidateBlocks[blkNum]; !present {
 		// new candiateInfo for blockNum
-		candidate = &CandidateInfo{
+		candidate := &CandidateInfo{
 			Proposals:   make([]*blockProposalMsg, 0),
 			CommitMsgs:  make([]*blockCommitMsg, 0),
 			EndorseSigs: make(map[uint32][]*CandidateEndorseSigInfo),
@@ -137,7 +137,7 @@ func (pool *BlockPool) newBlockProposal(msg *blockProposalMsg) error {
 	// check dup-proposal from same proposer
 	for _, p := range candidate.Proposals {
 		if p.Block.getProposer() == msg.Block.getProposer() {
-			if bytes.Compare(p.BlockProposerSig, msg.BlockProposerSig) == 0 {
+			if bytes.Equal(p.BlockProposerSig, msg.BlockProposerSig) {
 				return nil
 			}
 			return errDupProposal
@@ -287,7 +287,6 @@ func (pool *BlockPool) addBlockEndorsementLocked(blkNum uint32, endorser uint32,
 	} else {
 		candidate.EndorseSigs[endorser] = []*CandidateEndorseSigInfo{eSig}
 	}
-	return
 }
 
 //
diff --git a/consensus/vbft/chain_store.go b/consensus/vbft/chain_store.go
index 59fcd65d1f..c9c3a44db6 100644
--- a/consensus/vbft/chain_store.go
+++ b/consensus/vbft/chain_store.go
@@ -176,14 +176,12 @@ func (self *ChainStore) submitBlock(blkNum uint32) error {
 	if blkNum == 0 {
 		return nil
 	}
-	if submitBlk, present := self.pendingBlocks[blkNum]; submitBlk != nil && submitBlk.hasSubmitted == false && present {
+	if submitBlk, present := self.pendingBlocks[blkNum]; submitBlk != nil && !submitBlk.hasSubmitted && present {
 		err := self.db.SubmitBlock(submitBlk.block.Block, submitBlk.block.CrossChainMsg, *submitBlk.execResult)
 		if err != nil {
 			return fmt.Errorf("ledger add submitBlk (%d, %d, %d) failed: %s", blkNum, self.GetChainedBlockNum(), self.db.GetCurrentBlockHeight(), err)
 		}
-		if _, present := self.pendingBlocks[blkNum-1]; present {
-			delete(self.pendingBlocks, blkNum-1)
-		}
+		delete(self.pendingBlocks, blkNum-1)
 		submitBlk.hasSubmitted = true
 	}
 	return nil
diff --git a/consensus/vbft/node_sync.go b/consensus/vbft/node_sync.go
index ec9b7de690..fc739bad5e 100644
--- a/consensus/vbft/node_sync.go
+++ b/consensus/vbft/node_sync.go
@@ -153,9 +153,9 @@ func (self *Syncer) run() {
 					// report err
 					p.msgC <- nil
 				}
-			} else {
-				// report error
-			}
+			} //  else {
+			// 	// report error
+			// }
 
 		case blkMsgFromPeer := <-self.blockFromPeerC:
 			blkNum := blkMsgFromPeer.block.getBlockNum()
@@ -312,12 +312,7 @@ func (self *Syncer) onNewBlockSyncReq(req *BlockSyncReq) {
 		self.nextReqBlkNum = req.startBlockNum
 	}
 	self.targetBlkNum = req.targetBlockNum
-	peers := req.targetPeers
-	if len(peers) == 0 {
-		for p := range self.peers {
-			peers = append(peers, p)
-		}
-	}
+	// }
 
 	for _, peerIdx := range req.targetPeers {
 		if p, present := self.peers[peerIdx]; !present || !p.active {
@@ -434,7 +429,7 @@ func (self *PeerSyncer) requestBlock(blkNum uint32) (*Block, error) {
 		case BlockFetchRespMessage:
 			pMsg, ok := msg.(*BlockFetchRespMsg)
 			if !ok {
-				// log error
+				return nil, fmt.Errorf("expect request type: BlockFetchMessage")
 			}
 			return pMsg.BlockData, nil
 		}
@@ -465,7 +460,7 @@ func (self *PeerSyncer) requestBlockInfo(startBlkNum uint32) ([]*BlockInfo_, err
 		case BlockInfoFetchRespMessage:
 			pMsg, ok := msg.(*BlockInfoFetchRespMsg)
 			if !ok {
-				// log error
+				return nil, fmt.Errorf("expect request type: BlockInfoFetchRespMessage")
 			}
 			return pMsg.Blocks, nil
 		}
diff --git a/consensus/vbft/service.go b/consensus/vbft/service.go
index 089de9d072..628f5c7118 100644
--- a/consensus/vbft/service.go
+++ b/consensus/vbft/service.go
@@ -485,8 +485,8 @@ func (self *Server) initialize() error {
 	go self.msgSendLoop()
 	go self.timerLoop()
 	go self.actionLoop()
+	self.quitWg.Add(1)
 	go func() {
-		self.quitWg.Add(1)
 		defer self.quitWg.Done()
 
 		for {
@@ -1226,9 +1226,9 @@ func (self *Server) processMsgEvent() error {
 			if msgBlkNum == self.GetCurrentBlockNo() {
 				// add proposal to block-pool
 				if err := self.blockPool.newBlockProposal(pMsg); err != nil {
-					if err == errDupProposal {
-						// TODO: faulty proposer detected
-					}
+					// if err == errDupProposal {
+					// 	// TODO: faulty proposer detected
+					// }
 					log.Errorf("failed to add block proposal (%d): %s", msgBlkNum, err)
 					return nil
 				}
@@ -1263,13 +1263,13 @@ func (self *Server) processMsgEvent() error {
 					}
 					// makeProposalTimeout handles non-leader proposals
 				}
-			} else {
-				// process new proposal when
-				// 1. we have endorsed for current BlockNum
-				// 2. proposal is from next potential-leader
+			} //  else {
+			// 	// process new proposal when
+			// 	// 1. we have endorsed for current BlockNum
+			// 	// 2. proposal is from next potential-leader
 
-				// TODO
-			}
+			// 	// TODO
+			// }
 
 		case BlockEndorseMessage:
 			pMsg := msg.(*blockEndorseMsg)
@@ -1314,12 +1314,12 @@ func (self *Server) processMsgEvent() error {
 								return nil
 							}
 						}
-					} else {
-						// wait until endorse timeout
-					}
-				} else {
-					// makeEndorsementTimeout handles non-endorser endorsements
-				}
+					} // else {
+					// 	// wait until endorse timeout
+					// }
+				} // else {
+				// 	// makeEndorsementTimeout handles non-endorser endorsements
+				// }
 				if self.blockPool.endorseFailed(msgBlkNum, self.GetChainConfig().C) {
 					// endorse failed, start empty endorsing
 					self.timer.C <- &TimerEvent{
@@ -1327,11 +1327,11 @@ func (self *Server) processMsgEvent() error {
 						blockNum: msgBlkNum,
 					}
 				}
-			} else {
-				// process new endorsement when
-				// 1. we have committed for current BlockNum
-				// 2. endorsed proposal is from next potential-leader
-			}
+			} // else {
+			// 	// process new endorsement when
+			// 	// 1. we have committed for current BlockNum
+			// 	// 2. endorsed proposal is from next potential-leader
+			// }
 
 		case BlockCommitMessage:
 			pMsg := msg.(*blockCommitMsg)
@@ -1376,15 +1376,15 @@ func (self *Server) processMsgEvent() error {
 					if err := self.makeSealed(proposal, forEmpty); err != nil {
 						log.Errorf("failed to seal block %d, err: %s", msgBlkNum, err)
 					}
-				} else {
-					// wait commit timeout, nothing to do
-				}
+				} // else {
+				// 	// wait commit timeout, nothing to do
+				// }
 
-			} else {
-				// nothing to do besides adding to msg pool
+			} //  else {
+			// 	// nothing to do besides adding to msg pool
 
-				// FIXME: add msg from msg-pool to block-pool when starting new block-round
-			}
+			// 	// FIXME: add msg from msg-pool to block-pool when starting new block-round
+			// }
 		}
 
 	case <-self.quitC:
@@ -2212,8 +2212,7 @@ func (self *Server) makeProposal(blkNum uint32, forEmpty bool) error {
 	userTxs := make([]*types.Transaction, 0)
 
 	//check need upate chainconfig
-	cfg := &vconfig.ChainConfig{}
-	cfg = nil
+	var cfg *vconfig.ChainConfig
 	if self.checkNeedUpdateChainConfig(blkNum) || self.checkUpdateChainConfig(blkNum) {
 		chainconfig, err := getChainConfig(self.blockPool.getExecWriteSet(blkNum-1), blkNum)
 		if err != nil {
diff --git a/consensus/vbft/utils.go b/consensus/vbft/utils.go
index 1d819889f5..bbcdc0ad37 100644
--- a/consensus/vbft/utils.go
+++ b/consensus/vbft/utils.go
@@ -146,7 +146,7 @@ func GetVbftConfigInfo(memdb *overlaydb.MemDB) (*config.VBFTConfig, error) {
 		}
 	}
 
-	chainconfig := new(config.VBFTConfig)
+	var chainconfig *config.VBFTConfig
 	if preCfg.SetView == goveranceview.View {
 		chainconfig = &config.VBFTConfig{
 			N:                    uint32(preCfg.Configuration.N),
diff --git a/core/payload/deploy_code.go b/core/payload/deploy_code.go
index baaa6fe68c..40212ec243 100644
--- a/core/payload/deploy_code.go
+++ b/core/payload/deploy_code.go
@@ -140,27 +140,51 @@ func (dc *DeployCode) Serialization(sink *common.ZeroCopySink) {
 func (dc *DeployCode) Deserialization(source *common.ZeroCopySource) error {
 	var eof, irregular bool
 	dc.code, _, irregular, eof = source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
 
 	dc.vmFlags, eof = source.NextByte()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	dc.Name, _, irregular, eof = source.NextString()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
 
 	dc.Version, _, irregular, eof = source.NextString()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
 
 	dc.Author, _, irregular, eof = source.NextString()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
 
 	dc.Email, _, irregular, eof = source.NextString()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
diff --git a/core/program/program.go b/core/program/program.go
index 5c148e904b..8b8a2815d6 100644
--- a/core/program/program.go
+++ b/core/program/program.go
@@ -356,7 +356,7 @@ func GetParamInfo(program []byte) ([][]byte, error) {
 	parser := programParser{source: common.NewZeroCopySource(program)}
 
 	var signatures [][]byte
-	for parser.IsEOF() == false {
+	for !parser.IsEOF() {
 		sig, err := parser.ReadBytes()
 		if err != nil {
 			return nil, err
diff --git a/core/signature/signature.go b/core/signature/signature.go
index 46be381364..3f60e73205 100644
--- a/core/signature/signature.go
+++ b/core/signature/signature.go
@@ -76,7 +76,7 @@ func VerifyMultiSignature(data []byte, keys []keypair.PublicKey, m int, sigs [][
 			}
 		}
 
-		if valid == false {
+		if !valid {
 			return errors.New("multi-signature verification failed")
 		}
 	}
diff --git a/core/store/ledgerstore/ledger_store.go b/core/store/ledgerstore/ledger_store.go
index b2838f5812..cac164c7b1 100644
--- a/core/store/ledgerstore/ledger_store.go
+++ b/core/store/ledgerstore/ledger_store.go
@@ -385,7 +385,6 @@ func (this *LedgerStoreImp) setCurrentBlock(height uint32, blockHash common.Uint
 	defer this.lock.Unlock()
 	this.currBlockHash = blockHash
 	this.currBlockHeight = height
-	return
 }
 
 //GetCurrentBlock return the current block height, and block hash.
diff --git a/core/store/ledgerstore/state_store.go b/core/store/ledgerstore/state_store.go
index 40fa169d96..62dc053338 100644
--- a/core/store/ledgerstore/state_store.go
+++ b/core/store/ledgerstore/state_store.go
@@ -176,6 +176,9 @@ func (self *StateStore) GetStateMerkleRoot(height uint32) (result common.Uint256
 	}
 	source := common.NewZeroCopySource(value)
 	_, eof := source.NextHash()
+	if eof {
+		err = io.ErrUnexpectedEOF
+	}
 	result, eof = source.NextHash()
 	if eof {
 		err = io.ErrUnexpectedEOF
diff --git a/core/store/overlaydb/iterator.go b/core/store/overlaydb/iterator.go
index f04325e7d8..09c5587f64 100644
--- a/core/store/overlaydb/iterator.go
+++ b/core/store/overlaydb/iterator.go
@@ -50,11 +50,11 @@ func NewJoinIter(memIter, backendIter common.StoreIterator) *JoinIter {
 
 func (iter *JoinIter) First() bool {
 	f := iter.first()
-	if f == false {
+	if !f {
 		return false
 	}
 	for len(iter.value) == 0 {
-		if iter.next() == false {
+		if !iter.next() {
 			return false
 		}
 	}
@@ -73,7 +73,7 @@ func (iter *JoinIter) first() bool {
 	if back {
 		bkey = iter.backend.Key()
 		bval = iter.backend.Value()
-		if mem == false {
+		if !mem {
 			iter.key = bkey
 			iter.value = bval
 			iter.keyOrigin = FromBack
@@ -117,12 +117,12 @@ func (iter *JoinIter) Value() []byte {
 
 func (iter *JoinIter) Next() bool {
 	f := iter.next()
-	if f == false {
+	if !f {
 		return false
 	}
 
 	for len(iter.value) == 0 {
-		if iter.next() == false {
+		if !iter.next() {
 			return false
 		}
 	}
@@ -131,10 +131,10 @@ func (iter *JoinIter) Next() bool {
 }
 
 func (iter *JoinIter) next() bool {
-	if (iter.keyOrigin == FromMem || iter.keyOrigin == FromBoth) && iter.nextMemEnd == false {
+	if (iter.keyOrigin == FromMem || iter.keyOrigin == FromBoth) && !iter.nextMemEnd {
 		iter.nextMemEnd = !iter.memdb.Next()
 	}
-	if (iter.keyOrigin == FromBack || iter.keyOrigin == FromBoth) && iter.nextBackEnd == false {
+	if (iter.keyOrigin == FromBack || iter.keyOrigin == FromBoth) && !iter.nextBackEnd {
 		iter.nextBackEnd = !iter.backend.Next()
 	}
 
diff --git a/core/store/overlaydb/memdb.go b/core/store/overlaydb/memdb.go
index ed305e9afc..f2cebf7c77 100644
--- a/core/store/overlaydb/memdb.go
+++ b/core/store/overlaydb/memdb.go
@@ -312,7 +312,6 @@ func (p *MemDB) Put(key []byte, value []byte) {
 
 	p.kvSize += len(key) + len(value)
 	p.n++
-	return
 }
 
 // Delete deletes the value for the given key.
diff --git a/core/store/overlaydb/overlaydb.go b/core/store/overlaydb/overlaydb.go
index 06f989279b..a0eceab21a 100644
--- a/core/store/overlaydb/overlaydb.go
+++ b/core/store/overlaydb/overlaydb.go
@@ -58,7 +58,7 @@ func (self *OverlayDB) SetError(err error) {
 func (self *OverlayDB) Get(key []byte) (value []byte, err error) {
 	var unknown bool
 	value, unknown = self.memdb.Get(key)
-	if unknown == false {
+	if !unknown {
 		return value, nil
 	}
 
diff --git a/core/types/header.go b/core/types/header.go
index 3f96880011..97845a5e54 100644
--- a/core/types/header.go
+++ b/core/types/header.go
@@ -93,6 +93,10 @@ func (self *RawHeader) deserializationUnsigned(source *common.ZeroCopySource) er
 	source.Skip(8)
 	// ConsensusPayload
 	_, _, irregular, eof := source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
@@ -224,14 +228,43 @@ func (bd *Header) deserializationUnsigned(source *common.ZeroCopySource) error {
 	var irregular, eof bool
 
 	bd.Version, eof = source.NextUint32()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	bd.PrevBlockHash, eof = source.NextHash()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	bd.TransactionsRoot, eof = source.NextHash()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	bd.BlockRoot, eof = source.NextHash()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	bd.Timestamp, eof = source.NextUint32()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	bd.Height, eof = source.NextUint32()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	bd.ConsensusData, eof = source.NextUint64()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 
 	bd.ConsensusPayload, _, irregular, eof = source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
+
 	if irregular {
 		return common.ErrIrregularData
 	}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 100c6ee5b5..3dc64d4641 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -143,12 +143,27 @@ func (tx *Transaction) IntoMutable() (*MutableTransaction, error) {
 func (tx *Transaction) deserializationUnsigned(source *common.ZeroCopySource) error {
 	var irregular, eof bool
 	tx.Version, eof = source.NextByte()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	var txtype byte
 	txtype, eof = source.NextByte()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	tx.TxType = TransactionType(txtype)
 	tx.Nonce, eof = source.NextUint32()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	tx.GasPrice, eof = source.NextUint64()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	tx.GasLimit, eof = source.NextUint64()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	var buf []byte
 	buf, eof = source.NextBytes(common.ADDR_LEN)
 	if eof {
@@ -206,10 +221,16 @@ func (self *RawSig) Serialization(sink *common.ZeroCopySink) error {
 func (self *RawSig) Deserialization(source *common.ZeroCopySource) error {
 	var eof, irregular bool
 	self.Invoke, _, irregular, eof = source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	if irregular {
 		return common.ErrIrregularData
 	}
 	self.Verify, _, irregular, eof = source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	if irregular {
 		return common.ErrIrregularData
 	}
@@ -308,7 +329,7 @@ type Payload interface {
 }
 
 func (tx *Transaction) Serialization(sink *common.ZeroCopySink) {
-	if tx.nonDirectConstracted == false || len(tx.Raw) == 0 {
+	if !tx.nonDirectConstracted || len(tx.Raw) == 0 {
 		panic("wrong constructed transaction")
 	}
 	sink.WriteBytes(tx.Raw)
diff --git a/core/validation/block_validator.go b/core/validation/block_validator.go
index 210e758bc6..49155105df 100644
--- a/core/validation/block_validator.go
+++ b/core/validation/block_validator.go
@@ -66,11 +66,11 @@ func VerifyBlock(block *types.Block, ld *ledger.Ledger, completely bool) error {
 		*/
 		for _, txVerify := range block.Transactions {
 			if errCode := VerifyTransaction(txVerify); errCode != ontErrors.ErrNoError {
-				return errors.New(fmt.Sprintf("VerifyTransaction failed when verifiy block"))
+				return errors.New("VerifyTransaction failed when verifiy block")
 			}
 
 			if errCode := VerifyTransactionWithLedger(txVerify, ld); errCode != ontErrors.ErrNoError {
-				return errors.New(fmt.Sprintf("VerifyTransaction failed when verifiy block"))
+				return errors.New("VerifyTransaction failed when verifiy block")
 			}
 		}
 	}
diff --git a/core/validation/transaction_validator.go b/core/validation/transaction_validator.go
index e7b3b0ceee..66a39f19b7 100644
--- a/core/validation/transaction_validator.go
+++ b/core/validation/transaction_validator.go
@@ -98,7 +98,7 @@ func checkTransactionSignatures(tx *types.Transaction) error {
 	}
 
 	// check payer in address
-	if address[tx.Payer] == false {
+	if !address[tx.Payer] {
 		return errors.New("signature missing for payer: " + tx.Payer.ToBase58())
 	}
 
diff --git a/errors/callstack.go b/errors/callstack.go
index 7b55e58b27..0f59e69066 100644
--- a/errors/callstack.go
+++ b/errors/callstack.go
@@ -42,7 +42,7 @@ func GetCallStacks(err error) *CallStack {
 func CallStacksString(call *CallStack) string {
 	buf := bytes.Buffer{}
 	if call == nil {
-		return fmt.Sprintf("No call stack available")
+		return "No call stack available"
 	}
 
 	for _, stack := range call.Stacks {
diff --git a/http/restful/restful/router.go b/http/restful/restful/router.go
index 6a14ad1447..3d5266e8a6 100644
--- a/http/restful/restful/router.go
+++ b/http/restful/restful/router.go
@@ -48,7 +48,7 @@ func (this *Router) Try(path string, method string) (http.HandlerFunc, paramsMap
 	for _, route := range this.routes {
 		if route.Method == method {
 			match := route.Path.MatchString(path)
-			if match == false {
+			if !match {
 				continue
 			}
 			params := paramsMap{}
@@ -71,11 +71,9 @@ func (this *Router) add(method string, path string, handler http.HandlerFunc) {
 
 	if strings.Contains(path, ":") {
 		matches := regexp.MustCompile(`:(\w+)`).FindAllStringSubmatch(path, -1)
-		if matches != nil {
-			for _, v := range matches {
-				route.Params = append(route.Params, v[1])
-				path = strings.Replace(path, v[0], `(\w+)`, 1)
-			}
+		for _, v := range matches {
+			route.Params = append(route.Params, v[1])
+			path = strings.Replace(path, v[0], `(\w+)`, 1)
 		}
 	}
 	compiledPath, err := regexp.Compile(path)
@@ -138,6 +136,6 @@ func parseParams(route *Route, path string) paramsMap {
 func getParam(r *http.Request, key string) string {
 	ctx := r.Context()
 	params := ctx.Value("params").(paramsMap)
-	val, _ := params[key]
+	val := params[key]
 	return val
 }
diff --git a/merkle/merkle_tree.go b/merkle/merkle_tree.go
index 80a275298f..2850260c49 100644
--- a/merkle/merkle_tree.go
+++ b/merkle/merkle_tree.go
@@ -274,7 +274,7 @@ func (self *CompactMerkleTree) subproof(m, n uint32, b bool) []common.Uint256 {
 	}
 
 	//assert m == n
-	if b == false {
+	if !b {
 		pos := getSubTreePos(n)
 		//assert len(pos) == 1
 		if len(pos) != 1 {
diff --git a/p2pserver/message/types/offline_witness.go b/p2pserver/message/types/offline_witness.go
index 8811a7d5c6..d45949b4e2 100644
--- a/p2pserver/message/types/offline_witness.go
+++ b/p2pserver/message/types/offline_witness.go
@@ -112,6 +112,9 @@ func (self *OfflineWitnessMsg) Deserialization(source *common.ZeroCopySource) (e
 			return err
 		}
 		sig, err := source.ReadVarBytes()
+		if err != nil {
+			return err
+		}
 
 		self.Voters = append(self.Voters, VoterMsg{OfflineIndex: index, PubKey: pubKey, Sig: sig})
 	}
diff --git a/smartcontract/service/native/governance/method.go b/smartcontract/service/native/governance/method.go
index deaceff70a..aa4f82c56b 100644
--- a/smartcontract/service/native/governance/method.go
+++ b/smartcontract/service/native/governance/method.go
@@ -375,7 +375,7 @@ func normalQuit(native *native.NativeService, contract common.Address, peerPoolI
 	if err := iter.Error(); err != nil {
 		return err
 	}
-	if flag == false {
+	if !flag {
 		authorizeInfo := &AuthorizeInfo{
 			PeerPubkey:          peerPoolItem.PeerPubkey,
 			Address:             peerPoolItem.Address,
diff --git a/smartcontract/service/native/native_service.go b/smartcontract/service/native/native_service.go
index 9b10226c3d..f4a31725de 100644
--- a/smartcontract/service/native/native_service.go
+++ b/smartcontract/service/native/native_service.go
@@ -29,7 +29,6 @@ import (
 	"github.com/ontio/ontology/smartcontract/context"
 	"github.com/ontio/ontology/smartcontract/event"
 	"github.com/ontio/ontology/smartcontract/states"
-	sstates "github.com/ontio/ontology/smartcontract/states"
 	"github.com/ontio/ontology/smartcontract/storage"
 )
 
@@ -49,7 +48,7 @@ type NativeService struct {
 	CacheDB       *storage.CacheDB
 	ServiceMap    map[string]Handler
 	Notifications []*event.NotifyEventInfo
-	InvokeParam   sstates.ContractInvokeParam
+	InvokeParam   states.ContractInvokeParam
 	Input         []byte
 	Tx            *types.Transaction
 	Height        uint32
diff --git a/smartcontract/service/native/ong/ong.go b/smartcontract/service/native/ong/ong.go
index 4daef89468..0c8640a993 100644
--- a/smartcontract/service/native/ong/ong.go
+++ b/smartcontract/service/native/ong/ong.go
@@ -97,7 +97,7 @@ func OngApprove(native *native.NativeService) ([]byte, error) {
 	if state.Value > constants.ONG_TOTAL_SUPPLY {
 		return utils.BYTE_FALSE, fmt.Errorf("approve ong amount:%d over totalSupply:%d", state.Value, constants.ONG_TOTAL_SUPPLY)
 	}
-	if native.ContextRef.CheckWitness(state.From) == false {
+	if !native.ContextRef.CheckWitness(state.From) {
 		return utils.BYTE_FALSE, errors.NewErr("authentication failed!")
 	}
 	contract := native.ContextRef.CurrentContext().ContractAddress
diff --git a/smartcontract/service/native/ont/ont.go b/smartcontract/service/native/ont/ont.go
index 09d93cece5..a1dba581a5 100644
--- a/smartcontract/service/native/ont/ont.go
+++ b/smartcontract/service/native/ont/ont.go
@@ -183,7 +183,7 @@ func OntApprove(native *native.NativeService) ([]byte, error) {
 	if state.Value > constants.ONT_TOTAL_SUPPLY {
 		return utils.BYTE_FALSE, fmt.Errorf("approve ont amount:%d over totalSupply:%d", state.Value, constants.ONT_TOTAL_SUPPLY)
 	}
-	if native.ContextRef.CheckWitness(state.From) == false {
+	if !native.ContextRef.CheckWitness(state.From) {
 		return utils.BYTE_FALSE, errors.NewErr("authentication failed!")
 	}
 	contract := native.ContextRef.CurrentContext().ContractAddress
diff --git a/smartcontract/service/native/ontfs/app_sdk.go b/smartcontract/service/native/ontfs/app_sdk.go
index cd2398da99..00b6e62d7d 100644
--- a/smartcontract/service/native/ontfs/app_sdk.go
+++ b/smartcontract/service/native/ontfs/app_sdk.go
@@ -859,7 +859,7 @@ func FsTransferFiles(native *native.NativeService) ([]byte, error) {
 	}
 
 	for _, fileTransfer := range fileTransferList.FilesTransfer {
-		if native.ContextRef.CheckWitness(fileTransfer.OriOwner) == false {
+		if !native.ContextRef.CheckWitness(fileTransfer.OriOwner) {
 			errInfos.AddObjectError(string(fileTransfer.FileHash), "[APP SDK] FsTransferFiles CheckFileOwner failed!")
 			continue
 		}
diff --git a/smartcontract/service/native/ontid/event.go b/smartcontract/service/native/ontid/event.go
index 2fd2cd2ebc..5bb18ce5c6 100644
--- a/smartcontract/service/native/ontid/event.go
+++ b/smartcontract/service/native/ontid/event.go
@@ -30,7 +30,6 @@ func newEvent(srvc *native.NativeService, st interface{}) {
 	e.ContractAddress = srvc.ContextRef.CurrentContext().ContractAddress
 	e.States = st
 	srvc.Notifications = append(srvc.Notifications, &e)
-	return
 }
 
 func triggerRegisterEvent(srvc *native.NativeService, id []byte) {
diff --git a/smartcontract/service/native/ontid/init.go b/smartcontract/service/native/ontid/init.go
index 135398dd6c..faa8b9c13e 100644
--- a/smartcontract/service/native/ontid/init.go
+++ b/smartcontract/service/native/ontid/init.go
@@ -83,5 +83,4 @@ func RegisterIDContract(srvc *native.NativeService) {
 	srvc.Register("getServiceJson", GetServiceJson)
 	srvc.Register("getControllerJson", GetControllerJson)
 	srvc.Register("getDocumentJson", GetDocumentJson)
-	return
 }
diff --git a/smartcontract/service/native/ontid/method.go b/smartcontract/service/native/ontid/method.go
index 79379e5add..6371882e1a 100644
--- a/smartcontract/service/native/ontid/method.go
+++ b/smartcontract/service/native/ontid/method.go
@@ -315,6 +315,9 @@ func removeKey(srvc *native.NativeService) ([]byte, error) {
 	}
 	var auth = false
 	rec, err := getOldRecovery(srvc, key)
+	if err != nil {
+		return utils.BYTE_FALSE, err
+	}
 	if len(rec) > 0 {
 		auth = bytes.Equal(rec, arg2)
 	}
diff --git a/smartcontract/service/native/utils/operation.go b/smartcontract/service/native/utils/operation.go
index 29418b0f10..08787dccbc 100644
--- a/smartcontract/service/native/utils/operation.go
+++ b/smartcontract/service/native/utils/operation.go
@@ -45,7 +45,7 @@ func ConcatBytes(args ...[]byte) []byte {
 }
 
 func ValidateOwner(native *native.NativeService, address common.Address) error {
-	if native.ContextRef.CheckWitness(address) == false {
+	if !native.ContextRef.CheckWitness(address) {
 		return errors.NewErr("validateOwner, authentication failed!")
 	}
 	return nil
diff --git a/smartcontract/service/neovm/runtime.go b/smartcontract/service/neovm/runtime.go
index f340d06815..e9f0dea150 100644
--- a/smartcontract/service/neovm/runtime.go
+++ b/smartcontract/service/neovm/runtime.go
@@ -155,6 +155,9 @@ func RuntimeNotify(service *NeoVmService, engine *vm.Executor) error {
 // RuntimeLog push smart contract execute event log to client
 func RuntimeLog(service *NeoVmService, engine *vm.Executor) error {
 	sitem, err := engine.EvalStack.Peek(0)
+	if err != nil {
+		return err
+	}
 	item, err := engine.EvalStack.PopAsBytes()
 	if err != nil {
 		return err
diff --git a/smartcontract/service/neovm/wasmvm.go b/smartcontract/service/neovm/wasmvm.go
index e0dbe89f94..ec05d31661 100644
--- a/smartcontract/service/neovm/wasmvm.go
+++ b/smartcontract/service/neovm/wasmvm.go
@@ -63,7 +63,7 @@ func WASMInvoke(service *NeoVmService, engine *vm.Executor) error {
 	}
 
 	params, ok := list.([]interface{})
-	if ok == false {
+	if !ok {
 		return fmt.Errorf("wasm invoke error: wrong param type:%s", reflect.TypeOf(list).String())
 	}
 
diff --git a/smartcontract/service/util/util.go b/smartcontract/service/util/util.go
index 30a9726681..149e1b06e3 100644
--- a/smartcontract/service/util/util.go
+++ b/smartcontract/service/util/util.go
@@ -52,7 +52,7 @@ func GenerateNeoVMParamEvalStack(input []byte) (*neovm.ValueStack, error) {
 	}
 
 	list, ok := params.([]interface{})
-	if ok == false {
+	if !ok {
 		return nil, errors.New("invoke neovm param is not list type")
 	}
 
@@ -66,7 +66,7 @@ func GenerateNeoVMParamEvalStack(input []byte) (*neovm.ValueStack, error) {
 
 func SetNeoServiceParamAndEngine(addr common.Address, engine context.Engine, stack *neovm.ValueStack) error {
 	service, ok := engine.(*neovms.NeoVmService)
-	if ok == false {
+	if !ok {
 		return errors.New("engine should be NeoVmService")
 	}
 
diff --git a/smartcontract/service/wasmvm/contract.go b/smartcontract/service/wasmvm/contract.go
index b9aa6403fc..b96bf37739 100644
--- a/smartcontract/service/wasmvm/contract.go
+++ b/smartcontract/service/wasmvm/contract.go
@@ -136,6 +136,9 @@ func ContractCreate(proc *exec.Process,
 	self.Service.CacheDB.PutContract(dep)
 
 	length, err := proc.WriteAt(contractAddr[:], int64(newAddressPtr))
+	if err != nil {
+		panic(err)
+	}
 	return uint32(length)
 
 }
diff --git a/smartcontract/service/wasmvm/utils.go b/smartcontract/service/wasmvm/utils.go
index ebc261f70e..3a9558c838 100644
--- a/smartcontract/service/wasmvm/utils.go
+++ b/smartcontract/service/wasmvm/utils.go
@@ -55,7 +55,7 @@ func checkOntoWasm(m *wasm.Module) error {
 	}
 
 	entry, ok := m.Export.Entries["invoke"]
-	if ok == false {
+	if !ok {
 		return errors.New("[Validate] invoke entry function does not export.")
 	}
 
diff --git a/smartcontract/service/wasmvm/wasm_service.go b/smartcontract/service/wasmvm/wasm_service.go
index 6a2e35a5d6..38a64e8c0b 100644
--- a/smartcontract/service/wasmvm/wasm_service.go
+++ b/smartcontract/service/wasmvm/wasm_service.go
@@ -198,7 +198,7 @@ func invokeInterpreter(this *WasmVmService, contract *states.WasmContractParam,
 
 	entry, ok := compiled.RawModule.Export.Entries[entryName]
 
-	if ok == false {
+	if !ok {
 		return nil, errors.NewErr("[Call]Method:" + entryName + " does not exist!")
 	}
 
diff --git a/smartcontract/states/contract.go b/smartcontract/states/contract.go
index bec34b03f4..e43930538f 100644
--- a/smartcontract/states/contract.go
+++ b/smartcontract/states/contract.go
@@ -48,9 +48,18 @@ func (this *ContractInvokeParam) Serialization(sink *common.ZeroCopySink) {
 func (this *ContractInvokeParam) Deserialization(source *common.ZeroCopySource) error {
 	var irregular, eof bool
 	this.Version, eof = source.NextByte()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	this.Address, eof = source.NextAddress()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	var method []byte
 	method, _, irregular, eof = source.NextVarBytes()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 	if irregular {
 		return common.ErrIrregularData
 	}
diff --git a/smartcontract/states/wasmContract.go b/smartcontract/states/wasmContract.go
index 411746dc8a..723133052a 100644
--- a/smartcontract/states/wasmContract.go
+++ b/smartcontract/states/wasmContract.go
@@ -38,6 +38,9 @@ func (this *WasmContractParam) Serialization(sink *common.ZeroCopySink) {
 func (this *WasmContractParam) Deserialization(source *common.ZeroCopySource) error {
 	var irregular, eof bool
 	this.Address, eof = source.NextAddress()
+	if eof {
+		return io.ErrUnexpectedEOF
+	}
 
 	this.Args, _, irregular, eof = source.NextVarBytes()
 	if irregular {
diff --git a/txnpool/proc/txnpool_server.go b/txnpool/proc/txnpool_server.go
index c40ee6a04b..c293cf6c6b 100644
--- a/txnpool/proc/txnpool_server.go
+++ b/txnpool/proc/txnpool_server.go
@@ -611,9 +611,8 @@ func (s *TXPoolServer) getStats() []uint64 {
 	s.stats.RLock()
 	defer s.stats.RUnlock()
 	ret := make([]uint64, 0, len(s.stats.count))
-	for _, v := range s.stats.count {
-		ret = append(ret, v)
-	}
+	ret = append(ret, s.stats.count...)
+
 	return ret
 }
 
diff --git a/vm/crossvm_codec/notify_codec.go b/vm/crossvm_codec/notify_codec.go
index c1bdfd74c4..b9858a9386 100644
--- a/vm/crossvm_codec/notify_codec.go
+++ b/vm/crossvm_codec/notify_codec.go
@@ -65,7 +65,7 @@ func stringify(notify interface{}) interface{} {
 // input byte array should be the following format
 // evt\0(4byte) + type(1byte) + usize( bytearray or list) (4 bytes) + data...
 func parseNotify(input []byte) (interface{}, error) {
-	if bytes.HasPrefix(input, []byte("evt\x00")) == false {
+	if !bytes.HasPrefix(input, []byte("evt\x00")) {
 		return nil, ERROR_PARAM_FORMAT
 	}
 
diff --git a/vm/crossvm_codec/vmcall_codec.go b/vm/crossvm_codec/vmcall_codec.go
index 340c73c510..7727b71eec 100644
--- a/vm/crossvm_codec/vmcall_codec.go
+++ b/vm/crossvm_codec/vmcall_codec.go
@@ -27,7 +27,7 @@ import (
 //input byte array should be the following format
 // version(1byte) + type(1byte) + data...
 func DeserializeCallParam(input []byte) (interface{}, error) {
-	if bytes.HasPrefix(input, []byte{0}) == false {
+	if !bytes.HasPrefix(input, []byte{0}) {
 		return nil, ERROR_PARAM_FORMAT
 	}
 
diff --git a/vm/neovm/executor.go b/vm/neovm/executor.go
index 91ac078bae..41eb78356c 100644
--- a/vm/neovm/executor.go
+++ b/vm/neovm/executor.go
@@ -877,7 +877,7 @@ func (self *Executor) ExecuteOp(opcode OpCode, context *ExecutionContext) (VMSta
 			value, ok, err := mapVal.Get(index)
 			if err != nil {
 				return FAULT, err
-			} else if ok == false {
+			} else if !ok {
 				// todo: suply a nil value in vm?
 				return FAULT, errors.ERR_MAP_NOT_EXIST
 			}
diff --git a/vm/neovm/types/int_value.go b/vm/neovm/types/int_value.go
index 3013fc046b..45e2126c55 100644
--- a/vm/neovm/types/int_value.go
+++ b/vm/neovm/types/int_value.go
@@ -36,14 +36,14 @@ type IntValue struct {
 
 func (self IntValue) Rsh(other IntValue) (result IntValue, err error) {
 	var val uint64
-	if other.isbig == false {
+	if !other.isbig {
 		if other.integer < 0 {
 			err = errors.ERR_SHIFT_BY_NEG
 			return
 		}
 		val = uint64(other.integer)
 	} else {
-		if other.bigint.IsUint64() == false {
+		if !other.bigint.IsUint64() {
 			return IntValue{}, errors.ERR_SHIFT_BY_NEG
 		}
 		val = other.bigint.Uint64()
@@ -71,14 +71,14 @@ func (self IntValue) Rsh(other IntValue) (result IntValue, err error) {
 
 func (self IntValue) Lsh(other IntValue) (result IntValue, err error) {
 	var val uint64
-	if other.isbig == false {
+	if !other.isbig {
 		if other.integer < 0 {
 			err = errors.ERR_SHIFT_BY_NEG
 			return
 		}
 		val = uint64(other.integer)
 	} else {
-		if other.bigint.IsUint64() == false {
+		if !other.bigint.IsUint64() {
 			return IntValue{}, errors.ERR_SHIFT_BY_NEG
 		}
 		val = other.bigint.Uint64()
@@ -127,7 +127,7 @@ func IntValFromNeoBytes(val []byte) (IntValue, error) {
 
 func (self *IntValue) ToNeoBytes() []byte {
 	val := self.bigint
-	if self.isbig == false {
+	if !self.isbig {
 		val = big.NewInt(self.integer)
 	}
 	value := common.BigIntToNeoBytes(val)
@@ -221,7 +221,7 @@ func (self IntValue) Or(other IntValue) (IntValue, error) {
 }
 
 func (self IntValue) Cmp(other IntValue) int {
-	if self.isbig == false && other.isbig == false {
+	if !self.isbig && !other.isbig {
 		if self.integer < other.integer {
 			return -1
 		} else if self.integer == other.integer {
@@ -231,12 +231,12 @@ func (self IntValue) Cmp(other IntValue) int {
 		}
 	}
 	var left, right *big.Int
-	if self.isbig == false {
+	if !self.isbig {
 		left = big.NewInt(self.integer)
 	} else {
 		left = self.bigint
 	}
-	if other.isbig == false {
+	if !other.isbig {
 		right = big.NewInt(other.integer)
 	} else {
 		right = other.bigint
@@ -321,19 +321,19 @@ type overflowFn func(a, b int64) (result int64, ok bool)
 type bigintFn func(a, b *big.Int) (IntValue, error)
 
 func (self IntValue) intOp(other IntValue, littleintFunc overflowFn, bigintFunc bigintFn) (IntValue, error) {
-	if self.isbig == false && other.isbig == false {
+	if !self.isbig && !other.isbig {
 		val, ok := littleintFunc(self.integer, other.integer)
 		if ok {
 			return IntValFromInt(val), nil
 		}
 	}
 	var left, right *big.Int
-	if self.isbig == false {
+	if !self.isbig {
 		left = big.NewInt(self.integer)
 	} else {
 		left = self.bigint
 	}
-	if other.isbig == false {
+	if !other.isbig {
 		right = big.NewInt(other.integer)
 	} else {
 		right = other.bigint
diff --git a/vm/neovm/types/neovm_value.go b/vm/neovm/types/neovm_value.go
index 3c61d8184d..f63e53defe 100644
--- a/vm/neovm/types/neovm_value.go
+++ b/vm/neovm/types/neovm_value.go
@@ -556,7 +556,7 @@ func (self *VmValue) AsInt64() (int64, error) {
 		return 0, err
 	}
 	if val.isbig {
-		if val.bigint.IsInt64() == false {
+		if !val.bigint.IsInt64() {
 			return 0, errors.ERR_INTEGER_UNDERFLOW
 		}
 		return val.bigint.Int64(), nil

From 37874ef4a082487bc4f81c6328004563425df92c Mon Sep 17 00:00:00 2001
From: rongyi <rongyi@onchain.com>
Date: Fri, 4 Sep 2020 10:36:23 +0800
Subject: [PATCH 08/11] Update docker file (#1278)

---
 Makefile          | 25 +++----------------------
 docker/Dockerfile | 22 +++++++++++++++-------
 2 files changed, 18 insertions(+), 29 deletions(-)

diff --git a/Makefile b/Makefile
index 440004d985..f66ba6917b 100644
--- a/Makefile
+++ b/Makefile
@@ -63,32 +63,13 @@ all-cross: ontology-cross tools-cross abi
 format:
 	$(GOFMT) -w main.go
 
-docker/payload: docker/build/bin/ontology docker/Dockerfile
-	@echo "Building ontology payload"
-	@mkdir -p $@
-	@cp docker/Dockerfile $@
-	@cp docker/build/bin/ontology $@
-	@touch $@
-
-docker/build/bin/%: Makefile
-	@echo "Building ontology in docker"
-	@mkdir -p docker/build/bin docker/build/pkg
-	@$(DRUN) --rm \
-		-v $(abspath docker/build/bin):/go/bin \
-		-v $(abspath docker/build/pkg):/go/pkg \
-		-v $(GOPATH)/src:/go/src \
-		-w /go/src/github.com/ontio/ontology \
-		golang:1.9.5-stretch \
-		$(GC)  $(BUILD_NODE_PAR) -o docker/build/bin/ontology main.go
-	@touch $@
 
-docker: Makefile docker/payload docker/Dockerfile 
+docker: Makefile
 	@echo "Building ontology docker"
-	@$(DBUILD) -t $(DOCKER_NS)/ontology docker/payload
-	@docker tag $(DOCKER_NS)/ontology $(DOCKER_NS)/ontology:$(DOCKER_TAG)
+	@$(DBUILD) --no-cache -t $(DOCKER_NS)/ontology:$(DOCKER_TAG) - < docker/Dockerfile 
 	@touch $@
 
 clean:
 	rm -rf *.8 *.o *.out *.6 *exe coverage
-	rm -rf ontology ontology-* tools docker/payload docker/build
+	rm -rf ontology ontology-* tools
 
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 3f94ca85c5..1e4747cdac 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,9 +1,17 @@
+# 1. Stage one: build ontology
+FROM golang:1.13 AS build
+WORKDIR /app
+RUN git clone https://github.com/ontio/ontology.git  && \
+    cd ontology && \
+    make 
+
+# 2. Stage two: copy compiled binary from prev builded container(referenced by name build)
+FROM ubuntu:18.04
+WORKDIR /app
+COPY --from=build /app/ontology/ontology ontology
 
-FROM tianon/ubuntu-core:14.04
-ENV ONTOLOGY_PATH /var/ontology
-RUN mkdir -p $ONTOLOGY_PATH
-COPY ontology $ONTOLOGY_PATH
-EXPOSE 20334 20335 20336 20337 20338 20339
-WORKDIR $ONTOLOGY_PATH
-ENTRYPOINT ["./ontology"]
 
+EXPOSE 20334 20335 20336 20337 20338 20339
+#NOTE! we highly recommand that you put data dir to a mounted volume, e.g. --data-dir /data/Chain
+#write data to docker image is *not* a best practice
+CMD ["/app/ontology"]

From 1834a44cdcbf32ebb5356d1da2efb60d33e56e61 Mon Sep 17 00:00:00 2001
From: lucas <sishsh@163.com>
Date: Thu, 17 Sep 2020 12:19:02 +0800
Subject: [PATCH 09/11] add getoep4balance restful api (#1279)

---
 http/base/common/common.go | 68 ++++++++++++++++++++++++++++++++++++++
 http/jsonrpc/interfaces.go | 37 +++++++++++++++++++++
 http/jsonrpc/rpc_server.go |  1 +
 3 files changed, 106 insertions(+)

diff --git a/http/base/common/common.go b/http/base/common/common.go
index cc9683d8ff..d838bda8ab 100644
--- a/http/base/common/common.go
+++ b/http/base/common/common.go
@@ -54,6 +54,16 @@ type BalanceOfRsp struct {
 	Height string `json:"height"`
 }
 
+type Oep4BalanceOfRsp struct {
+	Oep4   []Oep4Balance `json:"oep4"`
+	Height string        `json:"height"`
+}
+
+type Oep4Balance struct {
+	Addr    string `json:"addr"`
+	Balance string `json:"balance"`
+}
+
 type MerkleProof struct {
 	Type             string
 	TransactionsRoot string
@@ -312,6 +322,24 @@ func GetBalance(address common.Address) (*BalanceOfRsp, error) {
 	}, nil
 }
 
+func GetOep4Balance(contractAddress common.Address, addrs []common.Address) (*Oep4BalanceOfRsp, error) {
+	balances, height, err := GetOep4ContractBalance(contractAddress, addrs, true)
+	if err != nil {
+		return nil, fmt.Errorf("get ont balance error:%s", err)
+	}
+	res := make([]Oep4Balance, len(addrs))
+	for i, addr := range addrs {
+		res[i] = Oep4Balance{
+			Addr:    addr.ToBase58(),
+			Balance: balances[i],
+		}
+	}
+	return &Oep4BalanceOfRsp{
+		Oep4:   res,
+		Height: fmt.Sprintf("%d", height),
+	}, nil
+}
+
 func GetGrantOng(addr common.Address) (string, error) {
 	key := append([]byte(ont.UNBOUND_TIME_OFFSET), addr[:]...)
 	value, err := ledger.DefLedger.GetStorageItem(utils.OntContractAddress, key)
@@ -355,6 +383,7 @@ func GetContractBalance(cVersion byte, contractAddres []common.Address, accAddr
 		if err != nil {
 			return nil, 0, fmt.Errorf("NewNativeInvokeTransaction error:%s", err)
 		}
+
 		tx, err := mutable.IntoImmutable()
 		if err != nil {
 			return nil, 0, err
@@ -384,6 +413,45 @@ func GetContractBalance(cVersion byte, contractAddres []common.Address, accAddr
 	return balances, height, nil
 }
 
+func GetOep4ContractBalance(contractAddr common.Address, accAddr []common.Address, atomic bool) ([]string, uint32, error) {
+	txes := make([]*types.Transaction, 0, len(accAddr))
+	var mutable *types.MutableTransaction
+	var err error
+	for _, userAcc := range accAddr {
+		mutable, err = NewNeovmInvokeTransaction(0, 0, contractAddr, []interface{}{"balanceOf", []interface{}{userAcc}})
+		if err != nil {
+			return nil, 0, fmt.Errorf("NewNeovmInvokeTransaction error:%s", err)
+		}
+
+		tx, err := mutable.IntoImmutable()
+		if err != nil {
+			return nil, 0, err
+		}
+
+		txes = append(txes, tx)
+	}
+
+	results, height, err := bactor.PreExecuteContractBatch(txes, atomic)
+	if err != nil {
+		return nil, 0, fmt.Errorf("PrepareInvokeContract error:%s", err)
+	}
+	balances := make([]string, 0, len(contractAddr))
+	for _, result := range results {
+		if result.State == 0 {
+			return nil, 0, fmt.Errorf("prepare invoke failed")
+		}
+		data, err := hex.DecodeString(result.Result.(string))
+		if err != nil {
+			return nil, 0, fmt.Errorf("hex.DecodeString error:%s", err)
+		}
+
+		balance := common.BigIntFromNeoBytes(data)
+		balances = append(balances, balance.String())
+	}
+
+	return balances, height, nil
+}
+
 func GetContractAllowance(cVersion byte, contractAddr, fromAddr, toAddr common.Address) (uint64, error) {
 	type allowanceStruct struct {
 		From common.Address
diff --git a/http/jsonrpc/interfaces.go b/http/jsonrpc/interfaces.go
index 7a58b07b04..344aaed1ac 100644
--- a/http/jsonrpc/interfaces.go
+++ b/http/jsonrpc/interfaces.go
@@ -459,6 +459,43 @@ func GetBalance(params []interface{}) map[string]interface{} {
 	return rpc.ResponseSuccess(rsp)
 }
 
+//get balance of address
+func GetOep4Balance(params []interface{}) map[string]interface{} {
+	if len(params) < 2 {
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
+	}
+
+	contractAddrHex, ok := params[0].(string)
+	if !ok {
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
+	}
+	contractAddr, err := common.AddressFromHexString(contractAddrHex)
+	if err != nil {
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
+	}
+	addrs, err := parseAddressParam(params[1].([]interface{}))
+	if err != nil {
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
+	}
+	rsp, err := bcomn.GetOep4Balance(contractAddr, addrs)
+	if err != nil {
+		return rpc.ResponsePack(berr.INVALID_PARAMS, "")
+	}
+	return rpc.ResponseSuccess(rsp)
+}
+
+func parseAddressParam(params []interface{}) ([]common.Address, error) {
+	res := make([]common.Address, len(params))
+	var err error
+	for i, param := range params {
+		res[i], err = common.AddressFromBase58(param.(string))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return res, nil
+}
+
 //get allowance
 func GetAllowance(params []interface{}) map[string]interface{} {
 	if len(params) < 3 {
diff --git a/http/jsonrpc/rpc_server.go b/http/jsonrpc/rpc_server.go
index 6e3eb20793..89f3b988bd 100644
--- a/http/jsonrpc/rpc_server.go
+++ b/http/jsonrpc/rpc_server.go
@@ -54,6 +54,7 @@ func StartRPCServer() error {
 	rpc.HandleFunc("getblockheightbytxhash", GetBlockHeightByTxHash)
 
 	rpc.HandleFunc("getbalance", GetBalance)
+	rpc.HandleFunc("getoep4balance", GetOep4Balance)
 	rpc.HandleFunc("getallowance", GetAllowance)
 	rpc.HandleFunc("getmerkleproof", GetMerkleProof)
 	rpc.HandleFunc("getblocktxsbyheight", GetBlockTxsByHeight)

From dd99dc4786ce07d366345ded76e617a4810122c7 Mon Sep 17 00:00:00 2001
From: laizy <laizy@users.noreply.github.com>
Date: Sun, 20 Sep 2020 12:39:18 +0800
Subject: [PATCH 10/11] provide more error info (#1280)

---
 smartcontract/service/wasmvm/runtime.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/smartcontract/service/wasmvm/runtime.go b/smartcontract/service/wasmvm/runtime.go
index 8980b099f7..5cc616fd20 100644
--- a/smartcontract/service/wasmvm/runtime.go
+++ b/smartcontract/service/wasmvm/runtime.go
@@ -604,7 +604,7 @@ func getContractTypeInner(service *WasmVmService, addr common.Address) (Contract
 		return UNKOWN_CONTRACT, err
 	}
 	if dep == nil {
-		return UNKOWN_CONTRACT, errors.NewErr("contract is not exist.")
+		return UNKOWN_CONTRACT, fmt.Errorf("contract %s is not exist", addr.ToHexString())
 	}
 	if dep.VmType() == payload.WASMVM_TYPE {
 		return WASMVM_CONTRACT, nil

From d6c968acd7b429532796cb6adad701350d24db7a Mon Sep 17 00:00:00 2001
From: laizy <aochyi@126.com>
Date: Mon, 12 Oct 2020 19:21:48 +0800
Subject: [PATCH 11/11] fix identity create

---
 account/identity.go      | 24 +++++-------------------
 account/identity_test.go | 26 +++++++++-----------------
 2 files changed, 14 insertions(+), 36 deletions(-)

diff --git a/account/identity.go b/account/identity.go
index 75a8f8f809..a84bf45d31 100644
--- a/account/identity.go
+++ b/account/identity.go
@@ -28,14 +28,13 @@ import (
 
 	"github.com/itchyny/base58-go"
 	"github.com/ontio/ontology-crypto/keypair"
+	"github.com/ontio/ontology/common"
 	"github.com/ontio/ontology/core/types"
-	"golang.org/x/crypto/ripemd160"
 )
 
 const (
 	SCHEME = "did"
 	METHOD = "ont"
-	VER    = 0x41
 )
 
 func GenerateID() (string, error) {
@@ -44,25 +43,12 @@ func GenerateID() (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("generate ID error, %s", err)
 	}
-	return CreateID(buf[:])
+	return CreateID(buf[:]), nil
 }
 
-func CreateID(nonce []byte) (string, error) {
-	hasher := ripemd160.New()
-	_, err := hasher.Write(nonce)
-	if err != nil {
-		return "", fmt.Errorf("create ID error, %s", err)
-	}
-	data := hasher.Sum([]byte{VER})
-	data = append(data, checksum(data)...)
-
-	bi := new(big.Int).SetBytes(data).String()
-	idstring, err := base58.BitcoinEncoding.Encode([]byte(bi))
-	if err != nil {
-		return "", fmt.Errorf("create ID error, %s", err)
-	}
-
-	return SCHEME + ":" + METHOD + ":" + string(idstring), nil
+func CreateID(nonce []byte) string {
+	addr := common.AddressFromVmCode(nonce)
+	return SCHEME + ":" + METHOD + ":" + addr.ToBase58()
 }
 
 func VerifyID(id string) bool {
diff --git a/account/identity_test.go b/account/identity_test.go
index fae61ef606..e08108f41c 100644
--- a/account/identity_test.go
+++ b/account/identity_test.go
@@ -21,27 +21,22 @@ package account
 import (
 	"encoding/hex"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-var id = "did:ont:TSS6S4Xhzt5wtvRBTm4y3QCTRqB4BnU7vT"
+var id = "did:ont:AQr5dncx7L7MjgnE91tgsJheBCLMGRwjDt"
 
 func TestCreate(t *testing.T) {
 	nonce, _ := hex.DecodeString("4c6b58adc6b8c6774eee0eb07dac4e198df87aae28f8932db3982edf3ff026e4")
-	id1, err := CreateID(nonce)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Log("result ID:", id1)
-	if id != id1 {
-		t.Fatal("expected ID:", id)
-	}
+	id1 := CreateID(nonce)
+	assert.Equal(t, id1, id)
+	id2 := CreateID([]byte{1})
+	assert.NotEqual(t, id1, id2)
 }
 
 func TestVerify(t *testing.T) {
-	t.Log("verify", id)
-	if !VerifyID(id) {
-		t.Error("error: failed")
-	}
+	assert.True(t, VerifyID(id))
 
 	invalid := []string{
 		"did:ont:",
@@ -52,9 +47,6 @@ func TestVerify(t *testing.T) {
 	}
 
 	for _, v := range invalid {
-		t.Log("verify", v)
-		if VerifyID(v) {
-			t.Error("error: passed")
-		}
+		assert.False(t, VerifyID(v))
 	}
 }