ecrecover for transactions (#498)

* ecrecover for transactions

* doc update

* change tx method to take data, not hash

* gen doc

Author: christophercampbell

cmd/ecrecover/ecrecover.go

@@ -7,11 +7,11 @@ import (
 	"math/big"
 	"os"
 
+	"github.com/0xPolygon/polygon-cli/util"
 	ethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	ethrpc "github.com/ethereum/go-ethereum/rpc"
-	"github.com/0xPolygon/polygon-cli/util"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 )
@@ -23,9 +23,10 @@ var (
 	rpcUrl      string
 	blockNumber uint64
 	filePath    string
+	txData      string
 )
 
-var EcRecoverCmd = &cobra.Command{
+var EcRecoverCmd = &cobra.Command {
 	Use:   "ecrecover",
 	Short: "Recovers and returns the public key of the signature",
 	Long:  usage,
@@ -35,11 +36,12 @@ var EcRecoverCmd = &cobra.Command{
 	},
 	Run: func(cmd *cobra.Command, args []string) {
 		ctx := cmd.Context()
+		var (
+			signerBytes []byte
+			err         error
+		)
 
-		var block *types.Block
-		var err error
-
-		if rpcUrl == "" {
+		if filePath != "" { // block signer from file
 			var blockJSON []byte
 			if filePath != "" {
 				blockJSON, err = os.ReadFile(filePath)
@@ -61,39 +63,60 @@ var EcRecoverCmd = &cobra.Command{
 				return
 			}
 
-			block = types.NewBlockWithHeader(&header)
+			block := types.NewBlockWithHeader(&header)
 			blockNumber = header.Number.Uint64()
-		} else {
+			signerBytes, err = util.Ecrecover(block)
+
+		} else if txData != "" { // transaction signer from data
+
+			txBytes := ethcommon.FromHex(txData)
+			var tx types.Transaction
+			err = tx.UnmarshalBinary(txBytes)
+			if err != nil {
+				log.Error().Err(err).Msg("Unable to decode transaction")
+				return
+			}
+			signerBytes, err = util.EcrecoverTx(&tx)
+			if err != nil {
+				log.Error().Err(err).Msg("Unable to retrieve block")
+				return
+			}
+
+		} else { // block signer block-number, requires rcp-url
+			if rpcUrl == "" {
+				log.Error().Msg("No RPC URL provided")
+				return
+			}
 			var rpc *ethrpc.Client
 			rpc, err = ethrpc.DialContext(ctx, rpcUrl)
 			if err != nil {
 				log.Error().Err(err).Msg("Unable to dial rpc")
 				return
 			}
-
 			ec := ethclient.NewClient(rpc)
+			defer ec.Close()
 
+			var block *types.Block
 			if blockNumber == 0 {
 				blockNumber, err = ec.BlockNumber(ctx)
 				if err != nil {
 					log.Error().Err(err).Msg("Unable to retrieve latest block number")
 					return
 				}
+				cmd.Println("Using latest block number:", blockNumber)
 			}
-
 			block, err = ec.BlockByNumber(ctx, big.NewInt(int64(blockNumber)))
 			if err != nil {
 				log.Error().Err(err).Msg("Unable to retrieve block")
 				return
 			}
+			signerBytes, err = util.Ecrecover(block)
 		}
 
-		signerBytes, err := util.Ecrecover(block)
 		if err != nil {
 			log.Error().Err(err).Msg("Unable to recover signature")
 			return
 		}
-		cmd.Printf("Recovering signer from block #%d\n", blockNumber)
 		cmd.Println(ethcommon.BytesToAddress(signerBytes))
 	},
 }
@@ -102,12 +125,18 @@ func init() {
 	EcRecoverCmd.PersistentFlags().StringVarP(&rpcUrl, "rpc-url", "r", "", "The RPC endpoint url")
 	EcRecoverCmd.PersistentFlags().Uint64VarP(&blockNumber, "block-number", "b", 0, "Block number to check the extra data for (default: latest)")
 	EcRecoverCmd.PersistentFlags().StringVarP(&filePath, "file", "f", "", "Path to a file containing block information in JSON format")
+	EcRecoverCmd.PersistentFlags().StringVarP(&txData, "tx", "t", "", "Transaction data in hex format")
+
+	// The sources of decoding are mutually exclusive
+	EcRecoverCmd.MarkFlagsMutuallyExclusive("file", "block-number", "tx")
 }
 
-func checkFlags() (err error) {
-	if rpcUrl != "" && util.ValidateUrl(rpcUrl) != nil {
-		return
+func checkFlags() error {
+	var err error
+	if rpcUrl != "" {
+		if err = util.ValidateUrl(rpcUrl); err != nil {
+			return err
+		}
 	}
-
-	return nil
+	return err
 }

doc/polycli_ecrecover.md

@@ -48,6 +48,7 @@ JSON Data passed in follows object definition [here](https://www.quicknode.com/d
   -f, --file string         Path to a file containing block information in JSON format
   -h, --help                help for ecrecover
   -r, --rpc-url string      The RPC endpoint url
+  -t, --tx string           Transaction data in hex format
 ```
 
 The command also inherits flags from parent commands.

util/util.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
-	"reflect"
 
 	"github.com/cenkalti/backoff"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -50,6 +50,16 @@ func Ecrecover(block *types.Block) ([]byte, error) {
 	return signer, nil
 }
 
+func EcrecoverTx(tx *types.Transaction) ([]byte, error) {
+	chainID := tx.ChainId()
+	signer := types.LatestSignerForChainID(chainID)
+	from, err := types.Sender(signer, tx)
+	if err != nil {
+		return nil, err
+	}
+	return from.Bytes(), nil
+}
+
 func GetBlockRange(ctx context.Context, from, to uint64, c *ethrpc.Client) ([]*json.RawMessage, error) {
 	blms := make([]ethrpc.BatchElem, 0)
 	for i := from; i <= to; i = i + 1 {