fix linter

plugin/dapp/blackwhite/types/const.go

@@ -59,12 +59,12 @@ var (
 		"TimeoutDone": BlackwhiteActionTimeoutDone,
 	}
 	logInfo = map[int64]*types.LogInfo{
-		TyLogBlackwhiteCreate:   {reflect.TypeOf(ReceiptBlackwhite{}), "LogBlackwhiteCreate"},
-		TyLogBlackwhitePlay:     {reflect.TypeOf(ReceiptBlackwhite{}), "LogBlackwhitePlay"},
-		TyLogBlackwhiteShow:     {reflect.TypeOf(ReceiptBlackwhite{}), "LogBlackwhiteShow"},
-		TyLogBlackwhiteTimeout:  {reflect.TypeOf(ReceiptBlackwhite{}), "LogBlackwhiteTimeout"},
-		TyLogBlackwhiteDone:     {reflect.TypeOf(ReceiptBlackwhite{}), "LogBlackwhiteDone"},
-		TyLogBlackwhiteLoopInfo: {reflect.TypeOf(ReplyLoopResults{}), "LogBlackwhiteLoopInfo"},
+		TyLogBlackwhiteCreate:   {Ty: reflect.TypeOf(ReceiptBlackwhite{}), Name: "LogBlackwhiteCreate"},
+		TyLogBlackwhitePlay:     {Ty: reflect.TypeOf(ReceiptBlackwhite{}), Name: "LogBlackwhitePlay"},
+		TyLogBlackwhiteShow:     {Ty: reflect.TypeOf(ReceiptBlackwhite{}), Name: "LogBlackwhiteShow"},
+		TyLogBlackwhiteTimeout:  {Ty: reflect.TypeOf(ReceiptBlackwhite{}), Name: "LogBlackwhiteTimeout"},
+		TyLogBlackwhiteDone:     {Ty: reflect.TypeOf(ReceiptBlackwhite{}), Name: "LogBlackwhiteDone"},
+		TyLogBlackwhiteLoopInfo: {Ty: reflect.TypeOf(ReplyLoopResults{}), Name: "LogBlackwhiteLoopInfo"},
 	}
 )
 

plugin/dapp/game/types/types.go

@@ -45,10 +45,10 @@ type GameType struct {
 // GetLogMap get log
 func (gt *GameType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogCreateGame: {reflect.TypeOf(ReceiptGame{}), "LogCreateGame"},
-		TyLogCancleGame: {reflect.TypeOf(ReceiptGame{}), "LogCancleGame"},
-		TyLogMatchGame:  {reflect.TypeOf(ReceiptGame{}), "LogMatchGame"},
-		TyLogCloseGame:  {reflect.TypeOf(ReceiptGame{}), "LogCloseGame"},
+		TyLogCreateGame: {Ty: reflect.TypeOf(ReceiptGame{}), Name: "LogCreateGame"},
+		TyLogCancleGame: {Ty: reflect.TypeOf(ReceiptGame{}), Name: "LogCancleGame"},
+		TyLogMatchGame:  {Ty: reflect.TypeOf(ReceiptGame{}), Name: "LogMatchGame"},
+		TyLogCloseGame:  {Ty: reflect.TypeOf(ReceiptGame{}), Name: "LogCloseGame"},
 	}
 }
 

plugin/dapp/lottery/types/lottery.go

@@ -38,10 +38,10 @@ func NewType() *LotteryType {
 // GetLogMap method
 func (lottery *LotteryType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogLotteryCreate: {reflect.TypeOf(ReceiptLottery{}), "LogLotteryCreate"},
-		TyLogLotteryBuy:    {reflect.TypeOf(ReceiptLottery{}), "LogLotteryBuy"},
-		TyLogLotteryDraw:   {reflect.TypeOf(ReceiptLottery{}), "LogLotteryDraw"},
-		TyLogLotteryClose:  {reflect.TypeOf(ReceiptLottery{}), "LogLotteryClose"},
+		TyLogLotteryCreate: {Ty: reflect.TypeOf(ReceiptLottery{}), Name: "LogLotteryCreate"},
+		TyLogLotteryBuy:    {Ty: reflect.TypeOf(ReceiptLottery{}), Name: "LogLotteryBuy"},
+		TyLogLotteryDraw:   {Ty: reflect.TypeOf(ReceiptLottery{}), Name: "LogLotteryDraw"},
+		TyLogLotteryClose:  {Ty: reflect.TypeOf(ReceiptLottery{}), Name: "LogLotteryClose"},
 	}
 }
 

plugin/dapp/paracross/types/type.go

@@ -16,25 +16,6 @@ var (
 	// ParaX paracross exec name
 	ParaX = "paracross"
 	glog  = log.New("module", ParaX)
-
-	/*
-		logInfo = map[int64]*types.LogInfo{
-			TyLogParacrossCommit:  {reflect.TypeOf(ReceiptParacrossCommit{}), "LogParacrossCommit"},
-			TyLogParacrossCommitDone:  {reflect.TypeOf(ReceiptParacrossDone{}), "LogParacrossDone"},
-			TyLogParacrossCommitRecord: {reflect.TypeOf(ReceiptParacrossRecord{}), "LogParacrossCommitRecord"},
-			TyLogParaAssetTransfer: {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParacrossAssetTransfer"},
-			TyLogParaAssetWithdraw:   {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParacrossAssetWithdraw"},
-			TyLogParacrossMiner:  {reflect.TypeOf(ReceiptParacrossMiner{}), "LogParacrossMiner"},
-			TyLogParaAssetDeposit: {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParacrossAssetDeposit"},
-		}*/
-
-	// init query rpc
-	/* TODO-TODO
-	types.RegisterRPCQueryHandle("ParacrossGetTitle", &ParacrossGetTitle{})
-	types.RegisterRPCQueryHandle("paracrossListTitles", &paracrossListTitles{})
-	types.RegisterRPCQueryHandle("paracrossGetTitleHeight", &paracrossGetTitleHeight{})
-	types.RegisterRPCQueryHandle("paracrossGetAssetTxResult", &paracrossGetAssetTxResult{})
-	*/
 )
 
 func init() {
@@ -64,13 +45,13 @@ func NewType() *ParacrossType {
 // GetLogMap get receipt log map
 func (p *ParacrossType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogParacrossCommit:       {reflect.TypeOf(ReceiptParacrossCommit{}), "LogParacrossCommit"},
-		TyLogParacrossCommitDone:   {reflect.TypeOf(ReceiptParacrossDone{}), "LogParacrossCommitDone"},
-		TyLogParacrossCommitRecord: {reflect.TypeOf(ReceiptParacrossRecord{}), "LogParacrossCommitRecord"},
-		TyLogParaAssetWithdraw:     {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParaAssetWithdraw"},
-		TyLogParaAssetTransfer:     {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParaAssetTransfer"},
-		TyLogParaAssetDeposit:      {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogParaAssetDeposit"},
-		TyLogParacrossMiner:        {reflect.TypeOf(ReceiptParacrossMiner{}), "LogParacrossMiner"},
+		TyLogParacrossCommit:       {Ty: reflect.TypeOf(ReceiptParacrossCommit{}), Name: "LogParacrossCommit"},
+		TyLogParacrossCommitDone:   {Ty: reflect.TypeOf(ReceiptParacrossDone{}), Name: "LogParacrossCommitDone"},
+		TyLogParacrossCommitRecord: {Ty: reflect.TypeOf(ReceiptParacrossRecord{}), Name: "LogParacrossCommitRecord"},
+		TyLogParaAssetWithdraw:     {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogParaAssetWithdraw"},
+		TyLogParaAssetTransfer:     {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogParaAssetTransfer"},
+		TyLogParaAssetDeposit:      {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogParaAssetDeposit"},
+		TyLogParacrossMiner:        {Ty: reflect.TypeOf(ReceiptParacrossMiner{}), Name: "LogParacrossMiner"},
 	}
 }
 

plugin/dapp/pokerbull/types/types.go

@@ -47,9 +47,9 @@ func (t *PokerBullType) GetTypeMap() map[string]int32 {
 // GetLogMap 获取日志map
 func (t *PokerBullType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogPBGameStart:    {reflect.TypeOf(ReceiptPBGame{}), "TyLogPBGameStart"},
-		TyLogPBGameContinue: {reflect.TypeOf(ReceiptPBGame{}), "TyLogPBGameContinue"},
-		TyLogPBGameQuit:     {reflect.TypeOf(ReceiptPBGame{}), "TyLogPBGameQuit"},
-		TyLogPBGameQuery:    {reflect.TypeOf(ReceiptPBGame{}), "TyLogPBGameQuery"},
+		TyLogPBGameStart:    {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameStart"},
+		TyLogPBGameContinue: {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameContinue"},
+		TyLogPBGameQuit:     {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameQuit"},
+		TyLogPBGameQuery:    {Ty: reflect.TypeOf(ReceiptPBGame{}), Name: "TyLogPBGameQuery"},
 	}
 }

plugin/dapp/privacy/types/privacy.go

@@ -105,9 +105,9 @@ func (t *PrivacyType) GetName() string {
 // GetLogMap get PrivacyType log map
 func (t *PrivacyType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogPrivacyFee:    {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogPrivacyFee"},
-		TyLogPrivacyInput:  {reflect.TypeOf(PrivacyInput{}), "LogPrivacyInput"},
-		TyLogPrivacyOutput: {reflect.TypeOf(PrivacyOutput{}), "LogPrivacyOutput"},
+		TyLogPrivacyFee:    {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogPrivacyFee"},
+		TyLogPrivacyInput:  {Ty: reflect.TypeOf(PrivacyInput{}), Name: "LogPrivacyInput"},
+		TyLogPrivacyOutput: {Ty: reflect.TypeOf(PrivacyOutput{}), Name: "LogPrivacyOutput"},
 	}
 }
 

plugin/dapp/relay/types/relay.go

@@ -86,13 +86,13 @@ func (r *RelayType) GetName() string {
 // 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"},
-		TyLogRelayAccept:       {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayAccept"},
-		TyLogRelayRevokeAccept: {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayRevokeAccept"},
-		TyLogRelayConfirmTx:    {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayConfirmTx"},
-		TyLogRelayFinishTx:     {reflect.TypeOf(ReceiptRelayLog{}), "LogRelayFinishTx"},
-		TyLogRelayRcvBTCHead:   {reflect.TypeOf(ReceiptRelayRcvBTCHeaders{}), "LogRelayRcvBTCHead"},
+		TyLogRelayCreate:       {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayCreate"},
+		TyLogRelayRevokeCreate: {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayRevokeCreate"},
+		TyLogRelayAccept:       {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayAccept"},
+		TyLogRelayRevokeAccept: {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayRevokeAccept"},
+		TyLogRelayConfirmTx:    {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayConfirmTx"},
+		TyLogRelayFinishTx:     {Ty: reflect.TypeOf(ReceiptRelayLog{}), Name: "LogRelayFinishTx"},
+		TyLogRelayRcvBTCHead:   {Ty: reflect.TypeOf(ReceiptRelayRcvBTCHeaders{}), Name: "LogRelayRcvBTCHead"},
 	}
 }
 

plugin/dapp/ticket/types/ticket.go

@@ -82,10 +82,10 @@ func (ticket *TicketType) GetPayload() types.Message {
 // GetLogMap get log map
 func (ticket *TicketType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogNewTicket:   {reflect.TypeOf(ReceiptTicket{}), "LogNewTicket"},
-		TyLogCloseTicket: {reflect.TypeOf(ReceiptTicket{}), "LogCloseTicket"},
-		TyLogMinerTicket: {reflect.TypeOf(ReceiptTicket{}), "LogMinerTicket"},
-		TyLogTicketBind:  {reflect.TypeOf(ReceiptTicketBind{}), "LogTicketBind"},
+		TyLogNewTicket:   {Ty: reflect.TypeOf(ReceiptTicket{}), Name: "LogNewTicket"},
+		TyLogCloseTicket: {Ty: reflect.TypeOf(ReceiptTicket{}), Name: "LogCloseTicket"},
+		TyLogMinerTicket: {Ty: reflect.TypeOf(ReceiptTicket{}), Name: "LogMinerTicket"},
+		TyLogTicketBind:  {Ty: reflect.TypeOf(ReceiptTicketBind{}), Name: "LogTicketBind"},
 	}
 }
 

plugin/dapp/token/cmd/signatory-server/main.go

@@ -73,7 +73,7 @@ func main() {
 		panic(err)
 	}
 
-	approver := signatory.Signatory{cfg.Privkey}
+	approver := signatory.Signatory{Privkey: cfg.Privkey}
 	server := rpc.NewServer()
 	server.Register(&approver)
 

plugin/dapp/token/types/types.go

@@ -52,18 +52,18 @@ func (t *TokenType) GetTypeMap() map[string]int32 {
 // GetLogMap 获取log的映射对应关系
 func (t *TokenType) GetLogMap() map[int64]*types.LogInfo {
 	return map[int64]*types.LogInfo{
-		TyLogTokenTransfer:        {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogTokenTransfer"},
-		TyLogTokenDeposit:         {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogTokenDeposit"},
-		TyLogTokenExecTransfer:    {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenExecTransfer"},
-		TyLogTokenExecWithdraw:    {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenExecWithdraw"},
-		TyLogTokenExecDeposit:     {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenExecDeposit"},
-		TyLogTokenExecFrozen:      {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenExecFrozen"},
-		TyLogTokenExecActive:      {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenExecActive"},
-		TyLogTokenGenesisTransfer: {reflect.TypeOf(types.ReceiptAccountTransfer{}), "LogTokenGenesisTransfer"},
-		TyLogTokenGenesisDeposit:  {reflect.TypeOf(types.ReceiptExecAccountTransfer{}), "LogTokenGenesisDeposit"},
-		TyLogPreCreateToken:       {reflect.TypeOf(ReceiptToken{}), "LogPreCreateToken"},
-		TyLogFinishCreateToken:    {reflect.TypeOf(ReceiptToken{}), "LogFinishCreateToken"},
-		TyLogRevokeCreateToken:    {reflect.TypeOf(ReceiptToken{}), "LogRevokeCreateToken"},
+		TyLogTokenTransfer:        {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogTokenTransfer"},
+		TyLogTokenDeposit:         {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogTokenDeposit"},
+		TyLogTokenExecTransfer:    {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenExecTransfer"},
+		TyLogTokenExecWithdraw:    {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenExecWithdraw"},
+		TyLogTokenExecDeposit:     {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenExecDeposit"},
+		TyLogTokenExecFrozen:      {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenExecFrozen"},
+		TyLogTokenExecActive:      {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenExecActive"},
+		TyLogTokenGenesisTransfer: {Ty: reflect.TypeOf(types.ReceiptAccountTransfer{}), Name: "LogTokenGenesisTransfer"},
+		TyLogTokenGenesisDeposit:  {Ty: reflect.TypeOf(types.ReceiptExecAccountTransfer{}), Name: "LogTokenGenesisDeposit"},
+		TyLogPreCreateToken:       {Ty: reflect.TypeOf(ReceiptToken{}), Name: "LogPreCreateToken"},
+		TyLogFinishCreateToken:    {Ty: reflect.TypeOf(ReceiptToken{}), Name: "LogFinishCreateToken"},
+		TyLogRevokeCreateToken:    {Ty: reflect.TypeOf(ReceiptToken{}), Name: "LogRevokeCreateToken"},
 	}
 }