github.com/Finschia/finschia-sdk@v0.48.1/client/debug/main.go (about)

     1  package debug
     2  
     3  import (
     4  	"encoding/hex"
     5  	"fmt"
     6  	"strconv"
     7  	"strings"
     8  
     9  	"github.com/spf13/cobra"
    10  
    11  	"github.com/Finschia/finschia-sdk/client"
    12  	cryptotypes "github.com/Finschia/finschia-sdk/crypto/types"
    13  	sdk "github.com/Finschia/finschia-sdk/types"
    14  	"github.com/Finschia/finschia-sdk/version"
    15  )
    16  
    17  // Cmd creates a main CLI command
    18  func Cmd() *cobra.Command {
    19  	cmd := &cobra.Command{
    20  		Use:   "debug",
    21  		Short: "Tool for helping with debugging your application",
    22  		RunE:  client.ValidateCmd,
    23  	}
    24  
    25  	cmd.AddCommand(PubkeyCmd())
    26  	cmd.AddCommand(AddrCmd())
    27  	cmd.AddCommand(RawBytesCmd())
    28  
    29  	return cmd
    30  }
    31  
    32  // getPubKeyFromString decodes SDK PubKey using JSON marshaler.
    33  func getPubKeyFromString(ctx client.Context, pkstr string) (cryptotypes.PubKey, error) {
    34  	var pk cryptotypes.PubKey
    35  	err := ctx.Codec.UnmarshalInterfaceJSON([]byte(pkstr), &pk)
    36  	return pk, err
    37  }
    38  
    39  func PubkeyCmd() *cobra.Command {
    40  	return &cobra.Command{
    41  		Use:   "pubkey [pubkey]",
    42  		Short: "Decode a pubkey from proto JSON",
    43  		Long: fmt.Sprintf(`Decode a pubkey from proto JSON and display it's address.
    44  
    45  Example:
    46  $ %s debug pubkey '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AurroA7jvfPd1AadmmOvWM2rJSwipXfRf8yD6pLbA2DJ"}'
    47  			`, version.AppName),
    48  		Args: cobra.ExactArgs(1),
    49  		RunE: func(cmd *cobra.Command, args []string) error {
    50  			clientCtx := client.GetClientContextFromCmd(cmd)
    51  			pk, err := getPubKeyFromString(clientCtx, args[0])
    52  			if err != nil {
    53  				return err
    54  			}
    55  			cmd.Println("Address:", pk.Address())
    56  			cmd.Println("PubKey Hex:", hex.EncodeToString(pk.Bytes()))
    57  			return nil
    58  		},
    59  	}
    60  }
    61  
    62  func AddrCmd() *cobra.Command {
    63  	return &cobra.Command{
    64  		Use:   "addr [address]",
    65  		Short: "Convert an address between hex and bech32",
    66  		Long: fmt.Sprintf(`Convert an address between hex encoding and bech32.
    67  
    68  Example:
    69  $ %s debug addr link19wgf6ymq2ur6r59st95e04e49m69z4al4fc982
    70  			`, version.AppName),
    71  		Args: cobra.ExactArgs(1),
    72  		RunE: func(cmd *cobra.Command, args []string) error {
    73  			addrString := args[0]
    74  			var addr []byte
    75  
    76  			// try hex, then bech32
    77  			var err error
    78  			addr, err = hex.DecodeString(addrString)
    79  			if err != nil {
    80  				var err2 error
    81  				addr, err2 = sdk.AccAddressFromBech32(addrString)
    82  				if err2 != nil {
    83  					var err3 error
    84  					addr, err3 = sdk.ValAddressFromBech32(addrString)
    85  
    86  					if err3 != nil {
    87  						return fmt.Errorf("expected hex or bech32. Got errors: hex: %v, bech32 acc: %v, bech32 val: %v", err, err2, err3)
    88  					}
    89  				}
    90  			}
    91  
    92  			cmd.Println("Address:", addr)
    93  			cmd.Printf("Address (hex): %X\n", addr)
    94  			cmd.Printf("Bech32 Acc: %s\n", sdk.AccAddress(addr))
    95  			cmd.Printf("Bech32 Val: %s\n", sdk.ValAddress(addr))
    96  			return nil
    97  		},
    98  	}
    99  }
   100  
   101  func RawBytesCmd() *cobra.Command {
   102  	return &cobra.Command{
   103  		Use:   "raw-bytes [raw-bytes]",
   104  		Short: "Convert raw bytes output (eg. [10 21 13 255]) to hex",
   105  		Long: fmt.Sprintf(`Convert raw-bytes to hex.
   106  
   107  Example:
   108  $ %s debug raw-bytes [72 101 108 108 111 44 32 112 108 97 121 103 114 111 117 110 100]
   109  			`, version.AppName),
   110  		Args: cobra.ExactArgs(1),
   111  		RunE: func(_ *cobra.Command, args []string) error {
   112  			stringBytes := args[0]
   113  			stringBytes = strings.Trim(stringBytes, "[")
   114  			stringBytes = strings.Trim(stringBytes, "]")
   115  			spl := strings.Split(stringBytes, " ")
   116  
   117  			byteArray := []byte{}
   118  			for _, s := range spl {
   119  				b, err := strconv.ParseInt(s, 10, 8)
   120  				if err != nil {
   121  					return err
   122  				}
   123  				byteArray = append(byteArray, byte(b))
   124  			}
   125  			fmt.Printf("%X\n", byteArray)
   126  			return nil
   127  		},
   128  	}
   129  }