correct relay plugin lint error

plugin/dapp/relay/cmd/relayd/relayd/btcd.go

@@ -18,6 +18,7 @@ import (
 	"github.com/btcsuite/btcd/rpcclient"
 )
 
+// BtcClient interface
 type BtcClient interface {
 	Start() error
 	Stop() error
@@ -29,28 +30,28 @@ type BtcClient interface {
 }
 
 type (
-	BlockStamp struct {
+	blockStamp struct {
 		Height int32
 		Hash   chainhash.Hash
 	}
 
-	BlockMeta struct {
-		BlockStamp
+	blockMeta struct {
+		blockStamp
 		Time time.Time
 	}
 
-	ClientConnected   struct{}
-	BlockConnected    BlockMeta
-	BlockDisconnected BlockMeta
+	clientConnected   struct{}
+	blockConnected    blockMeta
+	blockDisconnected blockMeta
 )
 
-type Params struct {
+type params struct {
 	*chaincfg.Params
 	RPCClientPort string
 	RPCServerPort string
 }
 
-var MainNetParams = Params{
+var mainNetParams = params{
 	Params:        &chaincfg.MainNetParams,
 	RPCClientPort: "8334",
 	RPCServerPort: "8332",
@@ -63,24 +64,24 @@ type btcdClient struct {
 	reconnectAttempts   int
 	enqueueNotification chan interface{}
 	dequeueNotification chan interface{}
-	currentBlock        chan *BlockStamp
+	currentBlock        chan *blockStamp
 	quit                chan struct{}
 	wg                  sync.WaitGroup
 	started             bool
 	quitMtx             sync.Mutex
 }
 
-func NewBtcd(config *rpcclient.ConnConfig, reconnectAttempts int) (BtcClient, error) {
+func newBtcd(config *rpcclient.ConnConfig, reconnectAttempts int) (BtcClient, error) {
 	if reconnectAttempts < 0 {
 		return nil, errors.New("ReconnectAttempts must be positive")
 	}
 	client := &btcdClient{
 		connConfig:          config,
-		chainParams:         MainNetParams.Params,
+		chainParams:         mainNetParams.Params,
 		reconnectAttempts:   reconnectAttempts,
 		enqueueNotification: make(chan interface{}),
 		dequeueNotification: make(chan interface{}),
-		currentBlock:        make(chan *BlockStamp),
+		currentBlock:        make(chan *blockStamp),
 		quit:                make(chan struct{}),
 	}
 	ntfnCallbacks := &rpcclient.NotificationHandlers{
@@ -147,7 +148,7 @@ func (b *btcdClient) Notifications() <-chan interface{} {
 	return b.dequeueNotification
 }
 
-func (b *btcdClient) BlockStamp() (*BlockStamp, error) {
+func (b *btcdClient) BlockStamp() (*blockStamp, error) {
 	select {
 	case bs := <-b.currentBlock:
 		return bs, nil
@@ -158,15 +159,15 @@ func (b *btcdClient) BlockStamp() (*BlockStamp, error) {
 
 func (b *btcdClient) onClientConnect() {
 	select {
-	case b.enqueueNotification <- ClientConnected{}:
+	case b.enqueueNotification <- clientConnected{}:
 	case <-b.quit:
 	}
 }
 
 func (b *btcdClient) onBlockConnected(hash *chainhash.Hash, height int32, time time.Time) {
 	select {
-	case b.enqueueNotification <- BlockConnected{
-		BlockStamp: BlockStamp{
+	case b.enqueueNotification <- blockConnected{
+		blockStamp: blockStamp{
 			Hash:   *hash,
 			Height: height,
 		},
@@ -178,8 +179,8 @@ func (b *btcdClient) onBlockConnected(hash *chainhash.Hash, height int32, time t
 
 func (b *btcdClient) onBlockDisconnected(hash *chainhash.Hash, height int32, time time.Time) {
 	select {
-	case b.enqueueNotification <- BlockDisconnected{
-		BlockStamp: BlockStamp{
+	case b.enqueueNotification <- blockDisconnected{
+		blockStamp: blockStamp{
 			Hash:   *hash,
 			Height: height,
 		},
@@ -197,7 +198,7 @@ func (b *btcdClient) handler() {
 		return
 	}
 
-	bs := &BlockStamp{Hash: *hash, Height: height}
+	bs := &blockStamp{Hash: *hash, Height: height}
 	var notifications []interface{}
 	enqueue := b.enqueueNotification
 	var dequeue chan interface{}
@@ -225,8 +226,8 @@ out:
 			pingChan = time.After(time.Minute)
 
 		case dequeue <- next:
-			if n, ok := next.(BlockConnected); ok {
-				bs = &BlockStamp{
+			if n, ok := next.(blockConnected); ok {
+				bs = &blockStamp{
 					Height: n.Height,
 					Hash:   n.Hash,
 				}

plugin/dapp/relay/cmd/relayd/relayd/btcd_test.go

@@ -36,7 +36,7 @@ func (s *suiteBctd) SetupSuite() {
 		HTTPPostMode: true,
 		Certificates: certs,
 	}
-	s.btc, _ = NewBtcd(connCfg, reconnectAttempts)
+	s.btc, _ = newBtcd(connCfg, reconnectAttempts)
 }
 
 func (s *suiteBctd) TestGetBlockHeader() {

plugin/dapp/relay/cmd/relayd/relayd/btcweb.go

@@ -22,7 +22,7 @@ type btcWeb struct {
 	httpClient *fasthttp.Client
 }
 
-func NewBtcWeb() (BtcClient, error) {
+func newBtcWeb() (BtcClient, error) {
 	b := &btcWeb{
 		urlRoot:    "https://blockchain.info",
 		httpClient: &fasthttp.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}},
@@ -46,16 +46,16 @@ func (b *btcWeb) GetBlockHeader(height uint64) (*ty.BtcHeader, error) {
 	return block.BtcHeader(), nil
 }
 
-func (b *btcWeb) getBlock(height uint64) (*Block, error) {
+func (b *btcWeb) getBlock(height uint64) (*block, error) {
 	if height < 0 {
 		return nil, errors.New("height < 0")
 	}
 	url := fmt.Sprintf("%s/block-height/%d?format=json", b.urlRoot, height)
-	data, err := b.requestUrl(url)
+	data, err := b.requestURL(url)
 	if err != nil {
 		return nil, err
 	}
-	var blocks = Blocks{}
+	var blocks = blocks{}
 	err = json.Unmarshal(data, &blocks)
 	if err != nil {
 		return nil, err
@@ -66,11 +66,11 @@ func (b *btcWeb) getBlock(height uint64) (*Block, error) {
 
 func (b *btcWeb) GetLatestBlock() (*chainhash.Hash, uint64, error) {
 	url := b.urlRoot + "/latestblock"
-	data, err := b.requestUrl(url)
+	data, err := b.requestURL(url)
 	if err != nil {
 		return nil, 0, err
 	}
-	var blocks = LatestBlock{}
+	var blocks = latestBlock{}
 	err = json.Unmarshal(data, &blocks)
 	if err != nil {
 		return nil, 0, err
@@ -94,11 +94,11 @@ func (b *btcWeb) Ping() {
 
 func (b *btcWeb) GetTransaction(hash string) (*ty.BtcTransaction, error) {
 	url := b.urlRoot + "/rawtx/" + hash
-	data, err := b.requestUrl(url)
+	data, err := b.requestURL(url)
 	if err != nil {
 		return nil, err
 	}
-	var tx = TransactionResult{}
+	var tx = transactionResult{}
 	err = json.Unmarshal(data, &tx)
 	if err != nil {
 		return nil, err
@@ -135,7 +135,7 @@ func (b *btcWeb) GetSPV(height uint64, txHash string) (*ty.BtcSpv, error) {
 	return spv, nil
 }
 
-func (b *btcWeb) requestUrl(url string) ([]byte, error) {
+func (b *btcWeb) requestURL(url string) ([]byte, error) {
 	status, body, err := b.httpClient.Get(nil, url)
 	if err != nil {
 		return nil, err

plugin/dapp/relay/cmd/relayd/relayd/btcweb_test.go

@@ -22,7 +22,7 @@ func TestRunSuiteWeb(t *testing.T) {
 }
 
 func (s *suiteWeb) SetupSuite() {
-	s.btc, _ = NewBtcWeb()
+	s.btc, _ = newBtcWeb()
 }
 
 func (s *suiteWeb) TestGetBlockHeader() {

plugin/dapp/relay/cmd/relayd/relayd/chain33.go

@@ -16,6 +16,7 @@ import (
 	"google.golang.org/grpc"
 )
 
+// Client33 to connect with chain33
 type Client33 struct {
 	config     *Chain33
 	isSyncing  bool
@@ -25,6 +26,7 @@ type Client33 struct {
 	closer io.Closer
 }
 
+// NewClient33 new client instance
 func NewClient33(cfg *Chain33) *Client33 {
 	conn, err := grpc.Dial(cfg.Host, grpc.WithInsecure())
 	if err != nil {
@@ -53,7 +55,7 @@ out:
 			err := c.ping(ctx)
 			if err != nil {
 				log.Error("heartbeat", "heartbeat chain33 error: ", err.Error(), "reconnectAttempts: ", reconnectAttempts)
-				c.AutoReconnect(ctx)
+				c.autoReconnect(ctx)
 				reconnectAttempts--
 			} else {
 				reconnectAttempts = c.config.ReconnectAttempts
@@ -66,6 +68,7 @@ out:
 	}
 }
 
+// Start begin heartbeat to chain33
 func (c *Client33) Start(ctx context.Context) {
 	go c.heartbeat(ctx)
 }
@@ -93,7 +96,7 @@ func (c *Client33) ping(ctx context.Context) error {
 	return nil
 }
 
-func (c *Client33) AutoReconnect(ctx context.Context) {
+func (c *Client33) autoReconnect(ctx context.Context) {
 	if c.isClosed && !c.config.DisableAutoReconnect {
 		c.closer.Close()
 		conn, err := grpc.Dial(c.config.Host, grpc.WithInsecure())
@@ -109,6 +112,7 @@ func (c *Client33) AutoReconnect(ctx context.Context) {
 	}
 }
 
+// SendTransaction send tx to chain33
 func (c *Client33) SendTransaction(ctx context.Context, in *types.Transaction) (*types.Reply, error) {
 	if c.isSyncing {
 		return nil, errors.New("node is syncing")
@@ -116,6 +120,7 @@ func (c *Client33) SendTransaction(ctx context.Context, in *types.Transaction) (
 	return c.Chain33Client.SendTransaction(ctx, in)
 }
 
+// Close chain33 close
 func (c *Client33) Close() error {
 	return c.closer.Close()
 }

plugin/dapp/relay/cmd/relayd/relayd/config.go

@@ -13,6 +13,7 @@ import (
 	"github.com/btcsuite/btcd/rpcclient"
 )
 
+// Config relayd toml config
 type Config struct {
 	Title          string
 	Watch          bool
@@ -28,8 +29,9 @@ type Config struct {
 	Auth           Auth
 }
 
+// Btcd adapt to btcd
 type Btcd struct {
-	Id                   string
+	ID                   string
 	Host                 string
 	Endpoint             string
 	User                 string
@@ -46,12 +48,14 @@ type Btcd struct {
 	ReconnectAttempts    int
 }
 
+// Auth auth key struct
 type Auth struct {
 	PrivateKey string `json:"privateKey"`
 	PublicKey  string `json:"publicKey"`
 	Address    string `json:"address"`
 }
 
+// BitConnConfig btc connect config
 func (b *Btcd) BitConnConfig() *rpcclient.ConnConfig {
 	conn := &rpcclient.ConnConfig{}
 	conn.Host = b.Host
@@ -74,8 +78,9 @@ func (b *Btcd) BitConnConfig() *rpcclient.ConnConfig {
 	return conn
 }
 
+// Chain33 define adapt to chain33 relay exec
 type Chain33 struct {
-	Id                   string
+	ID                   string
 	Host                 string
 	User                 string
 	Pass                 string
@@ -83,6 +88,7 @@ type Chain33 struct {
 	ReconnectAttempts    int
 }
 
+// NewConfig create a new config
 func NewConfig(path string) *Config {
 	var cfg Config
 	if _, err := toml.DecodeFile(path, &cfg); err != nil {

plugin/dapp/relay/cmd/relayd/relayd/db.go

@@ -26,7 +26,8 @@ type relaydDB struct {
 	db db.DB
 }
 
-func NewRelayDB(name string, dir string, cache int32) *relaydDB {
+
+func newRelayDB(name string, dir string, cache int32) *relaydDB {
 	d := db.NewDB(name, "goleveldb", dir, cache)
 	return &relaydDB{d}
 }

plugin/dapp/relay/cmd/relayd/relayd/relayd.go

@@ -22,6 +22,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 )
 
+// Relayd define
 type Relayd struct {
 	config            *Config
 	db                *relaydDB
@@ -40,13 +41,14 @@ type Relayd struct {
 	isResetBtcHeight  bool
 }
 
+// NewRelayd create relayd instance
 func NewRelayd(config *Config) *Relayd {
 	ctx, cancel := context.WithCancel(context.Background())
 	dir, err := os.Getwd()
 	if err != nil {
 		panic(err)
 	}
-	db := NewRelayDB("relayd", dir, 256)
+	db := newRelayDB("relayd", dir, 256)
 
 	var firstHeight int
 	var isResetBtcHeight bool
@@ -84,9 +86,9 @@ func NewRelayd(config *Config) *Relayd {
 	client33 := NewClient33(&config.Chain33)
 	var btc BtcClient
 	if config.BtcdOrWeb == 0 {
-		btc, err = NewBtcd(config.Btcd.BitConnConfig(), config.Btcd.ReconnectAttempts)
+		btc, err = newBtcd(config.Btcd.BitConnConfig(), config.Btcd.ReconnectAttempts)
 	} else {
-		btc, err = NewBtcWeb()
+		btc, err = newBtcWeb()
 	}
 	if err != nil {
 		panic(err)
@@ -140,11 +142,13 @@ func NewRelayd(config *Config) *Relayd {
 	}
 }
 
+// Close relayd close
 func (r *Relayd) Close() {
 	r.client33.Close()
 	r.cancel()
 }
 
+// Start relayd start up
 func (r *Relayd) Start() {
 	r.btcClient.Start()
 	r.client33.Start(r.ctx)

plugin/dapp/relay/cmd/relayd/relayd/type.go

@@ -14,7 +14,7 @@ var (
 	privateKey               = []byte("privateKey-relayd")
 )
 
-type LatestBlock struct {
+type latestBlock struct {
 	Hash       string   `json:"hash"`
 	Time       int64    `json:"time"`
 	BlockIndex uint64   `json:"block_index"`
@@ -22,7 +22,7 @@ type LatestBlock struct {
 	TxIndexes  []uint64 `json:"txIndexes"`
 }
 
-type Header struct {
+type header struct {
 	Hash         string  `json:"hash"`
 	Ver          uint64  `json:"ver"`
 	PrevBlock    string  `json:"prev_block"`
@@ -40,7 +40,7 @@ type Header struct {
 	RelayedBy    string  `json:"relayed_by"`
 }
 
-func (b *Block) BtcHeader() *ty.BtcHeader {
+func (b *block) BtcHeader() *ty.BtcHeader {
 	return &ty.BtcHeader{
 		Hash:         b.Hash,
 		Height:       b.Height,
@@ -53,8 +53,8 @@ func (b *Block) BtcHeader() *ty.BtcHeader {
 	}
 }
 
-type Block struct {
-	// Header
+type block struct {
+	// header
 	Hash         string               `json:"hash"`
 	Ver          uint64               `json:"ver"`
 	PrevBlock    string               `json:"prev_block"`
@@ -70,14 +70,14 @@ type Block struct {
 	Height       uint64               `json:"height"`
 	ReceivedTime int64                `json:"received_time"`
 	RelayedBy    string               `json:"relayed_by"`
-	Tx           []TransactionDetails `json:"tx"`
+	Tx           []transactionDetails `json:"tx"`
 }
 
-type TransactionDetails struct {
+type transactionDetails struct {
 	LockTime  int64     `json:"lock_time"`
 	Ver       uint64    `json:"ver"`
 	Size      uint64    `json:"size"`
-	Inputs    []TxInput `json:"inputs"`
+	Inputs    []txInput `json:"inputs"`
 	Weight    int64     `json:"weight"`
 	Time      int64     `json:"time"`
 	TxIndex   uint64    `json:"tx_index"`
@@ -85,16 +85,16 @@ type TransactionDetails struct {
 	Hash      string    `json:"hash"`
 	VoutSz    uint64    `json:"vout_sz"`
 	RelayedBy string    `json:"relayed_by"`
-	Outs      []TxOut   `json:"out"`
+	Outs      []txOut   `json:"out"`
 }
 
-type TxInput struct {
+type txInput struct {
 	Sequence int64  `json:"sequence"`
 	Witness  string `json:"witness"`
 	Script   string `json:"script"`
 }
 
-type TxOut struct {
+type txOut struct {
 	Spent   bool   `json:"spent"`
 	TxIndex uint64 `json:"tx_index"`
 	Type    int    `json:"type"`
@@ -104,17 +104,17 @@ type TxOut struct {
 	Script  string `json:"script"`
 }
 
-type Blocks struct {
-	Blocks []Block `json:"blocks"`
+type blocks struct {
+	Blocks []block `json:"blocks"`
 }
 
-type TransactionResult struct {
+type transactionResult struct {
 	Ver         uint     `json:"ver"`
-	Inputs      []Inputs `json:"inputs"`
+	Inputs      []inputs `json:"inputs"`
 	Weight      int64    `json:"weight"`
 	BlockHeight uint64   `json:"block_height"`
 	RelayedBy   string   `json:"relayed_by"`
-	Out         []TxOut  `json:"out"`
+	Out         []txOut  `json:"out"`
 	LockTime    int64    `json:"lock_time"`
 	Size        uint64   `json:"size"`
 	DoubleSpend bool     `json:"double_spend"`
@@ -125,14 +125,14 @@ type TransactionResult struct {
 	VoutSz      uint64   `json:"vout_sz"`
 }
 
-type Inputs struct {
+type inputs struct {
 	Sequence uint   `json:"sequence"`
 	Witness  string `json:"witness"`
-	PrevOut  TxOut  `json:"prev_out"`
+	PrevOut  txOut  `json:"prev_out"`
 	Script   string `json:"script"`
 }
 
-func (t *TransactionResult) BtcTransaction() *ty.BtcTransaction {
+func (t *transactionResult) BtcTransaction() *ty.BtcTransaction {
 	btcTx := &ty.BtcTransaction{}
 	btcTx.Hash = t.Hash
 	btcTx.Time = t.Time

plugin/dapp/relay/commands/relay.go

@@ -17,6 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// RelayCmd relay exec cmd register
 func RelayCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "relay",
@@ -41,6 +42,7 @@ func RelayCmd() *cobra.Command {
 	return cmd
 }
 
+// ShowBTCHeadHeightListCmd show btc head height list cmd
 func ShowBTCHeadHeightListCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "btc_height_list",
@@ -94,6 +96,7 @@ func showBtcHeadHeightList(cmd *cobra.Command, args []string) {
 	parseRelayBtcHeadHeightList(res)
 }
 
+// ShowBTCHeadCurHeightCmd show BTC head current height in chain33
 func ShowBTCHeadCurHeightCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "btc_cur_height",
@@ -137,6 +140,7 @@ func showBtcHeadCurHeight(cmd *cobra.Command, args []string) {
 	parseRelayBtcCurHeight(res)
 }
 
+// ShowOnesCreateRelayOrdersCmd show ones created orders
 func ShowOnesCreateRelayOrdersCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "creator_orders",
@@ -187,6 +191,7 @@ func showOnesRelayOrders(cmd *cobra.Command, args []string) {
 	parseRelayOrders(res)
 }
 
+// ShowOnesAcceptRelayOrdersCmd show ones accepted orders
 func ShowOnesAcceptRelayOrdersCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "acceptor_orders",
@@ -236,6 +241,7 @@ func showRelayAcceptOrders(cmd *cobra.Command, args []string) {
 	parseRelayOrders(res)
 }
 
+// ShowOnesStatusOrdersCmd show ones order's status
 func ShowOnesStatusOrdersCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "status",
@@ -292,8 +298,8 @@ func showCoinRelayOrders(cmd *cobra.Command, args []string) {
 
 func parseRelayOrders(res ty.ReplyRelayOrders) {
 	for _, order := range res.Relayorders {
-		var show RelayOrder2Show
-		show.OrderId = order.Id
+		var show relayOrder2Show
+		show.OrderID = order.Id
 		show.Status = order.Status.String()
 		show.Creator = order.CreaterAddr
 		show.CoinOperation = ty.RelayOrderOperation[order.CoinOperation]
@@ -334,6 +340,7 @@ func parseRelayBtcCurHeight(res ty.ReplayRelayQryBTCHeadHeight) {
 	fmt.Println(string(data))
 }
 
+// CreateRawRelayOrderTxCmd create relay order, buy or sell
 func CreateRawRelayOrderTxCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "create",
@@ -395,6 +402,7 @@ func relayOrder(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// CreateRawRelayAcceptTxCmd accept order
 func CreateRawRelayAcceptTxCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "accept",
@@ -437,6 +445,7 @@ func relayAccept(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// CreateRawRevokeTxCmd revoke order
 func CreateRawRevokeTxCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "revoke",
@@ -476,6 +485,7 @@ func relayRevoke(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// CreateRawRelayConfirmTxCmd confirm tx
 func CreateRawRelayConfirmTxCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "confirm",
@@ -498,11 +508,11 @@ func addConfirmFlags(cmd *cobra.Command) {
 
 func relayConfirm(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	orderId, _ := cmd.Flags().GetString("order_id")
+	orderID, _ := cmd.Flags().GetString("order_id")
 	txHash, _ := cmd.Flags().GetString("tx_hash")
 
 	params := &ty.RelayConfirmTx{
-		OrderId: orderId,
+		OrderId: orderID,
 		TxHash:  txHash,
 	}
 	var res string
@@ -510,6 +520,7 @@ func relayConfirm(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// CreateRawRelayBtcHeaderCmd save btc header from cli
 func CreateRawRelayBtcHeaderCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "save_header",
@@ -559,6 +570,7 @@ func relaySaveBtcHead(cmd *cobra.Command, args []string) {
 	ctx.RunWithoutMarshal()
 }
 
+// CreateRawRelayVerifyBTCTxCmd verify btc tx from cli
 func CreateRawRelayVerifyBTCTxCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "verify",

plugin/dapp/relay/commands/types.go

@@ -4,8 +4,8 @@
 
 package commands
 
-type RelayOrder2Show struct {
-	OrderId       string `json:"orderid"`
+type relayOrder2Show struct {
+	OrderID       string `json:"orderid"`
 	Status        string `json:"status"`
 	Creator       string `json:"address"`
 	Amount        string `json:"amount"`

plugin/dapp/relay/executor/relay.go

@@ -22,10 +22,12 @@ func init() {
 	ety.InitFuncList(types.ListMethod(&relay{}))
 }
 
+// Init relay register driver
 func Init(name string, sub []byte) {
 	drivers.Register(GetName(), newRelay, types.GetDappFork(driverName, "Enable")) //TODO: ForkV18Relay
 }
 
+// GetName relay get driver name
 func GetName() string {
 	return newRelay().GetName()
 }
@@ -45,7 +47,7 @@ func (r *relay) GetDriverName() string {
 	return driverName
 }
 
-func (c *relay) GetPayloadValue() types.Message {
+func (r *relay) GetPayloadValue() types.Message {
 	return &ty.RelayAction{}
 }
 
@@ -119,16 +121,16 @@ func (r *relay) GetSellOrder(prefixs [][]byte) (types.Message, error) {
 
 }
 
-func (r *relay) getRelayOrderReply(OrderIds [][]byte) (types.Message, error) {
-	OrderIdGot := make(map[string]bool)
+func (r *relay) getRelayOrderReply(OrderIDs [][]byte) (types.Message, error) {
+	orderIDGot := make(map[string]bool)
 
 	var reply ty.ReplyRelayOrders
-	for _, OrderId := range OrderIds {
-		if !OrderIdGot[string(OrderId)] {
-			if order, err := r.getSellOrderFromDb(OrderId); err == nil {
+	for _, orderID := range OrderIDs {
+		if !orderIDGot[string(orderID)] {
+			if order, err := r.getSellOrderFromDb(orderID); err == nil {
 				reply.Relayorders = insertOrderDescending(order, reply.Relayorders)
 			}
-			OrderIdGot[string(OrderId)] = true
+			orderIDGot[string(orderID)] = true
 		}
 	}
 	return &reply, nil
@@ -157,8 +159,8 @@ func insertOrderDescending(toBeInserted *ty.RelayOrder, orders []*ty.RelayOrder)
 	return orders
 }
 
-func (r *relay) getSellOrderFromDb(OrderId []byte) (*ty.RelayOrder, error) {
-	value, err := r.GetStateDB().Get(OrderId)
+func (r *relay) getSellOrderFromDb(OrderID []byte) (*ty.RelayOrder, error) {
+	value, err := r.GetStateDB().Get(OrderID)
 	if err != nil {
 		return nil, err
 	}
@@ -177,8 +179,8 @@ func (r *relay) getBTCHeaderFromDb(hash []byte) (*ty.BtcHeader, error) {
 	return &header, nil
 }
 
-func (r *relay) getOrderKv(OrderId []byte, ty int32) []*types.KeyValue {
-	order, _ := r.getSellOrderFromDb(OrderId)
+func (r *relay) getOrderKv(OrderID []byte, ty int32) []*types.KeyValue {
+	order, _ := r.getSellOrderFromDb(OrderID)
 
 	var kv []*types.KeyValue
 	kv = deleteCreateOrderKeyValue(kv, order, int32(order.PreStatus))
@@ -187,8 +189,8 @@ func (r *relay) getOrderKv(OrderId []byte, ty int32) []*types.KeyValue {
 	return kv
 }
 
-func (r *relay) getDeleteOrderKv(OrderId []byte, ty int32) []*types.KeyValue {
-	order, _ := r.getSellOrderFromDb(OrderId)
+func (r *relay) getDeleteOrderKv(OrderID []byte, ty int32) []*types.KeyValue {
+	order, _ := r.getSellOrderFromDb(OrderID)
 	var kv []*types.KeyValue
 	kv = deleteCreateOrderKeyValue(kv, order, int32(order.Status))
 	kv = getCreateOrderKeyValue(kv, order, int32(order.PreStatus))
@@ -197,23 +199,23 @@ func (r *relay) getDeleteOrderKv(OrderId []byte, ty int32) []*types.KeyValue {
 }
 
 func getCreateOrderKeyValue(kv []*types.KeyValue, order *ty.RelayOrder, status int32) []*types.KeyValue {
-	OrderId := []byte(order.Id)
+	orderID := []byte(order.Id)
 
 	key := calcOrderKeyStatus(order, status)
-	kv = append(kv, &types.KeyValue{Key: key, Value: OrderId})
+	kv = append(kv, &types.KeyValue{Key: key, Value: orderID})
 
 	key = calcOrderKeyCoin(order, status)
-	kv = append(kv, &types.KeyValue{Key: key, Value: OrderId})
+	kv = append(kv, &types.KeyValue{Key: key, Value: orderID})
 
 	key = calcOrderKeyAddrStatus(order, status)
-	kv = append(kv, &types.KeyValue{Key: key, Value: OrderId})
+	kv = append(kv, &types.KeyValue{Key: key, Value: orderID})
 
 	key = calcOrderKeyAddrCoin(order, status)
-	kv = append(kv, &types.KeyValue{Key: key, Value: OrderId})
+	kv = append(kv, &types.KeyValue{Key: key, Value: orderID})
 
 	key = calcAcceptKeyAddr(order, status)
 	if key != nil {
-		kv = append(kv, &types.KeyValue{Key: key, Value: OrderId})
+		kv = append(kv, &types.KeyValue{Key: key, Value: orderID})
 	}
 
 	return kv
@@ -223,20 +225,20 @@ func getCreateOrderKeyValue(kv []*types.KeyValue, order *ty.RelayOrder, status i
 func deleteCreateOrderKeyValue(kv []*types.KeyValue, order *ty.RelayOrder, status int32) []*types.KeyValue {
 
 	key := calcOrderKeyStatus(order, status)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	key = calcOrderKeyCoin(order, status)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	key = calcOrderKeyAddrStatus(order, status)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	key = calcOrderKeyAddrCoin(order, status)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	key = calcAcceptKeyAddr(order, status)
 	if key != nil {
-		kv = append(kv, &types.KeyValue{key, nil})
+		kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 	}
 
 	return kv

plugin/dapp/relay/executor/relay_test.go

@@ -30,7 +30,7 @@ type suiteRelay struct {
 	kvdb      *mocks.KVDB
 	relay     *relay
 	addrRelay string
-	orderId   string
+	orderID   string
 	//relayDb   *relayDB
 }
 
@@ -92,7 +92,7 @@ func (s *suiteRelay) testExecLocal(tx *types.Transaction, receipt *types.Receipt
 
 	set, err := s.relay.ExecLocal(tx, rData, 0)
 	s.Nil(err)
-	order, _ := s.relay.getSellOrderFromDb([]byte(s.orderId))
+	order, _ := s.relay.getSellOrderFromDb([]byte(s.orderID))
 	var kv []*types.KeyValue
 	kv = deleteCreateOrderKeyValue(kv, order, int32(order.PreStatus))
 	kv = getCreateOrderKeyValue(kv, order, int32(order.Status))
@@ -109,7 +109,7 @@ func (s *suiteRelay) testExecDelLocal(tx *types.Transaction, receipt *types.Rece
 
 	set, err := s.relay.ExecDelLocal(tx, rData, 0)
 	s.Nil(err)
-	order, _ := s.relay.getSellOrderFromDb([]byte(s.orderId))
+	order, _ := s.relay.getSellOrderFromDb([]byte(s.orderID))
 	var kv []*types.KeyValue
 	kv = deleteCreateOrderKeyValue(kv, order, int32(order.Status))
 	kv = getCreateOrderKeyValue(kv, order, int32(order.PreStatus))
@@ -129,7 +129,7 @@ func (s *suiteRelay) TestExec_1() {
 
 	sell := &ty.RelayAction{
 		Ty:    ty.RelayActionCreate,
-		Value: &ty.RelayAction_Create{order},
+		Value: &ty.RelayAction_Create{Create:order},
 	}
 
 	tx := &types.Transaction{}
@@ -140,7 +140,7 @@ func (s *suiteRelay) TestExec_1() {
 	tx.Sign(types.SECP256K1, privFrom)
 
 	s.relay.SetEnv(10, 1000, 1)
-	heightBytes := types.Encode(&types.Int64{int64(10)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(10)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 
 	receipt, err := s.relay.Exec(tx, 0)
@@ -156,7 +156,7 @@ func (s *suiteRelay) TestExec_1() {
 	s.Equal("200.0000", log.TxAmount)
 	s.Equal(uint64(10), log.CoinHeight)
 
-	s.orderId = log.OrderId
+	s.orderID = log.OrderId
 
 	//s.testExecLocal(tx, receipt)
 	//s.testExecDelLocal(tx, receipt)
@@ -166,13 +166,13 @@ func (s *suiteRelay) TestExec_1() {
 //accept
 func (s *suiteRelay) TestExec_2() {
 	order := &ty.RelayAccept{
-		OrderId:  s.orderId,
+		OrderId:  s.orderID,
 		CoinAddr: addrBtc,
 	}
 
 	sell := &ty.RelayAction{
 		Ty:    ty.RelayActionAccept,
-		Value: &ty.RelayAction_Accept{order},
+		Value: &ty.RelayAction_Accept{Accept:order},
 	}
 
 	tx := &types.Transaction{}
@@ -181,7 +181,7 @@ func (s *suiteRelay) TestExec_2() {
 	tx.Sign(types.SECP256K1, privTo)
 
 	s.relay.SetEnv(20, 2000, 1)
-	heightBytes := types.Encode(&types.Int64{int64(20)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(20)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	receipt, err := s.relay.Exec(tx, 0)
 	s.Nil(err)
@@ -203,12 +203,12 @@ func (s *suiteRelay) TestExec_2() {
 func (s *suiteRelay) TestExec_3() {
 
 	order := &ty.RelayConfirmTx{
-		OrderId: s.orderId,
+		OrderId: s.orderID,
 		TxHash:  "6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4",
 	}
 	sell := &ty.RelayAction{
 		Ty:    ty.RelayActionConfirmTx,
-		Value: &ty.RelayAction_ConfirmTx{order},
+		Value: &ty.RelayAction_ConfirmTx{ConfirmTx:order},
 	}
 
 	tx := &types.Transaction{}
@@ -217,7 +217,7 @@ func (s *suiteRelay) TestExec_3() {
 	tx.Sign(types.SECP256K1, privFrom)
 
 	s.relay.SetEnv(30, 3000, 1)
-	heightBytes := types.Encode(&types.Int64{int64(30)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(30)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	receipt, err := s.relay.Exec(tx, 0)
 	s.Nil(err)
@@ -248,11 +248,11 @@ func (s *suiteRelay) TestExec_4() {
 		BlockHeight: 1000,
 		Hash:        "6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4",
 	}
-	str_merkleproof := []string{"e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d",
+	strMerkleproof := []string{"e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d",
 		"ccdafb73d8dcd0173d5d5c3c9a0770d0b3953db889dab99ef05b1907518cb815"}
 
-	proofs := make([][]byte, len(str_merkleproof))
-	for i, kk := range str_merkleproof {
+	proofs := make([][]byte, len(strMerkleproof))
+	for i, kk := range strMerkleproof {
 		proofs[i], _ = btcHashStrRevers(kk)
 	}
 
@@ -264,7 +264,7 @@ func (s *suiteRelay) TestExec_4() {
 		Hash:        "6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4",
 	}
 
-	heightBytes := types.Encode(&types.Int64{int64(1006)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(1006)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	var head = &ty.BtcHeader{
 		Version:    1,
@@ -274,13 +274,13 @@ func (s *suiteRelay) TestExec_4() {
 	s.kvdb.On("Get", mock.Anything).Return(headEnc, nil).Once()
 
 	order := &ty.RelayVerify{
-		OrderId: s.orderId,
+		OrderId: s.orderID,
 		Tx:      transaction,
 		Spv:     spv,
 	}
 	sell := &ty.RelayAction{
 		Ty:    ty.RelayActionVerifyTx,
-		Value: &ty.RelayAction_Verify{order},
+		Value: &ty.RelayAction_Verify{Verify:order},
 	}
 	tx := &types.Transaction{}
 	tx.To = s.addrRelay
@@ -314,7 +314,7 @@ func (s *suiteRelay) TestExec_9_QryStatus1() {
 	}
 
 	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderId))
+	OrderIds = append(OrderIds, []byte(s.orderID))
 	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
 	msg, err := s.relay.Query_GetRelayOrderByStatus(addrCoins)
 	s.Nil(err)
@@ -331,7 +331,7 @@ func (s *suiteRelay) TestExec_9_QryStatus2() {
 	}
 
 	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderId))
+	OrderIds = append(OrderIds, []byte(s.orderID))
 	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
 	msg, err := s.relay.Query_GetSellRelayOrder(addrCoins)
 	s.Nil(err)
@@ -346,7 +346,7 @@ func (s *suiteRelay) TestExec_9_QryStatus3() {
 	}
 
 	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderId))
+	OrderIds = append(OrderIds, []byte(s.orderID))
 	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
 	msg, err := s.relay.Query_GetBuyRelayOrder(addrCoins)
 	s.Nil(err)
@@ -361,7 +361,7 @@ func (s *suiteRelay) TestExec_9_QryStatus4() {
 	}
 
 	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderId))
+	OrderIds = append(OrderIds, []byte(s.orderID))
 	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
 	msg, err := s.relay.Query_GetBTCHeaderList(addrCoins)
 	s.Nil(err)
@@ -374,7 +374,7 @@ func (s *suiteRelay) TestExec_9_QryStatus5() {
 		BaseHeight: 10,
 	}
 
-	heightBytes := types.Encode(&types.Int64{int64(10)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(10)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Twice()
 	msg, err := s.relay.Query_GetBTCHeaderCurHeight(addrCoins)
 	s.Nil(err)
@@ -505,7 +505,7 @@ func (s *suiteBtcHeader) TestSaveBtcHead_1() {
 
 	sell := &ty.RelayAction{
 		Ty:    ty.RelayActionRcvBTCHeaders,
-		Value: &ty.RelayAction_BtcHeaders{headers},
+		Value: &ty.RelayAction_BtcHeaders{BtcHeaders:headers},
 	}
 
 	tx := &types.Transaction{}

plugin/dapp/relay/executor/relaybtc.go

@@ -88,19 +88,19 @@ func (b *btcStore) saveBlockHead(head *ty.BtcHeader) ([]*types.KeyValue, error)
 		relaylog.Error("saveBlockHead", "height", head.Height, "hash", head.Hash)
 		return nil, err
 
-	} else {
-		// hash:header
-		key = calcBtcHeaderKeyHash(head.Hash)
-		kv = append(kv, &types.KeyValue{key, val})
-		// height:header
-		key = calcBtcHeaderKeyHeight(int64(head.Height))
-		kv = append(kv, &types.KeyValue{key, val})
 	}
 
+	// hash:header
+	key = calcBtcHeaderKeyHash(head.Hash)
+	kv = append(kv, &types.KeyValue{Key:key,Value: val})
+	// height:header
+	key = calcBtcHeaderKeyHeight(int64(head.Height))
+	kv = append(kv, &types.KeyValue{Key:key, Value:val})
+
 	// prefix-height:height
 	key = calcBtcHeaderKeyHeightList(int64(head.Height))
-	heightBytes := types.Encode(&types.Int64{int64(head.Height)})
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	heightBytes := types.Encode(&types.Int64{Data:int64(head.Height)})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
 	return kv, nil
 }
@@ -108,13 +108,13 @@ func (b *btcStore) saveBlockHead(head *ty.BtcHeader) ([]*types.KeyValue, error)
 func (b *btcStore) saveBlockLastHead(head *ty.ReceiptRelayRcvBTCHeaders) ([]*types.KeyValue, error) {
 	var kv []*types.KeyValue
 
-	heightBytes := types.Encode(&types.Int64{int64(head.NewHeight)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(head.NewHeight)})
 	key := relayBTCHeaderLastHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
-	heightBytes = types.Encode(&types.Int64{int64(head.NewBaseHeight)})
+	heightBytes = types.Encode(&types.Int64{Data:int64(head.NewBaseHeight)})
 	key = relayBTCHeaderBaseHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
 	return kv, nil
 }
@@ -123,14 +123,14 @@ func (b *btcStore) delBlockHead(head *ty.BtcHeader) ([]*types.KeyValue, error) {
 	var kv []*types.KeyValue
 
 	key := calcBtcHeaderKeyHash(head.Hash)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key,Value: nil})
 	// height:header
 	key = calcBtcHeaderKeyHeight(int64(head.Height))
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key,Value: nil})
 
 	// prefix-height:height
 	key = calcBtcHeaderKeyHeightList(int64(head.Height))
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	return kv, nil
 }
@@ -139,13 +139,13 @@ func (b *btcStore) delBlockLastHead(head *ty.ReceiptRelayRcvBTCHeaders) ([]*type
 	var kv []*types.KeyValue
 	var key []byte
 
-	heightBytes := types.Encode(&types.Int64{int64(head.LastHeight)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(head.LastHeight)})
 	key = relayBTCHeaderLastHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
-	heightBytes = types.Encode(&types.Int64{int64(head.LastBaseHeight)})
+	heightBytes = types.Encode(&types.Int64{Data:int64(head.LastBaseHeight)})
 	key = relayBTCHeaderBaseHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
 	return kv, nil
 }

plugin/dapp/relay/executor/relaybtc_test.go

@@ -34,14 +34,14 @@ func (s *suiteBtcStore) SetupSuite() {
 }
 
 func (s *suiteBtcStore) TestGetBtcHeadHeightFromDb() {
-	heightBytes := types.Encode(&types.Int64{int64(10)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(10)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	val, _ := s.btc.getBtcHeadHeightFromDb([]byte("key"))
 	s.Assert().Equal(val, int64(10))
 }
 
 func (s *suiteBtcStore) TestGetLastBtcHeadHeight() {
-	heightBytes := types.Encode(&types.Int64{int64(10)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(10)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	val, _ := s.btc.getLastBtcHeadHeight()
 	s.Assert().Equal(val, int64(10))
@@ -58,7 +58,7 @@ func (s *suiteBtcStore) TestGetBtcHeadByHeight() {
 }
 
 func (s *suiteBtcStore) TestGetLastBtcHead() {
-	heightBytes := types.Encode(&types.Int64{int64(10)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(10)})
 	head := &ty.BtcHeader{}
 
 	header := types.Encode(head)
@@ -82,12 +82,12 @@ func (s *suiteBtcStore) TestSaveBlockHead() {
 	}
 	val, _ := proto.Marshal(head)
 	key := calcBtcHeaderKeyHash(head.Hash)
-	kv = append(kv, &types.KeyValue{key, val})
+	kv = append(kv, &types.KeyValue{Key:key, Value:val})
 	key = calcBtcHeaderKeyHeight(int64(head.Height))
-	kv = append(kv, &types.KeyValue{key, val})
+	kv = append(kv, &types.KeyValue{Key:key,Value: val})
 	key = calcBtcHeaderKeyHeightList(int64(head.Height))
-	heightBytes := types.Encode(&types.Int64{int64(head.Height)})
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	heightBytes := types.Encode(&types.Int64{Data:int64(head.Height)})
+	kv = append(kv, &types.KeyValue{Key:key,Value: heightBytes})
 
 	res, err := s.btc.saveBlockHead(head)
 	s.Nil(err)
@@ -104,13 +104,13 @@ func (s *suiteBtcStore) TestSaveBlockLastHead() {
 		NewBaseHeight:  150,
 	}
 
-	heightBytes := types.Encode(&types.Int64{int64(lastHead.NewHeight)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(lastHead.NewHeight)})
 	key := relayBTCHeaderLastHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key, Value:heightBytes})
 
-	heightBytes = types.Encode(&types.Int64{int64(lastHead.NewBaseHeight)})
+	heightBytes = types.Encode(&types.Int64{Data:int64(lastHead.NewBaseHeight)})
 	key = relayBTCHeaderBaseHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key, Value:heightBytes})
 
 	res, err := s.btc.saveBlockLastHead(lastHead)
 	s.Nil(err)
@@ -131,14 +131,14 @@ func (s *suiteBtcStore) TestDelBlockHead() {
 	}
 
 	key := calcBtcHeaderKeyHash(head.Hash)
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 	// height:header
 	key = calcBtcHeaderKeyHeight(int64(head.Height))
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	// prefix-height:height
 	key = calcBtcHeaderKeyHeightList(int64(head.Height))
-	kv = append(kv, &types.KeyValue{key, nil})
+	kv = append(kv, &types.KeyValue{Key:key, Value:nil})
 
 	res, err := s.btc.delBlockHead(head)
 	s.Nil(err)
@@ -155,13 +155,13 @@ func (s *suiteBtcStore) TestDelBlockLastHead() {
 		NewBaseHeight:  150,
 	}
 
-	heightBytes := types.Encode(&types.Int64{int64(lastHead.LastHeight)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(lastHead.LastHeight)})
 	key := relayBTCHeaderLastHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key, Value:heightBytes})
 
-	heightBytes = types.Encode(&types.Int64{int64(lastHead.LastBaseHeight)})
+	heightBytes = types.Encode(&types.Int64{Data:int64(lastHead.LastBaseHeight)})
 	key = relayBTCHeaderBaseHeight
-	kv = append(kv, &types.KeyValue{key, heightBytes})
+	kv = append(kv, &types.KeyValue{Key:key, Value:heightBytes})
 
 	res, err := s.btc.delBlockLastHead(lastHead)
 	s.Nil(err)
@@ -173,7 +173,7 @@ func (s *suiteBtcStore) TestGetBtcCurHeight() {
 
 	rep, err := s.btc.getBtcCurHeight(nil)
 	s.Nil(err)
-	s.Equal(rep, &ty.ReplayRelayQryBTCHeadHeight{-1, -1})
+	s.Equal(rep, &ty.ReplayRelayQryBTCHeadHeight{CurHeight: -1, BaseHeight: -1})
 }
 
 func (s *suiteBtcStore) TestGetMerkleRootFromHeader() {
@@ -188,8 +188,8 @@ func (s *suiteBtcStore) TestGetMerkleRootFromHeader() {
 		Height:       2,
 	}
 
-	head_enc := types.Encode(head)
-	s.kvdb.On("Get", mock.Anything).Return(head_enc, nil).Once()
+	headEnc := types.Encode(head)
+	s.kvdb.On("Get", mock.Anything).Return(headEnc, nil).Once()
 	res, err := s.btc.getMerkleRootFromHeader(head.Hash)
 	s.Nil(err)
 	s.Equal(head.MerkleRoot, res)
@@ -221,11 +221,11 @@ func (s *suiteBtcStore) TestVerifyBtcTx() {
 	//					"6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4",
 	//					"e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d"}
 	//the 3rd tx's branch
-	str_merkleproof := []string{"e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d",
+	strMerkleproof := []string{"e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d",
 		"ccdafb73d8dcd0173d5d5c3c9a0770d0b3953db889dab99ef05b1907518cb815"}
 
-	proofs := make([][]byte, len(str_merkleproof))
-	for i, kk := range str_merkleproof {
+	proofs := make([][]byte, len(strMerkleproof))
+	for i, kk := range strMerkleproof {
 		proofs[i], _ = btcHashStrRevers(kk)
 	}
 
@@ -241,7 +241,7 @@ func (s *suiteBtcStore) TestVerifyBtcTx() {
 		Spv: spv,
 	}
 
-	heightBytes := types.Encode(&types.Int64{int64(1006)})
+	heightBytes := types.Encode(&types.Int64{Data:int64(1006)})
 	s.kvdb.On("Get", mock.Anything).Return(heightBytes, nil).Once()
 	var head = &ty.BtcHeader{
 		Version:    1,
@@ -290,7 +290,7 @@ func (s *suiteBtcStore) TestGetHeadHeightList() {
 	heightArry := make([][]byte, 10)
 	for i := 0; i < 10; i++ {
 		height := int64(1000 + i)
-		heightBytes := types.Encode(&types.Int64{height})
+		heightBytes := types.Encode(&types.Int64{Data:height})
 		heightArry[i] = heightBytes
 		replay.Heights = append(replay.Heights, height)
 	}

plugin/dapp/relay/executor/relaydb.go

@@ -43,11 +43,11 @@ func (r *relayLog) save(db dbm.KV) []*types.KeyValue {
 func (r *relayLog) getKVSet() (kvSet []*types.KeyValue) {
 	value := types.Encode(&r.RelayOrder)
 	key := []byte(r.Id)
-	kvSet = append(kvSet, &types.KeyValue{key, value})
+	kvSet = append(kvSet, &types.KeyValue{Key:key, Value:value})
 
 	if r.CoinTxHash != "" {
 		key = []byte(calcCoinHash(r.CoinTxHash))
-		kvSet = append(kvSet, &types.KeyValue{key, value})
+		kvSet = append(kvSet, &types.KeyValue{Key:key, Value:value})
 	}
 
 	return kvSet
@@ -100,8 +100,8 @@ func newRelayDB(r *relay, tx *types.Transaction) *relayDB {
 		fromAddr, r.GetBlockTime(), r.GetHeight(), dapp.ExecAddress(r.GetName()), btc}
 }
 
-func (action *relayDB) getOrderByID(orderId []byte) (*ty.RelayOrder, error) {
-	value, err := action.db.Get(orderId)
+func (action *relayDB) getOrderByID(orderID []byte) (*ty.RelayOrder, error) {
+	value, err := action.db.Get(orderID)
 	if err != nil {
 		return nil, err
 	}
@@ -179,7 +179,7 @@ func (action *relayDB) create(order *ty.RelayCreate) (*types.Receipt, error) {
 	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayCreate))
 	kv = append(kv, sellOrderKV...)
 
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 }
 
 func (action *relayDB) checkRevokeOrder(order *ty.RelayOrder) error {
@@ -216,8 +216,8 @@ func (action *relayDB) checkRevokeOrder(order *ty.RelayOrder) error {
 }
 
 func (action *relayDB) revokeCreate(revoke *ty.RelayRevoke) (*types.Receipt, error) {
-	orderId := []byte(revoke.OrderId)
-	order, err := action.getOrderByID(orderId)
+	orderID := []byte(revoke.OrderId)
+	order, err := action.getOrderByID(orderID)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -290,12 +290,12 @@ func (action *relayDB) revokeCreate(revoke *ty.RelayRevoke) (*types.Receipt, err
 	}
 	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayRevokeCreate))
 	kv = append(kv, orderKV...)
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv,Logs: logs}, nil
 }
 
 func (action *relayDB) accept(accept *ty.RelayAccept) (*types.Receipt, error) {
-	orderId := []byte(accept.OrderId)
-	order, err := action.getOrderByID(orderId)
+	orderID := []byte(accept.OrderId)
+	order, err := action.getOrderByID(orderID)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -355,7 +355,7 @@ func (action *relayDB) accept(accept *ty.RelayAccept) (*types.Receipt, error) {
 	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayAccept))
 	kv = append(kv, sellOrderKV...)
 
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 
 }
 
@@ -368,8 +368,8 @@ func (action *relayDB) relayRevoke(revoke *ty.RelayRevoke) (*types.Receipt, erro
 }
 
 func (action *relayDB) revokeAccept(revoke *ty.RelayRevoke) (*types.Receipt, error) {
-	orderIdByte := []byte(revoke.OrderId)
-	order, err := action.getOrderByID(orderIdByte)
+	orderIDByte := []byte(revoke.OrderId)
+	order, err := action.getOrderByID(orderIDByte)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -429,12 +429,12 @@ func (action *relayDB) revokeAccept(revoke *ty.RelayRevoke) (*types.Receipt, err
 	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayRevokeAccept))
 	kv = append(kv, sellOrderKV...)
 
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 }
 
 func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, error) {
-	orderId := []byte(confirm.OrderId)
-	order, err := action.getOrderByID(orderId)
+	orderID := []byte(confirm.OrderId)
+	order, err := action.getOrderByID(orderID)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -449,7 +449,7 @@ func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, er
 		return nil, ty.ErrRelayOrderRevoked
 	}
 
-	//report Error if coinTxHash has been used and not same orderId, if same orderId, means to modify the txHash
+	//report Error if coinTxHash has been used and not same orderID, if same orderID, means to modify the txHash
 	coinTxOrder, _ := action.getOrderByCoinHash([]byte(calcCoinHash(confirm.TxHash)))
 	if coinTxOrder != nil {
 		if coinTxOrder.Id != confirm.OrderId {
@@ -487,14 +487,14 @@ func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, er
 	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayConfirmTx))
 	kv = append(kv, sellOrderKV...)
 
-	receipt := &types.Receipt{types.ExecOk, kv, logs}
+	receipt := &types.Receipt{Ty:types.ExecOk,KV: kv, Logs:logs}
 	return receipt, nil
 
 }
 
 func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error) {
-	orderId := []byte(verify.OrderId)
-	order, err := action.getOrderByID(orderId)
+	orderID := []byte(verify.OrderId)
+	order, err := action.getOrderByID(orderID)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -562,13 +562,13 @@ func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error)
 	kv = append(kv, receipt.KV...)
 	kv = append(kv, receiptTransfer.KV...)
 	kv = append(kv, orderKV...)
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 
 }
 
 func (action *relayDB) verifyCmdTx(verify *ty.RelayVerifyCli) (*types.Receipt, error) {
-	orderId := []byte(verify.OrderId)
-	order, err := action.getOrderByID(orderId)
+	orderID := []byte(verify.OrderId)
+	order, err := action.getOrderByID(orderID)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -637,7 +637,7 @@ func (action *relayDB) verifyCmdTx(verify *ty.RelayVerifyCli) (*types.Receipt, e
 	kv = append(kv, receipt.KV...)
 	kv = append(kv, receiptTransfer.KV...)
 	kv = append(kv, orderKV...)
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 
 }
 
@@ -648,7 +648,7 @@ func saveBtcLastHead(db dbm.KV, head *ty.RelayLastRcvBtcHeader) (set []*types.Ke
 
 	value := types.Encode(head)
 	key := []byte(btcLastHead)
-	set = append(set, &types.KeyValue{key, value})
+	set = append(set, &types.KeyValue{Key:key,Value: value})
 
 	for i := 0; i < len(set); i++ {
 		db.Set(set[i].GetKey(), set[i].Value)
@@ -714,5 +714,5 @@ func (action *relayDB) saveBtcHeader(headers *ty.BtcHeaders, localDb dbm.KVDB) (
 	log.Log = types.Encode(receipt)
 	logs = append(logs, log)
 	kv = saveBtcLastHead(action.db, preHead)
-	return &types.Receipt{types.ExecOk, kv, logs}, nil
+	return &types.Receipt{Ty:types.ExecOk, KV:kv, Logs:logs}, nil
 }

plugin/dapp/relay/rpc/rpc.go

@@ -11,7 +11,7 @@ import (
 	ty "github.com/33cn/plugin/plugin/dapp/relay/types"
 )
 
-func CreateRawRelayOrderTx(parm *ty.RelayCreate) ([]byte, error) {
+func createRawRelayOrderTx(parm *ty.RelayCreate) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
@@ -19,21 +19,21 @@ func CreateRawRelayOrderTx(parm *ty.RelayCreate) ([]byte, error) {
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "Create", &v)
 }
 
-func CreateRawRelayAcceptTx(parm *ty.RelayAccept) ([]byte, error) {
+func createRawRelayAcceptTx(parm *ty.RelayAccept) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "Accept", parm)
 }
 
-func CreateRawRelayRevokeTx(parm *ty.RelayRevoke) ([]byte, error) {
+func createRawRelayRevokeTx(parm *ty.RelayRevoke) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "Revoke", parm)
 }
 
-func CreateRawRelayConfirmTx(parm *ty.RelayConfirmTx) ([]byte, error) {
+func createRawRelayConfirmTx(parm *ty.RelayConfirmTx) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
@@ -41,7 +41,7 @@ func CreateRawRelayConfirmTx(parm *ty.RelayConfirmTx) ([]byte, error) {
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "ConfirmTx", parm)
 }
 
-func CreateRawRelayVerifyBTCTx(parm *ty.RelayVerifyCli) ([]byte, error) {
+func createRawRelayVerifyBTCTx(parm *ty.RelayVerifyCli) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
@@ -49,7 +49,7 @@ func CreateRawRelayVerifyBTCTx(parm *ty.RelayVerifyCli) ([]byte, error) {
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "VerifyCli", &v)
 }
 
-func CreateRawRelaySaveBTCHeadTx(parm *ty.BtcHeader) ([]byte, error) {
+func createRawRelaySaveBTCHeadTx(parm *ty.BtcHeader) ([]byte, error) {
 	if parm == nil {
 		return nil, types.ErrInvalidParam
 	}
@@ -66,8 +66,8 @@ func CreateRawRelaySaveBTCHeadTx(parm *ty.BtcHeader) ([]byte, error) {
 	return types.CallCreateTx(types.ExecName(ty.RelayX), "BtcHeaders", v)
 }
 
-func (c *Jrpc) CreateRawRelayOrderTx(in *ty.RelayCreate, result *interface{}) error {
-	reply, err := CreateRawRelayOrderTx(in)
+func (c *jrpc) CreateRawRelayOrderTx(in *ty.RelayCreate, result *interface{}) error {
+	reply, err := createRawRelayOrderTx(in)
 	if err != nil {
 		return err
 	}
@@ -75,8 +75,8 @@ func (c *Jrpc) CreateRawRelayOrderTx(in *ty.RelayCreate, result *interface{}) er
 	return nil
 }
 
-func (c *Jrpc) CreateRawRelayAcceptTx(in *ty.RelayAccept, result *interface{}) error {
-	reply, err := CreateRawRelayAcceptTx(in)
+func (c *jrpc) CreateRawRelayAcceptTx(in *ty.RelayAccept, result *interface{}) error {
+	reply, err := createRawRelayAcceptTx(in)
 	if err != nil {
 		return err
 	}
@@ -85,8 +85,8 @@ func (c *Jrpc) CreateRawRelayAcceptTx(in *ty.RelayAccept, result *interface{}) e
 	return nil
 }
 
-func (c *Jrpc) CreateRawRelayRevokeTx(in *ty.RelayRevoke, result *interface{}) error {
-	reply, err := CreateRawRelayRevokeTx(in)
+func (c *jrpc) CreateRawRelayRevokeTx(in *ty.RelayRevoke, result *interface{}) error {
+	reply, err := createRawRelayRevokeTx(in)
 	if err != nil {
 		return err
 	}
@@ -95,8 +95,8 @@ func (c *Jrpc) CreateRawRelayRevokeTx(in *ty.RelayRevoke, result *interface{}) e
 	return nil
 }
 
-func (c *Jrpc) CreateRawRelayConfirmTx(in *ty.RelayConfirmTx, result *interface{}) error {
-	reply, err := CreateRawRelayConfirmTx(in)
+func (c *jrpc) CreateRawRelayConfirmTx(in *ty.RelayConfirmTx, result *interface{}) error {
+	reply, err := createRawRelayConfirmTx(in)
 	if err != nil {
 		return err
 	}
@@ -105,8 +105,8 @@ func (c *Jrpc) CreateRawRelayConfirmTx(in *ty.RelayConfirmTx, result *interface{
 	return nil
 }
 
-func (c *Jrpc) CreateRawRelayVerifyBTCTx(in *ty.RelayVerifyCli, result *interface{}) error {
-	reply, err := CreateRawRelayVerifyBTCTx(in)
+func (c *jrpc) CreateRawRelayVerifyBTCTx(in *ty.RelayVerifyCli, result *interface{}) error {
+	reply, err := createRawRelayVerifyBTCTx(in)
 	if err != nil {
 		return err
 	}
@@ -114,8 +114,8 @@ func (c *Jrpc) CreateRawRelayVerifyBTCTx(in *ty.RelayVerifyCli, result *interfac
 	return nil
 }
 
-func (c *Jrpc) CreateRawRelaySaveBTCHeadTx(in *ty.BtcHeader, result *interface{}) error {
-	reply, err := CreateRawRelaySaveBTCHeadTx(in)
+func (c *jrpc) CreateRawRelaySaveBTCHeadTx(in *ty.BtcHeader, result *interface{}) error {
+	reply, err := createRawRelaySaveBTCHeadTx(in)
 	if err != nil {
 		return err
 	}

plugin/dapp/relay/rpc/rpc_test.go

@@ -16,6 +16,6 @@ func newTestChannelClient() *channelClient {
 	}
 }
 
-func newTestJrpcClient() *Jrpc {
-	return &Jrpc{cli: newTestChannelClient()}
+func newTestJrpcClient() *jrpc {
+	return &jrpc{cli: newTestChannelClient()}
 }

plugin/dapp/relay/rpc/types.go

@@ -8,11 +8,11 @@ import (
 	"github.com/33cn/chain33/rpc/types"
 )
 
-type Jrpc struct {
+type jrpc struct {
 	cli *channelClient
 }
 
-type Grpc struct {
+type grpc struct {
 	*channelClient
 }
 
@@ -20,8 +20,9 @@ type channelClient struct {
 	types.ChannelClient
 }
 
+// Init relay rpc register
 func Init(name string, s types.RPCServer) {
 	cli := &channelClient{}
-	grpc := &Grpc{channelClient: cli}
-	cli.Init(name, s, &Jrpc{cli: cli}, grpc)
+	grpc := &grpc{channelClient: cli}
+	cli.Init(name, s, &jrpc{cli: cli}, grpc)
 }

plugin/dapp/relay/types/errors.go

@@ -7,23 +7,40 @@ package types
 import "errors"
 
 var (
-	ErrRelayBalanceNotEnough   = errors.New("ErrRelaySellBalanceNotEnough")
+	// ErrRelayOrderNotExist relay order not exist
 	ErrRelayOrderNotExist      = errors.New("ErrRelayOrderNotExist")
+	// ErrRelayOrderOnSell relay order  on sell status
 	ErrRelayOrderOnSell        = errors.New("ErrRelayOrderOnSell")
+	// ErrRelayOrderStatusErr relay order status err
 	ErrRelayOrderStatusErr     = errors.New("ErrRelayOrderStatusErr")
+	// ErrRelayOrderParamErr relay order parameter err
 	ErrRelayOrderParamErr      = errors.New("ErrRelayOrderParamErr")
+	// ErrRelayOrderSoldout order has been sold
 	ErrRelayOrderSoldout       = errors.New("ErrRelayOrderSoldout")
+	// ErrRelayOrderRevoked order revoked
 	ErrRelayOrderRevoked       = errors.New("ErrRelayOrderRevoked")
+	// ErrRelayOrderConfirming order is confirming, not time out
 	ErrRelayOrderConfirming    = errors.New("ErrRelayOrderConfirming")
+	// ErrRelayOrderFinished order has finished
 	ErrRelayOrderFinished      = errors.New("ErrRelayOrderFinished")
+	// ErrRelayReturnAddr relay order return addr error
 	ErrRelayReturnAddr         = errors.New("ErrRelayReturnAddr")
+	// ErrRelayVerify order is verifying
 	ErrRelayVerify             = errors.New("ErrRelayVerify")
+	// ErrRelayVerifyAddrNotFound order verify addr not found
 	ErrRelayVerifyAddrNotFound = errors.New("ErrRelayVerifyAddrNotFound")
+	// ErrRelayWaitBlocksErr order wait block not enough
 	ErrRelayWaitBlocksErr      = errors.New("ErrRelayWaitBlocks")
+	// ErrRelayCoinTxHashUsed order confirm tx has been used
 	ErrRelayCoinTxHashUsed     = errors.New("ErrRelayCoinTxHashUsed")
+	// ErrRelayBtcTxTimeErr btc tx time not reasonable
 	ErrRelayBtcTxTimeErr       = errors.New("ErrRelayBtcTxTimeErr")
+	// ErrRelayBtcHeadSequenceErr btc header sequence not continuous
 	ErrRelayBtcHeadSequenceErr = errors.New("ErrRelayBtcHeadSequenceErr")
+	// ErrRelayBtcHeadHashErr btc header hash not correct
 	ErrRelayBtcHeadHashErr     = errors.New("ErrRelayBtcHeadHashErr")
+	// ErrRelayBtcHeadBitsErr rcv btc header bit not correct
 	ErrRelayBtcHeadBitsErr     = errors.New("ErrRelayBtcHeadBitsErr")
+	// ErrRelayBtcHeadNewBitsErr calc btc header new bits error
 	ErrRelayBtcHeadNewBitsErr  = errors.New("ErrRelayBtcHeadNewBitsErr")
 )

plugin/dapp/relay/types/relay.go

@@ -12,6 +12,7 @@ import (
 	"github.com/33cn/chain33/types"
 )
 
+// RelayX name for executor
 var RelayX = "relay"
 
 //var tlog = log.New("module", name)
@@ -28,22 +29,29 @@ const (
 
 // relay
 const (
+	// RelayRevokeCreate revoke created order
 	RelayRevokeCreate = iota
+	// RelayRevokeAccept revoke accept order
 	RelayRevokeAccept
 )
 
 const (
-	RelayOrderBuy = iota
+	// RelayOrderBuy define relay buy order
+	RelayOrderBuy    = iota
+	// RelayOrderSell define relay sell order
 	RelayOrderSell
 )
 
+// RelayOrderOperation buy or sell operation
 var RelayOrderOperation = map[uint32]string{
 	RelayOrderBuy:  "buy",
 	RelayOrderSell: "sell",
 }
 
 const (
+	// RelayUnlock revoke order
 	RelayUnlock = iota
+	// RelayCancel order owner cancel order
 	RelayCancel
 )
 
@@ -53,25 +61,30 @@ func init() {
 	types.RegisterDappFork(RelayX, "Enable", 570000)
 }
 
+// NewType new relay type
 func NewType() *RelayType {
 	c := &RelayType{}
 	c.SetChild(c)
 	return c
 }
 
-func (at *RelayType) GetPayload() types.Message {
+// GetPayload return relay action msg
+func (r *RelayType) GetPayload() types.Message {
 	return &RelayAction{}
 }
 
+// RelayType relay exec type
 type RelayType struct {
 	types.ExecTypeBase
 }
 
-func (b *RelayType) GetName() string {
+// GetName return relay name
+func (r *RelayType) GetName() string {
 	return RelayX
 }
 
-func (t *RelayType) GetLogMap() map[int64]*types.LogInfo {
+// GetLogMap return receipt log map function
+func (r *RelayType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
 		TyLogRelayCreate:       {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayCreate"},
 		TyLogRelayRevokeCreate: {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayRevokeCreate"},
@@ -84,16 +97,24 @@ func (t *RelayType) GetLogMap() map[int64]*types.LogInfo {
 }
 
 const (
-	RelayActionCreate = iota
+	// RelayActionCreate relay create order action
+	RelayActionCreate                = iota
+	// RelayActionAccept accept order action
 	RelayActionAccept
+	// RelayActionRevoke revoke order action
 	RelayActionRevoke
+	// RelayActionConfirmTx confirm tx action
 	RelayActionConfirmTx
+	// RelayActionVerifyTx relayd send this tx to verify btc tx
 	RelayActionVerifyTx
+	// RelayActionVerifyCmdTx verify tx by cli action
 	RelayActionVerifyCmdTx
+	// RelayActionRcvBTCHeaders relay rcv BTC headers by this
 	RelayActionRcvBTCHeaders
 )
 
-func (t *RelayType) GetTypeMap() map[string]int32 {
+// GetTypeMap get relay action type map
+func (r *RelayType) GetTypeMap() map[string]int32 {
 	return map[string]int32{
 		"Create":     RelayActionCreate,
 		"Accept":     RelayActionAccept,
@@ -105,6 +126,7 @@ func (t *RelayType) GetTypeMap() map[string]int32 {
 	}
 }
 
+// ActionName return action name
 func (r RelayType) ActionName(tx *types.Transaction) string {
 	var relay RelayAction
 	err := types.Decode(tx.Payload, &relay)
@@ -132,6 +154,7 @@ func (r RelayType) ActionName(tx *types.Transaction) string {
 	return "unknown"
 }
 
+// Amount return relay create bty amount
 func (r *RelayType) Amount(tx *types.Transaction) (int64, error) {
 	data, err := r.DecodePayload(tx)
 	if err != nil {
@@ -144,120 +167,9 @@ func (r *RelayType) Amount(tx *types.Transaction) (int64, error) {
 	return 0, nil
 }
 
-// TODO 暂时不修改实现， 先完成结构的重构
+
+// CreateTx relay create tx TODO 暂时不修改实现， 先完成结构的重构
 func (r *RelayType) CreateTx(action string, message json.RawMessage) (*types.Transaction, error) {
 	var tx *types.Transaction
 	return tx, nil
 }
-
-type RelayCreateLog struct {
-}
-
-func (l RelayCreateLog) Name() string {
-	return "LogRelayCreate"
-}
-
-func (l RelayCreateLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayRevokeCreateLog struct {
-}
-
-func (l RelayRevokeCreateLog) Name() string {
-	return "LogRelayRevokeCreate"
-}
-
-func (l RelayRevokeCreateLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayAcceptLog struct {
-}
-
-func (l RelayAcceptLog) Name() string {
-	return "LogRelayAccept"
-}
-
-func (l RelayAcceptLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayRevokeAcceptLog struct {
-}
-
-func (l RelayRevokeAcceptLog) Name() string {
-	return "LogRelayRevokeAccept"
-}
-
-func (l RelayRevokeAcceptLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayConfirmTxLog struct {
-}
-
-func (l RelayConfirmTxLog) Name() string {
-	return "LogRelayConfirmTx"
-}
-
-func (l RelayConfirmTxLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayFinishTxLog struct {
-}
-
-func (l RelayFinishTxLog) Name() string {
-	return "LogRelayFinishTx"
-}
-
-func (l RelayFinishTxLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayLog
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}
-
-type RelayRcvBTCHeadLog struct {
-}
-
-func (l RelayRcvBTCHeadLog) Name() string {
-	return "LogRelayRcvBTCHead"
-}
-
-func (l RelayRcvBTCHeadLog) Decode(msg []byte) (interface{}, error) {
-	var logTmp ReceiptRelayRcvBTCHeaders
-	err := types.Decode(msg, &logTmp)
-	if err != nil {
-		return nil, err
-	}
-	return logTmp, err
-}