aarifullin/neoneo-go
1
0
Fork 0
forked from TrueCloudLab/neoneo-go
Code Pull requests Activity

cli: use fmt.Append* where possibble

Browse source 
Close #2629.

Signed-off-by: Anna Shaleva <shaleva.ann@nspcc.ru>
This commit is contained in:
Anna Shaleva 2023-10-12 18:07:54 +03:00
parent 3aa858a69f
commit e06051e14c
3 changed files with 66 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
cli/query/query.go
View file

@ -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 return nil
} }
@ -120,47 +123,49 @@ func DumpApplicationLog(
res *result.ApplicationLog, res *result.ApplicationLog,
tx *transaction.Transaction, tx *transaction.Transaction,
txMeta *result.TransactionMetadata, 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 { 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 { } else {
if txMeta != nil { 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 { 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 { } 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 { if verbose {
for _, sig := range tx.Signers { 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 := vm.New()
v.Load(tx.Script) v.Load(tx.Script)
v.PrintOps(tw) opts := bytes.NewBuffer(nil)
v.PrintOps(opts)
buf = append(buf, opts.Bytes()...)
if res != nil { if res != nil {
for _, e := range res.Executions { for _, e := range res.Executions {
if e.VMState != vmstate.Halt { 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 { 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 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 { 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 { func queryCommittee(ctx *cli.Context) error {

5
cli/util/dump.go
View file

@ -29,7 +29,10 @@ func txDump(ctx *cli.Context) error {
return cli.NewExitError("verifiable item is not a transaction", 1) 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) != "" { if ctx.String(options.RPCEndpointFlag) != "" {
gctx, cancel := options.GetTimeoutContext(ctx) gctx, cancel := options.GetTimeoutContext(ctx)

55
cli/vm/cli.go
View file

@ -1436,58 +1436,57 @@ func Parse(args []string) (string, error) {
return "", ErrMissingParameter return "", ErrMissingParameter
} }
arg := args[0] arg := args[0]
buf := bytes.NewBuffer(nil) var buf []byte
if val, err := strconv.ParseInt(arg, 10, 64); err == nil { if val, err := strconv.ParseInt(arg, 10, 64); err == nil {
bs := bigint.ToBytes(big.NewInt(val)) 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") noX := strings.TrimPrefix(arg, "0x")
if rawStr, err := hex.DecodeString(noX); err == nil { if rawStr, err := hex.DecodeString(noX); err == nil {
if val, err := util.Uint160DecodeBytesBE(rawStr); 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 { if pub, err := keys.NewPublicKeyFromBytes(rawStr, elliptic.P256()); err == nil {
sh := pub.GetScriptHash() 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 { 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 { 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 { 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 return "", err
} }
if err := w.Flush(); err != nil { if err := w.Flush(); err != nil {
return "", err return "", err
} }
return buf.String(), nil return res.String(), nil
} }
const logo = ` const logo = `