DRY up the use of fromHex and put it in ethutil

ethutil/common.go

@@ -64,6 +64,19 @@ func DefaultDataDir() string {
 		return path.Join(usr.HomeDir, ".ethereum")
 	}
 }
+
+func FromHex(s string) []byte {
+	if len(s) > 1 {
+		if s[0:2] == "0x" {
+			s = s[2:]
+		}
+		if len(s)%2 == 1 {
+			s = "0" + s
+		}
+		return Hex2Bytes(s)
+	}
+	return nil
+}
 func IsWindows() bool {
 	return runtime.GOOS == "windows"
 }

ethutil/common_test.go

@@ -1,8 +1,10 @@
 package ethutil
 
 import (
+	"bytes"
 	"math/big"
 	"os"
+	"testing"
 
 	checker "gopkg.in/check.v1"
 )
@@ -66,3 +68,22 @@ func (s *CommonSuite) TestLarge(c *checker.C) {
 	c.Assert(adalarge, checker.Equals, "10000E7 Einstein")
 	c.Assert(weilarge, checker.Equals, "100 Babbage")
 }
+
+//fromHex
+func TestFromHex(t *testing.T) {
+	input := "0x01"
+	expected := []byte{1}
+	result := FromHex(input)
+	if bytes.Compare(expected, result) != 0 {
+		t.Errorf("Expected % x got % x", expected, result)
+	}
+}
+
+func TestFromHexOddLength(t *testing.T) {
+	input := "0x1"
+	expected := []byte{1}
+	result := FromHex(input)
+	if bytes.Compare(expected, result) != 0 {
+		t.Errorf("Expected % x got % x", expected, result)
+	}
+}

rpc/api.go

@@ -241,7 +241,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) (err error)
 	//	p.register[args.From] = append(p.register[args.From], args)
 	//} else {
 	/*
-		account := accounts.Get(fromHex(args.From))
+		account := accounts.Get(ethutil.FromHex(args.From))
 		if account != nil {
 			if account.Unlocked() {
 				if !unlockAccount(account) {
@@ -249,7 +249,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) (err error)
 				}
 			}
 
-			result, _ := account.Transact(fromHex(args.To), fromHex(args.Value), fromHex(args.Gas), fromHex(args.GasPrice), fromHex(args.Data))
+			result, _ := account.Transact(ethutil.FromHex(args.To), ethutil.FromHex(args.Value), ethutil.FromHex(args.Gas), ethutil.FromHex(args.GasPrice), ethutil.FromHex(args.Data))
 			if len(result) > 0 {
 				*reply = toHex(result)
 			}
@@ -480,7 +480,7 @@ func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error
 		if err := json.Unmarshal(req.Params, &args); err != nil {
 			return err
 		}
-		*reply = toHex(crypto.Sha3(fromHex(args.Data)))
+		*reply = toHex(crypto.Sha3(ethutil.FromHex(args.Data)))
 	case "web3_clientVersion":
 		*reply = p.xeth().Backend().Version()
 	case "net_version":
@@ -815,12 +815,12 @@ func toFilterOptions(options *FilterOptions) core.FilterOptions {
 
 	// Convert optional address slice/string to byte slice
 	if str, ok := options.Address.(string); ok {
-		opts.Address = [][]byte{fromHex(str)}
+		opts.Address = [][]byte{ethutil.FromHex(str)}
 	} else if slice, ok := options.Address.([]interface{}); ok {
 		bslice := make([][]byte, len(slice))
 		for i, addr := range slice {
 			if saddr, ok := addr.(string); ok {
-				bslice[i] = fromHex(saddr)
+				bslice[i] = ethutil.FromHex(saddr)
 			}
 		}
 		opts.Address = bslice
@@ -834,11 +834,11 @@ func toFilterOptions(options *FilterOptions) core.FilterOptions {
 		if slice, ok := topicDat.([]interface{}); ok {
 			topics[i] = make([][]byte, len(slice))
 			for j, topic := range slice {
-				topics[i][j] = fromHex(topic.(string))
+				topics[i][j] = ethutil.FromHex(topic.(string))
 			}
 		} else if str, ok := topicDat.(string); ok {
 			topics[i] = make([][]byte, 1)
-			topics[i][0] = fromHex(str)
+			topics[i][0] = ethutil.FromHex(str)
 		}
 	}
 	opts.Topics = topics

rpc/util.go

@@ -128,19 +128,6 @@ func toHex(b []byte) string {
 	return "0x" + hex
 }
 
-func fromHex(s string) []byte {
-	if len(s) > 1 {
-		if s[0:2] == "0x" {
-			s = s[2:]
-		}
-		if len(s)%2 == 1 {
-			s = "0" + s
-		}
-		return ethutil.Hex2Bytes(s)
-	}
-	return nil
-}
-
 func i2hex(n int) string {
 	return toHex(big.NewInt(int64(n)).Bytes())
 }

rpc/util_test.go

@@ -1,25 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"testing"
-)
-
-//fromHex
-func TestFromHex(t *testing.T) {
-	input := "0x01"
-	expected := []byte{1}
-	result := fromHex(input)
-	if bytes.Compare(expected, result) != 0 {
-		t.Errorf("Expected % x got % x", expected, result)
-	}
-}
-
-func TestFromHexOddLength(t *testing.T) {
-	input := "0x1"
-	expected := []byte{1}
-	result := fromHex(input)
-	if bytes.Compare(expected, result) != 0 {
-		t.Errorf("Expected % x got % x", expected, result)
-	}
-}

ui/qt/qwhisper/whisper.go

@@ -13,12 +13,6 @@ import (
 
 var qlogger = logger.NewLogger("QSHH")
 
-func fromHex(s string) []byte {
-	if len(s) > 1 {
-		return ethutil.Hex2Bytes(s[2:])
-	}
-	return nil
-}
 func toHex(b []byte) string { return "0x" + ethutil.Bytes2Hex(b) }
 
 type Whisper struct {
@@ -39,15 +33,15 @@ func (self *Whisper) SetView(view qml.Object) {
 func (self *Whisper) Post(payload []string, to, from string, topics []string, priority, ttl uint32) {
 	var data []byte
 	for _, d := range payload {
-		data = append(data, fromHex(d)...)
+		data = append(data, ethutil.FromHex(d)...)
 	}
 
-	pk := crypto.ToECDSAPub(fromHex(from))
+	pk := crypto.ToECDSAPub(ethutil.FromHex(from))
 	if key := self.Whisper.GetIdentity(pk); key != nil {
 		msg := whisper.NewMessage(data)
 		envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
 			Ttl:    time.Duration(ttl) * time.Second,
-			To:     crypto.ToECDSAPub(fromHex(to)),
+			To:     crypto.ToECDSAPub(ethutil.FromHex(to)),
 			From:   key,
 			Topics: whisper.TopicsFromString(topics...),
 		})
@@ -76,7 +70,7 @@ func (self *Whisper) NewIdentity() string {
 }
 
 func (self *Whisper) HasIdentity(key string) bool {
-	return self.Whisper.HasIdentity(crypto.ToECDSAPub(fromHex(key)))
+	return self.Whisper.HasIdentity(crypto.ToECDSAPub(ethutil.FromHex(key)))
 }
 
 func (self *Whisper) Watch(opts map[string]interface{}, view *qml.Common) int {
@@ -106,10 +100,10 @@ func (self *Whisper) Messages(id int) (messages *ethutil.List) {
 
 func filterFromMap(opts map[string]interface{}) (f whisper.Filter) {
 	if to, ok := opts["to"].(string); ok {
-		f.To = crypto.ToECDSAPub(fromHex(to))
+		f.To = crypto.ToECDSAPub(ethutil.FromHex(to))
 	}
 	if from, ok := opts["from"].(string); ok {
-		f.From = crypto.ToECDSAPub(fromHex(from))
+		f.From = crypto.ToECDSAPub(ethutil.FromHex(from))
 	}
 	if topicList, ok := opts["topics"].(*qml.List); ok {
 		var topics []string

xeth/state.go

@@ -1,6 +1,9 @@
 package xeth
 
-import "github.com/ethereum/go-ethereum/state"
+import (
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
+)
 
 type State struct {
 	xeth  *XEth
@@ -16,7 +19,7 @@ func (self *State) State() *state.StateDB {
 }
 
 func (self *State) Get(addr string) *Object {
-	return &Object{self.state.GetStateObject(fromHex(addr))}
+	return &Object{self.state.GetStateObject(ethutil.FromHex(addr))}
 }
 
 func (self *State) SafeGet(addr string) *Object {
@@ -24,9 +27,9 @@ func (self *State) SafeGet(addr string) *Object {
 }
 
 func (self *State) safeGet(addr string) *state.StateObject {
-	object := self.state.GetStateObject(fromHex(addr))
+	object := self.state.GetStateObject(ethutil.FromHex(addr))
 	if object == nil {
-		object = state.NewStateObject(fromHex(addr), self.xeth.eth.StateDb())
+		object = state.NewStateObject(ethutil.FromHex(addr), self.xeth.eth.StateDb())
 	}
 
 	return object

xeth/types.go

@@ -17,15 +17,6 @@ import (
 func toHex(b []byte) string {
 	return "0x" + ethutil.Bytes2Hex(b)
 }
-func fromHex(s string) []byte {
-	if len(s) > 1 {
-		if s[0:2] == "0x" {
-			s = s[2:]
-		}
-		return ethutil.Hex2Bytes(s)
-	}
-	return nil
-}
 
 type Object struct {
 	*state.StateObject
@@ -123,7 +114,7 @@ func (self *Block) ToString() string {
 }
 
 func (self *Block) GetTransaction(hash string) *Transaction {
-	tx := self.ref.Transaction(fromHex(hash))
+	tx := self.ref.Transaction(ethutil.FromHex(hash))
 	if tx == nil {
 		return nil
 	}

xeth/whisper.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/whisper"
 )
@@ -28,12 +29,12 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio
 		ttl = 100
 	}
 
-	pk := crypto.ToECDSAPub(fromHex(from))
+	pk := crypto.ToECDSAPub(ethutil.FromHex(from))
 	if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 {
-		msg := whisper.NewMessage(fromHex(payload))
+		msg := whisper.NewMessage(ethutil.FromHex(payload))
 		envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
 			Ttl:    time.Duration(ttl) * time.Second,
-			To:     crypto.ToECDSAPub(fromHex(to)),
+			To:     crypto.ToECDSAPub(ethutil.FromHex(to)),
 			From:   key,
 			Topics: whisper.TopicsFromString(topics...),
 		})
@@ -59,13 +60,13 @@ func (self *Whisper) NewIdentity() string {
 }
 
 func (self *Whisper) HasIdentity(key string) bool {
-	return self.Whisper.HasIdentity(crypto.ToECDSAPub(fromHex(key)))
+	return self.Whisper.HasIdentity(crypto.ToECDSAPub(ethutil.FromHex(key)))
 }
 
 func (self *Whisper) Watch(opts *Options) int {
 	filter := whisper.Filter{
-		To:     crypto.ToECDSAPub(fromHex(opts.To)),
+		To:     crypto.ToECDSAPub(ethutil.FromHex(opts.To)),
-		From:   crypto.ToECDSAPub(fromHex(opts.From)),
+		From:   crypto.ToECDSAPub(ethutil.FromHex(opts.From)),
 		Topics: whisper.TopicsFromString(opts.Topics...),
 	}
 

xeth/xeth.go

@@ -116,21 +116,21 @@ func (self *XEth) State() *State { return self.state }
 func (self *XEth) Whisper() *Whisper { return self.whisper }
 
 func (self *XEth) BlockByHash(strHash string) *Block {
-	hash := fromHex(strHash)
+	hash := ethutil.FromHex(strHash)
 	block := self.chainManager.GetBlock(hash)
 
 	return NewBlock(block)
 }
 
 func (self *XEth) EthBlockByHash(strHash string) *types.Block {
-	hash := fromHex(strHash)
+	hash := ethutil.FromHex(strHash)
 	block := self.chainManager.GetBlock(hash)
 
 	return block
 }
 
 func (self *XEth) EthTransactionByHash(hash string) *types.Transaction {
-	data, _ := self.eth.ExtraDb().Get(fromHex(hash))
+	data, _ := self.eth.ExtraDb().Get(ethutil.FromHex(hash))
 	if len(data) != 0 {
 		return types.NewTransactionFromBytes(data)
 	}
@@ -233,7 +233,7 @@ func (self *XEth) IsContract(address string) bool {
 }
 
 func (self *XEth) SecretToAddress(key string) string {
-	pair, err := crypto.NewKeyPairFromSec(fromHex(key))
+	pair, err := crypto.NewKeyPairFromSec(ethutil.FromHex(key))
 	if err != nil {
 		return ""
 	}
@@ -273,7 +273,7 @@ func (self *XEth) FromAscii(str string) string {
 		str = str[2:]
 	}
 
-	return string(bytes.Trim(fromHex(str), "\x00"))
+	return string(bytes.Trim(ethutil.FromHex(str), "\x00"))
 }
 
 func (self *XEth) FromNumber(str string) string {
@@ -281,11 +281,11 @@ func (self *XEth) FromNumber(str string) string {
 		str = str[2:]
 	}
 
-	return ethutil.BigD(fromHex(str)).String()
+	return ethutil.BigD(ethutil.FromHex(str)).String()
 }
 
 func (self *XEth) PushTx(encodedTx string) (string, error) {
-	tx := types.NewTransactionFromBytes(fromHex(encodedTx))
+	tx := types.NewTransactionFromBytes(ethutil.FromHex(encodedTx))
 	err := self.eth.TxPool().Add(tx)
 	if err != nil {
 		return "", err
@@ -306,12 +306,12 @@ var (
 func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
 	statedb := self.State().State() //self.chainManager.TransState()
 	msg := callmsg{
-		from:     statedb.GetOrNewStateObject(fromHex(fromStr)),
+		from:     statedb.GetOrNewStateObject(ethutil.FromHex(fromStr)),
-		to:       fromHex(toStr),
+		to:       ethutil.FromHex(toStr),
 		gas:      ethutil.Big(gasStr),
 		gasPrice: ethutil.Big(gasPriceStr),
 		value:    ethutil.Big(valueStr),
-		data:     fromHex(dataStr),
+		data:     ethutil.FromHex(dataStr),
 	}
 	if msg.gas.Cmp(big.NewInt(0)) == 0 {
 		msg.gas = defaultGas
@@ -339,9 +339,9 @@ func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeSt
 		contractCreation bool
 	)
 
-	from = fromHex(fromStr)
+	from = ethutil.FromHex(fromStr)
-	data = fromHex(codeStr)
+	data = ethutil.FromHex(codeStr)
-	to = fromHex(toStr)
+	to = ethutil.FromHex(toStr)
 	if len(to) == 0 {
 		contractCreation = true
 	}