mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

DRY up the use of fromHex and put it in ethutil

Browse Source
pull/481/head
Maran 10 years ago
parent b927c29469
commit 991993357c
10 changed files with 75 additions and 90 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 13
      ethutil/common.go
  2. 21
      ethutil/common_test.go
  3. 14
      rpc/api.go
  4. 13
      rpc/util.go
  5. 25
      rpc/util_test.go
  6. 18
      ui/qt/qwhisper/whisper.go
  7. 11
      xeth/state.go
  8. 11
      xeth/types.go
  9. 13
      xeth/whisper.go
  10. 26
      xeth/xeth.go

13
ethutil/common.go
Unescape View File

@ -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"
}

21
ethutil/common_test.go
Unescape View File

@ -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)
}
}

14
rpc/api.go
Unescape View File

@ -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

13
rpc/util.go
Unescape View File

@ -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())
}

25
rpc/util_test.go
Unescape View File

@ -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)
}
}

18
ui/qt/qwhisper/whisper.go
Unescape View File

@ -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

11
xeth/state.go
Unescape View File

@ -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

11
xeth/types.go
Unescape View File

@ -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
}

13
xeth/whisper.go
Unescape View File

@ -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)),
From: crypto.ToECDSAPub(fromHex(opts.From)),
To: crypto.ToECDSAPub(ethutil.FromHex(opts.To)),
From: crypto.ToECDSAPub(ethutil.FromHex(opts.From)),
Topics: whisper.TopicsFromString(opts.Topics...),
}

26
xeth/xeth.go
Unescape View File

@ -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)),
to: fromHex(toStr),
from: statedb.GetOrNewStateObject(ethutil.FromHex(fromStr)),
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)
data = fromHex(codeStr)
to = fromHex(toStr)
from = ethutil.FromHex(fromStr)
data = ethutil.FromHex(codeStr)
to = ethutil.FromHex(toStr)
if len(to) == 0 {
contractCreation = true
}

Write Preview
Loading…
Cancel
Save