cmd/bytomcli/commands/transaction.go

   1 package commands
   2
   3 import (
   4         "encoding/hex"
   5         "encoding/json"
   6         "fmt"
   7         "os"
   8
   9         "github.com/spf13/cobra"
  10         jww "github.com/spf13/jwalterweatherman"
  11
  12         "github.com/bytom/api"
  13         "github.com/bytom/blockchain/txbuilder"
  14         chainjson "github.com/bytom/encoding/json"
  15         "github.com/bytom/protocol/bc/types"
  16         "github.com/bytom/util"
  17 )
  18
  19 func init() {
  20         buildTransactionCmd.PersistentFlags().StringVarP(&buildType, "type", "t", "", "transaction type, valid types: 'issue', 'spend'")
  21         buildTransactionCmd.PersistentFlags().StringVarP(&receiverProgram, "receiver", "r", "", "program of receiver")
  22         buildTransactionCmd.PersistentFlags().StringVarP(&address, "address", "a", "", "address of receiver")
  23         buildTransactionCmd.PersistentFlags().StringVarP(&btmGas, "gas", "g", "20000000", "gas of this transaction")
  24         buildTransactionCmd.PersistentFlags().BoolVar(&pretty, "pretty", false, "pretty print json result")
  25         buildTransactionCmd.PersistentFlags().BoolVar(&alias, "alias", false, "use alias build transaction")
  26
  27         signTransactionCmd.PersistentFlags().StringVarP(&password, "password", "p", "", "password of the account which sign these transaction(s)")
  28         signTransactionCmd.PersistentFlags().BoolVar(&pretty, "pretty", false, "pretty print json result")
  29
  30         listTransactionsCmd.PersistentFlags().StringVar(&txID, "id", "", "transaction id")
  31         listTransactionsCmd.PersistentFlags().StringVar(&account, "account_id", "", "account id")
  32         listTransactionsCmd.PersistentFlags().BoolVar(&detail, "detail", false, "list transactions details")
  33 }
  34
  35 var (
  36         buildType       = ""
  37         btmGas          = ""
  38         receiverProgram = ""
  39         address         = ""
  40         password        = ""
  41         pretty          = false
  42         alias           = false
  43         txID            = ""
  44         account         = ""
  45         detail          = false
  46 )
  47
  48 var buildIssueReqFmt = `
  49         {"actions": [
  50                 {"type": "spend_account", "asset_id": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "amount":%s, "account_id": "%s"},
  51                 {"type": "issue", "asset_id": "%s", "amount": %s},
  52                 {"type": "control_address", "asset_id": "%s", "amount": %s, "address": "%s"}
  53         ]}`
  54
  55 var buildIssueReqFmtByAlias = `
  56         {"actions": [
  57                 {"type": "spend_account", "asset_alias": "BTM", "amount":%s, "account_alias": "%s"},
  58                 {"type": "issue", "asset_alias": "%s", "amount": %s},
  59                 {"type": "control_address", "asset_alias": "%s", "amount": %s, "address": "%s"}
  60         ]}`
  61
  62 var buildSpendReqFmt = `
  63         {"actions": [
  64                 {"type": "spend_account", "asset_id": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "amount":%s, "account_id": "%s"},
  65                 {"type": "spend_account", "asset_id": "%s","amount": %s,"account_id": "%s"},
  66                 {"type": "control_receiver", "asset_id": "%s", "amount": %s, "receiver":{"control_program": "%s"}}
  67         ]}`
  68
  69 var buildSpendReqFmtByAlias = `
  70         {"actions": [
  71                 {"type": "spend_account", "asset_alias": "BTM", "amount":%s, "account_alias": "%s"},
  72                 {"type": "spend_account", "asset_alias": "%s","amount": %s,"account_alias": "%s"},
  73                 {"type": "control_receiver", "asset_alias": "%s", "amount": %s, "receiver":{"control_program": "%s"}}
  74         ]}`
  75
  76 var buildRetireReqFmt = `
  77         {"actions": [
  78                 {"type": "spend_account", "asset_id": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "amount":%s, "account_id": "%s"},
  79                 {"type": "spend_account", "asset_id": "%s","amount": %s,"account_id": "%s"},
  80                 {"type": "retire", "asset_id": "%s","amount": %s,"account_id": "%s"}
  81         ]}`
  82
  83 var buildRetireReqFmtByAlias = `
  84         {"actions": [
  85                 {"type": "spend_account", "asset_alias": "BTM", "amount":%s, "account_alias": "%s"},
  86                 {"type": "spend_account", "asset_alias": "%s","amount": %s,"account_alias": "%s"},
  87                 {"type": "retire", "asset_alias": "%s","amount": %s,"account_alias": "%s"}
  88         ]}`
  89
  90 var buildControlAddressReqFmt = `
  91         {"actions": [
  92                 {"type": "spend_account", "asset_id": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "amount":%s, "account_id": "%s"},
  93                 {"type": "spend_account", "asset_id": "%s","amount": %s,"account_id": "%s"},
  94                 {"type": "control_address", "asset_id": "%s", "amount": %s,"address": "%s"}
  95         ]}`
  96
  97 var buildControlAddressReqFmtByAlias = `
  98         {"actions": [
  99                 {"type": "spend_account", "asset_alias": "BTM", "amount":%s, "account_alias": "%s"},
 100                 {"type": "spend_account", "asset_alias": "%s","amount": %s, "account_alias": "%s"},
 101                 {"type": "control_address", "asset_alias": "%s", "amount": %s,"address": "%s"}
 102         ]}`
 103
 104 var buildTransactionCmd = &cobra.Command{
 105         Use:   "build-transaction <accountID|alias> <assetID|alias> <amount>",
 106         Short: "Build one transaction template,default use account id and asset id",
 107         Args:  cobra.RangeArgs(3, 4),
 108         PreRun: func(cmd *cobra.Command, args []string) {
 109                 cmd.MarkFlagRequired("type")
 110                 if buildType == "spend" {
 111                         cmd.MarkFlagRequired("receiver")
 112                 }
 113         },
 114         Run: func(cmd *cobra.Command, args []string) {
 115                 var buildReqStr string
 116                 accountInfo := args[0]
 117                 assetInfo := args[1]
 118                 amount := args[2]
 119                 switch buildType {
 120                 case "issue":
 121                         if alias {
 122                                 buildReqStr = fmt.Sprintf(buildIssueReqFmtByAlias, btmGas, accountInfo, assetInfo, amount, assetInfo, amount, address)
 123                                 break
 124                         }
 125                         buildReqStr = fmt.Sprintf(buildIssueReqFmt, btmGas, accountInfo, assetInfo, amount, assetInfo, amount, address)
 126                 case "spend":
 127                         if alias {
 128                                 buildReqStr = fmt.Sprintf(buildSpendReqFmtByAlias, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, receiverProgram)
 129                                 break
 130                         }
 131                         buildReqStr = fmt.Sprintf(buildSpendReqFmt, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, receiverProgram)
 132                 case "retire":
 133                         if alias {
 134                                 buildReqStr = fmt.Sprintf(buildRetireReqFmtByAlias, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, accountInfo)
 135                                 break
 136                         }
 137                         buildReqStr = fmt.Sprintf(buildRetireReqFmt, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, accountInfo)
 138                 case "address":
 139                         if alias {
 140                                 buildReqStr = fmt.Sprintf(buildControlAddressReqFmtByAlias, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, address)
 141                                 break
 142                         }
 143                         buildReqStr = fmt.Sprintf(buildControlAddressReqFmt, btmGas, accountInfo, assetInfo, amount, accountInfo, assetInfo, amount, address)
 144                 default:
 145                         jww.ERROR.Println("Invalid transaction template type")
 146                         os.Exit(util.ErrLocalExe)
 147                 }
 148
 149                 var buildReq api.BuildRequest
 150                 if err := json.Unmarshal([]byte(buildReqStr), &buildReq); err != nil {
 151                         jww.ERROR.Println(err)
 152                         os.Exit(util.ErrLocalExe)
 153                 }
 154
 155                 data, exitCode := util.ClientCall("/build-transaction", &buildReq)
 156                 if exitCode != util.Success {
 157                         os.Exit(exitCode)
 158                 }
 159
 160                 if pretty {
 161                         printJSON(data)
 162                         return
 163                 }
 164
 165                 dataMap, ok := data.(map[string]interface{})
 166                 if ok != true {
 167                         jww.ERROR.Println("invalid type assertion")
 168                         os.Exit(util.ErrLocalParse)
 169                 }
 170
 171                 rawTemplate, err := json.Marshal(dataMap)
 172                 if err != nil {
 173                         jww.ERROR.Println(err)
 174                         os.Exit(util.ErrLocalParse)
 175                 }
 176
 177                 jww.FEEDBACK.Printf("Template Type: %s\n%s\n", buildType, string(rawTemplate))
 178         },
 179 }
 180
 181 var signTransactionCmd = &cobra.Command{
 182         Use:   "sign-transaction  <json templates>",
 183         Short: "Sign transaction templates with account password",
 184         Args:  cobra.ExactArgs(1),
 185         PreRun: func(cmd *cobra.Command, args []string) {
 186                 cmd.MarkFlagRequired("password")
 187         },
 188         Run: func(cmd *cobra.Command, args []string) {
 189                 template := txbuilder.Template{}
 190
 191                 err := json.Unmarshal([]byte(args[0]), &template)
 192                 if err != nil {
 193                         jww.ERROR.Println(err)
 194                         os.Exit(util.ErrLocalExe)
 195                 }
 196
 197                 var req = struct {
 198                         Password string             `json:"password"`
 199                         Txs      txbuilder.Template `json:"transaction"`
 200                 }{Password: password, Txs: template}
 201
 202                 jww.FEEDBACK.Printf("\n\n")
 203                 data, exitCode := util.ClientCall("/sign-transaction", &req)
 204                 if exitCode != util.Success {
 205                         os.Exit(exitCode)
 206                 }
 207
 208                 if pretty {
 209                         printJSON(data)
 210                         return
 211                 }
 212
 213                 dataMap, ok := data.(map[string]interface{})
 214                 if ok != true {
 215                         jww.ERROR.Println("invalid type assertion")
 216                         os.Exit(util.ErrLocalParse)
 217                 }
 218
 219                 rawSign, err := json.Marshal(dataMap)
 220                 if err != nil {
 221                         jww.ERROR.Println(err)
 222                         os.Exit(util.ErrLocalParse)
 223                 }
 224                 jww.FEEDBACK.Printf("\nSign Template:\n%s\n", string(rawSign))
 225         },
 226 }
 227
 228 var submitTransactionCmd = &cobra.Command{
 229         Use:   "submit-transaction  <signed json raw_transaction>",
 230         Short: "Submit signed transaction",
 231         Args:  cobra.ExactArgs(1),
 232         Run: func(cmd *cobra.Command, args []string) {
 233                 var ins = struct {
 234                         Tx types.Tx `json:"raw_transaction"`
 235                 }{}
 236
 237                 err := json.Unmarshal([]byte(args[0]), &ins)
 238                 if err != nil {
 239                         jww.ERROR.Println(err)
 240                         os.Exit(util.ErrLocalExe)
 241                 }
 242
 243                 data, exitCode := util.ClientCall("/submit-transaction", &ins)
 244                 if exitCode != util.Success {
 245                         os.Exit(exitCode)
 246                 }
 247
 248                 printJSON(data)
 249         },
 250 }
 251
 252 var estimateTransactionGasCmd = &cobra.Command{
 253         Use:   "estimate-transaction-gas  <signed json raw_transaction>",
 254         Short: "estimate gas for signed transaction",
 255         Args:  cobra.ExactArgs(1),
 256         Run: func(cmd *cobra.Command, args []string) {
 257                 var ins = struct {
 258                         Tx types.Tx `json:"raw_transaction"`
 259                 }{}
 260
 261                 err := json.Unmarshal([]byte(args[0]), &ins)
 262                 if err != nil {
 263                         jww.ERROR.Println(err)
 264                         os.Exit(util.ErrLocalExe)
 265                 }
 266
 267                 data, exitCode := util.ClientCall("/estimate-transaction-gas", &ins)
 268                 if exitCode != util.Success {
 269                         os.Exit(exitCode)
 270                 }
 271
 272                 printJSON(data)
 273         },
 274 }
 275
 276 var getTransactionCmd = &cobra.Command{
 277         Use:   "get-transaction <hash>",
 278         Short: "get the transaction by matching the given transaction hash",
 279         Args:  cobra.ExactArgs(1),
 280         Run: func(cmd *cobra.Command, args []string) {
 281                 txInfo := &struct {
 282                         TxID string `json:"tx_id"`
 283                 }{TxID: args[0]}
 284
 285                 data, exitCode := util.ClientCall("/get-transaction", txInfo)
 286                 if exitCode != util.Success {
 287                         os.Exit(exitCode)
 288                 }
 289
 290                 printJSON(data)
 291         },
 292 }
 293
 294 var listTransactionsCmd = &cobra.Command{
 295         Use:   "list-transactions",
 296         Short: "List the transactions",
 297         Args:  cobra.NoArgs,
 298         Run: func(cmd *cobra.Command, args []string) {
 299                 filter := struct {
 300                         ID        string `json:"id"`
 301                         AccountID string `json:"account_id"`
 302                         Detail    bool   `json:"detail"`
 303                 }{ID: txID, AccountID: account, Detail: detail}
 304
 305                 data, exitCode := util.ClientCall("/list-transactions", &filter)
 306                 if exitCode != util.Success {
 307                         os.Exit(exitCode)
 308                 }
 309
 310                 printJSONList(data)
 311         },
 312 }
 313
 314 var getUnconfirmedTransactionCmd = &cobra.Command{
 315         Use:   "get-unconfirmed-transaction <hash>",
 316         Short: "get unconfirmed transaction by matching the given transaction hash",
 317         Args:  cobra.ExactArgs(1),
 318         Run: func(cmd *cobra.Command, args []string) {
 319                 txID, err := hex.DecodeString(args[0])
 320                 if err != nil {
 321                         jww.ERROR.Println(err)
 322                         os.Exit(util.ErrLocalExe)
 323                 }
 324
 325                 txInfo := &struct {
 326                         TxID chainjson.HexBytes `json:"tx_id"`
 327                 }{TxID: txID}
 328
 329                 data, exitCode := util.ClientCall("/get-unconfirmed-transaction", txInfo)
 330                 if exitCode != util.Success {
 331                         os.Exit(exitCode)
 332                 }
 333
 334                 printJSON(data)
 335         },
 336 }
 337
 338 var listUnconfirmedTransactionsCmd = &cobra.Command{
 339         Use:   "list-unconfirmed-transactions",
 340         Short: "list unconfirmed transactions hashes",
 341         Args:  cobra.NoArgs,
 342         Run: func(cmd *cobra.Command, args []string) {
 343                 data, exitCode := util.ClientCall("/list-unconfirmed-transactions")
 344                 if exitCode != util.Success {
 345                         os.Exit(exitCode)
 346                 }
 347
 348                 printJSONList(data)
 349         },
 350 }
 351
 352 var gasRateCmd = &cobra.Command{
 353         Use:   "gas-rate",
 354         Short: "Print the current gas rate",
 355         Args:  cobra.NoArgs,
 356         Run: func(cmd *cobra.Command, args []string) {
 357                 data, exitCode := util.ClientCall("/gas-rate")
 358                 if exitCode != util.Success {
 359                         os.Exit(exitCode)
 360                 }
 361                 printJSON(data)
 362         },
 363 }