Merge pull request #1 from bcdevtools/feat/send-evm-tx

feat: add new feature send evm legacy transfer tx

Author: 0xbcdev

README.md

@@ -71,6 +71,14 @@ devd query debug_traceTransaction [0xHash] [--tracer callTracer] [--rpc http://l
 # devd q trace 0xHash --tracer callTracer
 ```
 
+### Tx tools
+
+#### Send EVM transaction
+
+```bash
+devd tx send [to] [amount] [--rpc http://localhost:8545]
+```
+
 ### Convert tools
 
 #### Convert address between different formats

cmd/query/balance.go

@@ -18,7 +18,7 @@ func GetQueryBalanceCommand() *cobra.Command {
 		Short:   "Get ERC-20 token information. If account address is provided, it will query the balance of the account (bech32 is accepted).",
 		Args:    cobra.MinimumNArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
-			evmAddrs, err := getEvmAddressFromAnyFormatAddress(args...)
+			evmAddrs, err := utils.GetEvmAddressFromAnyFormatAddress(args...)
 			if err != nil {
 				utils.PrintlnStdErr("ERR:", err)
 				return

cmd/query/debug_traceTransaction.go

@@ -42,7 +42,7 @@ func GetQueryTraceTxCommand() *cobra.Command {
 				params = append(params, types.NewJsonRpcRawQueryParam(fmt.Sprintf(`{"tracer":"%s"}`, tracer)))
 			}
 
-			bz, err := doQuery(
+			bz, err := types.DoEvmQuery(
 				rpc,
 				types.NewJsonRpcQueryBuilder(
 					"debug_traceTransaction",

cmd/query/erc20.go

@@ -18,7 +18,7 @@ func GetQueryErc20Command() *cobra.Command {
 		Run: func(cmd *cobra.Command, args []string) {
 			ethClient8545, _ := mustGetEthClient(cmd, true)
 
-			evmAddrs, err := getEvmAddressFromAnyFormatAddress(args...)
+			evmAddrs, err := utils.GetEvmAddressFromAnyFormatAddress(args...)
 			utils.ExitOnErr(err, "failed to get evm address from input")
 
 			contextHeight := readContextHeightFromFlag(cmd)

cmd/query/eth_getBlockByNumber.go

@@ -56,7 +56,7 @@ func GetQueryBlockCommand() *cobra.Command {
 				paramBlockNumber = types.NewJsonRpcInt64QueryParam(blockNumber.Int64())
 			}
 
-			bz, err := doQuery(
+			bz, err := types.DoEvmQuery(
 				rpc,
 				types.NewJsonRpcQueryBuilder(
 					"eth_getBlockByNumber",

cmd/query/evm.go

@@ -1,100 +1,17 @@
 package query
 
 import (
-	"bytes"
 	"context"
-	"encoding/hex"
 	"fmt"
-	"github.com/bcdevtools/devd/v2/cmd/types"
 	"github.com/bcdevtools/devd/v2/cmd/utils"
 	"github.com/bcdevtools/devd/v2/constants"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"io"
 	"math/big"
-	"net/http"
 	"os"
-	"regexp"
 	"strings"
-	"time"
 )
 
-const generalQueryTimeout = 3 * time.Second
-
-func doQuery(host string, qb types.JsonRpcQueryBuilder, optionalTimeout time.Duration) ([]byte, error) {
-	var timeout = optionalTimeout
-	if optionalTimeout == 0 {
-		timeout = generalQueryTimeout
-	}
-	if timeout < time.Second {
-		timeout = time.Second
-	}
-
-	httpClient := http.Client{
-		Timeout: timeout,
-	}
-
-	fmt.Println("Querying", host, strings.ReplaceAll(strings.ReplaceAll(qb.String(), "\n", " "), " ", ""))
-
-	resp, err := httpClient.Post(host, "application/json", bytes.NewBuffer([]byte(qb.String())))
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("non-OK status code: %d", resp.StatusCode)
-	}
-
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-
-	bz, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read response body")
-	}
-
-	return bz, nil
-}
-
-func getEvmAddressFromAnyFormatAddress(addrs ...string) (evmAddrs []common.Address, err error) {
-	for _, addr := range addrs {
-		normalizedAddr := strings.ToLower(addr)
-
-		if regexp.MustCompile(`^(0x)?[a-f\d]{40}$`).MatchString(normalizedAddr) {
-			evmAddrs = append(evmAddrs, common.HexToAddress(normalizedAddr))
-		} else if regexp.MustCompile(`^(0x)?[a-f\d]{64}$`).MatchString(normalizedAddr) {
-			err = fmt.Errorf("ERR: invalid address format: %s", normalizedAddr)
-			return
-		} else { // bech32
-			spl := strings.Split(normalizedAddr, "1")
-			if len(spl) != 2 || len(spl[0]) < 1 || len(spl[1]) < 1 {
-				err = fmt.Errorf("ERR: invalid bech32 address: %s", normalizedAddr)
-				return
-			}
-
-			var bz []byte
-			bz, err = sdk.GetFromBech32(normalizedAddr, spl[0])
-			if err != nil {
-				err = fmt.Errorf("ERR: failed to decode bech32 address %s: %s", normalizedAddr, err)
-				return
-			}
-
-			if len(bz) != 20 {
-				err = fmt.Errorf("ERR: bech32 address %s has invalid length, must be 20 bytes, got %s %d bytes", normalizedAddr, hex.EncodeToString(bz), len(bz))
-				return
-			}
-
-			evmAddrs = append(evmAddrs, common.BytesToAddress(bz))
-		}
-	}
-
-	return
-}
-
 func mustGetEthClient(cmd *cobra.Command, fallbackDeprecatedFlagHost bool) (ethClient8545 *ethclient.Client, rpc string) {
 	var inputSource string
 	var err error

cmd/root.go

@@ -7,6 +7,7 @@ import (
 	"github.com/bcdevtools/devd/v2/cmd/debug"
 	"github.com/bcdevtools/devd/v2/cmd/hash"
 	"github.com/bcdevtools/devd/v2/cmd/query"
+	"github.com/bcdevtools/devd/v2/cmd/tx"
 	"github.com/bcdevtools/devd/v2/cmd/types"
 	"github.com/bcdevtools/devd/v2/constants"
 	"github.com/spf13/cobra"
@@ -39,6 +40,7 @@ func init() {
 	rootCmd.AddCommand(query.Commands())
 	rootCmd.AddCommand(hash.Commands())
 	rootCmd.AddCommand(check.Commands())
+	rootCmd.AddCommand(tx.Commands())
 
 	rootCmd.PersistentFlags().Bool("help", false, "show help")
 }

cmd/tx/evm.go

@@ -0,0 +1,93 @@
+package tx
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"fmt"
+	"github.com/bcdevtools/devd/v2/cmd/utils"
+	"github.com/bcdevtools/devd/v2/constants"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/spf13/cobra"
+	"os"
+	"strings"
+)
+
+func mustGetEthClient(cmd *cobra.Command) (ethClient8545 *ethclient.Client, rpc string) {
+	var inputSource string
+	var err error
+
+	if rpcFromFlagRpc, _ := cmd.Flags().GetString(flagRpc); len(rpcFromFlagRpc) > 0 {
+		rpc = rpcFromFlagRpc
+		inputSource = "flag"
+	} else if rpcFromEnv := os.Getenv(constants.ENV_EVM_RPC); len(rpcFromEnv) > 0 {
+		rpc = rpcFromEnv
+		inputSource = "environment variable"
+	} else {
+		rpc = constants.DEFAULT_EVM_RPC
+		inputSource = "default"
+	}
+
+	utils.PrintlnStdErr("INF: Connecting to EVM Json-RPC", rpc, fmt.Sprintf("(from %s)", inputSource))
+
+	ethClient8545, err = ethclient.Dial(rpc)
+	utils.ExitOnErr(err, "failed to connect to EVM Json-RPC")
+
+	// pre-flight check to ensure the connection is working
+	_, err = ethClient8545.BlockNumber(context.Background())
+	if err != nil && strings.Contains(err.Error(), "connection refused") {
+		utils.PrintlnStdErr("ERR: failed to connect to EVM Json-RPC, please check the connection and try again.")
+		utils.PrintfStdErr("ERR: if you are using a custom EVM Json-RPC, please provide it via flag '--%s <your_custom>' or setting environment variable 'export %s=<your_custom>'.\n", flagRpc, constants.ENV_EVM_RPC)
+		os.Exit(1)
+	}
+
+	return
+}
+
+func mustSecretEvmAccount(cmd *cobra.Command) (privKey string, ecdsaPrivateKey *ecdsa.PrivateKey, ecdsaPubKey *ecdsa.PublicKey, account *common.Address) {
+	var inputSource string
+	var err error
+	var ok bool
+
+	if secretFromFlag, _ := cmd.Flags().GetString(flagSecretKey); len(secretFromFlag) > 0 {
+		privKey = secretFromFlag
+		inputSource = "flag"
+	} else if secretFromEnv := os.Getenv(constants.ENV_SECRET_KEY); len(secretFromEnv) > 0 {
+		privKey = secretFromEnv
+		inputSource = "environment variable"
+	} else {
+		utils.PrintlnStdErr("ERR: secret key is required")
+		utils.PrintfStdErr("ERR: secret key can be set by flag '--%s <your_secret_key>' or environment variable 'export %s=<your_secret_key>'.\n", flagSecretKey, constants.ENV_SECRET_KEY)
+		os.Exit(1)
+	}
+
+	privKey = strings.TrimPrefix(privKey, "0x")
+
+	pKeyBytes, err := hexutil.Decode("0x" + privKey)
+	if err != nil {
+		utils.PrintlnStdErr("ERR: failed to decode secret key")
+		os.Exit(1)
+	}
+
+	ecdsaPrivateKey, err = crypto.ToECDSA(pKeyBytes)
+	if err != nil {
+		utils.PrintlnStdErr("ERR: failed to convert secret key to ECDSA")
+		os.Exit(1)
+	}
+
+	publicKey := ecdsaPrivateKey.Public()
+	ecdsaPubKey, ok = publicKey.(*ecdsa.PublicKey)
+	if !ok {
+		utils.PrintlnStdErr("ERR: failed to convert secret public key to ECDSA")
+		os.Exit(1)
+	}
+
+	fromAddress := crypto.PubkeyToAddress(*ecdsaPubKey)
+	account = &fromAddress
+
+	fmt.Println("Account Address:", account.Hex(), "(from", inputSource, ")")
+
+	return
+}

cmd/tx/root.go

@@ -0,0 +1,30 @@
+package tx
+
+import (
+	"github.com/bcdevtools/devd/v2/constants"
+	"github.com/spf13/cobra"
+)
+
+const (
+	flagRpc       = "rpc"
+	flagSecretKey = "secret-key"
+)
+
+const (
+	flagEvmRpcDesc    = "EVM Json-RPC endpoint, default is " + constants.DEFAULT_EVM_RPC + ", can be set by environment variable " + constants.ENV_EVM_RPC
+	flagSecretKeyDesc = "Secret key of the account, can be set by environment variable " + constants.ENV_SECRET_KEY
+)
+
+// Commands registers a sub-tree of commands
+func Commands() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "tx",
+		Short: "Tx commands",
+	}
+
+	cmd.AddCommand(
+		GetSendEvmTxCommand(),
+	)
+
+	return cmd
+}

cmd/tx/send.go

@@ -0,0 +1,72 @@
+package tx
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"github.com/bcdevtools/devd/v2/cmd/utils"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/spf13/cobra"
+	"math/big"
+)
+
+func GetSendEvmTxCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "send [to] [amount]",
+		Short: "Send some token to an address via EVM transfer",
+		Args:  cobra.ExactArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			ethClient8545, _ := mustGetEthClient(cmd)
+
+			evmAddrs, err := utils.GetEvmAddressFromAnyFormatAddress(args[0])
+			utils.ExitOnErr(err, "failed to get evm address from input")
+
+			receiverAddr := evmAddrs[0]
+			amount, ok := new(big.Int).SetString(args[1], 10)
+			if !ok {
+				utils.ExitOnErr(fmt.Errorf("invalid amount %s", args[1]), "failed to parse amount")
+			}
+			display, _, _, err := utils.ConvertNumberIntoDisplayWithExponent(amount, 18)
+			utils.ExitOnErr(err, "failed to convert amount into display with exponent")
+
+			_, ecdsaPrivateKey, _, from := mustSecretEvmAccount(cmd)
+
+			nonce, err := ethClient8545.NonceAt(context.Background(), *from, nil)
+			utils.ExitOnErr(err, "failed to get nonce of sender")
+
+			chainId, err := ethClient8545.ChainID(context.Background())
+			utils.ExitOnErr(err, "failed to get chain ID")
+
+			txData := ethtypes.LegacyTx{
+				Nonce:    nonce,
+				GasPrice: big.NewInt(20_000_000_000),
+				Gas:      21000,
+				To:       &receiverAddr,
+				Value:    amount,
+			}
+			tx := ethtypes.NewTx(&txData)
+
+			fmt.Println("Send", display, "from", from.Hex(), "to", receiverAddr.Hex())
+			fmt.Println("EIP155 Chain ID:", chainId.String(), "and nonce", txData.Nonce)
+
+			signedTx, err := ethtypes.SignTx(tx, ethtypes.LatestSignerForChainID(chainId), ecdsaPrivateKey)
+			utils.ExitOnErr(err, "failed to sign tx")
+
+			var buf bytes.Buffer
+			err = signedTx.EncodeRLP(&buf)
+			utils.ExitOnErr(err, "failed to encode tx")
+
+			rawTxRLPHex := hex.EncodeToString(buf.Bytes())
+			fmt.Printf("RawTx: 0x%s\n", rawTxRLPHex)
+
+			err = ethClient8545.SendTransaction(context.Background(), signedTx)
+			utils.ExitOnErr(err, "failed to send tx")
+		},
+	}
+
+	cmd.Flags().String(flagRpc, "", flagEvmRpcDesc)
+	cmd.Flags().String(flagSecretKey, "", flagSecretKeyDesc)
+
+	return cmd
+}