use rpc to create token asset tx

plugin/dapp/token/commands/token.go

@@ -7,6 +7,7 @@ package commands
 import (
 	"encoding/json"
 	"fmt"
+	"math"
 	"os"
 	"strconv"
 	"strings"
@@ -75,12 +76,27 @@ func createTokenTransfer(cmd *cobra.Command, args []string) {
 	amount, _ := cmd.Flags().GetFloat64("amount")
 	note, _ := cmd.Flags().GetString("note")
 	symbol, _ := cmd.Flags().GetString("symbol")
-	txHex, err := CreateRawTx(cmd, toAddr, amount, note, false, symbol, "")
+
+	payload := &types.AssetsTransfer{
+		To:        toAddr,
+		Amount:    int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4,
+		Note:      []byte(note),
+		Cointoken: symbol,
+	}
+	data, err := json.Marshal(&payload)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
-	fmt.Println(txHex)
+	params := &rpctypes.CreateTxIn{
+		Execer:     types.ExecName(tokenty.TokenX),
+		ActionName: "Transfer",
+		Payload:    data,
+	}
+
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.CreateTransaction", params, nil)
+	ctx.RunWithoutMarshal()
 }
 
 // CreateTokenTransferCmd create raw transfer tx
@@ -108,16 +124,41 @@ func addCreateTokenSendToExecFlags(cmd *cobra.Command) {
 }
 
 func createTokenSendToExec(cmd *cobra.Command, args []string) {
+	paraName, _ := cmd.Flags().GetString("paraName")
 	exec, _ := cmd.Flags().GetString("exec")
+	exec = getRealExecName(paraName, exec)
+	to, err := GetExecAddr(exec)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+
 	amount, _ := cmd.Flags().GetFloat64("amount")
 	note, _ := cmd.Flags().GetString("note")
 	symbol, _ := cmd.Flags().GetString("symbol")
-	txHex, err := CreateRawTx(cmd, "", amount, note, false, symbol, exec)
+
+	payload := &types.AssetsTransferToExec{
+		To:        to,
+		Amount:    int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4,
+		Note:      []byte(note),
+		Cointoken: symbol,
+		ExecName:  exec,
+	}
+
+	data, err := json.Marshal(&payload)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
-	fmt.Println(txHex)
+	params := &rpctypes.CreateTxIn{
+		Execer:     types.ExecName(tokenty.TokenX),
+		ActionName: "TransferToExec",
+		Payload:    data,
+	}
+
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.CreateTransaction", params, nil)
+	ctx.RunWithoutMarshal()
 }
 
 // CreateTokenWithdrawCmd create raw withdraw tx
@@ -151,17 +192,34 @@ func createTokenWithdraw(cmd *cobra.Command, args []string) {
 	amount, _ := cmd.Flags().GetFloat64("amount")
 	note, _ := cmd.Flags().GetString("note")
 	symbol, _ := cmd.Flags().GetString("symbol")
+
+	exec = getRealExecName(paraName, exec)
 	execAddr, err := GetExecAddr(exec)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
-	txHex, err := CreateRawTx(cmd, execAddr, amount, note, true, symbol, exec)
+	payload := &types.AssetsWithdraw{
+		To:        execAddr,
+		Amount:    int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4,
+		Note:      []byte(note),
+		Cointoken: symbol,
+		ExecName:  exec,
+	}
+	data, err := json.Marshal(&payload)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
-	fmt.Println(txHex)
+	params := &rpctypes.CreateTxIn{
+		Execer:     types.ExecName(tokenty.TokenX),
+		ActionName: "Withdraw",
+		Payload:    data,
+	}
+
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.CreateTransaction", params, nil)
+	ctx.RunWithoutMarshal()
 }
 
 // GetTokensPreCreatedCmd get precreated tokens

plugin/dapp/token/commands/utils.go

@@ -5,70 +5,12 @@
 package commands
 
 import (
-	"encoding/hex"
-	"fmt"
-	"math"
-	"os"
 	"strings"
 
 	"github.com/33cn/chain33/common/address"
 	"github.com/33cn/chain33/types"
-	tokenty "github.com/33cn/plugin/plugin/dapp/token/types"
-	"github.com/spf13/cobra"
 )
 
-// CreateRawTx 创建交易
-// 主链交易使用 Transaction 的 To
-// 平行链使用的 payload 的 To， Transaction 的 To 作为执行器的合约地址
-// 在执行合约时， 有GetRealTo 用来读取这个项
-// 在命令行中， 参数需要加前缀才是对的
-// 在平行链上 执行器地址注册不带前缀， withdraw To地址有前缀， 算出来不一致
-func CreateRawTx(cmd *cobra.Command, to string, amount float64, note string, isWithdraw bool, tokenSymbol, execName string) (string, error) {
-	if amount < 0 {
-		return "", types.ErrAmount
-	}
-	paraName, _ := cmd.Flags().GetString("paraName")
-	amountInt64 := int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4
-	var tx *types.Transaction
-	transfer := &tokenty.TokenAction{}
-	if isWithdraw {
-		v := &tokenty.TokenAction_Withdraw{Withdraw: &types.AssetsWithdraw{Cointoken: tokenSymbol, Amount: amountInt64,
-			Note: []byte(note), To: to, ExecName: getRealExecName(paraName, execName)}}
-		transfer.Value = v
-		transfer.Ty = tokenty.ActionWithdraw
-	} else if execName != "" {
-		execName = getRealExecName(paraName, execName)
-		if execName != "" && !types.IsAllowExecName([]byte(execName), []byte(execName)) {
-			return "", types.ErrExecNameNotMatch
-		}
-		to, err := GetExecAddr(execName)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			return "", err
-		}
-		v := &tokenty.TokenAction_TransferToExec{TransferToExec: &types.AssetsTransferToExec{Cointoken: tokenSymbol,
-			Amount: amountInt64, Note: []byte(note), ExecName: execName, To: to}}
-		transfer.Value = v
-		transfer.Ty = tokenty.TokenActionTransferToExec
-	} else {
-		v := &tokenty.TokenAction_Transfer{Transfer: &types.AssetsTransfer{Cointoken: tokenSymbol, Amount: amountInt64, Note: []byte(note), To: to}}
-		transfer.Value = v
-		transfer.Ty = tokenty.ActionTransfer
-	}
-	execer := []byte(getRealExecName(paraName, "token"))
-	if paraName == "" {
-		tx = &types.Transaction{Execer: execer, Payload: types.Encode(transfer), To: to}
-	} else {
-		tx = &types.Transaction{Execer: execer, Payload: types.Encode(transfer), To: address.ExecAddress(string(execer))}
-	}
-	tx, err := types.FormatTx(string(execer), tx)
-	if err != nil {
-		return "", err
-	}
-	txHex := types.Encode(tx)
-	return hex.EncodeToString(txHex), nil
-}
-
 // GetExecAddr 获取执行器地址
 func GetExecAddr(exec string) (string, error) {
 	if ok := types.IsAllowExecName([]byte(exec), []byte(exec)); !ok {