Merge pull request #295 from MaxMustermann2/data-signing

[console/cmd] add support for `data` signing

cmd/subcommands/ethtransfer.go

@@ -5,6 +5,7 @@ import (
  "errors"
  "fmt"
  "io/ioutil"
+ "os"
  "strconv"
  "strings"
  "time"
@@ -43,9 +44,13 @@ func ethHandlerForShard(node string) (*rpc.HTTPMessenger, error) {
 // Note that the vars need to be set before calling this handler.
 func ethHandlerForTransaction(txLog *transactionLog) error {
  from := fromAddress.String()
- networkHandler, err := ethHandlerForShard(node)
- if handlerForError(txLog, err) != nil {
- return err
+ var networkHandler *rpc.HTTPMessenger
+ if !offlineSign {
+ var err error
+ networkHandler, err = ethHandlerForShard(node)
+ if handlerForError(txLog, err) != nil {
+ return err
+ }
  }
 
  var ctrlr *transaction.EthController
@@ -98,12 +103,17 @@ func ethHandlerForTransaction(txLog *transactionLog) error {
  gLimit = uint64(tempLimit)
  }
 
+ dataByte, err := transaction.StringToByte(data)
+ if err != nil {
+ return handlerForError(txLog, err)
+ }
+
  txLog.TimeSigned = time.Now().UTC().Format(timeFormat) // Approximate time of signature
  err = ctrlr.ExecuteEthTransaction(
  nonce, gLimit,
  toAddress.String(),
  amt, gPrice,
- []byte{},
+ dataByte,
  )
 
  if dryRun {
@@ -187,6 +197,9 @@ func ethOpts(ctlr *transaction.EthController) {
  if dryRun {
  ctlr.Behavior.DryRun = true
  }
+ if offlineSign {
+ ctlr.Behavior.OfflineSign = true
+ }
  if useLedgerWallet {
  ctlr.Behavior.SigningImpl = transaction.Ledger
  }
@@ -204,6 +217,9 @@ func init() {
 Create an Ethereum compatible transaction, sign it, and send off to the Harmony blockchain
 `,
  PreRunE: func(cmd *cobra.Command, args []string) error {
+ if offlineSign {
+ dryRun = true
+ }
  if givenFilePath == "" {
  for _, flagName := range [...]string{"from", "to", "amount", "chain-id"} {
  _ = cmd.MarkFlagRequired(flagName)
@@ -269,15 +285,72 @@ Create an Ethereum compatible transaction, sign it, and send off to the Harmony
  cmdEthTransfer.Flags().Var(&fromAddress, "from", "sender's one address, keystore must exist locally")
  cmdEthTransfer.Flags().Var(&toAddress, "to", "the destination one address")
  cmdEthTransfer.Flags().BoolVar(&dryRun, "dry-run", false, "do not send signed transaction")
+ cmdEthTransfer.Flags().BoolVar(&offlineSign, "offline-sign", false, "output offline signing")
  cmdEthTransfer.Flags().BoolVar(&trueNonce, "true-nonce", false, "send transaction with on-chain nonce")
  cmdEthTransfer.Flags().StringVar(&amount, "amount", "0", "amount to send (ONE)")
  cmdEthTransfer.Flags().StringVar(&gasPrice, "gas-price", "100", "gas price to pay (NANO)")
  cmdEthTransfer.Flags().StringVar(&gasLimit, "gas-limit", "", "gas limit")
  cmdEthTransfer.Flags().StringVar(&inputNonce, "nonce", "", "set nonce for tx")
+ cmdEthTransfer.Flags().StringVar(&data, "data", "", "transaction data")
  cmdEthTransfer.Flags().StringVar(&targetChain, "chain-id", "", "what chain ID to target")
  cmdEthTransfer.Flags().Uint32Var(&timeout, "timeout", defaultTimeout, "set timeout in seconds. Set to 0 to not wait for confirm")
  cmdEthTransfer.Flags().BoolVar(&userProvidesPassphrase, "passphrase", false, ppPrompt)
  cmdEthTransfer.Flags().StringVar(&passphraseFilePath, "passphrase-file", "", "path to a file containing the passphrase")
 
  RootCmd.AddCommand(cmdEthTransfer)
+
+ cmdOfflineSignEthTransfer := &cobra.Command{
+ Use: "offline-sign-eth-transfer",
+ Short: "Send a Offline Signed Ethereum transaction",
+ Args: cobra.ExactArgs(0),
+ Long: `
+Send a offline signed transaction to the Harmony blockchain (on the same shard)
+`,
+ PreRunE: func(cmd *cobra.Command, args []string) error {
+ if givenFilePath == "" {
+ return fmt.Errorf("must give a offline-signed file")
+ }
+ return nil
+ },
+ RunE: func(cmd *cobra.Command, args []string) error {
+ var txLogs []*transactionLog
+
+ networkHandler := rpc.NewHTTPHandler(node)
+
+ openFile, err := os.Open(givenFilePath)
+ if err != nil {
+ return err
+ }
+ defer openFile.Close()
+
+ err = json.NewDecoder(openFile).Decode(&txLogs)
+ if err != nil {
+ return err
+ }
+
+ for _, txLog := range txLogs {
+ if len(txLog.Errors) > 0 {
+ continue
+ }
+
+ ctrlr := transaction.NewEthController(networkHandler, nil, nil, *chainName.chainID, ethOpts)
+ err := ctrlr.ExecuteRawTransaction(txLog.RawTxn)
+ if handlerForError(txLog, err) != nil {
+ txLog.Errors = append(txLog.Errors, err.Error())
+ continue
+ }
+
+ if txHash := ctrlr.TransactionHash(); txHash != nil {
+ txLog.TxHash = *txHash
+ }
+
+ txLog.Receipt = ctrlr.Receipt()["result"]
+ }
+
+ fmt.Println(common.ToJSONUnsafe(txLogs, true))
+ return nil
+ },
+ }
+
+ RootCmd.AddCommand(cmdOfflineSignEthTransfer)
 }

cmd/subcommands/transfer.go

@@ -42,6 +42,7 @@ var (
  transferFileFlags []transferFlags
  timeout uint32
  timeFormat = "2006-01-02 15:04:05.000000"
+ data string
 )
 
 type transactionLog struct {
@@ -169,6 +170,11 @@ func handlerForTransaction(txLog *transactionLog) error {
  gLimit = uint64(tempLimit)
  }
 
+ dataByte, err := transaction.StringToByte(data)
+ if err != nil {
+ return handlerForError(txLog, err)
+ }
+
  addr := toAddress.String()
 
  txLog.TimeSigned = time.Now().UTC().Format(timeFormat) // Approximate time of signature
@@ -177,7 +183,7 @@ func handlerForTransaction(txLog *transactionLog) error {
  &addr,
  fromShardID, toShardID,
  amt, gPrice,
- []byte{},
+ dataByte,
  )
 
  if dryRun {
@@ -414,6 +420,7 @@ Create a transaction, sign it, and send off to the Harmony blockchain
  cmdTransfer.Flags().StringVar(&inputNonce, "nonce", "", "set nonce for tx")
  cmdTransfer.Flags().Uint32Var(&fromShardID, "from-shard", 0, "source shard id")
  cmdTransfer.Flags().Uint32Var(&toShardID, "to-shard", 0, "target shard id")
+ cmdTransfer.Flags().StringVar(&data, "data", "", "transaction data")
  cmdTransfer.Flags().StringVar(&targetChain, "chain-id", "", "what chain ID to target")
  cmdTransfer.Flags().Uint32Var(&timeout, "timeout", defaultTimeout, "set timeout in seconds. Set to 0 to not wait for confirm")
  cmdTransfer.Flags().BoolVar(&userProvidesPassphrase, "passphrase", false, ppPrompt)
@@ -449,7 +456,7 @@ Get Nonce From a Account
  Short: "Send a Offline Signed transaction",
  Args: cobra.ExactArgs(0),
  Long: `
-Send a offline signed to the Harmony blockchain
+Send a offline signed transaction to the Harmony blockchain
 `,
  PreRunE: func(cmd *cobra.Command, args []string) error {
  if givenFilePath == "" {

pkg/console/console.go

@@ -4,18 +4,6 @@ import (
  "encoding/hex"
  "errors"
  "fmt"
- ethereum_rpc "github.com/ethereum/go-ethereum/rpc"
- "github.com/harmony-one/go-sdk/pkg/account"
- "github.com/harmony-one/go-sdk/pkg/address"
- "github.com/harmony-one/go-sdk/pkg/common"
- "github.com/harmony-one/go-sdk/pkg/console/jsre"
- "github.com/harmony-one/go-sdk/pkg/console/jsre/deps"
- "github.com/harmony-one/go-sdk/pkg/console/prompt"
- "github.com/harmony-one/go-sdk/pkg/console/web3ext"
- "github.com/harmony-one/go-sdk/pkg/rpc"
- "github.com/harmony-one/go-sdk/pkg/store"
- "github.com/harmony-one/go-sdk/pkg/transaction"
- "github.com/harmony-one/harmony/accounts"
  "io"
  "io/ioutil"
  "math/big"
@@ -29,6 +17,19 @@ import (
  "syscall"
  "time"
 
+ ethereum_rpc "github.com/ethereum/go-ethereum/rpc"
+ "github.com/harmony-one/go-sdk/pkg/account"
+ "github.com/harmony-one/go-sdk/pkg/address"
+ "github.com/harmony-one/go-sdk/pkg/common"
+ "github.com/harmony-one/go-sdk/pkg/console/jsre"
+ "github.com/harmony-one/go-sdk/pkg/console/jsre/deps"
+ "github.com/harmony-one/go-sdk/pkg/console/prompt"
+ "github.com/harmony-one/go-sdk/pkg/console/web3ext"
+ "github.com/harmony-one/go-sdk/pkg/rpc"
+ "github.com/harmony-one/go-sdk/pkg/store"
+ "github.com/harmony-one/go-sdk/pkg/transaction"
+ "github.com/harmony-one/harmony/accounts"
+
  "github.com/dop251/goja"
  "github.com/mattn/go-colorable"
  "github.com/peterh/liner"
@@ -553,6 +554,10 @@ func (b *bridge) HmySignTransaction(call jsre.Call) (goja.Value, error) {
  gasLimit := getStringFromJsObjWithDefault(txObj, "gas", "1000000")
  amount := getStringFromJsObjWithDefault(txObj, "value", "0")
  gasPrice := getStringFromJsObjWithDefault(txObj, "gasPrice", "1")
+ input, err := transaction.StringToByte(getStringFromJsObjWithDefault(txObj, "data", ""))
+ if err != nil {
+ return nil, err
+ }
 
  networkHandler := rpc.NewHTTPHandler(b.console.nodeUrl)
  chanId, err := common.StringToChainID(b.console.net)
@@ -598,7 +603,7 @@ func (b *bridge) HmySignTransaction(call jsre.Call) (goja.Value, error) {
  toP,
  uint32(b.console.shardId), uint32(b.console.shardId),
  amt, gPrice,
- []byte{},
+ input,
  )
  if err != nil {
  return nil, err
@@ -635,6 +640,10 @@ func (b *bridge) HmySendTransaction(call jsre.Call) (goja.Value, error) {
  gasLimit := getStringFromJsObjWithDefault(txObj, "gas", "1000000")
  amount := getStringFromJsObjWithDefault(txObj, "value", "0")
  gasPrice := getStringFromJsObjWithDefault(txObj, "gasPrice", "1")
+ input, err := transaction.StringToByte(getStringFromJsObjWithDefault(txObj, "data", ""))
+ if err != nil {
+ return nil, err
+ }
 
  networkHandler := rpc.NewHTTPHandler(b.console.nodeUrl)
  chanId, err := common.StringToChainID(b.console.net)
@@ -680,7 +689,7 @@ func (b *bridge) HmySendTransaction(call jsre.Call) (goja.Value, error) {
  toP,
  uint32(b.console.shardId), uint32(b.console.shardId),
  amt, gPrice,
- []byte{},
+ input,
  )
  if err != nil {
  return nil, err

pkg/transaction/controller.go

@@ -205,7 +205,6 @@ func (C *Controller) setAmount(amount numeric.Dec) {
  return
  }
  }
-
  C.transactionForRPC.params["transfer-amount"] = amountInAtto
 }
 

pkg/transaction/ethcontroller.go

@@ -134,34 +134,37 @@ func (C *EthController) setAmount(amount numeric.Dec) {
  })
  return
  }
- balanceRPCReply, err := C.messenger.SendRPC(
- rpc.Method.GetBalance,
- p{address.ToBech32(C.sender.account.Address), "latest"},
- )
- if err != nil {
- C.executionError = err
- return
- }
- currentBalance, _ := balanceRPCReply["result"].(string)
- bal, _ := new(big.Int).SetString(currentBalance[2:], 16)
- balance := numeric.NewDecFromBigInt(bal)
+
  gasAsDec := C.transactionForRPC.params["gas-price"].(numeric.Dec)
  gasAsDec = gasAsDec.Mul(numeric.NewDec(int64(C.transactionForRPC.params["gas-limit"].(uint64))))
  amountInAtto := amount.Mul(oneAsDec)
  total := amountInAtto.Add(gasAsDec)
 
- if total.GT(balance) {
- balanceInOne := balance.Quo(oneAsDec)
- C.executionError = ErrBadTransactionParam
- errorMsg := fmt.Sprintf(
- "insufficient balance of %s in shard %d for the requested transfer of %s",
- balanceInOne.String(), C.transactionForRPC.params["from-shard"].(uint32), amount.String(),
+ if !C.Behavior.OfflineSign {
+ balanceRPCReply, err := C.messenger.SendRPC(
+ rpc.Method.GetBalance,
+ p{address.ToBech32(C.sender.account.Address), "latest"},
  )
- C.transactionErrors = append(C.transactionErrors, &Error{
- ErrMessage: &errorMsg,
- TimestampOfRejection: time.Now().Unix(),
- })
- return
+ if err != nil {
+ C.executionError = err
+ return
+ }
+ currentBalance, _ := balanceRPCReply["result"].(string)
+ bal, _ := new(big.Int).SetString(currentBalance[2:], 16)
+ balance := numeric.NewDecFromBigInt(bal)
+ if total.GT(balance) {
+ balanceInOne := balance.Quo(oneAsDec)
+ C.executionError = ErrBadTransactionParam
+ errorMsg := fmt.Sprintf(
+ "insufficient balance of %s in shard %d for the requested transfer of %s",
+ balanceInOne.String(), C.transactionForRPC.params["from-shard"].(uint32), amount.String(),
+ )
+ C.transactionErrors = append(C.transactionErrors, &Error{
+ ErrMessage: &errorMsg,
+ TimestampOfRejection: time.Now().Unix(),
+ })
+ return
+ }
  }
  C.transactionForRPC.params["transfer-amount"] = amountInAtto
 }
@@ -304,4 +307,10 @@ func (C *EthController) ExecuteEthTransaction(
  return C.executionError
 }
 
-// TODO: add logic to create staking transactions in the SDK.
+func (C *EthController) ExecuteRawTransaction(txn string) error {
+ C.transactionForRPC.signature = &txn
+
+ C.sendSignedTx()
+ C.txConfirmation()
+ return C.executionError
+}

pkg/transaction/util.go

@@ -0,0 +1,17 @@
+package transaction
+
+import (
+ "encoding/hex"
+ "fmt"
+ "strings"
+)
+
+func StringToByte(dataStr string) ([]byte, error) {
+ if len(dataStr) == 0 {
+ return []byte{}, nil
+ }
+ if !strings.HasPrefix(dataStr, "0x") {
+ return nil, fmt.Errorf("invalid data literal: %q", dataStr)
+ }
+ return hex.DecodeString(dataStr[2:])
+}