cmd/bytomcli/commands/account.go

   1 package commands
   2
   3 import (
   4         "os"
   5         "strings"
   6
   7         "github.com/spf13/cobra"
   8         jww "github.com/spf13/jwalterweatherman"
   9
  10         "github.com/bytom/crypto/ed25519/chainkd"
  11         "github.com/bytom/util"
  12 )
  13
  14 func init() {
  15         createAccountCmd.PersistentFlags().IntVarP(&accountQuorum, "quorom", "q", 1, "quorum must be greater than 0 and less than or equal to the number of signers")
  16         createAccountCmd.PersistentFlags().StringVarP(&accountToken, "access", "a", "", "access token")
  17
  18         updateAccountAliasCmd.PersistentFlags().StringVar(&accountID, "id", "", "account ID")
  19         updateAccountAliasCmd.PersistentFlags().StringVar(&accountAlias, "alias", "", "account alias")
  20
  21         listAccountsCmd.PersistentFlags().StringVar(&accountID, "id", "", "account ID")
  22         listAccountsCmd.PersistentFlags().StringVar(&accountAlias, "alias", "", "account alias")
  23
  24         listAddressesCmd.PersistentFlags().StringVar(&accountID, "id", "", "account ID")
  25         listAddressesCmd.PersistentFlags().StringVar(&accountAlias, "alias", "", "account alias")
  26
  27         listBalancesCmd.PersistentFlags().StringVar(&accountID, "id", "", "account ID")
  28         listBalancesCmd.PersistentFlags().StringVar(&accountAlias, "alias", "", "account alias")
  29
  30         listUnspentOutputsCmd.PersistentFlags().StringVar(&accountID, "account_id", "", "account ID")
  31         listUnspentOutputsCmd.PersistentFlags().StringVar(&accountAlias, "account_alias", "", "account alias")
  32         listUnspentOutputsCmd.PersistentFlags().StringVar(&outputID, "id", "", "ID of unspent output")
  33         listUnspentOutputsCmd.PersistentFlags().BoolVar(&unconfirmed, "unconfirmed", false, "list unconfirmed unspent outputs")
  34         listUnspentOutputsCmd.PersistentFlags().BoolVar(&smartContract, "contract", false, "list smart contract unspent outputs")
  35         listUnspentOutputsCmd.PersistentFlags().IntVar(&from, "from", 0, "the starting position of a page")
  36         listUnspentOutputsCmd.PersistentFlags().IntVar(&count, "count", 0, "the longest count per page")
  37 }
  38
  39 var (
  40         accountID     = ""
  41         accountAlias  = ""
  42         accountQuorum = 1
  43         accountToken  = ""
  44         outputID      = ""
  45         smartContract = false
  46         from          = 0
  47         count         = 0
  48 )
  49
  50 var createAccountCmd = &cobra.Command{
  51         Use:   "create-account <alias> <xpub(s)>",
  52         Short: "Create an account",
  53         Args:  cobra.MinimumNArgs(2),
  54         Run: func(cmd *cobra.Command, args []string) {
  55                 ins := accountIns{}
  56
  57                 for _, x := range args[1:] {
  58                         xpub := chainkd.XPub{}
  59                         if err := xpub.UnmarshalText([]byte(x)); err != nil {
  60                                 jww.ERROR.Println(err)
  61                                 os.Exit(util.ErrLocalExe)
  62                         }
  63                         ins.RootXPubs = append(ins.RootXPubs, xpub)
  64                 }
  65
  66                 ins.Quorum = accountQuorum
  67                 ins.Alias = args[0]
  68                 ins.AccessToken = accountToken
  69
  70                 data, exitCode := util.ClientCall("/create-account", &ins)
  71                 if exitCode != util.Success {
  72                         os.Exit(exitCode)
  73                 }
  74
  75                 printJSON(data)
  76         },
  77 }
  78
  79 var updateAccountAliasCmd = &cobra.Command{
  80         Use:   "update-account-alias <newAlias>",
  81         Short: "update account alias",
  82         Args:  cobra.ExactArgs(1),
  83         Run: func(cmd *cobra.Command, args []string) {
  84                 var ins = struct {
  85                         AccountID    string `json:"account_id"`
  86                         AccountAlias string `json:"account_alias"`
  87                         NewAlias     string `json:"new_alias"`
  88                 }{AccountID: accountID, AccountAlias: accountAlias, NewAlias: args[0]}
  89
  90                 _, exitCode := util.ClientCall("/update-account-alias", &ins)
  91                 if exitCode != util.Success {
  92                         os.Exit(exitCode)
  93                 }
  94
  95                 jww.FEEDBACK.Println("Successfully update account alias")
  96         },
  97 }
  98
  99 var listAccountsCmd = &cobra.Command{
 100         Use:   "list-accounts",
 101         Short: "List the existing accounts",
 102         Args:  cobra.NoArgs,
 103         Run: func(cmd *cobra.Command, args []string) {
 104                 filter := struct {
 105                         ID    string `json:"id"`
 106                         Alias string `json:"alias"`
 107                 }{ID: accountID, Alias: accountAlias}
 108
 109                 data, exitCode := util.ClientCall("/list-accounts", &filter)
 110                 if exitCode != util.Success {
 111                         os.Exit(exitCode)
 112                 }
 113
 114                 printJSONList(data)
 115         },
 116 }
 117
 118 var deleteAccountCmd = &cobra.Command{
 119         Use:   "delete-account <accountID|alias>",
 120         Short: "Delete the existing account",
 121         Args:  cobra.ExactArgs(1),
 122         Run: func(cmd *cobra.Command, args []string) {
 123                 accountInfo := &struct {
 124                         AccountInfo string `json:"account_info"`
 125                 }{AccountInfo: args[0]}
 126
 127                 if _, exitCode := util.ClientCall("/delete-account", accountInfo); exitCode != util.Success {
 128                         os.Exit(exitCode)
 129                 }
 130
 131                 jww.FEEDBACK.Println("Successfully delete account")
 132         },
 133 }
 134
 135 var createAccountReceiverCmd = &cobra.Command{
 136         Use:   "create-account-receiver <accountAlias> [accountID]",
 137         Short: "Create an account receiver",
 138         Args:  cobra.RangeArgs(1, 2),
 139         Run: func(cmd *cobra.Command, args []string) {
 140                 var ins = struct {
 141                         AccountID    string `json:"account_id"`
 142                         AccountAlias string `json:"account_alias"`
 143                 }{AccountAlias: args[0]}
 144
 145                 if len(args) == 2 {
 146                         ins.AccountID = args[1]
 147                 }
 148
 149                 data, exitCode := util.ClientCall("/create-account-receiver", &ins)
 150                 if exitCode != util.Success {
 151                         os.Exit(exitCode)
 152                 }
 153
 154                 printJSON(data)
 155         },
 156 }
 157
 158 var listAddressesCmd = &cobra.Command{
 159         Use:   "list-addresses",
 160         Short: "List the account addresses",
 161         Args:  cobra.NoArgs,
 162         Run: func(cmd *cobra.Command, args []string) {
 163                 var ins = struct {
 164                         AccountID    string `json:"account_id"`
 165                         AccountAlias string `json:"account_alias"`
 166                 }{AccountID: accountID, AccountAlias: accountAlias}
 167
 168                 data, exitCode := util.ClientCall("/list-addresses", &ins)
 169                 if exitCode != util.Success {
 170                         os.Exit(exitCode)
 171                 }
 172
 173                 printJSONList(data)
 174         },
 175 }
 176
 177 var validateAddressCmd = &cobra.Command{
 178         Use:   "validate-address <address>",
 179         Short: "validate the account addresses",
 180         Args:  cobra.ExactArgs(1),
 181         Run: func(cmd *cobra.Command, args []string) {
 182                 var ins = struct {
 183                         Address string `json:"address"`
 184                 }{Address: args[0]}
 185
 186                 data, exitCode := util.ClientCall("/validate-address", &ins)
 187                 if exitCode != util.Success {
 188                         os.Exit(exitCode)
 189                 }
 190
 191                 printJSON(data)
 192         },
 193 }
 194
 195 var listPubKeysCmd = &cobra.Command{
 196         Use:   "list-pubkeys <accountInfo> [publicKey]",
 197         Short: "list the account pubkeys",
 198         Args:  cobra.RangeArgs(1, 2),
 199         Run: func(cmd *cobra.Command, args []string) {
 200                 var ins = struct {
 201                         AccountID    string `json:"account_id"`
 202                         AccountAlias string `json:"account_alias"`
 203                         PublicKey    string `json:"public_key"`
 204                 }{}
 205
 206                 if len(args[0]) == 13 && strings.HasPrefix(args[0], "0") {
 207                         ins.AccountID = args[0]
 208                 } else {
 209                         ins.AccountAlias = args[0]
 210                 }
 211
 212                 if len(args) == 2 {
 213                         ins.PublicKey = args[1]
 214                 }
 215
 216                 data, exitCode := util.ClientCall("/list-pubkeys", &ins)
 217                 if exitCode != util.Success {
 218                         os.Exit(exitCode)
 219                 }
 220
 221                 printJSON(data)
 222         },
 223 }
 224
 225 var listBalancesCmd = &cobra.Command{
 226         Use:   "list-balances",
 227         Short: "List the accounts balances",
 228         Args:  cobra.NoArgs,
 229         Run: func(cmd *cobra.Command, args []string) {
 230                 var filter = struct {
 231                         AccountID    string `json:"account_id"`
 232                         AccountAlias string `json:"account_alias"`
 233                 }{AccountID: accountID, AccountAlias: accountAlias}
 234
 235                 data, exitCode := util.ClientCall("/list-balances", &filter)
 236                 if exitCode != util.Success {
 237                         os.Exit(exitCode)
 238                 }
 239
 240                 printJSONList(data)
 241         },
 242 }
 243
 244 var listUnspentOutputsCmd = &cobra.Command{
 245         Use:   "list-unspent-outputs",
 246         Short: "List the accounts unspent outputs",
 247         Args:  cobra.NoArgs,
 248         Run: func(cmd *cobra.Command, args []string) {
 249                 filter := struct {
 250                         AccountID     string `json:"account_id"`
 251                         AccountAlias  string `json:"account_alias"`
 252                         ID            string `json:"id"`
 253                         Unconfirmed   bool   `json:"unconfirmed"`
 254                         SmartContract bool   `json:"smart_contract"`
 255                         From          uint   `json:"from"`
 256                         Count         uint   `json:"count"`
 257                 }{
 258                         AccountID:     accountID,
 259                         AccountAlias:  accountAlias,
 260                         ID:            outputID,
 261                         Unconfirmed:   unconfirmed,
 262                         SmartContract: smartContract,
 263                         From:          uint(from),
 264                         Count:         uint(count),
 265                 }
 266
 267                 data, exitCode := util.ClientCall("/list-unspent-outputs", &filter)
 268                 if exitCode != util.Success {
 269                         os.Exit(exitCode)
 270                 }
 271
 272                 printJSONList(data)
 273         },
 274 }