add by hyb for issues334 gosec

plugin/dapp/multisig/autotest/transferIn.go

@@ -66,8 +66,11 @@ func (pack *transferInPack) checkBalance(txInfo types.CheckHandlerParamType) boo
 	}
 
 	interCase := pack.TCase.(*transferInCase)
-	amount, _ := strconv.ParseFloat(interCase.Amount, 64)
-
+	amount, err := strconv.ParseFloat(interCase.Amount, 64)
+	if err != nil {
+		pack.FLog.Error("checkMultiSignTransferIn", "id", pack.PackID, "ParseFloat", err)
+		return false
+	}
 	return types.CheckBalanceDeltaWithAddr(fromLog, interCase.From, -amount) &&
 		types.CheckBalanceDeltaWithAddr(toLog, interCase.info.account, amount) &&
 		types.CheckFrozenDeltaWithAddr(frozenLog, interCase.info.account, amount) &&

plugin/dapp/multisig/autotest/transferOut.go

@@ -61,7 +61,11 @@ func (pack *transferOutPack) checkBalance(txInfo types.CheckHandlerParamType) bo
 
 	logLen := len(txInfo.Receipt.Logs)
 	var txLog map[string]interface{}
-	_ = json.Unmarshal(txInfo.Receipt.Logs[logLen-1].Log, &txLog)
+	err := json.Unmarshal(txInfo.Receipt.Logs[logLen-1].Log, &txLog)
+	if err != nil {
+		pack.FLog.Error("checkMultiSignTransferOut", "id", pack.PackID, "Unmarshal", err)
+		return false
+	}
 	pack.txID = txLog["multiSigTxOwner"].(map[string]interface{})["txid"].(string)
 	if logLen < 6 {
 		//need confirm
@@ -75,13 +79,16 @@ func (pack *transferOutPack) checkBalance(txInfo types.CheckHandlerParamType) bo
 	err2 := json.Unmarshal(txInfo.Receipt.Logs[2].Log, &toLog)
 
 	if err1 != nil || err2 != nil {
-		pack.FLog.Error("checkMultiSignTransferOut", "id", pack.PackID, "unmarshalErr1", err1, "unmarshalErr2")
+		pack.FLog.Error("checkMultiSignTransferOut", "id", pack.PackID, "unmarshalErr1", err1, "unmarshalErr2", err2)
 		return false
 	}
 
 	interCase := pack.TCase.(*transferOutCase)
-	amount, _ := strconv.ParseFloat(interCase.Amount, 64)
-
+	amount, err3 := strconv.ParseFloat(interCase.Amount, 64)
+	if err3 != nil {
+		pack.FLog.Error("checkMultiSignTransferOut", "id", pack.PackID, "ParseFloat", err3)
+		return false
+	}
 	return types.CheckFrozenDeltaWithAddr(fromLog, interCase.info.account, -amount) &&
 		types.CheckBalanceDeltaWithAddr(toLog, interCase.To, amount)
 }

plugin/dapp/multisig/commands/multisig.go

@@ -105,31 +105,35 @@ func CreateMultiSigAccCreateCmd() *cobra.Command {
 func createMultiSigAccTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("owners_addr", "a", "", "address of owners,separated by '-', addr0-addr1-addr2...")
-	cmd.MarkFlagRequired("owners_addr")
+	err := cmd.MarkFlagRequired("owners_addr")
 
 	cmd.Flags().StringP("owners_weight", "w", "", "weight of owners,separated by '-', w0-w1-w2..., uint64 type")
-	cmd.MarkFlagRequired("owners_weight")
+	err = cmd.MarkFlagRequired("owners_weight")
 
 	cmd.Flags().Uint64P("required_weight", "r", 0, "required weight of account execute tx")
-	cmd.MarkFlagRequired("required_weight")
+	err = cmd.MarkFlagRequired("required_weight")
 
 	cmd.Flags().StringP("execer", "e", "", "assets execer name")
-	cmd.MarkFlagRequired("execer")
+	err = cmd.MarkFlagRequired("execer")
 
 	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
-	cmd.MarkFlagRequired("symbol")
+	err = cmd.MarkFlagRequired("symbol")
 
 	cmd.Flags().Float64P("daily_limit", "d", 0, "daily_limit of assets ")
-	cmd.MarkFlagRequired("daily_limit")
+	err = cmd.MarkFlagRequired("daily_limit")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigAccTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
 
-	address, _ := cmd.Flags().GetString("owners_addr")
+	address, err := cmd.Flags().GetString("owners_addr")
 	addressArr := strings.Split(address, "-")
 
-	weightstr, _ := cmd.Flags().GetString("owners_weight")
+	weightstr, err := cmd.Flags().GetString("owners_weight")
 	weightsArr := strings.Split(weightstr, "-")
 
 	//校验owner和权重数量要一致
@@ -170,10 +174,10 @@ func createMultiSigAccTransfer(cmd *cobra.Command, args []string) {
 		return
 	}
 
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
 
-	dailylimit, _ := cmd.Flags().GetFloat64("daily_limit")
+	dailylimit, err := cmd.Flags().GetFloat64("daily_limit")
 	err = isValidDailylimit(dailylimit)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
@@ -209,22 +213,28 @@ func CreateMultiSigAccOwnerAddCmd() *cobra.Command {
 func createOwnerAddTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 
 	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
-	cmd.MarkFlagRequired("owner_addr")
+	err = cmd.MarkFlagRequired("owner_addr")
 
 	cmd.Flags().Uint64P("owner_weight", "w", 0, "weight of owner")
-	cmd.MarkFlagRequired("owner_weight")
-
+	err = cmd.MarkFlagRequired("owner_weight")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createOwnerAddTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
-	ownerWeight, _ := cmd.Flags().GetUint64("owner_weight")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, err := cmd.Flags().GetString("owner_addr")
+	ownerWeight, err := cmd.Flags().GetUint64("owner_weight")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &mty.MultiSigOwnerOperate{
 		MultiSigAccAddr: multiSigAddr,
 		NewOwner:        ownerAddr,
@@ -250,17 +260,24 @@ func CreateMultiSigAccOwnerDelCmd() *cobra.Command {
 func createOwnerDelTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 
 	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
-	cmd.MarkFlagRequired("owner_addr")
+	err = cmd.MarkFlagRequired("owner_addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createOwnerDelTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, err := cmd.Flags().GetString("owner_addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &mty.MultiSigOwnerOperate{
 		MultiSigAccAddr: multiSigAddr,
 		OldOwner:        ownerAddr,
@@ -285,19 +302,26 @@ func CreateMultiSigAccOwnerModifyCmd() *cobra.Command {
 func createOwnerModifyTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
-	cmd.MarkFlagRequired("owner_addr")
+	err = cmd.MarkFlagRequired("owner_addr")
 	cmd.Flags().Uint64P("owner_weight", "w", 0, "new weight of owner")
-	cmd.MarkFlagRequired("owner_weight")
+	err = cmd.MarkFlagRequired("owner_weight")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createOwnerModifyTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
-	ownerWeight, _ := cmd.Flags().GetUint64("owner_weight")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, err := cmd.Flags().GetString("owner_addr")
+	ownerWeight, err := cmd.Flags().GetUint64("owner_weight")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &mty.MultiSigOwnerOperate{
 		MultiSigAccAddr: multiSigAddr,
 		OldOwner:        ownerAddr,
@@ -323,19 +347,26 @@ func CreateMultiSigAccOwnerReplaceCmd() *cobra.Command {
 func createOwnerReplaceTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 	cmd.Flags().StringP("owner_addr", "o", "", "address of old owner")
-	cmd.MarkFlagRequired("owner_addr")
+	err = cmd.MarkFlagRequired("owner_addr")
 	cmd.Flags().StringP("new_owner", "n", "", "address of new owner")
-	cmd.MarkFlagRequired("new_owner")
+	err = cmd.MarkFlagRequired("new_owner")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createOwnerReplaceTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
-	newOwner, _ := cmd.Flags().GetString("new_owner")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, err := cmd.Flags().GetString("owner_addr")
+	newOwner, err := cmd.Flags().GetString("new_owner")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &mty.MultiSigOwnerOperate{
 		MultiSigAccAddr: multiSigAddr,
 		OldOwner:        ownerAddr,
@@ -361,15 +392,22 @@ func CreateMultiSigAccWeightModifyCmd() *cobra.Command {
 func createMultiSigAccWeightModifyTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 	cmd.Flags().Uint64P("weight", "w", 0, "new required weight of multisig account ")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigAccWeightModifyTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	weight, _ := cmd.Flags().GetUint64("weight")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	weight, err := cmd.Flags().GetUint64("weight")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &mty.MultiSigAccOperate{
 		MultiSigAccAddr:   multiSigAddr,
 		NewRequiredWeight: weight,
@@ -394,26 +432,33 @@ func CreateMultiSigAccDailyLimitModifyCmd() *cobra.Command {
 func createMultiSigAccDailyLimitModifyTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 
 	cmd.Flags().StringP("execer", "e", "", "assets execer name")
-	cmd.MarkFlagRequired("execer")
+	err = cmd.MarkFlagRequired("execer")
 
 	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
-	cmd.MarkFlagRequired("symbol")
+	err = cmd.MarkFlagRequired("symbol")
 
 	cmd.Flags().Float64P("daily_limit", "d", 0, "daily_limit of assets ")
-	cmd.MarkFlagRequired("daily_limit")
+	err = cmd.MarkFlagRequired("daily_limit")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigAccDailyLimitModifyTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
-	dailylimit, _ := cmd.Flags().GetFloat64("daily_limit")
-
-	err := isValidDailylimit(dailylimit)
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
+	dailylimit, err := cmd.Flags().GetFloat64("daily_limit")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+	err = isValidDailylimit(dailylimit)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
@@ -447,21 +492,24 @@ func CreateMultiSigConfirmTxCmd() *cobra.Command {
 func createMultiSigConfirmTransferFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("multisig_addr")
+	err := cmd.MarkFlagRequired("multisig_addr")
 
 	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
-	cmd.MarkFlagRequired("txid")
+	err = cmd.MarkFlagRequired("txid")
 
 	cmd.Flags().StringP("confirm_or_revoke", "c", "t", "whether confirm or revoke tx (0/f/false for No; 1/t/true for Yes)")
-
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigConfirmTransfer(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
-	txid, _ := cmd.Flags().GetUint64("txid")
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, err := cmd.Flags().GetString("multisig_addr")
+	txid, err := cmd.Flags().GetUint64("txid")
 
-	confirmOrRevoke, _ := cmd.Flags().GetString("confirm_or_revoke")
+	confirmOrRevoke, err := cmd.Flags().GetString("confirm_or_revoke")
 	confirmOrRevokeBool, err := strconv.ParseBool(confirmOrRevoke)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
@@ -491,28 +539,35 @@ func CreateMultiSigAccTransferInCmd() *cobra.Command {
 
 func createMultiSigAccTransferInFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("to", "t", "", "address of multisig account")
-	cmd.MarkFlagRequired("to")
+	err := cmd.MarkFlagRequired("to")
 
 	cmd.Flags().StringP("execer", "e", "", "assets  execer")
-	cmd.MarkFlagRequired("execer")
+	err = cmd.MarkFlagRequired("execer")
 
 	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
-	cmd.MarkFlagRequired("symbol")
+	err = cmd.MarkFlagRequired("symbol")
 
 	cmd.Flags().StringP("note", "n", "", "transaction note info")
 
 	cmd.Flags().Float64P("amount", "a", 0, "transaction amount")
-	cmd.MarkFlagRequired("amount")
+	err = cmd.MarkFlagRequired("amount")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigAccTransferIn(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	to, _ := cmd.Flags().GetString("to")
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
-	note, _ := cmd.Flags().GetString("note")
-	amount, _ := cmd.Flags().GetFloat64("amount")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	to, err := cmd.Flags().GetString("to")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
+	note, err := cmd.Flags().GetString("note")
+	amount, err := cmd.Flags().GetFloat64("amount")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	if float64(types.MaxCoin/types.Coin) < amount {
 		fmt.Fprintln(os.Stderr, types.ErrAmount)
 		return
@@ -543,32 +598,39 @@ func CreateMultiSigAccTransferOutCmd() *cobra.Command {
 func createMultiSigAccTransferOutFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringP("from", "f", "", "address of multisig account")
-	cmd.MarkFlagRequired("from")
+	err := cmd.MarkFlagRequired("from")
 
 	cmd.Flags().StringP("to", "t", "", "address of account")
-	cmd.MarkFlagRequired("to")
+	err = cmd.MarkFlagRequired("to")
 
 	cmd.Flags().StringP("execer", "e", "", "assets execer")
-	cmd.MarkFlagRequired("execer")
+	err = cmd.MarkFlagRequired("execer")
 
 	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
-	cmd.MarkFlagRequired("symbol")
+	err = cmd.MarkFlagRequired("symbol")
 
 	cmd.Flags().StringP("note", "n", "", "transaction note info")
 
 	cmd.Flags().Float64P("amount", "a", 0, "transaction amount")
-	cmd.MarkFlagRequired("amount")
+	err = cmd.MarkFlagRequired("amount")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func createMultiSigAccTransferOut(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	from, _ := cmd.Flags().GetString("from")
-	to, _ := cmd.Flags().GetString("to")
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
-	note, _ := cmd.Flags().GetString("note")
-	amount, _ := cmd.Flags().GetFloat64("amount")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	from, err := cmd.Flags().GetString("from")
+	to, err := cmd.Flags().GetString("to")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
+	note, err := cmd.Flags().GetString("note")
+	amount, err := cmd.Flags().GetFloat64("amount")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	if float64(types.MaxCoin/types.Coin) < amount {
 		fmt.Fprintln(os.Stderr, types.ErrAmount)
 		return
@@ -597,8 +659,11 @@ func GetMultiSigAccCountCmd() *cobra.Command {
 }
 
 func getMultiSigAccCount(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	var params rpctypes.Query4Jrpc
 
 	var rep interface{}
@@ -625,18 +690,25 @@ func GetMultiSigAccountsCmd() *cobra.Command {
 func addgetMultiSigAccountsFlags(cmd *cobra.Command) {
 
 	cmd.Flags().Int64P("start", "s", 0, "account start index")
-	cmd.MarkFlagRequired("start")
+	err := cmd.MarkFlagRequired("start")
 
 	cmd.Flags().Int64P("end", "e", 0, "account end index")
-	cmd.MarkFlagRequired("end")
+	err = cmd.MarkFlagRequired("end")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccounts(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-
-	start, _ := cmd.Flags().GetInt64("start")
-	end, _ := cmd.Flags().GetInt64("end")
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
 
+	start, err := cmd.Flags().GetInt64("start")
+	end, err := cmd.Flags().GetInt64("end")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	if start > end || start < 0 {
 		fmt.Fprintln(os.Stderr, "input parameter invalid!")
 		return
@@ -670,13 +742,20 @@ func GetMultiSigAccountInfoCmd() *cobra.Command {
 
 func getMultiSigAccountInfoFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccountInfo(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	req := mty.ReqMultiSigAccInfo{
 		MultiSigAccAddr: addr,
 	}
@@ -736,13 +815,20 @@ func GetMultiSigAccTxCountCmd() *cobra.Command {
 
 func getMultiSigAccTxCountFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccTxCount(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	req := mty.ReqMultiSigAccInfo{
 		MultiSigAccAddr: addr,
 	}
@@ -771,39 +857,45 @@ func GetMultiSigTxidsCmd() *cobra.Command {
 
 func getMultiSigTxidsCmdFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
 
 	cmd.Flags().Uint64P("start", "s", 0, "tx start index")
-	cmd.MarkFlagRequired("start")
+	err = cmd.MarkFlagRequired("start")
 
 	cmd.Flags().Uint64P("end", "e", 0, "tx end index")
-	cmd.MarkFlagRequired("end")
+	err = cmd.MarkFlagRequired("end")
 
 	cmd.Flags().StringP("pending", "p", "t", "whether pending tx (0/f/false for No; 1/t/true for Yes)")
-
 	cmd.Flags().StringP("executed", "x", "t", "whether executed tx (0/f/false for No; 1/t/true for Yes)")
-
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigTxids(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
 
-	start, _ := cmd.Flags().GetUint64("start")
-	end, _ := cmd.Flags().GetUint64("end")
+	start, err := cmd.Flags().GetUint64("start")
+	end, err := cmd.Flags().GetUint64("end")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	if start > end || start < 0 {
 		fmt.Fprintln(os.Stderr, "input parameter invalid!")
 		return
 	}
 
-	pending, _ := cmd.Flags().GetString("pending")
+	pending, err := cmd.Flags().GetString("pending")
 	pendingBool, err := strconv.ParseBool(pending)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
 
-	executed, _ := cmd.Flags().GetString("executed")
+	executed, err := cmd.Flags().GetString("executed")
 	executedBool, err := strconv.ParseBool(executed)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
@@ -842,17 +934,24 @@ func GetMultiSigTxInfoCmd() *cobra.Command {
 
 func getMultiSigTxInfoFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
 
 	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
-	cmd.MarkFlagRequired("txid")
+	err = cmd.MarkFlagRequired("txid")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigTxInfo(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-	txid, _ := cmd.Flags().GetUint64("txid")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	txid, err := cmd.Flags().GetUint64("txid")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	req := mty.ReqMultiSigTxInfo{
 		MultiSigAddr: addr,
 		TxId:         txid,
@@ -882,17 +981,24 @@ func GetMultiSigTxConfirmedWeightCmd() *cobra.Command {
 
 func getMultiSigTxConfirmedWeightFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
 
 	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
-	cmd.MarkFlagRequired("txid")
+	err = cmd.MarkFlagRequired("txid")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getGetMultiSigTxConfirmedWeight(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-	txid, _ := cmd.Flags().GetUint64("txid")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	txid, err := cmd.Flags().GetUint64("txid")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	req := mty.ReqMultiSigTxInfo{
 		MultiSigAddr: addr,
 		TxId:         txid,
@@ -922,18 +1028,25 @@ func GetMultiSigAccUnSpentTodayCmd() *cobra.Command {
 
 func getMultiSigAccUnSpentTodayFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
 
 	cmd.Flags().StringP("execer", "e", "", "assets execer name")
 	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccUnSpentToday(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	isallBool := true
 	assets := &mty.Assets{}
 	//获取指定资产信息时，execer和symbol不能为空
@@ -995,18 +1108,25 @@ func GetMultiSigAccAssetsCmd() *cobra.Command {
 
 func getMultiSigAccAssetsFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
 
 	cmd.Flags().StringP("execer", "e", "coins", "assets execer name ")
 	cmd.Flags().StringP("symbol", "s", "BTY", "assets symbol")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccAssets(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	addr, _ := cmd.Flags().GetString("addr")
-	execer, _ := cmd.Flags().GetString("execer")
-	symbol, _ := cmd.Flags().GetString("symbol")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	addr, err := cmd.Flags().GetString("addr")
+	execer, err := cmd.Flags().GetString("execer")
+	symbol, err := cmd.Flags().GetString("symbol")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	isallBool := true
 	assets := &mty.Assets{}
 	//获取指定资产信息时，execer和symbol不能为空
@@ -1075,13 +1195,20 @@ func GetMultiSigAccAllAddressCmd() *cobra.Command {
 
 func getMultiSigAccAllAddressFlags(cmd *cobra.Command) {
 	cmd.Flags().StringP("addr", "a", "", "address of created multisig account")
-	cmd.MarkFlagRequired("addr")
+	err := cmd.MarkFlagRequired("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 }
 
 func getMultiSigAccAllAddress(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	createAddr, _ := cmd.Flags().GetString("addr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	createAddr, err := cmd.Flags().GetString("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	var params rpctypes.Query4Jrpc
 	var rep interface{}
 	req := mty.ReqMultiSigAccInfo{
@@ -1118,9 +1245,12 @@ func getMultiSigAccByOwnerFlags(cmd *cobra.Command) {
 }
 
 func getMultiSigAccByOwner(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	ownerAddr, _ := cmd.Flags().GetString("addr")
-
+	rpcLaddr, err := cmd.Flags().GetString("rpc_laddr")
+	ownerAddr, err := cmd.Flags().GetString("addr")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
 	params := &types.ReqString{
 		Data: ownerAddr,
 	}

plugin/dapp/multisig/executor/action.go

@@ -212,8 +212,8 @@ func (a *action) MultiSigExecTransferFrom(multiSigAccTransfer *mty.MultiSigExecT
 	}
 
 	// to 地址必须不是多重签名账户地址
-	multiSigAccTo, _ := getMultiSigAccFromDb(a.db, multiSigAccTransfer.To)
-	if multiSigAccTo != nil {
+	multiSigAccTo, err := getMultiSigAccFromDb(a.db, multiSigAccTransfer.To)
+	if multiSigAccTo != nil && err == nil {
 		multisiglog.Error("MultiSigExecTransferFrom", "multiSigAccTo", multiSigAccTo, "ToAddr", multiSigAccTransfer.To)
 		return nil, mty.ErrAddrNotSupport
 	}
@@ -250,19 +250,19 @@ func (a *action) MultiSigExecTransferFrom(multiSigAccTransfer *mty.MultiSigExecT
 func (a *action) MultiSigExecTransferTo(execTransfer *mty.MultiSigExecTransferTo) (*types.Receipt, error) {
 
 	//from地址校验必须不是多重签名账户地址
-	multiSigAccFrom, _ := getMultiSigAccFromDb(a.db, a.fromaddr)
-	if multiSigAccFrom != nil {
+	multiSigAccFrom, err := getMultiSigAccFromDb(a.db, a.fromaddr)
+	if multiSigAccFrom != nil && err == nil {
 		multisiglog.Error("MultiSigExecTransferTo", "multiSigAccFrom", multiSigAccFrom, "From", a.fromaddr)
 		return nil, mty.ErrAddrNotSupport
 	}
 	// to 地址必须是多重签名账户地址
-	multiSigAccTo, _ := getMultiSigAccFromDb(a.db, execTransfer.To)
-	if multiSigAccTo == nil {
+	multiSigAccTo, err := getMultiSigAccFromDb(a.db, execTransfer.To)
+	if multiSigAccTo == nil || err != nil {
 		multisiglog.Error("MultiSigExecTransferTo", "ToAddr", execTransfer.To)
 		return nil, mty.ErrAddrNotSupport
 	}
 	//assete资产合法性校验
-	err := mty.IsAssetsInvalid(execTransfer.Execname, execTransfer.Symbol)
+	err = mty.IsAssetsInvalid(execTransfer.Execname, execTransfer.Symbol)
 	if err != nil {
 		return nil, err
 	}

plugin/dapp/multisig/executor/multisigdb.go

@@ -39,10 +39,10 @@ func setMultiSigAccToDb(db dbm.KV, multiSigAcc *mty.MultiSig) ([]byte, []byte) {
 	value := types.Encode(multiSigAcc)
 
 	//即时保存到db中，方便同一个区块的下一个交易使用
-	db.Set(key, value)
-	//test
-	multisiglog.Info("setMultiSigAccToDb", "multiSigAcc", multiSigAcc)
-
+	err := db.Set(key, value)
+	if err != nil {
+		multisiglog.Error("setMultiSigAccToDb", "multiSigAcc", multiSigAcc, "err", err)
+	}
 	return key, value
 }
 
@@ -71,10 +71,10 @@ func getMultiSigAccTxFromDb(db dbm.KV, multiSigAddr string, txid uint64) (*mty.M
 func setMultiSigAccTxToDb(db dbm.KV, multiSigTx *mty.MultiSigTx) ([]byte, []byte) {
 	key := calcMultiSigAccTxKey(multiSigTx.MultiSigAddr, multiSigTx.Txid)
 	value := types.Encode(multiSigTx)
-	db.Set(key, value)
-
-	//test
-	multisiglog.Info("setMultiSigAccTxToDb", "multiSigTx", multiSigTx)
+	err := db.Set(key, value)
+	if err != nil {
+		multisiglog.Error("setMultiSigAccTxToDb", "multiSigTx", multiSigTx, "err", err)
+	}
 	return key, value
 }
 
@@ -127,7 +127,10 @@ func updateMultiSigAccCount(cachedb dbm.KVDB, isadd bool) (*types.KeyValue, erro
 		}
 		count--
 	}
-	setMultiSigAccCount(cachedb, count)
+	err = setMultiSigAccCount(cachedb, count)
+	if err != nil {
+		multisiglog.Error("updateMultiSigAccCount:setMultiSigAccCount ", "count", count, "err", err)
+	}
 	//keyvalue
 	return getMultiSigAccCountKV(count), nil
 }
@@ -188,12 +191,18 @@ func updateMultiSigAccList(db dbm.KVDB, addr string, index int64, isadd bool) (*
 	}
 
 	if isadd { //新增
-		db.Set(calcMultiSigAllAcc(index), []byte(addr))
+		err = db.Set(calcMultiSigAllAcc(index), []byte(addr))
+		if err != nil {
+			multisiglog.Error("UpdateMultiSigAccList add", "addr", addr, "index", index, "err", err)
+		}
 		kv := &types.KeyValue{Key: calcMultiSigAllAcc(index), Value: []byte(addr)}
 		return kv, nil
 	}
 	// 删除
-	db.Set(calcMultiSigAllAcc(index), nil)
+	err = db.Set(calcMultiSigAllAcc(index), nil)
+	if err != nil {
+		multisiglog.Error("UpdateMultiSigAccList del", "addr", addr, "index", index, "err", err)
+	}
 	kv := &types.KeyValue{Key: calcMultiSigAllAcc(index), Value: nil}
 	return kv, nil
 }
@@ -263,7 +272,10 @@ func updateAddrReciver(cachedb dbm.KVDB, addr, execname, symbol string, amount i
 	} else {
 		recv -= amount
 	}
-	setAddrReciver(cachedb, addr, execname, symbol, recv)
+	err = setAddrReciver(cachedb, addr, execname, symbol, recv)
+	if err != nil {
+		multisiglog.Error("updateAddrReciver setAddrReciver", "addr", addr, "execname", execname, "symbol", symbol, "err", err)
+	}
 	//keyvalue
 	return getAddrReciverKV(addr, execname, symbol, recv), nil
 }
@@ -350,7 +362,10 @@ func setMultiSigAddress(db dbm.KVDB, createAddr, multiSigAddr string, isadd bool
 	key := calcMultiSigAccCreateAddr(createAddr)
 	value := types.Encode(accAddress)
 
-	db.Set(key, value)
+	err = db.Set(key, value)
+	if err != nil {
+		multisiglog.Error("setMultiSigAddress", "key", string(key), "err", err)
+	}
 	return &types.KeyValue{Key: key, Value: value}
 }
 

plugin/dapp/multisig/executor/query.go

@@ -340,7 +340,10 @@ func (m *MultiSig) Query_MultiSigAccAssets(in *mty.ReqAccAssets) (types.Message,
 					continue
 				}
 				accAssets := &mty.AccAssets{}
-				account, _ := m.getMultiSigAccAssets(reciver.MultiSigAddr, reciver.Assets)
+				account, err := m.getMultiSigAccAssets(reciver.MultiSigAddr, reciver.Assets)
+				if err != nil {
+					multisiglog.Error("Query_MultiSigAccAssets:getMultiSigAccAssets", "MultiSigAddr", reciver.MultiSigAddr, "err", err)
+				}
 				accAssets.Account = account
 				accAssets.Assets = reciver.Assets
 				accAssets.RecvAmount = reciver.Amount
@@ -355,11 +358,17 @@ func (m *MultiSig) Query_MultiSigAccAssets(in *mty.ReqAccAssets) (types.Message,
 		if err != nil {
 			return nil, err
 		}
-		account, _ := m.getMultiSigAccAssets(in.MultiSigAddr, in.Assets)
+		account, err := m.getMultiSigAccAssets(in.MultiSigAddr, in.Assets)
+		if err != nil {
+			multisiglog.Error("Query_MultiSigAccAssets:getMultiSigAccAssets", "MultiSigAddr", in.MultiSigAddr, "err", err)
+		}
 		accAssets.Account = account
 		accAssets.Assets = in.Assets
 
-		amount, _ := getAddrReciver(m.GetLocalDB(), in.MultiSigAddr, in.Assets.Execer, in.Assets.Symbol)
+		amount, err := getAddrReciver(m.GetLocalDB(), in.MultiSigAddr, in.Assets.Execer, in.Assets.Symbol)
+		if err != nil {
+			multisiglog.Error("Query_MultiSigAccAssets:getAddrReciver", "MultiSigAddr", in.MultiSigAddr, "err", err)
+		}
 		accAssets.RecvAmount = amount
 
 		replyAccAssets.AccAssets = append(replyAccAssets.AccAssets, accAssets)

plugin/dapp/multisig/wallet/multisig.go

@@ -492,7 +492,10 @@ func (policy *multisigPolicy) proceMultiSigAcc(multiSigAccs *mtypes.ReplyMultiSi
 				} else if ownerAttrs != nil {
 					AddOwnerAttr(false, ownerAttrs, ownerAttr, newbatch)
 				}
-				newbatch.Write()
+				err = newbatch.Write()
+				if err != nil {
+					bizlog.Error("ProceMultiSigAcc Write", "owneraddr", owneraddr, "err", err)
+				}
 				break
 			}
 		}
@@ -501,7 +504,10 @@ func (policy *multisigPolicy) proceMultiSigAcc(multiSigAccs *mtypes.ReplyMultiSi
 
 func (policy *multisigPolicy) proceWalletTxDetail(block *types.BlockDetail, tx *types.Transaction, index int32) *types.WalletTxDetail {
 	receipt := block.Receipts[index]
-	amount, _ := tx.Amount()
+	amount, err := tx.Amount()
+	if err != nil {
+		bizlog.Error("proceWalletTxDetail:tx.Amount()", "err", err)
+	}
 	wtxdetail := &types.WalletTxDetail{
 		Tx:         tx,
 		Height:     block.Block.Height,