cli: use fmt.Append* where possibble

Close #2629.

Signed-off-by: Anna Shaleva <shaleva.ann@nspcc.ru>

cli/query/query.go

@@ -111,7 +111,10 @@ func queryTx(ctx *cli.Context) error {
 		}
 	}
 
-	DumpApplicationLog(ctx, res, &txOut.Transaction, &txOut.TransactionMetadata, ctx.Bool("verbose"))
+	err = DumpApplicationLog(ctx, res, &txOut.Transaction, &txOut.TransactionMetadata, ctx.Bool("verbose"))
+	if err != nil {
+		return cli.NewExitError(err, 1)
+	}
 	return nil
 }
 
@@ -120,47 +123,49 @@ func DumpApplicationLog(
 	res *result.ApplicationLog,
 	tx *transaction.Transaction,
 	txMeta *result.TransactionMetadata,
-	verbose bool) {
+	verbose bool) error {
-	buf := bytes.NewBuffer(nil)
+	var buf []byte
 
-	// Ignore the errors below because `Write` to buffer doesn't return error.
+	buf = fmt.Appendf(buf, "Hash:\t%s\n", tx.Hash().StringLE())
-	tw := tabwriter.NewWriter(buf, 0, 4, 4, '\t', 0)
+	buf = fmt.Appendf(buf, "OnChain:\t%t\n", res != nil)
-	_, _ = tw.Write([]byte("Hash:\t" + tx.Hash().StringLE() + "\n"))
-	_, _ = tw.Write([]byte(fmt.Sprintf("OnChain:\t%t\n", res != nil)))
 	if res == nil {
-		_, _ = tw.Write([]byte("ValidUntil:\t" + strconv.FormatUint(uint64(tx.ValidUntilBlock), 10) + "\n"))
+		buf = fmt.Appendf(buf, "ValidUntil:\t%s\n", strconv.FormatUint(uint64(tx.ValidUntilBlock), 10))
 	} else {
 		if txMeta != nil {
-			_, _ = tw.Write([]byte("BlockHash:\t" + txMeta.Blockhash.StringLE() + "\n"))
+			buf = fmt.Appendf(buf, "BlockHash:\t%s\n", txMeta.Blockhash.StringLE())
 		}
 		if len(res.Executions) != 1 {
-			_, _ = tw.Write([]byte("Success:\tunknown (no execution data)\n"))
+			buf = fmt.Appendf(buf, "Success:\tunknown (no execution data)\n")
 		} else {
-			_, _ = tw.Write([]byte(fmt.Sprintf("Success:\t%t\n", res.Executions[0].VMState == vmstate.Halt)))
+			buf = fmt.Appendf(buf, "Success:\t%t\n", res.Executions[0].VMState == vmstate.Halt)
 		}
 	}
 	if verbose {
 		for _, sig := range tx.Signers {
-			_, _ = tw.Write([]byte(fmt.Sprintf("Signer:\t%s (%s)",
+			buf = fmt.Appendf(buf, "Signer:\t%s (%s)\n", address.Uint160ToString(sig.Account), sig.Scopes)
-				address.Uint160ToString(sig.Account),
-				sig.Scopes) + "\n"))
 		}
-		_, _ = tw.Write([]byte("SystemFee:\t" + fixedn.Fixed8(tx.SystemFee).String() + " GAS\n"))
+		buf = fmt.Appendf(buf, "SystemFee:\t%s GAS\n", fixedn.Fixed8(tx.SystemFee).String())
-		_, _ = tw.Write([]byte("NetworkFee:\t" + fixedn.Fixed8(tx.NetworkFee).String() + " GAS\n"))
+		buf = fmt.Appendf(buf, "NetworkFee:\t%s GAS\n", fixedn.Fixed8(tx.NetworkFee).String())
-		_, _ = tw.Write([]byte("Script:\t" + base64.StdEncoding.EncodeToString(tx.Script) + "\n"))
+		buf = fmt.Appendf(buf, "Script:\t%s\n", base64.StdEncoding.EncodeToString(tx.Script))
 		v := vm.New()
 		v.Load(tx.Script)
-		v.PrintOps(tw)
+		opts := bytes.NewBuffer(nil)
+		v.PrintOps(opts)
+		buf = append(buf, opts.Bytes()...)
 		if res != nil {
 			for _, e := range res.Executions {
 				if e.VMState != vmstate.Halt {
-					_, _ = tw.Write([]byte("Exception:\t" + e.FaultException + "\n"))
+					buf = fmt.Appendf(buf, "Exception:\t%s\n", e.FaultException)
 				}
 			}
 		}
 	}
-	_ = tw.Flush()
+	tw := tabwriter.NewWriter(ctx.App.Writer, 0, 4, 4, '\t', 0)
-	fmt.Fprint(ctx.App.Writer, buf.String())
+	_, err := tw.Write(buf)
+	if err != nil {
+		return err
+	}
+	return tw.Flush()
 }
 
 func queryCandidates(ctx *cli.Context) error {
@@ -196,15 +201,17 @@ func queryCandidates(ctx *cli.Context) error {
 		}
 		return vals[i].PublicKey.Cmp(&vals[j].PublicKey) == -1
 	})
-	buf := bytes.NewBuffer(nil)
+	var res []byte
-	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
+	res = fmt.Appendf(res, "Key\tVotes\tCommittee\tConsensus\n")
-	_, _ = tw.Write([]byte("Key\tVotes\tCommittee\tConsensus\n"))
 	for _, val := range vals {
-		_, _ = tw.Write([]byte(fmt.Sprintf("%s\t%d\t%t\t%t\n", hex.EncodeToString(val.PublicKey.Bytes()), val.Votes, comm.Contains(&val.PublicKey), val.Active)))
+		res = fmt.Appendf(res, "%s\t%d\t%t\t%t\n", hex.EncodeToString(val.PublicKey.Bytes()), val.Votes, comm.Contains(&val.PublicKey), val.Active)
 	}
-	_ = tw.Flush()
+	tw := tabwriter.NewWriter(ctx.App.Writer, 0, 2, 2, ' ', 0)
-	fmt.Fprint(ctx.App.Writer, buf.String())
+	_, err = tw.Write(res)
-	return nil
+	if err != nil {
+		return err
+	}
+	return tw.Flush()
 }
 
 func queryCommittee(ctx *cli.Context) error {

cli/util/dump.go

@@ -29,7 +29,10 @@ func txDump(ctx *cli.Context) error {
 		return cli.NewExitError("verifiable item is not a transaction", 1)
 	}
 
-	query.DumpApplicationLog(ctx, nil, tx, nil, true)
+	err = query.DumpApplicationLog(ctx, nil, tx, nil, true)
+	if err != nil {
+		return cli.NewExitError(err, 1)
+	}
 
 	if ctx.String(options.RPCEndpointFlag) != "" {
 		gctx, cancel := options.GetTimeoutContext(ctx)

cli/vm/cli.go

@@ -1436,58 +1436,57 @@ func Parse(args []string) (string, error) {
 		return "", ErrMissingParameter
 	}
 	arg := args[0]
-	buf := bytes.NewBuffer(nil)
+	var buf []byte
 	if val, err := strconv.ParseInt(arg, 10, 64); err == nil {
 		bs := bigint.ToBytes(big.NewInt(val))
-		buf.WriteString(fmt.Sprintf("Integer to Hex\t%s\n", hex.EncodeToString(bs)))
+		buf = fmt.Appendf(buf, "Integer to Hex\t%s\n", hex.EncodeToString(bs))
-		buf.WriteString(fmt.Sprintf("Integer to Base64\t%s\n", base64.StdEncoding.EncodeToString(bs)))
+		buf = fmt.Appendf(buf, "Integer to Base64\t%s\n", base64.StdEncoding.EncodeToString(bs))
 	}
 	noX := strings.TrimPrefix(arg, "0x")
 	if rawStr, err := hex.DecodeString(noX); err == nil {
 		if val, err := util.Uint160DecodeBytesBE(rawStr); err == nil {
-			buf.WriteString(fmt.Sprintf("BE ScriptHash to Address\t%s\n", address.Uint160ToString(val)))
+			buf = fmt.Appendf(buf, "BE ScriptHash to Address\t%s\n", address.Uint160ToString(val))
-			buf.WriteString(fmt.Sprintf("LE ScriptHash to Address\t%s\n", address.Uint160ToString(val.Reverse())))
+			buf = fmt.Appendf(buf, "LE ScriptHash to Address\t%s\n", address.Uint160ToString(val.Reverse()))
 		}
 		if pub, err := keys.NewPublicKeyFromBytes(rawStr, elliptic.P256()); err == nil {
 			sh := pub.GetScriptHash()
-			buf.WriteString(fmt.Sprintf("Public key to BE ScriptHash\t%s\n", sh))
+			buf = fmt.Appendf(buf, "Public key to BE ScriptHash\t%s\n", sh)
-			buf.WriteString(fmt.Sprintf("Public key to LE ScriptHash\t%s\n", sh.Reverse()))
+			buf = fmt.Appendf(buf, "Public key to LE ScriptHash\t%s\n", sh.Reverse())
-			buf.WriteString(fmt.Sprintf("Public key to Address\t%s\n", address.Uint160ToString(sh)))
+			buf = fmt.Appendf(buf, "Public key to Address\t%s\n", address.Uint160ToString(sh))
 		}
-		buf.WriteString(fmt.Sprintf("Hex to String\t%s\n", fmt.Sprintf("%q", string(rawStr))))
+		buf = fmt.Appendf(buf, "Hex to String\t%s\n", fmt.Sprintf("%q", string(rawStr)))
-		buf.WriteString(fmt.Sprintf("Hex to Integer\t%s\n", bigint.FromBytes(rawStr)))
+		buf = fmt.Appendf(buf, "Hex to Integer\t%s\n", bigint.FromBytes(rawStr))
-		buf.WriteString(fmt.Sprintf("Swap Endianness\t%s\n", hex.EncodeToString(slice.CopyReverse(rawStr))))
+		buf = fmt.Appendf(buf, "Swap Endianness\t%s\n", hex.EncodeToString(slice.CopyReverse(rawStr)))
 	}
 	if addr, err := address.StringToUint160(arg); err == nil {
-		buf.WriteString(fmt.Sprintf("Address to BE ScriptHash\t%s\n", addr))
+		buf = fmt.Appendf(buf, "Address to BE ScriptHash\t%s\n", addr)
-		buf.WriteString(fmt.Sprintf("Address to LE ScriptHash\t%s\n", addr.Reverse()))
+		buf = fmt.Appendf(buf, "Address to LE ScriptHash\t%s\n", addr.Reverse())
-		buf.WriteString(fmt.Sprintf("Address to Base64 (BE)\t%s\n", base64.StdEncoding.EncodeToString(addr.BytesBE())))
+		buf = fmt.Appendf(buf, "Address to Base64 (BE)\t%s\n", base64.StdEncoding.EncodeToString(addr.BytesBE()))
-		buf.WriteString(fmt.Sprintf("Address to Base64 (LE)\t%s\n", base64.StdEncoding.EncodeToString(addr.BytesLE())))
+		buf = fmt.Appendf(buf, "Address to Base64 (LE)\t%s\n", base64.StdEncoding.EncodeToString(addr.BytesLE()))
 	}
 	if rawStr, err := base64.StdEncoding.DecodeString(arg); err == nil {
-		buf.WriteString(fmt.Sprintf("Base64 to String\t%s\n", fmt.Sprintf("%q", string(rawStr))))
+		buf = fmt.Appendf(buf, "Base64 to String\t%s\n", fmt.Sprintf("%q", string(rawStr)))
-		buf.WriteString(fmt.Sprintf("Base64 to BigInteger\t%s\n", bigint.FromBytes(rawStr)))
+		buf = fmt.Appendf(buf, "Base64 to BigInteger\t%s\n", bigint.FromBytes(rawStr))
 		if u, err := util.Uint160DecodeBytesBE(rawStr); err == nil {
-			buf.WriteString(fmt.Sprintf("Base64 to BE ScriptHash\t%s\n", u.StringBE()))
+			buf = fmt.Appendf(buf, "Base64 to BE ScriptHash\t%s\n", u.StringBE())
-			buf.WriteString(fmt.Sprintf("Base64 to LE ScriptHash\t%s\n", u.StringLE()))
+			buf = fmt.Appendf(buf, "Base64 to LE ScriptHash\t%s\n", u.StringLE())
-			buf.WriteString(fmt.Sprintf("Base64 to Address (BE)\t%s\n", address.Uint160ToString(u)))
+			buf = fmt.Appendf(buf, "Base64 to Address (BE)\t%s\n", address.Uint160ToString(u))
-			buf.WriteString(fmt.Sprintf("Base64 to Address (LE)\t%s\n", address.Uint160ToString(u.Reverse())))
+			buf = fmt.Appendf(buf, "Base64 to Address (LE)\t%s\n", address.Uint160ToString(u.Reverse()))
 		}
 	}
 
-	buf.WriteString(fmt.Sprintf("String to Hex\t%s\n", hex.EncodeToString([]byte(arg))))
+	buf = fmt.Appendf(buf, "String to Hex\t%s\n", hex.EncodeToString([]byte(arg)))
-	buf.WriteString(fmt.Sprintf("String to Base64\t%s\n", base64.StdEncoding.EncodeToString([]byte(arg))))
+	buf = fmt.Appendf(buf, "String to Base64\t%s\n", base64.StdEncoding.EncodeToString([]byte(arg)))
 
-	out := buf.Bytes()
+	res := bytes.NewBuffer(nil)
-	buf = bytes.NewBuffer(nil)
+	w := tabwriter.NewWriter(res, 0, 4, 4, '\t', 0)
-	w := tabwriter.NewWriter(buf, 0, 4, 4, '\t', 0)
+	if _, err := w.Write(buf); err != nil {
-	if _, err := w.Write(out); err != nil {
 		return "", err
 	}
 	if err := w.Flush(); err != nil {
 		return "", err
 	}
-	return buf.String(), nil
+	return res.String(), nil
 }
 
 const logo = `