From b5234413611ce5984292f85a01de1f56c045b490 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 16 Mar 2015 11:27:38 +0100 Subject: [PATCH] Moved ethutil => common --- .../src/github.com/ethereum/ethash/ethash.go | 6 +- accounts/abi/numbers.go | 10 +- accounts/abi/type.go | 10 +- blockpool/blockpool_test.go | 8 +- blockpool/blockpool_util_test.go | 4 +- blockpool/peers.go | 6 +- cmd/disasm/main.go | 4 +- cmd/ethereum/blocktest.go | 4 +- cmd/ethereum/js.go | 6 +- cmd/ethereum/main.go | 6 +- cmd/ethtest/main.go | 32 ++--- cmd/evm/main.go | 12 +- cmd/mist/bindings.go | 14 +-- cmd/mist/gui.go | 20 ++-- cmd/mist/html_container.go | 8 +- cmd/mist/main.go | 4 +- cmd/mist/qml_container.go | 4 +- cmd/mist/ui_lib.go | 26 ++--- cmd/utils/cmd.go | 10 +- cmd/utils/flags.go | 8 +- {ethutil => common}/.gitignore | 0 {ethutil => common}/.travis.yml | 0 {ethutil => common}/README.md | 0 {ethutil => common}/big.go | 2 +- {ethutil => common}/big_test.go | 2 +- {ethutil => common}/bytes.go | 2 +- {ethutil => common}/bytes_test.go | 2 +- {ethutil => common}/common.go | 2 +- {ethutil => common}/common_test.go | 2 +- {ethutil => common}/config.go | 2 +- {ethutil => common}/db.go | 2 +- {ethutil => common}/list.go | 2 +- {ethutil => common}/main_test.go | 2 +- {ethutil => common}/math/dist.go | 4 +- {ethutil => common}/math/dist_test.go | 0 {ethutil => common}/natspec/natspec.go | 0 {ethutil => common}/natspec/natspec_js.go | 0 {ethutil => common}/natspec/natspec_test.go | 0 {ethutil => common}/number/int.go | 4 +- {ethutil => common}/number/uint_test.go | 4 +- {ethutil => common}/package.go | 2 +- {ethutil => common}/path.go | 2 +- {ethutil => common}/path_test.go | 2 +- {ethutil => common}/rlp.go | 2 +- {ethutil => common}/rlp_test.go | 2 +- {ethutil => common}/size.go | 2 +- {ethutil => common}/size_test.go | 2 +- common/types.go | 6 + {ethutil => common}/value.go | 2 +- {ethutil => common}/value_test.go | 2 +- core/asm.go | 6 +- core/block_processor.go | 12 +- core/chain_makers.go | 30 ++--- core/chain_manager.go | 36 +++--- core/genesis.go | 18 +-- core/helper_test.go | 6 +- core/manager.go | 6 +- core/state_transition.go | 8 +- core/transaction_pool.go | 6 +- core/transaction_pool_test.go | 6 +- core/types/block.go | 10 +- core/types/bloom9.go | 8 +- core/types/bloom9_test.go | 4 +- core/types/derive_sha.go | 4 +- core/types/receipt.go | 14 +-- core/types/transaction.go | 18 +-- crypto/crypto.go | 10 +- crypto/crypto_test.go | 4 +- crypto/encrypt_decrypt_test.go | 8 +- crypto/key_store_test.go | 10 +- crypto/keypair.go | 10 +- eth/backend.go | 26 ++--- eth/peer_util.go | 6 +- eth/protocol.go | 14 +-- eth/protocol_test.go | 4 +- ethdb/database.go | 4 +- ethdb/memory_database.go | 8 +- javascript/types.go | 10 +- logger/log.go | 4 +- miner/worker.go | 10 +- p2p/message.go | 4 +- p2p/server.go | 6 +- pow/dagger/dagger.go | 10 +- pow/dagger/dagger_test.go | 4 +- pow/ezp/pow.go | 6 +- rpc/api.go | 22 ++-- rpc/args.go | 42 +++---- rpc/util.go | 4 +- state/dump.go | 10 +- state/log.go | 8 +- state/managed_state_test.go | 4 +- state/state_object.go | 56 ++++----- state/state_test.go | 8 +- state/statedb.go | 16 +-- tests/blocktest.go | 4 +- tests/helper/common.go | 6 +- tests/helper/vm.go | 32 ++--- tests/vm/gh_test.go | 36 +++--- trie/hashnode.go | 4 +- trie/shortnode.go | 4 +- trie/trie.go | 16 +-- trie/trie_test.go | 22 ++-- trie/valuenode.go | 4 +- ui/qt/qwhisper/message.go | 6 +- ui/qt/qwhisper/whisper.go | 20 ++-- vm/address.go | 16 +-- vm/asm.go | 6 +- vm/common.go | 16 +-- vm/context.go | 4 +- vm/environment.go | 4 +- vm/vm.go | 110 +++++++++--------- whisper/envelope.go | 18 +-- xeth/state.go | 8 +- xeth/types.go | 30 ++--- xeth/whisper.go | 14 +-- xeth/xeth.go | 56 ++++----- 116 files changed, 610 insertions(+), 604 deletions(-) rename {ethutil => common}/.gitignore (100%) rename {ethutil => common}/.travis.yml (100%) rename {ethutil => common}/README.md (100%) rename {ethutil => common}/big.go (99%) rename {ethutil => common}/big_test.go (98%) rename {ethutil => common}/bytes.go (99%) rename {ethutil => common}/bytes_test.go (99%) rename {ethutil => common}/common.go (99%) rename {ethutil => common}/common_test.go (99%) rename {ethutil => common}/config.go (98%) rename {ethutil => common}/db.go (92%) rename {ethutil => common}/list.go (99%) rename {ethutil => common}/main_test.go (86%) rename {ethutil => common}/math/dist.go (92%) rename {ethutil => common}/math/dist_test.go (100%) rename {ethutil => common}/natspec/natspec.go (100%) rename {ethutil => common}/natspec/natspec_js.go (100%) rename {ethutil => common}/natspec/natspec_test.go (100%) rename {ethutil => common}/number/int.go (95%) rename {ethutil => common}/number/uint_test.go (94%) rename {ethutil => common}/package.go (99%) rename {ethutil => common}/path.go (98%) rename {ethutil => common}/path_test.go (98%) rename {ethutil => common}/rlp.go (99%) rename {ethutil => common}/rlp_test.go (99%) rename {ethutil => common}/size.go (94%) rename {ethutil => common}/size_test.go (96%) create mode 100644 common/types.go rename {ethutil => common}/value.go (99%) rename {ethutil => common}/value_test.go (99%) diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go index 1f615058d9..7328bc9221 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go @@ -32,7 +32,7 @@ import ( "unsafe" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow" ) @@ -337,7 +337,7 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte pow.HashRate = int64(hashes) C.ethash_full(&ret, pow.dag.dag, pow.dag.paramsAndCache.params, cMiningHash, C.uint64_t(nonce)) - result := ethutil.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32))) + result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32))) // TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining if result.Cmp(target) <= 0 { @@ -402,7 +402,7 @@ func (pow *Ethash) verify(hash []byte, mixDigest []byte, difficulty *big.Int, bl C.ethash_light(ret, pAc.cache, pAc.params, chash, cnonce) - result := ethutil.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32))) + result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32))) return result.Cmp(target) <= 0 } diff --git a/accounts/abi/numbers.go b/accounts/abi/numbers.go index 378f6541e4..9205c005e4 100644 --- a/accounts/abi/numbers.go +++ b/accounts/abi/numbers.go @@ -4,7 +4,7 @@ import ( "math/big" "reflect" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) var big_t = reflect.TypeOf(&big.Int{}) @@ -38,13 +38,13 @@ var big_ts = reflect.TypeOf([]*big.Int(nil)) // U256 will ensure unsigned 256bit on big nums func U256(n *big.Int) []byte { - return ethutil.LeftPadBytes(ethutil.U256(n).Bytes(), 32) + return common.LeftPadBytes(common.U256(n).Bytes(), 32) } func S256(n *big.Int) []byte { - sint := ethutil.S256(n) - ret := ethutil.LeftPadBytes(sint.Bytes(), 32) - if sint.Cmp(ethutil.Big0) < 0 { + sint := common.S256(n) + ret := common.LeftPadBytes(sint.Bytes(), 32) + if sint.Cmp(common.Big0) < 0 { for i, b := range ret { if b == 0 { ret[i] = 1 diff --git a/accounts/abi/type.go b/accounts/abi/type.go index b2d4abbd35..56520b6728 100644 --- a/accounts/abi/type.go +++ b/accounts/abi/type.go @@ -6,7 +6,7 @@ import ( "regexp" "strconv" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) const ( @@ -157,7 +157,7 @@ func (t Type) pack(v interface{}) ([]byte, error) { if t.Size > -1 && value.Len() > t.Size { return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size) } - return []byte(ethutil.LeftPadString(t.String(), 32)), nil + return []byte(common.LeftPadString(t.String(), 32)), nil case reflect.Slice: if t.Size > -1 && value.Len() > t.Size { return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size) @@ -165,7 +165,7 @@ func (t Type) pack(v interface{}) ([]byte, error) { // Address is a special slice. The slice acts as one rather than a list of elements. if t.T == AddressTy { - return ethutil.LeftPadBytes(v.([]byte), 32), nil + return common.LeftPadBytes(v.([]byte), 32), nil } // Signed / Unsigned check @@ -180,9 +180,9 @@ func (t Type) pack(v interface{}) ([]byte, error) { return packed, nil case reflect.Bool: if value.Bool() { - return ethutil.LeftPadBytes(ethutil.Big1.Bytes(), 32), nil + return common.LeftPadBytes(common.Big1.Bytes(), 32), nil } else { - return ethutil.LeftPadBytes(ethutil.Big0.Bytes(), 32), nil + return common.LeftPadBytes(common.Big0.Bytes(), 32), nil } } diff --git a/blockpool/blockpool_test.go b/blockpool/blockpool_test.go index bca48c6cae..411779057d 100644 --- a/blockpool/blockpool_test.go +++ b/blockpool/blockpool_test.go @@ -6,7 +6,7 @@ import ( "github.com/ethereum/go-ethereum/blockpool/test" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func TestPeerWithKnownBlock(t *testing.T) { @@ -69,9 +69,9 @@ func TestPeerPromotionByOptionalTdOnBlock(t *testing.T) { hashes := blockPoolTester.hashPool.IndexesToHashes([]int{2, 3}) peer1.waitBlocksRequests(3) blockPool.AddBlock(&types.Block{ - HeaderHash: ethutil.Bytes(hashes[1]), - ParentHeaderHash: ethutil.Bytes(hashes[0]), - Td: ethutil.Big3, + HeaderHash: common.Bytes(hashes[1]), + ParentHeaderHash: common.Bytes(hashes[0]), + Td: common.Big3, }, "peer1") blockPool.RemovePeer("peer2") diff --git a/blockpool/blockpool_util_test.go b/blockpool/blockpool_util_test.go index 8f0c8baa02..9ac996bcae 100644 --- a/blockpool/blockpool_util_test.go +++ b/blockpool/blockpool_util_test.go @@ -10,7 +10,7 @@ import ( "github.com/ethereum/go-ethereum/blockpool/test" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/errs" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/pow" ) @@ -315,7 +315,7 @@ func (self *peerTester) sendBlocks(indexes ...int) { hashes := self.hashPool.IndexesToHashes(indexes) for i := 1; i < len(hashes); i++ { fmt.Printf("adding block %v %x\n", indexes[i], hashes[i][:4]) - self.blockPool.AddBlock(&types.Block{HeaderHash: ethutil.Bytes(hashes[i]), ParentHeaderHash: ethutil.Bytes(hashes[i-1])}, self.id) + self.blockPool.AddBlock(&types.Block{HeaderHash: common.Bytes(hashes[i]), ParentHeaderHash: common.Bytes(hashes[i-1])}, self.id) } } diff --git a/blockpool/peers.go b/blockpool/peers.go index d56e270ab3..5f4889792a 100644 --- a/blockpool/peers.go +++ b/blockpool/peers.go @@ -10,7 +10,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/errs" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type peer struct { @@ -230,7 +230,7 @@ func (self *peers) addPeer( } best = true } else { - currentTD := ethutil.Big0 + currentTD := common.Big0 if self.best != nil { currentTD = self.best.td } @@ -264,7 +264,7 @@ func (self *peers) removePeer(id string) { if self.best == p { var newp *peer // FIXME: own TD - max := ethutil.Big0 + max := common.Big0 // peer with the highest self-acclaimed TD is chosen for _, pp := range self.peers { if pp.td.Cmp(max) > 0 { diff --git a/cmd/disasm/main.go b/cmd/disasm/main.go index c07246b004..5d42121b6f 100644 --- a/cmd/disasm/main.go +++ b/cmd/disasm/main.go @@ -5,7 +5,7 @@ import ( "io/ioutil" "os" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/vm" ) @@ -15,7 +15,7 @@ func main() { fmt.Println(err) os.Exit(1) } - code = ethutil.Hex2Bytes(string(code[:len(code)-1])) + code = common.Hex2Bytes(string(code[:len(code)-1])) fmt.Printf("%x\n", code) for pc := uint64(0); pc < uint64(len(code)); pc++ { diff --git a/cmd/ethereum/blocktest.go b/cmd/ethereum/blocktest.go index 1bb3809cf2..e6d701d2c8 100644 --- a/cmd/ethereum/blocktest.go +++ b/cmd/ethereum/blocktest.go @@ -7,7 +7,7 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/tests" ) @@ -41,7 +41,7 @@ func runblocktest(ctx *cli.Context) { } cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx) - cfg.NewDB = func(path string) (ethutil.Database, error) { return ethdb.NewMemDatabase() } + cfg.NewDB = func(path string) (common.Database, error) { return ethdb.NewMemDatabase() } ethereum, err := eth.New(cfg) if err != nil { utils.Fatalf("%v", err) diff --git a/cmd/ethereum/js.go b/cmd/ethereum/js.go index 3b98b588e7..a3c5f5d2d3 100644 --- a/cmd/ethereum/js.go +++ b/cmd/ethereum/js.go @@ -27,7 +27,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/javascript" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/xeth" @@ -226,7 +226,7 @@ func (self *jsre) dump(call otto.FunctionCall) otto.Value { block = self.ethereum.ChainManager().GetBlockByNumber(uint64(num)) } else if call.Argument(0).IsString() { hash, _ := call.Argument(0).ToString() - block = self.ethereum.ChainManager().GetBlock(ethutil.Hex2Bytes(hash)) + block = self.ethereum.ChainManager().GetBlock(common.Hex2Bytes(hash)) } else { fmt.Println("invalid argument for dump. Either hex string or number") } @@ -285,7 +285,7 @@ func (self *jsre) export(call otto.FunctionCall) otto.Value { data := self.ethereum.ChainManager().Export() - if err := ethutil.WriteFile(fn, data); err != nil { + if err := common.WriteFile(fn, data); err != nil { fmt.Println(err) return otto.FalseValue() } diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go index 53746627a0..1efea927fb 100644 --- a/cmd/ethereum/main.go +++ b/cmd/ethereum/main.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" "github.com/peterh/liner" @@ -200,7 +200,7 @@ func startEth(ctx *cli.Context, eth *eth.Ethereum) { } am := eth.AccountManager() // Attempt to unlock the account - err := am.Unlock(ethutil.FromHex(split[0]), split[1]) + err := am.Unlock(common.FromHex(split[0]), split[1]) if err != nil { utils.Fatalf("Unlock account failed '%v'", err) } @@ -284,7 +284,7 @@ func dump(ctx *cli.Context) { for _, arg := range ctx.Args() { var block *types.Block if hashish(arg) { - block = chainmgr.GetBlock(ethutil.Hex2Bytes(arg)) + block = chainmgr.GetBlock(common.Hex2Bytes(arg)) } else { num, _ := strconv.Atoi(arg) block = chainmgr.GetBlockByNumber(uint64(num)) diff --git a/cmd/ethtest/main.go b/cmd/ethtest/main.go index bbcde4c56a..23ae9e5250 100644 --- a/cmd/ethtest/main.go +++ b/cmd/ethtest/main.go @@ -34,7 +34,7 @@ import ( "strings" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/tests/helper" @@ -48,13 +48,13 @@ type Log struct { BloomF string `json:"bloom"` } -func (self Log) Address() []byte { return ethutil.Hex2Bytes(self.AddressF) } -func (self Log) Data() []byte { return ethutil.Hex2Bytes(self.DataF) } +func (self Log) Address() []byte { return common.Hex2Bytes(self.AddressF) } +func (self Log) Data() []byte { return common.Hex2Bytes(self.DataF) } func (self Log) RlpData() interface{} { return nil } func (self Log) Topics() [][]byte { t := make([][]byte, len(self.TopicsF)) for i, topic := range self.TopicsF { - t[i] = ethutil.Hex2Bytes(topic) + t[i] = common.Hex2Bytes(topic) } return t } @@ -66,15 +66,15 @@ type Account struct { Storage map[string]string } -func StateObjectFromAccount(db ethutil.Database, addr string, account Account) *state.StateObject { - obj := state.NewStateObject(ethutil.Hex2Bytes(addr), db) - obj.SetBalance(ethutil.Big(account.Balance)) +func StateObjectFromAccount(db common.Database, addr string, account Account) *state.StateObject { + obj := state.NewStateObject(common.Hex2Bytes(addr), db) + obj.SetBalance(common.Big(account.Balance)) - if ethutil.IsHex(account.Code) { + if common.IsHex(account.Code) { account.Code = account.Code[2:] } - obj.SetCode(ethutil.Hex2Bytes(account.Code)) - obj.SetNonce(ethutil.Big(account.Nonce).Uint64()) + obj.SetCode(common.Hex2Bytes(account.Code)) + obj.SetNonce(common.Big(account.Nonce).Uint64()) return obj } @@ -147,8 +147,8 @@ func RunVmTest(r io.Reader) (failed int) { } if len(test.Exec) == 0 { - if obj.Balance().Cmp(ethutil.Big(account.Balance)) != 0 { - fmt.Printf("FAIL: %s's : (%x) balance failed. Expected %v, got %v => %v\n", name, obj.Address()[:4], account.Balance, obj.Balance(), new(big.Int).Sub(ethutil.Big(account.Balance), obj.Balance())) + if obj.Balance().Cmp(common.Big(account.Balance)) != 0 { + fmt.Printf("FAIL: %s's : (%x) balance failed. Expected %v, got %v => %v\n", name, obj.Address()[:4], account.Balance, obj.Balance(), new(big.Int).Sub(common.Big(account.Balance), obj.Balance())) failed = 1 } } @@ -158,13 +158,13 @@ func RunVmTest(r io.Reader) (failed int) { vexp := helper.FromHex(value) if bytes.Compare(v, vexp) != 0 { - fmt.Printf("FAIL: %s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v)) + fmt.Printf("FAIL: %s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, common.BigD(vexp), common.BigD(v)) failed = 1 } } } - if !bytes.Equal(ethutil.Hex2Bytes(test.PostStateRoot), statedb.Root()) { + if !bytes.Equal(common.Hex2Bytes(test.PostStateRoot), statedb.Root()) { fmt.Printf("FAIL: %s's : Post state root error. Expected %s, got %x\n", name, test.PostStateRoot, statedb.Root()) failed = 1 } @@ -178,8 +178,8 @@ func RunVmTest(r io.Reader) (failed int) { fmt.Println("A", test.Logs) fmt.Println("B", logs) for i, log := range test.Logs { - genBloom := ethutil.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256) - if !bytes.Equal(genBloom, ethutil.Hex2Bytes(log.BloomF)) { + genBloom := common.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256) + if !bytes.Equal(genBloom, common.Hex2Bytes(log.BloomF)) { t.Errorf("bloom mismatch") } } diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 960558bb4f..af15dd4d40 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/vm" @@ -63,13 +63,13 @@ func main() { statedb := state.New(nil, db) sender := statedb.NewStateObject([]byte("sender")) receiver := statedb.NewStateObject([]byte("receiver")) - receiver.SetCode(ethutil.Hex2Bytes(*code)) + receiver.SetCode(common.Hex2Bytes(*code)) - vmenv := NewEnv(statedb, []byte("evmuser"), ethutil.Big(*value)) + vmenv := NewEnv(statedb, []byte("evmuser"), common.Big(*value)) tstart := time.Now() - ret, e := vmenv.Call(sender, receiver.Address(), ethutil.Hex2Bytes(*data), ethutil.Big(*gas), ethutil.Big(*price), ethutil.Big(*value)) + ret, e := vmenv.Call(sender, receiver.Address(), common.Hex2Bytes(*data), common.Big(*gas), common.Big(*price), common.Big(*value)) logger.Flush() if e != nil { @@ -117,11 +117,11 @@ func NewEnv(state *state.StateDB, transactor []byte, value *big.Int) *VMEnv { func (self *VMEnv) State() *state.StateDB { return self.state } func (self *VMEnv) Origin() []byte { return self.transactor } -func (self *VMEnv) BlockNumber() *big.Int { return ethutil.Big0 } +func (self *VMEnv) BlockNumber() *big.Int { return common.Big0 } func (self *VMEnv) PrevHash() []byte { return make([]byte, 32) } func (self *VMEnv) Coinbase() []byte { return self.transactor } func (self *VMEnv) Time() int64 { return self.time } -func (self *VMEnv) Difficulty() *big.Int { return ethutil.Big1 } +func (self *VMEnv) Difficulty() *big.Int { return common.Big1 } func (self *VMEnv) BlockHash() []byte { return make([]byte, 32) } func (self *VMEnv) Value() *big.Int { return self.value } func (self *VMEnv) GasLimit() *big.Int { return big.NewInt(1000000000) } diff --git a/cmd/mist/bindings.go b/cmd/mist/bindings.go index b56c0dddf5..1371c752c2 100644 --- a/cmd/mist/bindings.go +++ b/cmd/mist/bindings.go @@ -27,7 +27,7 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -39,13 +39,13 @@ type plugin struct { func (gui *Gui) Transact(from, recipient, value, gas, gasPrice, d string) (string, error) { var data string if len(recipient) == 0 { - code, err := ethutil.Compile(d, false) + code, err := common.Compile(d, false) if err != nil { return "", err } - data = ethutil.Bytes2Hex(code) + data = common.Bytes2Hex(code) } else { - data = ethutil.Bytes2Hex(utils.FormatTransactionData(d)) + data = common.Bytes2Hex(utils.FormatTransactionData(d)) } return gui.xeth.Transact(from, recipient, value, gas, gasPrice, data) @@ -55,14 +55,14 @@ func (self *Gui) AddPlugin(pluginPath string) { self.plugins[pluginPath] = plugin{Name: pluginPath, Path: pluginPath} json, _ := json.MarshalIndent(self.plugins, "", " ") - ethutil.WriteFile(self.eth.DataDir+"/plugins.json", json) + common.WriteFile(self.eth.DataDir+"/plugins.json", json) } func (self *Gui) RemovePlugin(pluginPath string) { delete(self.plugins, pluginPath) json, _ := json.MarshalIndent(self.plugins, "", " ") - ethutil.WriteFile(self.eth.DataDir+"/plugins.json", json) + common.WriteFile(self.eth.DataDir+"/plugins.json", json) } func (self *Gui) DumpState(hash, path string) { @@ -76,7 +76,7 @@ func (self *Gui) DumpState(hash, path string) { i, _ := strconv.Atoi(hash[1:]) block = self.eth.ChainManager().GetBlockByNumber(uint64(i)) } else { - block = self.eth.ChainManager().GetBlock(ethutil.Hex2Bytes(hash)) + block = self.eth.ChainManager().GetBlock(common.Hex2Bytes(hash)) } if block == nil { diff --git a/cmd/mist/gui.go b/cmd/mist/gui.go index a49e9f6f82..476b441c87 100644 --- a/cmd/mist/gui.go +++ b/cmd/mist/gui.go @@ -37,7 +37,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/ui/qt/qwhisper" "github.com/ethereum/go-ethereum/xeth" @@ -93,7 +93,7 @@ func NewWindow(ethereum *eth.Ethereum) *Gui { plugins: make(map[string]plugin), serviceEvents: make(chan ServEv, 1), } - data, _ := ethutil.ReadAllFile(path.Join(ethereum.DataDir, "plugins.json")) + data, _ := common.ReadAllFile(path.Join(ethereum.DataDir, "plugins.json")) json.Unmarshal([]byte(data), &gui.plugins) return gui @@ -200,7 +200,7 @@ func (gui *Gui) loadAddressBook() { it := nameReg.Trie().Iterator() for it.Next() { if it.Key[0] != 0 { - view.Call("addAddress", struct{ Name, Address string }{string(it.Key), ethutil.Bytes2Hex(it.Value)}) + view.Call("addAddress", struct{ Name, Address string }{string(it.Key), common.Bytes2Hex(it.Value)}) } } @@ -221,7 +221,7 @@ func (self *Gui) loadMergedMiningOptions() { Checked bool Name, Address string Id, ItemId int - }{false, string(it.Key), ethutil.Bytes2Hex(it.Value), 0, i}) + }{false, string(it.Key), common.Bytes2Hex(it.Value), 0, i}) i++ @@ -240,8 +240,8 @@ func (gui *Gui) insertTransaction(window string, tx *types.Transaction) { var ( ptx = xeth.NewTx(tx) - send = ethutil.Bytes2Hex(tx.From()) - rec = ethutil.Bytes2Hex(tx.To()) + send = common.Bytes2Hex(tx.From()) + rec = common.Bytes2Hex(tx.To()) ) ptx.Sender = send ptx.Address = rec @@ -265,7 +265,7 @@ func (gui *Gui) readPreviousTransactions() { } func (gui *Gui) processBlock(block *types.Block, initial bool) { - name := ethutil.Bytes2Hex(block.Coinbase()) + name := common.Bytes2Hex(block.Coinbase()) b := xeth.NewBlock(block) b.Name = name @@ -279,10 +279,10 @@ func (gui *Gui) setWalletValue(amount, unconfirmedFunds *big.Int) { if unconfirmedFunds.Cmp(big.NewInt(0)) < 0 { pos = "-" } - val := ethutil.CurrencyToString(new(big.Int).Abs(ethutil.BigCopy(unconfirmedFunds))) - str = fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(amount), pos, val) + val := common.CurrencyToString(new(big.Int).Abs(common.BigCopy(unconfirmedFunds))) + str = fmt.Sprintf("%v (%s %v)", common.CurrencyToString(amount), pos, val) } else { - str = fmt.Sprintf("%v", ethutil.CurrencyToString(amount)) + str = fmt.Sprintf("%v", common.CurrencyToString(amount)) } gui.win.Root().Call("setWalletValue", str) diff --git a/cmd/mist/html_container.go b/cmd/mist/html_container.go index e4ea57b9bb..195e81073a 100644 --- a/cmd/mist/html_container.go +++ b/cmd/mist/html_container.go @@ -30,7 +30,7 @@ import ( "path/filepath" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/xeth" "github.com/howeyc/fsnotify" "github.com/obscuren/qml" @@ -62,7 +62,7 @@ func (app *HtmlApplication) Create() error { return errors.New("Ethereum package not yet supported") // TODO - //ethutil.OpenPackage(app.path) + //common.OpenPackage(app.path) } win := component.CreateWindow(nil) @@ -80,7 +80,7 @@ func (app *HtmlApplication) RootFolder() string { if err != nil { return "" } - return path.Dir(ethutil.WindonizePath(folder.RequestURI())) + return path.Dir(common.WindonizePath(folder.RequestURI())) } func (app *HtmlApplication) RecursiveFolders() []os.FileInfo { files, _ := ioutil.ReadDir(app.RootFolder()) @@ -139,7 +139,7 @@ func (app *HtmlApplication) Window() *qml.Window { } func (app *HtmlApplication) NewBlock(block *types.Block) { - b := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} + b := &xeth.Block{Number: int(block.NumberU64()), Hash: common.Bytes2Hex(block.Hash())} app.webView.Call("onNewBlockCb", b) } diff --git a/cmd/mist/main.go b/cmd/mist/main.go index 4116783c9d..256c08691d 100644 --- a/cmd/mist/main.go +++ b/cmd/mist/main.go @@ -29,7 +29,7 @@ import ( "github.com/codegangsta/cli" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/ui/qt/webengine" "github.com/obscuren/qml" @@ -45,7 +45,7 @@ var ( assetPathFlag = cli.StringFlag{ Name: "asset_path", Usage: "absolute path to GUI assets directory", - Value: ethutil.DefaultAssetPath(), + Value: common.DefaultAssetPath(), } ) diff --git a/cmd/mist/qml_container.go b/cmd/mist/qml_container.go index 16a055bc06..778ef0e40e 100644 --- a/cmd/mist/qml_container.go +++ b/cmd/mist/qml_container.go @@ -25,7 +25,7 @@ import ( "runtime" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/xeth" "github.com/obscuren/qml" ) @@ -68,7 +68,7 @@ func (app *QmlApplication) NewWatcher(quitChan chan bool) { // Events func (app *QmlApplication) NewBlock(block *types.Block) { - pblock := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())} + pblock := &xeth.Block{Number: int(block.NumberU64()), Hash: common.Bytes2Hex(block.Hash())} app.win.Call("onNewBlockCb", pblock) } diff --git a/cmd/mist/ui_lib.go b/cmd/mist/ui_lib.go index cc213b49a7..b33b812670 100644 --- a/cmd/mist/ui_lib.go +++ b/cmd/mist/ui_lib.go @@ -27,7 +27,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event/filter" "github.com/ethereum/go-ethereum/javascript" "github.com/ethereum/go-ethereum/xeth" @@ -69,7 +69,7 @@ func (self *UiLib) Notef(args []interface{}) { } func (self *UiLib) ImportTx(rlpTx string) { - tx := types.NewTransactionFromBytes(ethutil.Hex2Bytes(rlpTx)) + tx := types.NewTransactionFromBytes(common.Hex2Bytes(rlpTx)) err := self.eth.TxPool().Add(tx) if err != nil { guilogger.Infoln("import tx failed ", err) @@ -138,12 +138,12 @@ func (self *UiLib) Transact(params map[string]interface{}) (string, error) { } func (self *UiLib) Compile(code string) (string, error) { - bcode, err := ethutil.Compile(code, false) + bcode, err := common.Compile(code, false) if err != nil { return err.Error(), err } - return ethutil.Bytes2Hex(bcode), err + return common.Bytes2Hex(bcode), err } func (self *UiLib) Call(params map[string]interface{}) (string, error) { @@ -163,8 +163,8 @@ func (self *UiLib) AddLocalTransaction(to, data, gas, gasPrice, value string) in return 0 /* return self.miner.AddLocalTx(&miner.LocalTx{ - To: ethutil.Hex2Bytes(to), - Data: ethutil.Hex2Bytes(data), + To: common.Hex2Bytes(to), + Data: common.Hex2Bytes(data), Gas: gas, GasPrice: gasPrice, Value: value, @@ -187,7 +187,7 @@ func (self *UiLib) ToggleMining() bool { } func (self *UiLib) ToHex(data string) string { - return "0x" + ethutil.Bytes2Hex([]byte(data)) + return "0x" + common.Bytes2Hex([]byte(data)) } func (self *UiLib) ToAscii(data string) string { @@ -195,7 +195,7 @@ func (self *UiLib) ToAscii(data string) string { if len(data) > 1 && data[0:2] == "0x" { start = 2 } - return string(ethutil.Hex2Bytes(data[start:])) + return string(common.Hex2Bytes(data[start:])) } /// Ethereum filter methods @@ -223,7 +223,7 @@ func (self *UiLib) NewFilterString(typ string, view *qml.Common) (id int) { return 0 } -func (self *UiLib) Messages(id int) *ethutil.List { +func (self *UiLib) Messages(id int) *common.List { /* TODO remove me filter := self.filterManager.GetFilter(id) if filter != nil { @@ -233,7 +233,7 @@ func (self *UiLib) Messages(id int) *ethutil.List { } */ - return ethutil.EmptyList() + return common.EmptyList() } func (self *UiLib) ReadFile(p string) string { @@ -275,14 +275,14 @@ func mapToTxParams(object map[string]interface{}) map[string]string { } for _, str := range data { - if ethutil.IsHex(str) { + if common.IsHex(str) { str = str[2:] if len(str) != 64 { - str = ethutil.LeftPadString(str, 64) + str = common.LeftPadString(str, 64) } } else { - str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32)) + str = common.Bytes2Hex(common.LeftPadBytes(common.Big(str).Bytes(), 32)) } dataStr += str diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 6b99b841f9..74fd5334e9 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -30,7 +30,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/rlp" ) @@ -62,7 +62,7 @@ func RunInterruptCallbacks(sig os.Signal) { } func openLogFile(Datadir string, filename string) *os.File { - path := ethutil.AbsolutePath(Datadir, filename) + path := common.AbsolutePath(Datadir, filename) file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) if err != nil { panic(fmt.Sprintf("error opening log file '%s': %v", filename, err)) @@ -132,10 +132,10 @@ func StartEthereumForTest(ethereum *eth.Ethereum) { } func FormatTransactionData(data string) []byte { - d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) { + d := common.StringToByteFunc(data, func(s string) (ret []byte) { slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000) for _, dataItem := range slice { - d := ethutil.FormatData(dataItem) + d := common.FormatData(dataItem) ret = append(ret, d...) } return @@ -171,7 +171,7 @@ func ExportChain(chainmgr *core.ChainManager, fn string) error { data := chainmgr.Export() - if err := ethutil.WriteFile(fn, data); err != nil { + if err := common.WriteFile(fn, data); err != nil { return err } fmt.Printf("exported blockchain\n") diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 6bcd7e8119..95666e3c9d 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -15,7 +15,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p/nat" @@ -87,7 +87,7 @@ var ( DataDirFlag = cli.StringFlag{ Name: "datadir", Usage: "Data directory to be used", - Value: ethutil.DefaultDataDir(), + Value: common.DefaultDataDir(), } MinerThreadsFlag = cli.IntFlag{ Name: "minerthreads", @@ -193,7 +193,7 @@ func GetNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) { func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { return ð.Config{ - Name: ethutil.MakeName(clientID, version), + Name: common.MakeName(clientID, version), DataDir: ctx.GlobalString(DataDirFlag.Name), LogFile: ctx.GlobalString(LogFileFlag.Name), LogLevel: ctx.GlobalInt(LogLevelFlag.Name), @@ -211,7 +211,7 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { } } -func GetChain(ctx *cli.Context) (*core.ChainManager, ethutil.Database, ethutil.Database) { +func GetChain(ctx *cli.Context) (*core.ChainManager, common.Database, common.Database) { dataDir := ctx.GlobalString(DataDirFlag.Name) blockDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "blockchain")) if err != nil { diff --git a/ethutil/.gitignore b/common/.gitignore similarity index 100% rename from ethutil/.gitignore rename to common/.gitignore diff --git a/ethutil/.travis.yml b/common/.travis.yml similarity index 100% rename from ethutil/.travis.yml rename to common/.travis.yml diff --git a/ethutil/README.md b/common/README.md similarity index 100% rename from ethutil/README.md rename to common/README.md diff --git a/ethutil/big.go b/common/big.go similarity index 99% rename from ethutil/big.go rename to common/big.go index b77e0af8c1..750b28f85a 100644 --- a/ethutil/big.go +++ b/common/big.go @@ -1,4 +1,4 @@ -package ethutil +package common import "math/big" diff --git a/ethutil/big_test.go b/common/big_test.go similarity index 98% rename from ethutil/big_test.go rename to common/big_test.go index bf3c96c6d4..cedbaf144b 100644 --- a/ethutil/big_test.go +++ b/common/big_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/bytes.go b/common/bytes.go similarity index 99% rename from ethutil/bytes.go rename to common/bytes.go index bd294f28a7..4aef9a2235 100644 --- a/ethutil/bytes.go +++ b/common/bytes.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/bytes_test.go b/common/bytes_test.go similarity index 99% rename from ethutil/bytes_test.go rename to common/bytes_test.go index 179a8c7efb..ec106bf4bd 100644 --- a/ethutil/bytes_test.go +++ b/common/bytes_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( checker "gopkg.in/check.v1" diff --git a/ethutil/common.go b/common/common.go similarity index 99% rename from ethutil/common.go rename to common/common.go index 29854c882b..1371d18d4e 100644 --- a/ethutil/common.go +++ b/common/common.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "fmt" diff --git a/ethutil/common_test.go b/common/common_test.go similarity index 99% rename from ethutil/common_test.go rename to common/common_test.go index 20064b1e7b..c7ba87f906 100644 --- a/ethutil/common_test.go +++ b/common/common_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/config.go b/common/config.go similarity index 98% rename from ethutil/config.go rename to common/config.go index c45c310ce6..23a902bc11 100644 --- a/ethutil/config.go +++ b/common/config.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "flag" diff --git a/ethutil/db.go b/common/db.go similarity index 92% rename from ethutil/db.go rename to common/db.go index e02a80fca7..6505e61c63 100644 --- a/ethutil/db.go +++ b/common/db.go @@ -1,4 +1,4 @@ -package ethutil +package common // Database interface type Database interface { diff --git a/ethutil/list.go b/common/list.go similarity index 99% rename from ethutil/list.go rename to common/list.go index db276f1e3b..594a8a24b7 100644 --- a/ethutil/list.go +++ b/common/list.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "encoding/json" diff --git a/ethutil/main_test.go b/common/main_test.go similarity index 86% rename from ethutil/main_test.go rename to common/main_test.go index fd4278ce79..2bed278e6d 100644 --- a/ethutil/main_test.go +++ b/common/main_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "testing" diff --git a/ethutil/math/dist.go b/common/math/dist.go similarity index 92% rename from ethutil/math/dist.go rename to common/math/dist.go index 262aa8591b..0a0731971a 100644 --- a/ethutil/math/dist.go +++ b/common/math/dist.go @@ -4,7 +4,7 @@ import ( "math/big" "sort" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type Summer interface { @@ -67,7 +67,7 @@ func (v vectorSummer) Sum(i int) *big.Int { return v.by(v.vectors[i]) } func GasSum(v Vector) *big.Int { return v.Gas } -var etherInWei = new(big.Rat).SetInt(ethutil.String2Big("1000000000000000000")) +var etherInWei = new(big.Rat).SetInt(common.String2Big("1000000000000000000")) func GasPrice(bp, gl, ep *big.Int) *big.Int { BP := new(big.Rat).SetInt(bp) diff --git a/ethutil/math/dist_test.go b/common/math/dist_test.go similarity index 100% rename from ethutil/math/dist_test.go rename to common/math/dist_test.go diff --git a/ethutil/natspec/natspec.go b/common/natspec/natspec.go similarity index 100% rename from ethutil/natspec/natspec.go rename to common/natspec/natspec.go diff --git a/ethutil/natspec/natspec_js.go b/common/natspec/natspec_js.go similarity index 100% rename from ethutil/natspec/natspec_js.go rename to common/natspec/natspec_js.go diff --git a/ethutil/natspec/natspec_test.go b/common/natspec/natspec_test.go similarity index 100% rename from ethutil/natspec/natspec_test.go rename to common/natspec/natspec_test.go diff --git a/ethutil/number/int.go b/common/number/int.go similarity index 95% rename from ethutil/number/int.go rename to common/number/int.go index 9a41fe3e5d..6cc5e68b4b 100644 --- a/ethutil/number/int.go +++ b/common/number/int.go @@ -3,7 +3,7 @@ package number import ( "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) var tt256 = new(big.Int).Lsh(big.NewInt(1), 256) @@ -171,7 +171,7 @@ var ( Zero = Uint(0) One = Uint(1) Two = Uint(2) - MaxUint256 = Uint(0).SetBytes(ethutil.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + MaxUint256 = Uint(0).SetBytes(common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) MinOne = Int(-1) diff --git a/ethutil/number/uint_test.go b/common/number/uint_test.go similarity index 94% rename from ethutil/number/uint_test.go rename to common/number/uint_test.go index c429894653..262d584ed4 100644 --- a/ethutil/number/uint_test.go +++ b/common/number/uint_test.go @@ -4,7 +4,7 @@ import ( "math/big" "testing" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func TestSet(t *testing.T) { @@ -15,7 +15,7 @@ func TestSet(t *testing.T) { t.Error("didn't compare", a, b) } - c := Uint(0).SetBytes(ethutil.Hex2Bytes("0a")) + c := Uint(0).SetBytes(common.Hex2Bytes("0a")) if c.num.Cmp(big.NewInt(10)) != 0 { t.Error("c set bytes failed.") } diff --git a/ethutil/package.go b/common/package.go similarity index 99% rename from ethutil/package.go rename to common/package.go index e5df989d23..7f38d8e4d9 100644 --- a/ethutil/package.go +++ b/common/package.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "archive/zip" diff --git a/ethutil/path.go b/common/path.go similarity index 98% rename from ethutil/path.go rename to common/path.go index e545c87315..680c8366c2 100644 --- a/ethutil/path.go +++ b/common/path.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "io/ioutil" diff --git a/ethutil/path_test.go b/common/path_test.go similarity index 98% rename from ethutil/path_test.go rename to common/path_test.go index 908c94ee7b..4af1bd7af7 100644 --- a/ethutil/path_test.go +++ b/common/path_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( // "os" diff --git a/ethutil/rlp.go b/common/rlp.go similarity index 99% rename from ethutil/rlp.go rename to common/rlp.go index 0cb0d611ce..602f132023 100644 --- a/ethutil/rlp.go +++ b/common/rlp.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/rlp_test.go b/common/rlp_test.go similarity index 99% rename from ethutil/rlp_test.go rename to common/rlp_test.go index ff98d32699..16a3553d75 100644 --- a/ethutil/rlp_test.go +++ b/common/rlp_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/size.go b/common/size.go similarity index 94% rename from ethutil/size.go rename to common/size.go index b4426465e6..80a17279bd 100644 --- a/ethutil/size.go +++ b/common/size.go @@ -1,4 +1,4 @@ -package ethutil +package common import "fmt" diff --git a/ethutil/size_test.go b/common/size_test.go similarity index 96% rename from ethutil/size_test.go rename to common/size_test.go index e0f28abc5d..c90eabc261 100644 --- a/ethutil/size_test.go +++ b/common/size_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( checker "gopkg.in/check.v1" diff --git a/common/types.go b/common/types.go new file mode 100644 index 0000000000..7646b2c340 --- /dev/null +++ b/common/types.go @@ -0,0 +1,6 @@ +package common + +type ( + Hash [32]byte + Address [20]byte +) diff --git a/ethutil/value.go b/common/value.go similarity index 99% rename from ethutil/value.go rename to common/value.go index 7d4a7d98c3..72a123772c 100644 --- a/ethutil/value.go +++ b/common/value.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "bytes" diff --git a/ethutil/value_test.go b/common/value_test.go similarity index 99% rename from ethutil/value_test.go rename to common/value_test.go index 861d35184f..09d37802d5 100644 --- a/ethutil/value_test.go +++ b/common/value_test.go @@ -1,4 +1,4 @@ -package ethutil +package common import ( "math/big" diff --git a/core/asm.go b/core/asm.go index a8b3023f42..fc3493fe11 100644 --- a/core/asm.go +++ b/core/asm.go @@ -4,7 +4,7 @@ import ( "fmt" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/vm" ) @@ -28,7 +28,7 @@ func Disassemble(script []byte) (asm []string) { vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32: - pc.Add(pc, ethutil.Big1) + pc.Add(pc, common.Big1) a := int64(op) - int64(vm.PUSH1) + 1 if int(pc.Int64()+a) > len(script) { return @@ -43,7 +43,7 @@ func Disassemble(script []byte) (asm []string) { pc.Add(pc, big.NewInt(a-1)) } - pc.Add(pc, ethutil.Big1) + pc.Add(pc, common.Big1) } return asm diff --git a/core/block_processor.go b/core/block_processor.go index f421c35395..f67d6d006b 100644 --- a/core/block_processor.go +++ b/core/block_processor.go @@ -8,7 +8,7 @@ import ( "time" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow" @@ -24,8 +24,8 @@ type PendingBlockEvent struct { var statelogger = logger.NewLogger("BLOCK") type BlockProcessor struct { - db ethutil.Database - extraDb ethutil.Database + db common.Database + extraDb common.Database // Mutex for locking the block processor. Blocks can only be handled one at a time mutex sync.Mutex // Canonical block chain @@ -47,7 +47,7 @@ type BlockProcessor struct { eventMux *event.TypeMux } -func NewBlockProcessor(db, extra ethutil.Database, pow pow.PoW, txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor { +func NewBlockProcessor(db, extra common.Database, pow pow.PoW, txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor { sm := &BlockProcessor{ db: db, extraDb: extra, @@ -217,7 +217,7 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (td *big // Commit state objects/accounts to a temporary trie (does not save) // used to calculate the state root. - state.Update(ethutil.Big0) + state.Update(common.Big0) if !bytes.Equal(header.Root, state.Root()) { err = fmt.Errorf("invalid merkle root. received=%x got=%x", header.Root, state.Root()) return @@ -352,7 +352,7 @@ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err erro return state.Logs(), nil } -func putTx(db ethutil.Database, tx *types.Transaction) { +func putTx(db common.Database, tx *types.Transaction) { rlpEnc, err := rlp.EncodeToBytes(tx) if err != nil { statelogger.Infoln("Failed encoding tx", err) diff --git a/core/chain_makers.go b/core/chain_makers.go index f140b5c7e7..59c297dbe7 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -5,7 +5,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/pow" "github.com/ethereum/go-ethereum/state" @@ -33,36 +33,36 @@ func NewBlockFromParent(addr []byte, parent *types.Block) *types.Block { return newBlockFromParent(addr, parent) } -func MakeBlock(bman *BlockProcessor, parent *types.Block, i int, db ethutil.Database, seed int) *types.Block { +func MakeBlock(bman *BlockProcessor, parent *types.Block, i int, db common.Database, seed int) *types.Block { return makeBlock(bman, parent, i, db, seed) } -func MakeChain(bman *BlockProcessor, parent *types.Block, max int, db ethutil.Database, seed int) types.Blocks { +func MakeChain(bman *BlockProcessor, parent *types.Block, max int, db common.Database, seed int) types.Blocks { return makeChain(bman, parent, max, db, seed) } -func NewChainMan(block *types.Block, eventMux *event.TypeMux, db ethutil.Database) *ChainManager { +func NewChainMan(block *types.Block, eventMux *event.TypeMux, db common.Database) *ChainManager { return newChainManager(block, eventMux, db) } -func NewBlockProc(db ethutil.Database, txpool *TxPool, cman *ChainManager, eventMux *event.TypeMux) *BlockProcessor { +func NewBlockProc(db common.Database, txpool *TxPool, cman *ChainManager, eventMux *event.TypeMux) *BlockProcessor { return newBlockProcessor(db, txpool, cman, eventMux) } -func NewCanonical(n int, db ethutil.Database) (*BlockProcessor, error) { +func NewCanonical(n int, db common.Database) (*BlockProcessor, error) { return newCanonical(n, db) } // block time is fixed at 10 seconds func newBlockFromParent(addr []byte, parent *types.Block) *types.Block { - block := types.NewBlock(parent.Hash(), addr, parent.Root(), ethutil.BigPow(2, 32), 0, "") + block := types.NewBlock(parent.Hash(), addr, parent.Root(), common.BigPow(2, 32), 0, "") block.SetUncles(nil) block.SetTransactions(nil) block.SetReceipts(nil) header := block.Header() header.Difficulty = CalcDifficulty(block.Header(), parent.Header()) - header.Number = new(big.Int).Add(parent.Header().Number, ethutil.Big1) + header.Number = new(big.Int).Add(parent.Header().Number, common.Big1) header.Time = parent.Header().Time + 10 header.GasLimit = CalcGasLimit(parent, block) @@ -73,22 +73,22 @@ func newBlockFromParent(addr []byte, parent *types.Block) *types.Block { // Actually make a block by simulating what miner would do // we seed chains by the first byte of the coinbase -func makeBlock(bman *BlockProcessor, parent *types.Block, i int, db ethutil.Database, seed int) *types.Block { - addr := ethutil.LeftPadBytes([]byte{byte(i)}, 20) +func makeBlock(bman *BlockProcessor, parent *types.Block, i int, db common.Database, seed int) *types.Block { + addr := common.LeftPadBytes([]byte{byte(i)}, 20) addr[0] = byte(seed) block := newBlockFromParent(addr, parent) state := state.New(block.Root(), db) cbase := state.GetOrNewStateObject(addr) cbase.SetGasPool(CalcGasLimit(parent, block)) cbase.AddBalance(BlockReward) - state.Update(ethutil.Big0) + state.Update(common.Big0) block.SetRoot(state.Root()) return block } // Make a chain with real blocks // Runs ProcessWithParent to get proper state roots -func makeChain(bman *BlockProcessor, parent *types.Block, max int, db ethutil.Database, seed int) types.Blocks { +func makeChain(bman *BlockProcessor, parent *types.Block, max int, db common.Database, seed int) types.Blocks { bman.bc.currentBlock = parent blocks := make(types.Blocks, max) for i := 0; i < max; i++ { @@ -107,7 +107,7 @@ func makeChain(bman *BlockProcessor, parent *types.Block, max int, db ethutil.Da // Create a new chain manager starting from given block // Effectively a fork factory -func newChainManager(block *types.Block, eventMux *event.TypeMux, db ethutil.Database) *ChainManager { +func newChainManager(block *types.Block, eventMux *event.TypeMux, db common.Database) *ChainManager { bc := &ChainManager{blockDb: db, stateDb: db, genesisBlock: GenesisBlock(db), eventMux: eventMux} if block == nil { bc.Reset() @@ -119,14 +119,14 @@ func newChainManager(block *types.Block, eventMux *event.TypeMux, db ethutil.Dat } // block processor with fake pow -func newBlockProcessor(db ethutil.Database, txpool *TxPool, cman *ChainManager, eventMux *event.TypeMux) *BlockProcessor { +func newBlockProcessor(db common.Database, txpool *TxPool, cman *ChainManager, eventMux *event.TypeMux) *BlockProcessor { bman := NewBlockProcessor(db, db, FakePow{}, txpool, newChainManager(nil, eventMux, db), eventMux) return bman } // Make a new, deterministic canonical chain by running InsertChain // on result of makeChain -func newCanonical(n int, db ethutil.Database) (*BlockProcessor, error) { +func newCanonical(n int, db common.Database) (*BlockProcessor, error) { eventMux := &event.TypeMux{} txpool := NewTxPool(eventMux) diff --git a/core/chain_manager.go b/core/chain_manager.go index 0b7dcf293a..ff91b04271 100644 --- a/core/chain_manager.go +++ b/core/chain_manager.go @@ -7,7 +7,7 @@ import ( "sync" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/rlp" @@ -60,7 +60,7 @@ func CalculateTD(block, parent *types.Block) *big.Int { func CalcGasLimit(parent, block *types.Block) *big.Int { if block.Number().Cmp(big.NewInt(0)) == 0 { - return ethutil.BigPow(10, 6) + return common.BigPow(10, 6) } // ((1024-1) * parent.gasLimit + (gasUsed * 6 / 5)) / 1024 @@ -71,13 +71,13 @@ func CalcGasLimit(parent, block *types.Block) *big.Int { result := new(big.Int).Add(previous, curInt) result.Div(result, big.NewInt(1024)) - return ethutil.BigMax(GenesisGasLimit, result) + return common.BigMax(GenesisGasLimit, result) } type ChainManager struct { //eth EthManager - blockDb ethutil.Database - stateDb ethutil.Database + blockDb common.Database + stateDb common.Database processor types.BlockProcessor eventMux *event.TypeMux genesisBlock *types.Block @@ -94,7 +94,7 @@ type ChainManager struct { quit chan struct{} } -func NewChainManager(blockDb, stateDb ethutil.Database, mux *event.TypeMux) *ChainManager { +func NewChainManager(blockDb, stateDb common.Database, mux *event.TypeMux) *ChainManager { bc := &ChainManager{blockDb: blockDb, stateDb: stateDb, genesisBlock: GenesisBlock(stateDb), eventMux: mux, quit: make(chan struct{})} bc.setLastBlock() bc.transState = bc.State().Copy() @@ -173,7 +173,7 @@ func (bc *ChainManager) setLastBlock() { bc.lastBlockHash = block.Hash() // Set the last know difficulty (might be 0x0 as initial value, Genesis) - bc.td = ethutil.BigD(bc.blockDb.LastKnownTD()) + bc.td = common.BigD(bc.blockDb.LastKnownTD()) } else { bc.Reset() } @@ -198,7 +198,7 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block { parentHash, coinbase, root, - ethutil.BigPow(2, 32), + common.BigPow(2, 32), 0, "") block.SetUncles(nil) @@ -209,7 +209,7 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block { if parent != nil { header := block.Header() header.Difficulty = CalcDifficulty(block.Header(), parent.Header()) - header.Number = new(big.Int).Add(parent.Header().Number, ethutil.Big1) + header.Number = new(big.Int).Add(parent.Header().Number, common.Big1) header.GasLimit = CalcGasLimit(parent, block) } @@ -230,7 +230,7 @@ func (bc *ChainManager) Reset() { bc.insert(bc.genesisBlock) bc.currentBlock = bc.genesisBlock - bc.setTotalDifficulty(ethutil.Big("0")) + bc.setTotalDifficulty(common.Big("0")) } func (bc *ChainManager) removeBlock(block *types.Block) { @@ -263,11 +263,11 @@ func (self *ChainManager) Export() []byte { blocks[block.NumberU64()] = block } - return ethutil.Encode(blocks) + return common.Encode(blocks) } func (bc *ChainManager) insert(block *types.Block) { - //encodedBlock := ethutil.Encode(block) + //encodedBlock := common.Encode(block) bc.blockDb.Put([]byte("LastBlock"), block.Hash()) bc.currentBlock = block bc.lastBlockHash = block.Hash() @@ -277,7 +277,7 @@ func (bc *ChainManager) insert(block *types.Block) { } func (bc *ChainManager) write(block *types.Block) { - encodedBlock := ethutil.Encode(block.RlpDataForStorage()) + encodedBlock := common.Encode(block.RlpDataForStorage()) key := append(blockHashPre, block.Hash()...) bc.blockDb.Put(key, encodedBlock) @@ -309,7 +309,7 @@ func (self *ChainManager) GetBlockHashesFromHash(hash []byte, max uint64) (chain } chain = append(chain, block.Hash()) - if block.Header().Number.Cmp(ethutil.Big0) <= 0 { + if block.Header().Number.Cmp(common.Big0) <= 0 { break } } @@ -434,7 +434,7 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error { // Compare the TD of the last known block in the canonical chain to make sure it's greater. // At this point it's possible that a different chain (fork) becomes the new canonical chain. if td.Cmp(self.td) > 0 { - if block.Header().Number.Cmp(new(big.Int).Add(cblock.Header().Number, ethutil.Big1)) < 0 { + if block.Header().Number.Cmp(new(big.Int).Add(cblock.Header().Number, common.Big1)) < 0 { chainlogger.Infof("Split detected. New head #%v (%x) TD=%v, was #%v (%x) TD=%v\n", block.Header().Number, block.Hash()[:4], td, cblock.Header().Number, cblock.Hash()[:4], self.td) queue[i] = ChainSplitEvent{block} @@ -446,10 +446,10 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error { /* XXX crashes jsonlogger.LogJson(&logger.EthChainNewHead{ - BlockHash: ethutil.Bytes2Hex(block.Hash()), + BlockHash: common.Bytes2Hex(block.Hash()), BlockNumber: block.Number(), - ChainHeadHash: ethutil.Bytes2Hex(cblock.Hash()), - BlockPrevHash: ethutil.Bytes2Hex(block.ParentHash()), + ChainHeadHash: common.Bytes2Hex(cblock.Hash()), + BlockPrevHash: common.Bytes2Hex(block.ParentHash()), }) */ diff --git a/core/genesis.go b/core/genesis.go index 9c82a28c85..bfd51f196f 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -8,7 +8,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -19,21 +19,21 @@ import ( var ZeroHash256 = make([]byte, 32) var ZeroHash160 = make([]byte, 20) var ZeroHash512 = make([]byte, 64) -var EmptyShaList = crypto.Sha3(ethutil.Encode([]interface{}{})) -var EmptyListRoot = crypto.Sha3(ethutil.Encode("")) +var EmptyShaList = crypto.Sha3(common.Encode([]interface{}{})) +var EmptyListRoot = crypto.Sha3(common.Encode("")) var GenesisDiff = big.NewInt(131072) var GenesisGasLimit = big.NewInt(3141592) -func GenesisBlock(db ethutil.Database) *types.Block { +func GenesisBlock(db common.Database) *types.Block { genesis := types.NewBlock(ZeroHash256, ZeroHash160, nil, GenesisDiff, 42, "") - genesis.Header().Number = ethutil.Big0 + genesis.Header().Number = common.Big0 genesis.Header().GasLimit = GenesisGasLimit - genesis.Header().GasUsed = ethutil.Big0 + genesis.Header().GasUsed = common.Big0 genesis.Header().Time = 0 genesis.Header().MixDigest = make([]byte, 32) - genesis.Td = ethutil.Big0 + genesis.Td = common.Big0 genesis.SetUncles([]*types.Header{}) genesis.SetTransactions(types.Transactions{}) @@ -48,9 +48,9 @@ func GenesisBlock(db ethutil.Database) *types.Block { statedb := state.New(genesis.Root(), db) for addr, account := range accounts { - codedAddr := ethutil.Hex2Bytes(addr) + codedAddr := common.Hex2Bytes(addr) accountState := statedb.GetAccount(codedAddr) - accountState.SetBalance(ethutil.Big(account.Balance)) + accountState.SetBalance(common.Big(account.Balance)) statedb.UpdateStateObject(accountState) } statedb.Sync() diff --git a/core/helper_test.go b/core/helper_test.go index b7f05db648..1e0ed178b8 100644 --- a/core/helper_test.go +++ b/core/helper_test.go @@ -7,7 +7,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" // "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" ) @@ -16,7 +16,7 @@ type TestManager struct { // stateManager *StateManager eventMux *event.TypeMux - db ethutil.Database + db common.Database txPool *TxPool blockChain *ChainManager Blocks []*types.Block @@ -58,7 +58,7 @@ func (tm *TestManager) EventMux() *event.TypeMux { // return nil // } -func (tm *TestManager) Db() ethutil.Database { +func (tm *TestManager) Db() common.Database { return tm.db } diff --git a/core/manager.go b/core/manager.go index c4052cc058..9b5407a9e2 100644 --- a/core/manager.go +++ b/core/manager.go @@ -1,7 +1,7 @@ package core import ( - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/p2p" ) @@ -13,7 +13,7 @@ type Backend interface { PeerCount() int IsListening() bool Peers() []*p2p.Peer - BlockDb() ethutil.Database - StateDb() ethutil.Database + BlockDb() common.Database + StateDb() common.Database EventMux() *event.TypeMux } diff --git a/core/state_transition.go b/core/state_transition.go index f49aed8742..279abee62b 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -5,7 +5,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/vm" ) @@ -58,7 +58,7 @@ type Message interface { func AddressFromMessage(msg Message) []byte { // Generate a new address - return crypto.Sha3(ethutil.NewValue([]interface{}{msg.From(), msg.Nonce()}).Encode())[12:] + return crypto.Sha3(common.NewValue([]interface{}{msg.From(), msg.Nonce()}).Encode())[12:] } func MessageCreatesContract(msg Message) bool { @@ -226,9 +226,9 @@ func (self *StateTransition) refundGas() { remaining := new(big.Int).Mul(self.gas, self.msg.GasPrice()) sender.AddBalance(remaining) - uhalf := new(big.Int).Div(self.gasUsed(), ethutil.Big2) + uhalf := new(big.Int).Div(self.gasUsed(), common.Big2) for addr, ref := range self.state.Refunds() { - refund := ethutil.BigMin(uhalf, ref) + refund := common.BigMin(uhalf, ref) self.gas.Add(self.gas, refund) self.state.AddBalance([]byte(addr), refund.Mul(refund, self.msg.GasPrice())) } diff --git a/core/transaction_pool.go b/core/transaction_pool.go index bd377f6790..515cc2040e 100644 --- a/core/transaction_pool.go +++ b/core/transaction_pool.go @@ -6,7 +6,7 @@ import ( "sync" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" ) @@ -113,13 +113,13 @@ func (self *TxPool) add(tx *types.Transaction) error { var to string if len(tx.To()) > 0 { - to = ethutil.Bytes2Hex(tx.To()[:4]) + to = common.Bytes2Hex(tx.To()[:4]) } else { to = "[NEW_CONTRACT]" } var from string if len(tx.From()) > 0 { - from = ethutil.Bytes2Hex(tx.From()[:4]) + from = common.Bytes2Hex(tx.From()[:4]) } else { return errors.New(fmt.Sprintf("FROM ADDRESS MUST BE POSITIVE (was %v)", tx.From())) } diff --git a/core/transaction_pool_test.go b/core/transaction_pool_test.go index b2d981f016..418cb04154 100644 --- a/core/transaction_pool_test.go +++ b/core/transaction_pool_test.go @@ -7,13 +7,13 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/state" ) // State query interface -type stateQuery struct{ db ethutil.Database } +type stateQuery struct{ db common.Database } func SQ() stateQuery { db, _ := ethdb.NewMemDatabase() @@ -25,7 +25,7 @@ func (self stateQuery) GetAccount(addr []byte) *state.StateObject { } func transaction() *types.Transaction { - return types.NewTransactionMessage(make([]byte, 20), ethutil.Big0, ethutil.Big0, ethutil.Big0, nil) + return types.NewTransactionMessage(make([]byte, 20), common.Big0, common.Big0, common.Big0, nil) } func setup() (*TxPool, *ecdsa.PrivateKey) { diff --git a/core/types/block.go b/core/types/block.go index ba6ef60149..2d65cdca62 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -9,7 +9,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" ) @@ -74,11 +74,11 @@ func (self *Header) RlpData() interface{} { } func (self *Header) Hash() []byte { - return crypto.Sha3(ethutil.Encode(self.rlpData(true))) + return crypto.Sha3(common.Encode(self.rlpData(true))) } func (self *Header) HashNoNonce() []byte { - return crypto.Sha3(ethutil.Encode(self.rlpData(false))) + return crypto.Sha3(common.Encode(self.rlpData(false))) } type Block struct { @@ -148,7 +148,7 @@ func (self *Block) Uncles() []*Header { func (self *Block) SetUncles(uncleHeaders []*Header) { self.uncles = uncleHeaders - self.header.UncleHash = crypto.Sha3(ethutil.Encode(uncleHeaders)) + self.header.UncleHash = crypto.Sha3(common.Encode(uncleHeaders)) } func (self *Block) Transactions() Transactions { @@ -213,7 +213,7 @@ func (self *Block) GasLimit() *big.Int { return self.header.GasLimit } func (self *Block) GasUsed() *big.Int { return self.header.GasUsed } func (self *Block) Root() []byte { return self.header.Root } func (self *Block) SetRoot(root []byte) { self.header.Root = root } -func (self *Block) Size() ethutil.StorageSize { return ethutil.StorageSize(len(ethutil.Encode(self))) } +func (self *Block) Size() common.StorageSize { return common.StorageSize(len(common.Encode(self))) } func (self *Block) GetTransaction(i int) *Transaction { if len(self.transactions) > i { return self.transactions[i] diff --git a/core/types/bloom9.go b/core/types/bloom9.go index 578265a343..af76f226f0 100644 --- a/core/types/bloom9.go +++ b/core/types/bloom9.go @@ -4,7 +4,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -14,7 +14,7 @@ func CreateBloom(receipts Receipts) []byte { bin.Or(bin, LogsBloom(receipt.logs)) } - return ethutil.LeftPadBytes(bin.Bytes(), 256) + return common.LeftPadBytes(bin.Bytes(), 256) } func LogsBloom(logs state.Logs) *big.Int { @@ -28,7 +28,7 @@ func LogsBloom(logs state.Logs) *big.Int { } for _, b := range data { - bin.Or(bin, ethutil.BigD(bloom9(crypto.Sha3(b)).Bytes())) + bin.Or(bin, common.BigD(bloom9(crypto.Sha3(b)).Bytes())) } } @@ -48,7 +48,7 @@ func bloom9(b []byte) *big.Int { } func BloomLookup(bin, topic []byte) bool { - bloom := ethutil.BigD(bin) + bloom := common.BigD(bin) cmp := bloom9(crypto.Sha3(topic)) return bloom.And(bloom, cmp).Cmp(cmp) == 0 diff --git a/core/types/bloom9_test.go b/core/types/bloom9_test.go index 74e00cac6b..0841bb8595 100644 --- a/core/types/bloom9_test.go +++ b/core/types/bloom9_test.go @@ -22,10 +22,10 @@ func TestBloom9(t *testing.T) { func TestAddress(t *testing.T) { block := &Block{} - block.Coinbase = ethutil.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f") + block.Coinbase = common.Hex2Bytes("22341ae42d6dd7384bc8584e50419ea3ac75b83f") fmt.Printf("%x\n", crypto.Sha3(block.Coinbase)) bin := CreateBloom(block) - fmt.Printf("bin = %x\n", ethutil.LeftPadBytes(bin, 64)) + fmt.Printf("bin = %x\n", common.LeftPadBytes(bin, 64)) } */ diff --git a/core/types/derive_sha.go b/core/types/derive_sha.go index b2c4422103..593a31f1c8 100644 --- a/core/types/derive_sha.go +++ b/core/types/derive_sha.go @@ -2,7 +2,7 @@ package types import ( "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/trie" ) @@ -15,7 +15,7 @@ func DeriveSha(list DerivableList) []byte { db, _ := ethdb.NewMemDatabase() trie := trie.New(nil, db) for i := 0; i < list.Len(); i++ { - trie.Update(ethutil.Encode(i), list.GetRlp(i)) + trie.Update(common.Encode(i), list.GetRlp(i)) } return trie.Root() diff --git a/core/types/receipt.go b/core/types/receipt.go index 49e68e2334..be14d0e0e3 100644 --- a/core/types/receipt.go +++ b/core/types/receipt.go @@ -5,7 +5,7 @@ import ( "fmt" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -17,10 +17,10 @@ type Receipt struct { } func NewReceipt(root []byte, cumalativeGasUsed *big.Int) *Receipt { - return &Receipt{PostState: ethutil.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumalativeGasUsed)} + return &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumalativeGasUsed)} } -func NewRecieptFromValue(val *ethutil.Value) *Receipt { +func NewRecieptFromValue(val *common.Value) *Receipt { r := &Receipt{} r.RlpValueDecode(val) @@ -31,7 +31,7 @@ func (self *Receipt) SetLogs(logs state.Logs) { self.logs = logs } -func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) { +func (self *Receipt) RlpValueDecode(decoder *common.Value) { self.PostState = decoder.Get(0).Bytes() self.CumulativeGasUsed = decoder.Get(1).BigInt() self.Bloom = decoder.Get(2).Bytes() @@ -47,7 +47,7 @@ func (self *Receipt) RlpData() interface{} { } func (self *Receipt) RlpEncode() []byte { - return ethutil.Encode(self.RlpData()) + return common.Encode(self.RlpData()) } func (self *Receipt) Cmp(other *Receipt) bool { @@ -74,8 +74,8 @@ func (self Receipts) RlpData() interface{} { } func (self Receipts) RlpEncode() []byte { - return ethutil.Encode(self.RlpData()) + return common.Encode(self.RlpData()) } func (self Receipts) Len() int { return len(self) } -func (self Receipts) GetRlp(i int) []byte { return ethutil.Rlp(self[i]) } +func (self Receipts) GetRlp(i int) []byte { return common.Rlp(self[i]) } diff --git a/core/types/transaction.go b/core/types/transaction.go index 88a718f937..dcd48af119 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -8,7 +8,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/secp256k1" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" ) @@ -42,7 +42,7 @@ func NewTransactionFromBytes(data []byte) *Transaction { return tx } -func NewTransactionFromAmount(val *ethutil.Value) *Transaction { +func NewTransactionFromAmount(val *common.Value) *Transaction { tx := &Transaction{} tx.RlpValueDecode(val) @@ -52,7 +52,7 @@ func NewTransactionFromAmount(val *ethutil.Value) *Transaction { func (tx *Transaction) Hash() []byte { data := []interface{}{tx.AccountNonce, tx.Price, tx.GasLimit, tx.Recipient, tx.Amount, tx.Payload} - return crypto.Sha3(ethutil.Encode(data)) + return crypto.Sha3(common.Encode(data)) } func (self *Transaction) Data() []byte { @@ -89,8 +89,8 @@ func (self *Transaction) To() []byte { func (tx *Transaction) Curve() (v byte, r []byte, s []byte) { v = byte(tx.V) - r = ethutil.LeftPadBytes(tx.R, 32) - s = ethutil.LeftPadBytes(tx.S, 32) + r = common.LeftPadBytes(tx.R, 32) + s = common.LeftPadBytes(tx.S, 32) return } @@ -159,14 +159,14 @@ func (tx *Transaction) RlpData() interface{} { } func (tx *Transaction) RlpEncode() []byte { - return ethutil.Encode(tx) + return common.Encode(tx) } func (tx *Transaction) RlpDecode(data []byte) { rlp.Decode(bytes.NewReader(data), tx) } -func (tx *Transaction) RlpValueDecode(decoder *ethutil.Value) { +func (tx *Transaction) RlpValueDecode(decoder *common.Value) { tx.AccountNonce = decoder.Get(0).Uint() tx.Price = decoder.Get(1).BigInt() tx.GasLimit = decoder.Get(2).BigInt() @@ -206,7 +206,7 @@ func (tx *Transaction) String() string { tx.V, tx.R, tx.S, - ethutil.Encode(tx), + common.Encode(tx), ) } @@ -225,7 +225,7 @@ func (self Transactions) RlpData() interface{} { } func (s Transactions) Len() int { return len(s) } func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] } -func (s Transactions) GetRlp(i int) []byte { return ethutil.Rlp(s[i]) } +func (s Transactions) GetRlp(i int) []byte { return common.Rlp(s[i]) } type TxByNonce struct{ Transactions } diff --git a/crypto/crypto.go b/crypto/crypto.go index 90e2c89393..bc72928ac8 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -19,7 +19,7 @@ import ( "github.com/ethereum/go-ethereum/crypto/ecies" "github.com/ethereum/go-ethereum/crypto/secp256k1" "github.com/ethereum/go-ethereum/crypto/sha3" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "golang.org/x/crypto/pbkdf2" "golang.org/x/crypto/ripemd160" ) @@ -39,7 +39,7 @@ func Sha3(data ...[]byte) []byte { // Creates an ethereum address given the bytes and the nonce func CreateAddress(b []byte, nonce uint64) []byte { - return Sha3(ethutil.NewValue([]interface{}{b, nonce}).Encode())[12:] + return Sha3(common.NewValue([]interface{}{b, nonce}).Encode())[12:] } func Sha256(data []byte) []byte { @@ -74,7 +74,7 @@ func ToECDSA(prv []byte) *ecdsa.PrivateKey { priv := new(ecdsa.PrivateKey) priv.PublicKey.Curve = S256() - priv.D = ethutil.BigD(prv) + priv.D = common.BigD(prv) priv.PublicKey.X, priv.PublicKey.Y = S256().ScalarBaseMult(prv) return priv } @@ -143,7 +143,7 @@ func Sign(hash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error) { return nil, fmt.Errorf("hash is required to be exactly 32 bytes (%d)", len(hash)) } - sig, err = secp256k1.Sign(hash, ethutil.LeftPadBytes(prv.D.Bytes(), prv.Params().BitSize/8)) + sig, err = secp256k1.Sign(hash, common.LeftPadBytes(prv.D.Bytes(), prv.Params().BitSize/8)) return } @@ -198,7 +198,7 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error Address: PubkeyToAddress(ecKey.PublicKey), PrivateKey: ecKey, } - derivedAddr := ethutil.Bytes2Hex(key.Address) + derivedAddr := common.Bytes2Hex(key.Address) expectedAddr := preSaleKeyStruct.EthAddr if derivedAddr != expectedAddr { err = errors.New("decrypted addr not equal to expected addr") diff --git a/crypto/crypto_test.go b/crypto/crypto_test.go index c688566227..7542876410 100644 --- a/crypto/crypto_test.go +++ b/crypto/crypto_test.go @@ -8,7 +8,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto/secp256k1" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) // These tests are sanity checks. @@ -53,7 +53,7 @@ func BenchmarkSha3(b *testing.B) { func Test0Key(t *testing.T) { t.Skip() - key := ethutil.Hex2Bytes("1111111111111111111111111111111111111111111111111111111111111111") + key := common.Hex2Bytes("1111111111111111111111111111111111111111111111111111111111111111") p, err := secp256k1.GeneratePubKey(key) addr := Sha3(p[1:])[12:] diff --git a/crypto/encrypt_decrypt_test.go b/crypto/encrypt_decrypt_test.go index 85b43c406b..6e5b40a379 100644 --- a/crypto/encrypt_decrypt_test.go +++ b/crypto/encrypt_decrypt_test.go @@ -5,13 +5,13 @@ import ( "fmt" "testing" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func TestBox(t *testing.T) { - prv1 := ToECDSA(ethutil.Hex2Bytes("4b50fa71f5c3eeb8fdc452224b2395af2fcc3d125e06c32c82e048c0559db03f")) - prv2 := ToECDSA(ethutil.Hex2Bytes("d0b043b4c5d657670778242d82d68a29d25d7d711127d17b8e299f156dad361a")) - pub2 := ToECDSAPub(ethutil.Hex2Bytes("04bd27a63c91fe3233c5777e6d3d7b39204d398c8f92655947eb5a373d46e1688f022a1632d264725cbc7dc43ee1cfebde42fa0a86d08b55d2acfbb5e9b3b48dc5")) + prv1 := ToECDSA(common.Hex2Bytes("4b50fa71f5c3eeb8fdc452224b2395af2fcc3d125e06c32c82e048c0559db03f")) + prv2 := ToECDSA(common.Hex2Bytes("d0b043b4c5d657670778242d82d68a29d25d7d711127d17b8e299f156dad361a")) + pub2 := ToECDSAPub(common.Hex2Bytes("04bd27a63c91fe3233c5777e6d3d7b39204d398c8f92655947eb5a373d46e1688f022a1632d264725cbc7dc43ee1cfebde42fa0a86d08b55d2acfbb5e9b3b48dc5")) message := []byte("Hello, world.") ct, err := Encrypt(pub2, message) diff --git a/crypto/key_store_test.go b/crypto/key_store_test.go index 11531d4601..f0a1e567b7 100644 --- a/crypto/key_store_test.go +++ b/crypto/key_store_test.go @@ -2,13 +2,13 @@ package crypto import ( "github.com/ethereum/go-ethereum/crypto/randentropy" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "reflect" "testing" ) func TestKeyStorePlain(t *testing.T) { - ks := NewKeyStorePlain(ethutil.DefaultDataDir()) + ks := NewKeyStorePlain(common.DefaultDataDir()) pass := "" // not used but required by API k1, err := ks.GenerateNewKey(randentropy.Reader, pass) if err != nil { @@ -36,7 +36,7 @@ func TestKeyStorePlain(t *testing.T) { } func TestKeyStorePassphrase(t *testing.T) { - ks := NewKeyStorePassphrase(ethutil.DefaultDataDir()) + ks := NewKeyStorePassphrase(common.DefaultDataDir()) pass := "foo" k1, err := ks.GenerateNewKey(randentropy.Reader, pass) if err != nil { @@ -62,7 +62,7 @@ func TestKeyStorePassphrase(t *testing.T) { } func TestKeyStorePassphraseDecryptionFail(t *testing.T) { - ks := NewKeyStorePassphrase(ethutil.DefaultDataDir()) + ks := NewKeyStorePassphrase(common.DefaultDataDir()) pass := "foo" k1, err := ks.GenerateNewKey(randentropy.Reader, pass) if err != nil { @@ -90,7 +90,7 @@ func TestImportPreSaleKey(t *testing.T) { // python pyethsaletool.py genwallet // with password "foo" fileContent := "{\"encseed\": \"26d87f5f2bf9835f9a47eefae571bc09f9107bb13d54ff12a4ec095d01f83897494cf34f7bed2ed34126ecba9db7b62de56c9d7cd136520a0427bfb11b8954ba7ac39b90d4650d3448e31185affcd74226a68f1e94b1108e6e0a4a91cdd83eba\", \"ethaddr\": \"d4584b5f6229b7be90727b0fc8c6b91bb427821f\", \"email\": \"gustav.simonsson@gmail.com\", \"btcaddr\": \"1EVknXyFC68kKNLkh6YnKzW41svSRoaAcx\"}" - ks := NewKeyStorePassphrase(ethutil.DefaultDataDir()) + ks := NewKeyStorePassphrase(common.DefaultDataDir()) pass := "foo" _, err := ImportPreSaleKey(ks, []byte(fileContent), pass) if err != nil { diff --git a/crypto/keypair.go b/crypto/keypair.go index da57884370..6702e6595e 100644 --- a/crypto/keypair.go +++ b/crypto/keypair.go @@ -4,7 +4,7 @@ import ( "strings" "github.com/ethereum/go-ethereum/crypto/secp256k1" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type KeyPair struct { @@ -40,19 +40,19 @@ func (k *KeyPair) Address() []byte { func (k *KeyPair) Mnemonic() string { if k.mnemonic == "" { - k.mnemonic = strings.Join(MnemonicEncode(ethutil.Bytes2Hex(k.PrivateKey)), " ") + k.mnemonic = strings.Join(MnemonicEncode(common.Bytes2Hex(k.PrivateKey)), " ") } return k.mnemonic } func (k *KeyPair) AsStrings() (string, string, string, string) { - return k.Mnemonic(), ethutil.Bytes2Hex(k.Address()), ethutil.Bytes2Hex(k.PrivateKey), ethutil.Bytes2Hex(k.PublicKey) + return k.Mnemonic(), common.Bytes2Hex(k.Address()), common.Bytes2Hex(k.PrivateKey), common.Bytes2Hex(k.PublicKey) } func (k *KeyPair) RlpEncode() []byte { return k.RlpValue().Encode() } -func (k *KeyPair) RlpValue() *ethutil.Value { - return ethutil.NewValue(k.PrivateKey) +func (k *KeyPair) RlpValue() *common.Value { + return common.NewValue(k.PrivateKey) } diff --git a/eth/backend.go b/eth/backend.go index 346fc43bc0..42f2b58087 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -14,7 +14,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/miner" @@ -65,7 +65,7 @@ type Config struct { // NewDB is used to create databases. // If nil, the default is to create leveldb databases on disk. - NewDB func(path string) (ethutil.Database, error) + NewDB func(path string) (common.Database, error) } func (cfg *Config) parseBootNodes() []*discover.Node { @@ -113,9 +113,9 @@ type Ethereum struct { shutdownChan chan bool // DB interfaces - blockDb ethutil.Database // Block chain database - stateDb ethutil.Database // State changes database - extraDb ethutil.Database // Extra database (txs, etc) + blockDb common.Database // Block chain database + stateDb common.Database // State changes database + extraDb common.Database // Extra database (txs, etc) //*** SERVICES *** // State manager for processing new blocks and managing the over all states @@ -146,7 +146,7 @@ func New(config *Config) (*Ethereum, error) { newdb := config.NewDB if newdb == nil { - newdb = func(path string) (ethutil.Database, error) { return ethdb.NewLDBDatabase(path) } + newdb = func(path string) (common.Database, error) { return ethdb.NewLDBDatabase(path) } } blockDb, err := newdb(path.Join(config.DataDir, "blockchain")) if err != nil { @@ -160,7 +160,7 @@ func New(config *Config) (*Ethereum, error) { // Perform database sanity checks d, _ := blockDb.Get([]byte("ProtocolVersion")) - protov := ethutil.NewValue(d).Uint() + protov := common.NewValue(d).Uint() if protov != ProtocolVersion && protov != 0 { path := path.Join(config.DataDir, "blockchain") return nil, fmt.Errorf("Database version mismatch. Protocol(%d / %d). `rm -rf %s`", protov, ProtocolVersion, path) @@ -246,9 +246,9 @@ func (s *Ethereum) TxPool() *core.TxPool { return s.txPool } func (s *Ethereum) BlockPool() *blockpool.BlockPool { return s.blockPool } func (s *Ethereum) Whisper() *whisper.Whisper { return s.whisper } func (s *Ethereum) EventMux() *event.TypeMux { return s.eventMux } -func (s *Ethereum) BlockDb() ethutil.Database { return s.blockDb } -func (s *Ethereum) StateDb() ethutil.Database { return s.stateDb } -func (s *Ethereum) ExtraDb() ethutil.Database { return s.extraDb } +func (s *Ethereum) BlockDb() common.Database { return s.blockDb } +func (s *Ethereum) StateDb() common.Database { return s.stateDb } +func (s *Ethereum) ExtraDb() common.Database { return s.extraDb } func (s *Ethereum) IsListening() bool { return true } // Always listening func (s *Ethereum) PeerCount() int { return s.net.PeerCount() } func (s *Ethereum) Peers() []*p2p.Peer { return s.net.Peers() } @@ -351,11 +351,11 @@ func (self *Ethereum) blockBroadcastLoop() { } } -func saveProtocolVersion(db ethutil.Database) { +func saveProtocolVersion(db common.Database) { d, _ := db.Get([]byte("ProtocolVersion")) - protocolVersion := ethutil.NewValue(d).Uint() + protocolVersion := common.NewValue(d).Uint() if protocolVersion == 0 { - db.Put([]byte("ProtocolVersion"), ethutil.NewValue(ProtocolVersion).Bytes()) + db.Put([]byte("ProtocolVersion"), common.NewValue(ProtocolVersion).Bytes()) } } diff --git a/eth/peer_util.go b/eth/peer_util.go index 6cf80cde29..18fef0ab50 100644 --- a/eth/peer_util.go +++ b/eth/peer_util.go @@ -3,19 +3,19 @@ package eth import ( "encoding/json" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func WritePeers(path string, addresses []string) { if len(addresses) > 0 { data, _ := json.MarshalIndent(addresses, "", " ") - ethutil.WriteFile(path, data) + common.WriteFile(path, data) } } func ReadPeers(path string) (ips []string, err error) { var data string - data, err = ethutil.ReadAllFile(path) + data, err = common.ReadAllFile(path) if err != nil { json.Unmarshal([]byte(data), &ips) } diff --git a/eth/protocol.go b/eth/protocol.go index 708e22087f..e368bbec50 100644 --- a/eth/protocol.go +++ b/eth/protocol.go @@ -7,7 +7,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/errs" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/rlp" @@ -167,7 +167,7 @@ func (self *ethProtocol) handle() error { } for _, tx := range txs { jsonlogger.LogJson(&logger.EthTxReceived{ - TxHash: ethutil.Bytes2Hex(tx.Hash()), + TxHash: common.Bytes2Hex(tx.Hash()), RemoteId: self.peer.ID().String(), }) } @@ -183,7 +183,7 @@ func (self *ethProtocol) handle() error { request.Amount = maxHashes } hashes := self.chainManager.GetBlockHashesFromHash(request.Hash, request.Amount) - return p2p.EncodeMsg(self.rw, BlockHashesMsg, ethutil.ByteSliceToInterface(hashes)...) + return p2p.EncodeMsg(self.rw, BlockHashesMsg, common.ByteSliceToInterface(hashes)...) case BlockHashesMsg: msgStream := rlp.NewStream(msg.Payload) @@ -259,10 +259,10 @@ func (self *ethProtocol) handle() error { _, chainHead, _ := self.chainManager.Status() jsonlogger.LogJson(&logger.EthChainReceivedNewBlock{ - BlockHash: ethutil.Bytes2Hex(hash), + BlockHash: common.Bytes2Hex(hash), BlockNumber: request.Block.Number(), // this surely must be zero - ChainHeadHash: ethutil.Bytes2Hex(chainHead), - BlockPrevHash: ethutil.Bytes2Hex(request.Block.ParentHash()), + ChainHeadHash: common.Bytes2Hex(chainHead), + BlockPrevHash: common.Bytes2Hex(request.Block.ParentHash()), RemoteId: self.peer.ID().String(), }) // to simplify backend interface adding a new block @@ -351,7 +351,7 @@ func (self *ethProtocol) requestBlockHashes(from []byte) error { func (self *ethProtocol) requestBlocks(hashes [][]byte) error { self.peer.Debugf("fetching %v blocks", len(hashes)) - return p2p.EncodeMsg(self.rw, GetBlocksMsg, ethutil.ByteSliceToInterface(hashes)...) + return p2p.EncodeMsg(self.rw, GetBlocksMsg, common.ByteSliceToInterface(hashes)...) } func (self *ethProtocol) protoError(code int, format string, params ...interface{}) (err *errs.Error) { diff --git a/eth/protocol_test.go b/eth/protocol_test.go index f499d033ef..a2b59f117b 100644 --- a/eth/protocol_test.go +++ b/eth/protocol_test.go @@ -12,7 +12,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/errs" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ethlogger "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/discover" @@ -223,7 +223,7 @@ func (self *ethProtocolTester) run() { func TestStatusMsgErrors(t *testing.T) { logInit() eth := newEth(t) - td := ethutil.Big1 + td := common.Big1 currentBlock := []byte{1} genesis := []byte{2} eth.chainManager.status = func() (*big.Int, []byte, []byte) { return td, currentBlock, genesis } diff --git a/ethdb/database.go b/ethdb/database.go index 4e3d01da07..cc2df5fa0b 100644 --- a/ethdb/database.go +++ b/ethdb/database.go @@ -4,7 +4,7 @@ import ( "fmt" "github.com/ethereum/go-ethereum/compression/rle" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb/iterator" ) @@ -82,7 +82,7 @@ func (self *LDBDatabase) Print() { value := iter.Value() fmt.Printf("%x(%d): ", key, len(key)) - node := ethutil.NewValueFromBytes(value) + node := common.NewValueFromBytes(value) fmt.Printf("%v\n", node) } } diff --git a/ethdb/memory_database.go b/ethdb/memory_database.go index 48aa830e77..d914f47f89 100644 --- a/ethdb/memory_database.go +++ b/ethdb/memory_database.go @@ -3,7 +3,7 @@ package ethdb import ( "fmt" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) /* @@ -32,10 +32,10 @@ func (db *MemDatabase) Get(key []byte) ([]byte, error) { } /* -func (db *MemDatabase) GetKeys() []*ethutil.Key { +func (db *MemDatabase) GetKeys() []*common.Key { data, _ := db.Get([]byte("KeyRing")) - return []*ethutil.Key{ethutil.NewKeyFromBytes(data)} + return []*common.Key{common.NewKeyFromBytes(data)} } */ @@ -48,7 +48,7 @@ func (db *MemDatabase) Delete(key []byte) error { func (db *MemDatabase) Print() { for key, val := range db.db { fmt.Printf("%x(%d): ", key, len(key)) - node := ethutil.NewValueFromBytes(val) + node := common.NewValueFromBytes(val) fmt.Printf("%q\n", node.Interface()) } } diff --git a/javascript/types.go b/javascript/types.go index 5f47c17356..a6a0bc8e2b 100644 --- a/javascript/types.go +++ b/javascript/types.go @@ -2,7 +2,7 @@ package javascript import ( "fmt" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/xeth" "github.com/obscuren/otto" @@ -18,7 +18,7 @@ func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value { it := self.Object.Trie().Iterator() for it.Next() { - cb.Call(self.eth.toVal(self), self.eth.toVal(ethutil.Bytes2Hex(it.Key)), self.eth.toVal(ethutil.Bytes2Hex(it.Value))) + cb.Call(self.eth.toVal(self), self.eth.toVal(common.Bytes2Hex(it.Key)), self.eth.toVal(common.Bytes2Hex(it.Value))) } return otto.UndefinedValue() @@ -44,10 +44,10 @@ type JSLog struct { func NewJSLog(log state.Log) JSLog { return JSLog{ - Address: ethutil.Bytes2Hex(log.Address()), - Topics: nil, //ethutil.Bytes2Hex(log.Address()), + Address: common.Bytes2Hex(log.Address()), + Topics: nil, //common.Bytes2Hex(log.Address()), Number: 0, - Data: ethutil.Bytes2Hex(log.Data()), + Data: common.Bytes2Hex(log.Data()), } } diff --git a/logger/log.go b/logger/log.go index baa3dfaf25..2dbec86de8 100644 --- a/logger/log.go +++ b/logger/log.go @@ -6,11 +6,11 @@ import ( "log" "os" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func openLogFile(datadir string, filename string) *os.File { - path := ethutil.AbsolutePath(datadir, filename) + path := common.AbsolutePath(datadir, filename) file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) if err != nil { panic(fmt.Sprintf("error opening log file '%s': %v", filename, err)) diff --git a/miner/worker.go b/miner/worker.go index 5c4a136985..10fc6f508c 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -9,7 +9,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow" @@ -155,10 +155,10 @@ func (self *worker) wait() { self.current.block.Header().MixDigest = work.MixDigest jsonlogger.LogJson(&logger.EthMinerNewBlock{ - BlockHash: ethutil.Bytes2Hex(block.Hash()), + BlockHash: common.Bytes2Hex(block.Hash()), BlockNumber: block.Number(), - ChainHeadHash: ethutil.Bytes2Hex(block.ParentHeaderHash), - BlockPrevHash: ethutil.Bytes2Hex(block.ParentHeaderHash), + ChainHeadHash: common.Bytes2Hex(block.ParentHeaderHash), + BlockPrevHash: common.Bytes2Hex(block.ParentHeaderHash), }) if err := self.chain.InsertChain(types.Blocks{self.current.block}); err == nil { @@ -221,7 +221,7 @@ gasLimit: self.current.state.AddBalance(self.coinbase, core.BlockReward) - self.current.state.Update(ethutil.Big0) + self.current.state.Update(common.Big0) self.push() } diff --git a/p2p/message.go b/p2p/message.go index f88c31d1de..14e4404c9a 100644 --- a/p2p/message.go +++ b/p2p/message.go @@ -11,7 +11,7 @@ import ( "sync/atomic" "time" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" ) @@ -30,7 +30,7 @@ type Msg struct { // NewMsg creates an RLP-encoded message with the given code. func NewMsg(code uint64, params ...interface{}) Msg { - p := bytes.NewReader(ethutil.Encode(params)) + p := bytes.NewReader(common.Encode(params)) return Msg{Code: code, Size: uint32(p.Len()), Payload: p} } diff --git a/p2p/server.go b/p2p/server.go index 9762fcc6d9..02f1b8572d 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -9,7 +9,7 @@ import ( "sync" "time" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/nat" @@ -46,7 +46,7 @@ type Server struct { MaxPeers int // Name sets the node name of this server. - // Use ethutil.MakeName to create a name that follows existing conventions. + // Use common.MakeName to create a name that follows existing conventions. Name string // Bootstrap nodes are used to establish connectivity @@ -132,7 +132,7 @@ func (srv *Server) SuggestPeer(n *discover.Node) { func (srv *Server) Broadcast(protocol string, code uint64, data ...interface{}) { var payload []byte if data != nil { - payload = ethutil.Encode(data) + payload = common.Encode(data) } srv.lock.RLock() defer srv.lock.RUnlock() diff --git a/pow/dagger/dagger.go b/pow/dagger/dagger.go index 3da7683d56..f2d65e8efe 100644 --- a/pow/dagger/dagger.go +++ b/pow/dagger/dagger.go @@ -7,7 +7,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto/sha3" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" ) @@ -50,7 +50,7 @@ func (dag *Dagger) Search(hash, diff *big.Int) ([]byte, []byte, []byte) { dag.hash = hash - obj := ethutil.BigPow(2, 256) + obj := common.BigPow(2, 256) obj = obj.Div(obj, diff) Found = false @@ -75,7 +75,7 @@ func (dag *Dagger) Search(hash, diff *big.Int) ([]byte, []byte, []byte) { func (dag *Dagger) Verify(hash, diff, nonce *big.Int) bool { dag.hash = hash - obj := ethutil.BigPow(2, 256) + obj := common.BigPow(2, 256) obj = obj.Div(obj, diff) return dag.Eval(nonce).Cmp(obj) < 0 @@ -85,7 +85,7 @@ func DaggerVerify(hash, diff, nonce *big.Int) bool { dagger := &Dagger{} dagger.hash = hash - obj := ethutil.BigPow(2, 256) + obj := common.BigPow(2, 256) obj = obj.Div(obj, diff) return dagger.Eval(nonce).Cmp(obj) < 0 @@ -133,7 +133,7 @@ func Sum(sha hash.Hash) []byte { } func (dag *Dagger) Eval(N *big.Int) *big.Int { - pow := ethutil.BigPow(2, 26) + pow := common.BigPow(2, 26) dag.xn = pow.Div(N, pow) sha := sha3.NewKeccak256() diff --git a/pow/dagger/dagger_test.go b/pow/dagger/dagger_test.go index f3a71d1eb4..f53f4bac98 100644 --- a/pow/dagger/dagger_test.go +++ b/pow/dagger/dagger_test.go @@ -4,12 +4,12 @@ import ( "math/big" "testing" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func BenchmarkDaggerSearch(b *testing.B) { hash := big.NewInt(0) - diff := ethutil.BigPow(2, 36) + diff := common.BigPow(2, 36) o := big.NewInt(0) // nonce doesn't matter. We're only testing against speed, not validity // Reset timer so the big generation isn't included in the benchmark diff --git a/pow/ezp/pow.go b/pow/ezp/pow.go index 3ca502d060..7eba95784b 100644 --- a/pow/ezp/pow.go +++ b/pow/ezp/pow.go @@ -7,7 +7,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto/sha3" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow" ) @@ -91,8 +91,8 @@ func verify(hash []byte, diff *big.Int, nonce uint64) bool { d := append(hash, n...) sha.Write(d) - verification := new(big.Int).Div(ethutil.BigPow(2, 256), diff) - res := ethutil.BigD(sha.Sum(nil)) + verification := new(big.Int).Div(common.BigPow(2, 256), diff) + res := common.BigD(sha.Sum(nil)) return res.Cmp(verification) <= 0 } diff --git a/rpc/api.go b/rpc/api.go index 2137de356b..1846e7db5a 100644 --- a/rpc/api.go +++ b/rpc/api.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event/filter" "github.com/ethereum/go-ethereum/state" @@ -43,7 +43,7 @@ type EthereumApi struct { regmut sync.Mutex register map[string][]*NewTxArgs - db ethutil.Database + db common.Database } func NewEthereumApi(eth *xeth.XEth, dataDir string) *EthereumApi { @@ -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(ethutil.FromHex(args.From)) + account := accounts.Get(common.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(ethutil.FromHex(args.To), ethutil.FromHex(args.Value), ethutil.FromHex(args.Gas), ethutil.FromHex(args.GasPrice), ethutil.FromHex(args.Data)) + result, _ := account.Transact(common.FromHex(args.To), common.FromHex(args.Value), common.FromHex(args.Gas), common.FromHex(args.GasPrice), common.FromHex(args.Data)) if len(result) > 0 { *reply = toHex(result) } @@ -258,7 +258,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) (err error) } */ // TODO: align default values to have the same type, e.g. not depend on - // ethutil.Value conversions later on + // common.Value conversions later on if args.Gas.Cmp(big.NewInt(0)) == 0 { args.Gas = defaultGas } @@ -316,7 +316,7 @@ func (p *EthereumApi) GetStorageAt(args *GetStorageAtArgs, reply *interface{}) e } else { // Convert the incoming string (which is a bigint) into hex i, _ := new(big.Int).SetString(args.Key, 10) - hx = ethutil.Bytes2Hex(i.Bytes()) + hx = common.Bytes2Hex(i.Bytes()) } rpclogger.Debugf("GetStateAt(%s, %s)\n", args.Address, hx) *reply = map[string]string{args.Key: value.Str()} @@ -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(ethutil.FromHex(args.Data))) + *reply = toHex(crypto.Sha3(common.FromHex(args.Data))) case "web3_clientVersion": *reply = p.xeth().Backend().Version() case "net_version": @@ -821,12 +821,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{ethutil.FromHex(str)} + opts.Address = [][]byte{common.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] = ethutil.FromHex(saddr) + bslice[i] = common.FromHex(saddr) } } opts.Address = bslice @@ -840,11 +840,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] = ethutil.FromHex(topic.(string)) + topics[i][j] = common.FromHex(topic.(string)) } } else if str, ok := topicDat.(string); ok { topics[i] = make([][]byte, 1) - topics[i][0] = ethutil.FromHex(str) + topics[i][0] = common.FromHex(str) } } opts.Topics = topics diff --git a/rpc/args.go b/rpc/args.go index b935c50071..7ed482c301 100644 --- a/rpc/args.go +++ b/rpc/args.go @@ -5,7 +5,7 @@ import ( "encoding/json" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func blockNumber(raw json.RawMessage, number *int64) (err error) { @@ -20,7 +20,7 @@ func blockNumber(raw json.RawMessage, number *int64) (err error) { case "pending": *number = 0 default: - *number = ethutil.String2Big(str).Int64() + *number = common.String2Big(str).Int64() } return nil } @@ -73,7 +73,7 @@ func (args *GetBlockByNumberArgs) UnmarshalJSON(b []byte) (err error) { if v, ok := obj[0].(float64); ok { args.BlockNumber = int64(v) } else { - args.BlockNumber = ethutil.Big(obj[0].(string)).Int64() + args.BlockNumber = common.Big(obj[0].(string)).Int64() } if len(obj) > 1 { @@ -102,9 +102,9 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) { args.From = obj.From args.To = obj.To - args.Value = ethutil.Big(obj.Value) - args.Gas = ethutil.Big(obj.Gas) - args.GasPrice = ethutil.Big(obj.GasPrice) + args.Value = common.Big(obj.Value) + args.Gas = common.Big(obj.Gas) + args.GasPrice = common.Big(obj.GasPrice) args.Data = obj.Data return nil @@ -208,7 +208,7 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) { if obj[1].(string) == "latest" { args.BlockNumber = -1 } else { - args.BlockNumber = ethutil.Big(obj[1].(string)).Int64() + args.BlockNumber = common.Big(obj[1].(string)).Int64() } } @@ -266,14 +266,14 @@ func (args *BlockNumIndexArgs) UnmarshalJSON(b []byte) (err error) { if !ok { return NewDecodeParamError("BlockNumber is not string") } - args.BlockNumber = ethutil.Big(arg0).Int64() + args.BlockNumber = common.Big(arg0).Int64() if len(obj) > 1 { arg1, ok := obj[1].(string) if !ok { return NewDecodeParamError("Index not a string") } - args.Index = ethutil.Big(arg1).Int64() + args.Index = common.Big(arg1).Int64() } return nil @@ -306,7 +306,7 @@ func (args *HashIndexArgs) UnmarshalJSON(b []byte) (err error) { if !ok { return NewDecodeParamError("Index not a string") } - args.Index = ethutil.Big(arg1).Int64() + args.Index = common.Big(arg1).Int64() } return nil @@ -357,10 +357,10 @@ func (args *Sha3Args) UnmarshalJSON(b []byte) (err error) { // if len(obj) < 1 { // return errArguments // } -// args.FromBlock = uint64(ethutil.Big(obj[0].FromBlock).Int64()) -// args.ToBlock = uint64(ethutil.Big(obj[0].ToBlock).Int64()) -// args.Limit = uint64(ethutil.Big(obj[0].Limit).Int64()) -// args.Offset = uint64(ethutil.Big(obj[0].Offset).Int64()) +// args.FromBlock = uint64(common.Big(obj[0].FromBlock).Int64()) +// args.ToBlock = uint64(common.Big(obj[0].ToBlock).Int64()) +// args.Limit = uint64(common.Big(obj[0].Limit).Int64()) +// args.Offset = uint64(common.Big(obj[0].Offset).Int64()) // args.Address = obj[0].Address // args.Topics = obj[0].Topics @@ -394,10 +394,10 @@ func (args *FilterOptions) UnmarshalJSON(b []byte) (err error) { return NewInsufficientParamsError(len(obj), 1) } - args.Earliest = int64(ethutil.Big(obj[0].FromBlock).Int64()) - args.Latest = int64(ethutil.Big(obj[0].ToBlock).Int64()) - args.Max = int(ethutil.Big(obj[0].Limit).Int64()) - args.Skip = int(ethutil.Big(obj[0].Offset).Int64()) + args.Earliest = int64(common.Big(obj[0].FromBlock).Int64()) + args.Latest = int64(common.Big(obj[0].ToBlock).Int64()) + args.Max = int(common.Big(obj[0].Limit).Int64()) + args.Skip = int(common.Big(obj[0].Offset).Int64()) args.Address = obj[0].Address args.Topics = obj[0].Topics @@ -474,8 +474,8 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) { args.To = obj[0].To args.From = obj[0].From args.Topics = obj[0].Topics - args.Priority = uint32(ethutil.Big(obj[0].Priority).Int64()) - args.Ttl = uint32(ethutil.Big(obj[0].Ttl).Int64()) + args.Priority = uint32(common.Big(obj[0].Priority).Int64()) + args.Ttl = uint32(common.Big(obj[0].Ttl).Int64()) return nil } @@ -538,7 +538,7 @@ func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) { return NewInsufficientParamsError(len(obj), 1) } - args.Id = int(ethutil.Big(obj[0]).Int64()) + args.Id = int(common.Big(obj[0]).Int64()) return nil } diff --git a/rpc/util.go b/rpc/util.go index 4acd902849..08f404c998 100644 --- a/rpc/util.go +++ b/rpc/util.go @@ -25,7 +25,7 @@ import ( "reflect" "time" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/xeth" @@ -120,7 +120,7 @@ func (self JsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) } func toHex(b []byte) string { - hex := ethutil.Bytes2Hex(b) + hex := common.Bytes2Hex(b) // Prefer output of "0x0" instead of "0x" if len(hex) == 0 { hex = "0" diff --git a/state/dump.go b/state/dump.go index 2c611d76b4..c5f556e1a5 100644 --- a/state/dump.go +++ b/state/dump.go @@ -4,7 +4,7 @@ import ( "encoding/json" "fmt" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type Account struct { @@ -22,7 +22,7 @@ type World struct { func (self *StateDB) RawDump() World { world := World{ - Root: ethutil.Bytes2Hex(self.trie.Root()), + Root: common.Bytes2Hex(self.trie.Root()), Accounts: make(map[string]Account), } @@ -30,14 +30,14 @@ func (self *StateDB) RawDump() World { for it.Next() { stateObject := NewStateObjectFromBytes(it.Key, it.Value, self.db) - account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.nonce, Root: ethutil.Bytes2Hex(stateObject.Root()), CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)} + account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.nonce, Root: common.Bytes2Hex(stateObject.Root()), CodeHash: common.Bytes2Hex(stateObject.codeHash)} account.Storage = make(map[string]string) storageIt := stateObject.State.trie.Iterator() for storageIt.Next() { - account.Storage[ethutil.Bytes2Hex(storageIt.Key)] = ethutil.Bytes2Hex(storageIt.Value) + account.Storage[common.Bytes2Hex(storageIt.Key)] = common.Bytes2Hex(storageIt.Value) } - world.Accounts[ethutil.Bytes2Hex(it.Key)] = account + world.Accounts[common.Bytes2Hex(it.Key)] = account } return world } diff --git a/state/log.go b/state/log.go index d503bd1a07..a0859aaf20 100644 --- a/state/log.go +++ b/state/log.go @@ -3,11 +3,11 @@ package state import ( "fmt" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type Log interface { - ethutil.RlpEncodable + common.RlpEncodable Address() []byte Topics() [][]byte @@ -43,7 +43,7 @@ func (self *StateLog) Number() uint64 { return self.number } -func NewLogFromValue(decoder *ethutil.Value) *StateLog { +func NewLogFromValue(decoder *common.Value) *StateLog { log := &StateLog{ address: decoder.Get(0).Bytes(), data: decoder.Get(2).Bytes(), @@ -58,7 +58,7 @@ func NewLogFromValue(decoder *ethutil.Value) *StateLog { } func (self *StateLog) RlpData() interface{} { - return []interface{}{self.address, ethutil.ByteSliceToInterface(self.topics), self.data} + return []interface{}{self.address, common.ByteSliceToInterface(self.topics), self.data} } func (self *StateLog) String() string { diff --git a/state/managed_state_test.go b/state/managed_state_test.go index f819d8ad3c..4aad1e1e34 100644 --- a/state/managed_state_test.go +++ b/state/managed_state_test.go @@ -3,10 +3,10 @@ package state import ( "testing" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) -var addr = ethutil.Address([]byte("test")) +var addr = common.Address([]byte("test")) func create() (*ManagedState, *account) { ms := ManageState(&StateDB{stateObjects: make(map[string]*StateObject)}) diff --git a/state/state_object.go b/state/state_object.go index dccbe8dade..8be9e28fcb 100644 --- a/state/state_object.go +++ b/state/state_object.go @@ -6,7 +6,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) @@ -17,7 +17,7 @@ func (self Code) String() string { return string(self) //strings.Join(Disassemble(self), " ") } -type Storage map[string]*ethutil.Value +type Storage map[string]*common.Value func (self Storage) String() (str string) { for key, value := range self { @@ -39,7 +39,7 @@ func (self Storage) Copy() Storage { type StateObject struct { // State database for storing state changes - db ethutil.Database + db common.Database // The state object State *StateDB @@ -77,12 +77,12 @@ func (self *StateObject) Reset() { self.State.Reset() } -func NewStateObject(addr []byte, db ethutil.Database) *StateObject { +func NewStateObject(addr []byte, db common.Database) *StateObject { // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter. - address := ethutil.Address(addr) + address := common.Address(addr) object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int), dirty: true} - object.State = New(nil, db) //New(trie.New(ethutil.Config.Db, "")) + object.State = New(nil, db) //New(trie.New(common.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) object.prepaid = new(big.Int) @@ -90,7 +90,7 @@ func NewStateObject(addr []byte, db ethutil.Database) *StateObject { return object } -func NewStateObjectFromBytes(address, data []byte, db ethutil.Database) *StateObject { +func NewStateObjectFromBytes(address, data []byte, db common.Database) *StateObject { // TODO clean me up var extobject struct { Nonce uint64 @@ -110,7 +110,7 @@ func NewStateObjectFromBytes(address, data []byte, db ethutil.Database) *StateOb object.balance = extobject.Balance object.codeHash = extobject.CodeHash object.State = New(extobject.Root, db) - object.storage = make(map[string]*ethutil.Value) + object.storage = make(map[string]*common.Value) object.gasPool = new(big.Int) object.prepaid = new(big.Int) object.code, _ = db.Get(extobject.CodeHash) @@ -124,18 +124,18 @@ func (self *StateObject) MarkForDeletion() { statelogger.Debugf("%x: #%d %v X\n", self.Address(), self.nonce, self.balance) } -func (c *StateObject) getAddr(addr []byte) *ethutil.Value { - return ethutil.NewValueFromBytes([]byte(c.State.trie.Get(addr))) +func (c *StateObject) getAddr(addr []byte) *common.Value { + return common.NewValueFromBytes([]byte(c.State.trie.Get(addr))) } func (c *StateObject) setAddr(addr []byte, value interface{}) { - c.State.trie.Update(addr, ethutil.Encode(value)) + c.State.trie.Update(addr, common.Encode(value)) } -func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value { +func (self *StateObject) GetStorage(key *big.Int) *common.Value { return self.GetState(key.Bytes()) } -func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) { +func (self *StateObject) SetStorage(key *big.Int, value *common.Value) { self.SetState(key.Bytes(), value) } @@ -143,8 +143,8 @@ func (self *StateObject) Storage() Storage { return self.storage } -func (self *StateObject) GetState(k []byte) *ethutil.Value { - key := ethutil.LeftPadBytes(k, 32) +func (self *StateObject) GetState(k []byte) *common.Value { + key := common.LeftPadBytes(k, 32) value := self.storage[string(key)] if value == nil { @@ -158,8 +158,8 @@ func (self *StateObject) GetState(k []byte) *ethutil.Value { return value } -func (self *StateObject) SetState(k []byte, value *ethutil.Value) { - key := ethutil.LeftPadBytes(k, 32) +func (self *StateObject) SetState(k []byte, value *common.Value) { + key := common.LeftPadBytes(k, 32) self.storage[string(key)] = value.Copy() self.dirty = true } @@ -176,12 +176,12 @@ func (self *StateObject) Sync() { self.storage = make(Storage) } -func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value { +func (c *StateObject) GetInstr(pc *big.Int) *common.Value { if int64(len(c.code)-1) < pc.Int64() { - return ethutil.NewValue(0) + return common.NewValue(0) } - return ethutil.NewValueFromBytes([]byte{c.code[pc.Int64()]}) + return common.NewValueFromBytes([]byte{c.code[pc.Int64()]}) } func (c *StateObject) AddBalance(amount *big.Int) { @@ -252,13 +252,13 @@ func (self *StateObject) RefundGas(gas, price *big.Int) { func (self *StateObject) Copy() *StateObject { stateObject := NewStateObject(self.Address(), self.db) stateObject.balance.Set(self.balance) - stateObject.codeHash = ethutil.CopyBytes(self.codeHash) + stateObject.codeHash = common.CopyBytes(self.codeHash) stateObject.nonce = self.nonce if self.State != nil { stateObject.State = self.State.Copy() } - stateObject.code = ethutil.CopyBytes(self.code) - stateObject.initCode = ethutil.CopyBytes(self.initCode) + stateObject.code = common.CopyBytes(self.code) + stateObject.initCode = common.CopyBytes(self.initCode) stateObject.storage = self.storage.Copy() stateObject.gasPool.Set(self.gasPool) stateObject.remove = self.remove @@ -330,19 +330,19 @@ func (self *StateObject) Nonce() uint64 { // State object encoding methods func (c *StateObject) RlpEncode() []byte { - return ethutil.Encode([]interface{}{c.nonce, c.balance, c.Root(), c.CodeHash()}) + return common.Encode([]interface{}{c.nonce, c.balance, c.Root(), c.CodeHash()}) } -func (c *StateObject) CodeHash() ethutil.Bytes { +func (c *StateObject) CodeHash() common.Bytes { return crypto.Sha3(c.code) } func (c *StateObject) RlpDecode(data []byte) { - decoder := ethutil.NewValueFromBytes(data) + decoder := common.NewValueFromBytes(data) c.nonce = decoder.Get(0).Uint() c.balance = decoder.Get(1).BigInt() - c.State = New(decoder.Get(2).Bytes(), c.db) //New(trie.New(ethutil.Config.Db, decoder.Get(2).Interface())) - c.storage = make(map[string]*ethutil.Value) + c.State = New(decoder.Get(2).Bytes(), c.db) //New(trie.New(common.Config.Db, decoder.Get(2).Interface())) + c.storage = make(map[string]*common.Value) c.gasPool = new(big.Int) c.codeHash = decoder.Get(3).Bytes() diff --git a/state/state_test.go b/state/state_test.go index 07e35f7e28..3ecc03ae03 100644 --- a/state/state_test.go +++ b/state/state_test.go @@ -6,7 +6,7 @@ import ( checker "gopkg.in/check.v1" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type StateSuite struct { @@ -63,9 +63,9 @@ func (s *StateSuite) SetUpTest(c *checker.C) { func (s *StateSuite) TestSnapshot(c *checker.C) { stateobjaddr := []byte("aa") - storageaddr := ethutil.Big("0") - data1 := ethutil.NewValue(42) - data2 := ethutil.NewValue(43) + storageaddr := common.Big("0") + data1 := common.NewValue(42) + data2 := common.NewValue(43) // get state object stateObject := s.state.GetOrNewStateObject(stateobjaddr) diff --git a/state/statedb.go b/state/statedb.go index a0dc7732f7..80bbe2afdc 100644 --- a/state/statedb.go +++ b/state/statedb.go @@ -4,7 +4,7 @@ import ( "bytes" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/trie" ) @@ -17,7 +17,7 @@ var statelogger = logger.NewLogger("STATE") // * Contracts // * Accounts type StateDB struct { - db ethutil.Database + db common.Database trie *trie.SecureTrie stateObjects map[string]*StateObject @@ -28,8 +28,8 @@ type StateDB struct { } // Create a new state from a given trie -func New(root []byte, db ethutil.Database) *StateDB { - trie := trie.NewSecure(ethutil.CopyBytes(root), db) +func New(root []byte, db common.Database) *StateDB { + trie := trie.NewSecure(common.CopyBytes(root), db) return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), refund: make(map[string]*big.Int)} } @@ -59,7 +59,7 @@ func (self *StateDB) GetBalance(addr []byte) *big.Int { return stateObject.balance } - return ethutil.Big0 + return common.Big0 } func (self *StateDB) AddBalance(addr []byte, amount *big.Int) { @@ -113,7 +113,7 @@ func (self *StateDB) SetCode(addr, code []byte) { func (self *StateDB) SetState(addr, key []byte, value interface{}) { stateObject := self.GetStateObject(addr) if stateObject != nil { - stateObject.SetState(key, ethutil.NewValue(value)) + stateObject.SetState(key, common.NewValue(value)) } } @@ -161,7 +161,7 @@ func (self *StateDB) DeleteStateObject(stateObject *StateObject) { // Retrieve a state object given my the address. Nil if not found func (self *StateDB) GetStateObject(addr []byte) *StateObject { - addr = ethutil.Address(addr) + addr = common.Address(addr) stateObject := self.stateObjects[string(addr)] if stateObject != nil { @@ -195,7 +195,7 @@ func (self *StateDB) GetOrNewStateObject(addr []byte) *StateObject { // Create a state object whether it exist in the trie or not func (self *StateDB) NewStateObject(addr []byte) *StateObject { - addr = ethutil.Address(addr) + addr = common.Address(addr) statelogger.Debugf("(+) %x\n", addr) diff --git a/tests/blocktest.go b/tests/blocktest.go index 6a9cf5f6dc..0b923f08b3 100644 --- a/tests/blocktest.go +++ b/tests/blocktest.go @@ -13,7 +13,7 @@ import ( "strings" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/state" ) @@ -97,7 +97,7 @@ func LoadBlockTests(file string) (map[string]*BlockTest, error) { // InsertPreState populates the given database with the genesis // accounts defined by the test. -func (t *BlockTest) InsertPreState(db ethutil.Database) error { +func (t *BlockTest) InsertPreState(db common.Database) error { statedb := state.New(nil, db) for addrString, acct := range t.preAccounts { // XXX: is is worth it checking for errors here? diff --git a/tests/helper/common.go b/tests/helper/common.go index 6a071968d2..21ea2261ff 100644 --- a/tests/helper/common.go +++ b/tests/helper/common.go @@ -1,11 +1,11 @@ package helper -import "github.com/ethereum/go-ethereum/ethutil" +import "github.com/ethereum/go-ethereum/common" func FromHex(h string) []byte { - if ethutil.IsHex(h) { + if common.IsHex(h) { h = h[2:] } - return ethutil.Hex2Bytes(h) + return common.Hex2Bytes(h) } diff --git a/tests/helper/vm.go b/tests/helper/vm.go index f1aaf74b8e..a7fd98696f 100644 --- a/tests/helper/vm.go +++ b/tests/helper/vm.go @@ -6,7 +6,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/vm" ) @@ -41,13 +41,13 @@ func NewEnv(state *state.StateDB) *Env { func NewEnvFromMap(state *state.StateDB, envValues map[string]string, exeValues map[string]string) *Env { env := NewEnv(state) - env.origin = ethutil.Hex2Bytes(exeValues["caller"]) - env.parent = ethutil.Hex2Bytes(envValues["previousHash"]) - env.coinbase = ethutil.Hex2Bytes(envValues["currentCoinbase"]) - env.number = ethutil.Big(envValues["currentNumber"]) - env.time = ethutil.Big(envValues["currentTimestamp"]).Int64() - env.difficulty = ethutil.Big(envValues["currentDifficulty"]) - env.gasLimit = ethutil.Big(envValues["currentGasLimit"]) + env.origin = common.Hex2Bytes(exeValues["caller"]) + env.parent = common.Hex2Bytes(envValues["previousHash"]) + env.coinbase = common.Hex2Bytes(envValues["currentCoinbase"]) + env.number = common.Big(envValues["currentNumber"]) + env.time = common.Big(envValues["currentTimestamp"]).Int64() + env.difficulty = common.Big(envValues["currentDifficulty"]) + env.gasLimit = common.Big(envValues["currentGasLimit"]) env.Gas = new(big.Int) return env @@ -135,9 +135,9 @@ func RunVm(state *state.StateDB, env, exec map[string]string) ([]byte, state.Log to = FromHex(exec["address"]) from = FromHex(exec["caller"]) data = FromHex(exec["data"]) - gas = ethutil.Big(exec["gas"]) - price = ethutil.Big(exec["gasPrice"]) - value = ethutil.Big(exec["value"]) + gas = common.Big(exec["gas"]) + price = common.Big(exec["gasPrice"]) + value = common.Big(exec["value"]) ) // Reset the pre-compiled contracts for VM tests. vm.Precompiled = make(map[string]*vm.PrecompiledAccount) @@ -155,12 +155,12 @@ func RunVm(state *state.StateDB, env, exec map[string]string) ([]byte, state.Log func RunState(statedb *state.StateDB, env, tx map[string]string) ([]byte, state.Logs, *big.Int, error) { var ( - keyPair, _ = crypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(tx["secretKey"]))) + keyPair, _ = crypto.NewKeyPairFromSec([]byte(common.Hex2Bytes(tx["secretKey"]))) to = FromHex(tx["to"]) data = FromHex(tx["data"]) - gas = ethutil.Big(tx["gasLimit"]) - price = ethutil.Big(tx["gasPrice"]) - value = ethutil.Big(tx["value"]) + gas = common.Big(tx["gasLimit"]) + price = common.Big(tx["gasPrice"]) + value = common.Big(tx["value"]) caddr = FromHex(env["currentCoinbase"]) ) @@ -169,7 +169,7 @@ func RunState(statedb *state.StateDB, env, tx map[string]string) ([]byte, state. snapshot := statedb.Copy() coinbase := statedb.GetOrNewStateObject(caddr) - coinbase.SetGasPool(ethutil.Big(env["currentGasLimit"])) + coinbase.SetGasPool(common.Big(env["currentGasLimit"])) message := NewMessage(keyPair.Address(), to, data, value, gas, price) vmenv := NewEnvFromMap(statedb, env, tx) diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go index 1e8cd5b51c..24718de7b6 100644 --- a/tests/vm/gh_test.go +++ b/tests/vm/gh_test.go @@ -7,7 +7,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/tests/helper" @@ -27,26 +27,26 @@ type Log struct { BloomF string `json:"bloom"` } -func (self Log) Address() []byte { return ethutil.Hex2Bytes(self.AddressF) } -func (self Log) Data() []byte { return ethutil.Hex2Bytes(self.DataF) } +func (self Log) Address() []byte { return common.Hex2Bytes(self.AddressF) } +func (self Log) Data() []byte { return common.Hex2Bytes(self.DataF) } func (self Log) RlpData() interface{} { return nil } func (self Log) Topics() [][]byte { t := make([][]byte, len(self.TopicsF)) for i, topic := range self.TopicsF { - t[i] = ethutil.Hex2Bytes(topic) + t[i] = common.Hex2Bytes(topic) } return t } -func StateObjectFromAccount(db ethutil.Database, addr string, account Account) *state.StateObject { - obj := state.NewStateObject(ethutil.Hex2Bytes(addr), db) - obj.SetBalance(ethutil.Big(account.Balance)) +func StateObjectFromAccount(db common.Database, addr string, account Account) *state.StateObject { + obj := state.NewStateObject(common.Hex2Bytes(addr), db) + obj.SetBalance(common.Big(account.Balance)) - if ethutil.IsHex(account.Code) { + if common.IsHex(account.Code) { account.Code = account.Code[2:] } - obj.SetCode(ethutil.Hex2Bytes(account.Code)) - obj.SetNonce(ethutil.Big(account.Nonce).Uint64()) + obj.SetCode(common.Hex2Bytes(account.Code)) + obj.SetNonce(common.Big(account.Nonce).Uint64()) return obj } @@ -86,7 +86,7 @@ func RunVmTest(p string, t *testing.T) { obj := StateObjectFromAccount(db, addr, account) statedb.SetStateObject(obj) for a, v := range account.Storage { - obj.SetState(helper.FromHex(a), ethutil.NewValue(helper.FromHex(v))) + obj.SetState(helper.FromHex(a), common.NewValue(helper.FromHex(v))) } } @@ -126,7 +126,7 @@ func RunVmTest(p string, t *testing.T) { if len(test.Gas) == 0 && err == nil { t.Errorf("%s's gas unspecified, indicating an error. VM returned (incorrectly) successfull", name) } else { - gexp := ethutil.Big(test.Gas) + gexp := common.Big(test.Gas) if gexp.Cmp(gas) != 0 { t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas) } @@ -140,8 +140,8 @@ func RunVmTest(p string, t *testing.T) { } if len(test.Exec) == 0 { - if obj.Balance().Cmp(ethutil.Big(account.Balance)) != 0 { - t.Errorf("%s's : (%x) balance failed. Expected %v, got %v => %v\n", name, obj.Address()[:4], account.Balance, obj.Balance(), new(big.Int).Sub(ethutil.Big(account.Balance), obj.Balance())) + if obj.Balance().Cmp(common.Big(account.Balance)) != 0 { + t.Errorf("%s's : (%x) balance failed. Expected %v, got %v => %v\n", name, obj.Address()[:4], account.Balance, obj.Balance(), new(big.Int).Sub(common.Big(account.Balance), obj.Balance())) } } @@ -150,14 +150,14 @@ func RunVmTest(p string, t *testing.T) { vexp := helper.FromHex(value) if bytes.Compare(v, vexp) != 0 { - t.Errorf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v)) + t.Errorf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, common.BigD(vexp), common.BigD(v)) } } } if !isVmTest { statedb.Sync() - if !bytes.Equal(ethutil.Hex2Bytes(test.PostStateRoot), statedb.Root()) { + if !bytes.Equal(common.Hex2Bytes(test.PostStateRoot), statedb.Root()) { t.Errorf("%s's : Post state root error. Expected %s, got %x", name, test.PostStateRoot, statedb.Root()) } } @@ -170,8 +170,8 @@ func RunVmTest(p string, t *testing.T) { fmt.Println("A", test.Logs) fmt.Println("B", logs) for i, log := range test.Logs { - genBloom := ethutil.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256) - if !bytes.Equal(genBloom, ethutil.Hex2Bytes(log.BloomF)) { + genBloom := common.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256) + if !bytes.Equal(genBloom, common.Hex2Bytes(log.BloomF)) { t.Errorf("bloom mismatch") } } diff --git a/trie/hashnode.go b/trie/hashnode.go index e46628368a..8125cc3c9f 100644 --- a/trie/hashnode.go +++ b/trie/hashnode.go @@ -1,6 +1,6 @@ package trie -import "github.com/ethereum/go-ethereum/ethutil" +import "github.com/ethereum/go-ethereum/common" type HashNode struct { key []byte @@ -22,4 +22,4 @@ func (self *HashNode) Hash() interface{} { // These methods will never be called but we have to satisfy Node interface func (self *HashNode) Value() Node { return nil } func (self *HashNode) Dirty() bool { return true } -func (self *HashNode) Copy(t *Trie) Node { return NewHash(ethutil.CopyBytes(self.key), t) } +func (self *HashNode) Copy(t *Trie) Node { return NewHash(common.CopyBytes(self.key), t) } diff --git a/trie/shortnode.go b/trie/shortnode.go index d964929584..edd490b4d0 100644 --- a/trie/shortnode.go +++ b/trie/shortnode.go @@ -1,6 +1,6 @@ package trie -import "github.com/ethereum/go-ethereum/ethutil" +import "github.com/ethereum/go-ethereum/common" type ShortNode struct { trie *Trie @@ -19,7 +19,7 @@ func (self *ShortNode) Value() Node { func (self *ShortNode) Dirty() bool { return true } func (self *ShortNode) Copy(t *Trie) Node { node := &ShortNode{t, nil, self.value.Copy(t)} - node.key = ethutil.CopyBytes(self.key) + node.key = common.CopyBytes(self.key) return node } diff --git a/trie/trie.go b/trie/trie.go index 9087f7bdaa..1c1112a7fe 100644 --- a/trie/trie.go +++ b/trie/trie.go @@ -7,7 +7,7 @@ import ( "sync" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func ParanoiaCheck(t1 *Trie, backend Backend) (bool, *Trie) { @@ -39,7 +39,7 @@ func New(root []byte, backend Backend) *Trie { } if root != nil { - value := ethutil.NewValueFromBytes(trie.cache.Get(root)) + value := common.NewValueFromBytes(trie.cache.Get(root)) trie.root = trie.mknode(value) } @@ -71,10 +71,10 @@ func (self *Trie) Hash() []byte { if byts, ok := t.([]byte); ok && len(byts) > 0 { hash = byts } else { - hash = crypto.Sha3(ethutil.Encode(self.root.RlpData())) + hash = crypto.Sha3(common.Encode(self.root.RlpData())) } } else { - hash = crypto.Sha3(ethutil.Encode("")) + hash = crypto.Sha3(common.Encode("")) } if !bytes.Equal(hash, self.roothash) { @@ -105,7 +105,7 @@ func (self *Trie) Reset() { revision := self.revisions.Remove(self.revisions.Back()).([]byte) self.roothash = revision } - value := ethutil.NewValueFromBytes(self.cache.Get(self.roothash)) + value := common.NewValueFromBytes(self.cache.Get(self.roothash)) self.root = self.mknode(value) } @@ -294,7 +294,7 @@ func (self *Trie) delete(node Node, key []byte) Node { } // casting functions and cache storing -func (self *Trie) mknode(value *ethutil.Value) Node { +func (self *Trie) mknode(value *common.Value) Node { l := value.Len() switch l { case 0: @@ -320,7 +320,7 @@ func (self *Trie) mknode(value *ethutil.Value) Node { func (self *Trie) trans(node Node) Node { switch node := node.(type) { case *HashNode: - value := ethutil.NewValueFromBytes(self.cache.Get(node.key)) + value := common.NewValueFromBytes(self.cache.Get(node.key)) return self.mknode(value) default: return node @@ -328,7 +328,7 @@ func (self *Trie) trans(node Node) Node { } func (self *Trie) store(node Node) interface{} { - data := ethutil.Encode(node) + data := common.Encode(node) if len(data) >= 32 { key := crypto.Sha3(data) self.cache.Put(key, data) diff --git a/trie/trie_test.go b/trie/trie_test.go index b6a2604837..1393e0c97c 100644 --- a/trie/trie_test.go +++ b/trie/trie_test.go @@ -6,7 +6,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type Db map[string][]byte @@ -26,7 +26,7 @@ func NewEmptySecure() *SecureTrie { func TestEmptyTrie(t *testing.T) { trie := NewEmpty() res := trie.Hash() - exp := crypto.Sha3(ethutil.Encode("")) + exp := crypto.Sha3(common.Encode("")) if !bytes.Equal(res, exp) { t.Errorf("expected %x got %x", exp, res) } @@ -39,7 +39,7 @@ func TestInsert(t *testing.T) { trie.UpdateString("dog", "puppy") trie.UpdateString("dogglesworth", "cat") - exp := ethutil.Hex2Bytes("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3") + exp := common.Hex2Bytes("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3") root := trie.Hash() if !bytes.Equal(root, exp) { t.Errorf("exp %x got %x", exp, root) @@ -48,7 +48,7 @@ func TestInsert(t *testing.T) { trie = NewEmpty() trie.UpdateString("A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") - exp = ethutil.Hex2Bytes("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab") + exp = common.Hex2Bytes("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab") root = trie.Hash() if !bytes.Equal(root, exp) { t.Errorf("exp %x got %x", exp, root) @@ -95,7 +95,7 @@ func TestDelete(t *testing.T) { } hash := trie.Hash() - exp := ethutil.Hex2Bytes("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84") + exp := common.Hex2Bytes("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84") if !bytes.Equal(hash, exp) { t.Errorf("expected %x got %x", exp, hash) } @@ -119,7 +119,7 @@ func TestEmptyValues(t *testing.T) { } hash := trie.Hash() - exp := ethutil.Hex2Bytes("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84") + exp := common.Hex2Bytes("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84") if !bytes.Equal(hash, exp) { t.Errorf("expected %x got %x", exp, hash) } @@ -168,7 +168,7 @@ func TestReset(t *testing.T) { } trie.Commit() - before := ethutil.CopyBytes(trie.roothash) + before := common.CopyBytes(trie.roothash) trie.UpdateString("should", "revert") trie.Hash() // Should have no effect @@ -177,7 +177,7 @@ func TestReset(t *testing.T) { // ### trie.Reset() - after := ethutil.CopyBytes(trie.roothash) + after := common.CopyBytes(trie.roothash) if !bytes.Equal(before, after) { t.Errorf("expected roots to be equal. %x - %x", before, after) @@ -272,8 +272,8 @@ func TestLargeData(t *testing.T) { vals := make(map[string]*kv) for i := byte(0); i < 255; i++ { - value := &kv{ethutil.LeftPadBytes([]byte{i}, 32), []byte{i}, false} - value2 := &kv{ethutil.LeftPadBytes([]byte{10, i}, 32), []byte{i}, false} + value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}, false} + value2 := &kv{common.LeftPadBytes([]byte{10, i}, 32), []byte{i}, false} trie.Update(value.k, value.v) trie.Update(value2.k, value2.v) vals[string(value.k)] = value @@ -322,7 +322,7 @@ func TestSecureDelete(t *testing.T) { } hash := trie.Hash() - exp := ethutil.Hex2Bytes("29b235a58c3c25ab83010c327d5932bcf05324b7d6b1185e650798034783ca9d") + exp := common.Hex2Bytes("29b235a58c3c25ab83010c327d5932bcf05324b7d6b1185e650798034783ca9d") if !bytes.Equal(hash, exp) { t.Errorf("expected %x got %x", exp, hash) } diff --git a/trie/valuenode.go b/trie/valuenode.go index 8912b1c82b..7bf8ff06e6 100644 --- a/trie/valuenode.go +++ b/trie/valuenode.go @@ -1,6 +1,6 @@ package trie -import "github.com/ethereum/go-ethereum/ethutil" +import "github.com/ethereum/go-ethereum/common" type ValueNode struct { trie *Trie @@ -10,6 +10,6 @@ type ValueNode struct { func (self *ValueNode) Value() Node { return self } // Best not to call :-) func (self *ValueNode) Val() []byte { return self.data } func (self *ValueNode) Dirty() bool { return true } -func (self *ValueNode) Copy(t *Trie) Node { return &ValueNode{t, ethutil.CopyBytes(self.data)} } +func (self *ValueNode) Copy(t *Trie) Node { return &ValueNode{t, common.CopyBytes(self.data)} } func (self *ValueNode) RlpData() interface{} { return self.data } func (self *ValueNode) Hash() interface{} { return self.data } diff --git a/ui/qt/qwhisper/message.go b/ui/qt/qwhisper/message.go index 26e72ac932..f8bed8a2d6 100644 --- a/ui/qt/qwhisper/message.go +++ b/ui/qt/qwhisper/message.go @@ -2,7 +2,7 @@ package qwhisper import ( "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/whisper" ) @@ -17,7 +17,7 @@ func ToQMessage(msg *whisper.Message) *Message { return &Message{ ref: msg, Flags: int32(msg.Flags), - Payload: "0x" + ethutil.Bytes2Hex(msg.Payload), - From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())), + Payload: "0x" + common.Bytes2Hex(msg.Payload), + From: "0x" + common.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())), } } diff --git a/ui/qt/qwhisper/whisper.go b/ui/qt/qwhisper/whisper.go index 7fef1929f8..90ec822aa5 100644 --- a/ui/qt/qwhisper/whisper.go +++ b/ui/qt/qwhisper/whisper.go @@ -5,7 +5,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/whisper" "github.com/obscuren/qml" @@ -13,7 +13,7 @@ import ( var qlogger = logger.NewLogger("QSHH") -func toHex(b []byte) string { return "0x" + ethutil.Bytes2Hex(b) } +func toHex(b []byte) string { return "0x" + common.Bytes2Hex(b) } type Whisper struct { *whisper.Whisper @@ -33,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, ethutil.FromHex(d)...) + data = append(data, common.FromHex(d)...) } - pk := crypto.ToECDSAPub(ethutil.FromHex(from)) + pk := crypto.ToECDSAPub(common.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(ethutil.FromHex(to)), + To: crypto.ToECDSAPub(common.FromHex(to)), From: key, Topics: whisper.TopicsFromString(topics...), }) @@ -70,7 +70,7 @@ func (self *Whisper) NewIdentity() string { } func (self *Whisper) HasIdentity(key string) bool { - return self.Whisper.HasIdentity(crypto.ToECDSAPub(ethutil.FromHex(key))) + return self.Whisper.HasIdentity(crypto.ToECDSAPub(common.FromHex(key))) } func (self *Whisper) Watch(opts map[string]interface{}, view *qml.Common) int { @@ -88,9 +88,9 @@ func (self *Whisper) Watch(opts map[string]interface{}, view *qml.Common) int { return i } -func (self *Whisper) Messages(id int) (messages *ethutil.List) { +func (self *Whisper) Messages(id int) (messages *common.List) { msgs := self.Whisper.Messages(id) - messages = ethutil.EmptyList() + messages = common.EmptyList() for _, message := range msgs { messages.Append(ToQMessage(message)) } @@ -100,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(ethutil.FromHex(to)) + f.To = crypto.ToECDSAPub(common.FromHex(to)) } if from, ok := opts["from"].(string); ok { - f.From = crypto.ToECDSAPub(ethutil.FromHex(from)) + f.From = crypto.ToECDSAPub(common.FromHex(from)) } if topicList, ok := opts["topics"].(*qml.List); ok { var topics []string diff --git a/vm/address.go b/vm/address.go index b1345da8f9..215f4bc8fa 100644 --- a/vm/address.go +++ b/vm/address.go @@ -4,7 +4,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type Address interface { @@ -26,25 +26,25 @@ var Precompiled = PrecompiledContracts() func PrecompiledContracts() map[string]*PrecompiledAccount { return map[string]*PrecompiledAccount{ // ECRECOVER - string(ethutil.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int { + string(common.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int { return GasEcrecover }, ecrecoverFunc}, // SHA256 - string(ethutil.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int { + string(common.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int { n := big.NewInt(int64(l+31) / 32) n.Mul(n, GasSha256Word) return n.Add(n, GasSha256Base) }, sha256Func}, // RIPEMD160 - string(ethutil.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int { + string(common.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int { n := big.NewInt(int64(l+31) / 32) n.Mul(n, GasRipemdWord) return n.Add(n, GasRipemdBase) }, ripemd160Func}, - string(ethutil.LeftPadBytes([]byte{4}, 20)): &PrecompiledAccount{func(l int) *big.Int { + string(common.LeftPadBytes([]byte{4}, 20)): &PrecompiledAccount{func(l int) *big.Int { n := big.NewInt(int64(l+31) / 32) n.Mul(n, GasIdentityWord) @@ -58,7 +58,7 @@ func sha256Func(in []byte) []byte { } func ripemd160Func(in []byte) []byte { - return ethutil.LeftPadBytes(crypto.Ripemd160(in), 32) + return common.LeftPadBytes(crypto.Ripemd160(in), 32) } func ecrecoverFunc(in []byte) []byte { @@ -66,10 +66,10 @@ func ecrecoverFunc(in []byte) []byte { defer func() { recover() }() hash := in[:32] - v := ethutil.BigD(in[32:64]).Bytes()[0] - 27 + v := common.BigD(in[32:64]).Bytes()[0] - 27 sig := append(in[64:], v) - return ethutil.LeftPadBytes(crypto.Sha3(crypto.Ecrecover(append(hash, sig...))[1:])[12:], 32) + return common.LeftPadBytes(crypto.Sha3(crypto.Ecrecover(append(hash, sig...))[1:])[12:], 32) } func memCpy(in []byte) []byte { diff --git a/vm/asm.go b/vm/asm.go index a94f01d3d2..83fcb0e083 100644 --- a/vm/asm.go +++ b/vm/asm.go @@ -4,7 +4,7 @@ import ( "fmt" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) func Disassemble(script []byte) (asm []string) { @@ -23,7 +23,7 @@ func Disassemble(script []byte) (asm []string) { switch op { case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32: - pc.Add(pc, ethutil.Big1) + pc.Add(pc, common.Big1) a := int64(op) - int64(PUSH1) + 1 if int(pc.Int64()+a) > len(script) { return nil @@ -38,7 +38,7 @@ func Disassemble(script []byte) (asm []string) { pc.Add(pc, big.NewInt(a-1)) } - pc.Add(pc, ethutil.Big1) + pc.Add(pc, common.Big1) } return diff --git a/vm/common.go b/vm/common.go index 1cb549228f..1f07ec8a23 100644 --- a/vm/common.go +++ b/vm/common.go @@ -4,7 +4,7 @@ import ( "math" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" ) @@ -82,22 +82,22 @@ var ( GasIdentityWord = big.NewInt(3) GasCopyWord = big.NewInt(3) - Pow256 = ethutil.BigPow(2, 256) + Pow256 = common.BigPow(2, 256) LogTyPretty byte = 0x1 LogTyDiff byte = 0x2 - U256 = ethutil.U256 - S256 = ethutil.S256 + U256 = common.U256 + S256 = common.S256 - Zero = ethutil.Big0 + Zero = common.Big0 ) const MaxCallDepth = 1025 func calcMemSize(off, l *big.Int) *big.Int { - if l.Cmp(ethutil.Big0) == 0 { - return ethutil.Big0 + if l.Cmp(common.Big0) == 0 { + return common.Big0 } return new(big.Int).Add(off, l) @@ -123,5 +123,5 @@ func getCode(code []byte, start, size uint64) []byte { x := uint64(math.Min(float64(start), float64(len(code)))) y := uint64(math.Min(float64(x+size), float64(len(code)))) - return ethutil.RightPadBytes(code[x:y], int(size)) + return common.RightPadBytes(code[x:y], int(size)) } diff --git a/vm/context.go b/vm/context.go index 78712f5619..6edde08248 100644 --- a/vm/context.go +++ b/vm/context.go @@ -4,7 +4,7 @@ import ( "math" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" ) type ContextRef interface { @@ -61,7 +61,7 @@ func (c *Context) GetRangeValue(x, size uint64) []byte { x = uint64(math.Min(float64(x), float64(len(c.Code)))) y := uint64(math.Min(float64(x+size), float64(len(c.Code)))) - return ethutil.RightPadBytes(c.Code[x:y], int(size)) + return common.RightPadBytes(c.Code[x:y], int(size)) } func (c *Context) GetCode(x, size uint64) []byte { diff --git a/vm/environment.go b/vm/environment.go index 69832241f8..83faaa23e0 100644 --- a/vm/environment.go +++ b/vm/environment.go @@ -5,7 +5,7 @@ import ( "fmt" "math/big" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -76,7 +76,7 @@ func (self *Log) Number() uint64 { } func (self *Log) RlpData() interface{} { - return []interface{}{self.address, ethutil.ByteSliceToInterface(self.topics), self.data} + return []interface{}{self.address, common.ByteSliceToInterface(self.topics), self.data} } func (self *Log) String() string { diff --git a/vm/vm.go b/vm/vm.go index 58aebeedb2..4d9e88e1af 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -5,7 +5,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -160,7 +160,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { x, y := stack.pop(), stack.pop() self.Printf(" %v / %v", x, y) - if y.Cmp(ethutil.Big0) != 0 { + if y.Cmp(common.Big0) != 0 { base.Div(x, y) } @@ -174,11 +174,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" %v / %v", x, y) - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) + if y.Cmp(common.Big0) == 0 { + base.Set(common.Big0) } else { n := new(big.Int) - if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 { + if new(big.Int).Mul(x, y).Cmp(common.Big0) < 0 { n.SetInt64(-1) } else { n.SetInt64(1) @@ -196,8 +196,8 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" %v %% %v", x, y) - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) + if y.Cmp(common.Big0) == 0 { + base.Set(common.Big0) } else { base.Mod(x, y) } @@ -211,11 +211,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" %v %% %v", x, y) - if y.Cmp(ethutil.Big0) == 0 { - base.Set(ethutil.Big0) + if y.Cmp(common.Big0) == 0 { + base.Set(common.Big0) } else { n := new(big.Int) - if x.Cmp(ethutil.Big0) < 0 { + if x.Cmp(common.Big0) < 0 { n.SetInt64(-1) } else { n.SetInt64(1) @@ -246,9 +246,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { if back.Cmp(big.NewInt(31)) < 0 { bit := uint(back.Uint64()*8 + 7) num := stack.pop() - mask := new(big.Int).Lsh(ethutil.Big1, bit) - mask.Sub(mask, ethutil.Big1) - if ethutil.BitTest(num, int(bit)) { + mask := new(big.Int).Lsh(common.Big1, bit) + mask.Sub(mask, common.Big1) + if common.BitTest(num, int(bit)) { num.Or(num, mask.Not(mask)) } else { num.And(num, mask) @@ -262,7 +262,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { } case NOT: stack.push(U256(new(big.Int).Not(stack.pop()))) - //base.Sub(Pow256, stack.pop()).Sub(base, ethutil.Big1) + //base.Sub(Pow256, stack.pop()).Sub(base, common.Big1) //base = U256(base) //stack.push(base) case LT: @@ -270,9 +270,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" %v < %v", x, y) // x < y if x.Cmp(y) < 0 { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } else { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) } case GT: x, y := stack.pop(), stack.pop() @@ -280,9 +280,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { // x > y if x.Cmp(y) > 0 { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } else { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) } case SLT: @@ -290,9 +290,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" %v < %v", x, y) // x < y if x.Cmp(S256(y)) < 0 { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } else { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) } case SGT: x, y := S256(stack.pop()), S256(stack.pop()) @@ -300,9 +300,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { // x > y if x.Cmp(y) > 0 { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } else { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) } case EQ: @@ -311,16 +311,16 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { // x == y if x.Cmp(y) == 0 { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } else { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) } case ISZERO: x := stack.pop() - if x.Cmp(ethutil.BigFalse) > 0 { - stack.push(ethutil.BigFalse) + if x.Cmp(common.BigFalse) > 0 { + stack.push(common.BigFalse) } else { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) } // 0x10 range @@ -343,11 +343,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { th, val := stack.pop(), stack.pop() if th.Cmp(big.NewInt(32)) < 0 { - byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()])) + byt := big.NewInt(int64(common.LeftPadBytes(val.Bytes(), 32)[th.Int64()])) base.Set(byt) } else { - base.Set(ethutil.BigFalse) + base.Set(common.BigFalse) } self.Printf(" => 0x%x", base.Bytes()) @@ -389,12 +389,12 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { offset, size := stack.pop(), stack.pop() data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64())) - stack.push(ethutil.BigD(data)) + stack.push(common.BigD(data)) self.Printf(" => (%v) %x", size, data) // 0x30 range case ADDRESS: - stack.push(ethutil.BigD(context.Address())) + stack.push(common.BigD(context.Address())) self.Printf(" => %x", context.Address()) case BALANCE: @@ -407,12 +407,12 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { case ORIGIN: origin := self.env.Origin() - stack.push(ethutil.BigD(origin)) + stack.push(common.BigD(origin)) self.Printf(" => %x", origin) case CALLER: caller := context.caller.Address() - stack.push(ethutil.BigD(caller)) + stack.push(common.BigD(caller)) self.Printf(" => %x", caller) case CALLVALUE: @@ -427,15 +427,15 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { ) if lenData.Cmp(offset) >= 0 { - length := new(big.Int).Add(offset, ethutil.Big32) - length = ethutil.BigMin(length, lenData) + length := new(big.Int).Add(offset, common.Big32) + length = common.BigMin(length, lenData) copy(data, callData[offset.Int64():length.Int64()]) } self.Printf(" => 0x%x", data) - stack.push(ethutil.BigD(data)) + stack.push(common.BigD(data)) case CALLDATASIZE: l := int64(len(callData)) stack.push(big.NewInt(l)) @@ -501,18 +501,18 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { case BLOCKHASH: num := stack.pop() - n := new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big257) + n := new(big.Int).Sub(self.env.BlockNumber(), common.Big257) if num.Cmp(n) > 0 && num.Cmp(self.env.BlockNumber()) < 0 { - stack.push(ethutil.BigD(self.env.GetHash(num.Uint64()))) + stack.push(common.BigD(self.env.GetHash(num.Uint64()))) } else { - stack.push(ethutil.Big0) + stack.push(common.Big0) } self.Printf(" => 0x%x", stack.peek().Bytes()) case COINBASE: coinbase := self.env.Coinbase() - stack.push(ethutil.BigD(coinbase)) + stack.push(common.BigD(coinbase)) self.Printf(" => 0x%x", coinbase) case TIMESTAMP: @@ -543,7 +543,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { a := uint64(op - PUSH1 + 1) byts := context.GetRangeValue(pc+1, a) // push value to stack - stack.push(ethutil.BigD(byts)) + stack.push(common.BigD(byts)) pc += a step += int(op) - int(PUSH1) + 1 @@ -566,7 +566,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { topics := make([][]byte, n) mStart, mSize := stack.pop(), stack.pop() for i := 0; i < n; i++ { - topics[i] = ethutil.LeftPadBytes(stack.pop().Bytes(), 32) + topics[i] = common.LeftPadBytes(stack.pop().Bytes(), 32) } data := mem.Get(mStart.Int64(), mSize.Int64()) @@ -576,14 +576,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" => %v", log) case MLOAD: offset := stack.pop() - val := ethutil.BigD(mem.Get(offset.Int64(), 32)) + val := common.BigD(mem.Get(offset.Int64(), 32)) stack.push(val) self.Printf(" => 0x%x", val.Bytes()) case MSTORE: // Store the value at stack top-1 in to memory at location stack top // pop value of the stack mStart, val := stack.pop(), stack.pop() - mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256)) + mem.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256)) self.Printf(" => 0x%x", val) case MSTORE8: @@ -594,7 +594,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { self.Printf(" => [%v] 0x%x", off, val) case SLOAD: loc := stack.pop() - val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes())) + val := common.BigD(statedb.GetState(context.Address(), loc.Bytes())) stack.push(val) self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) @@ -610,7 +610,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { case JUMPI: pos, cond := stack.pop(), stack.pop() - if cond.Cmp(ethutil.BigTrue) >= 0 { + if cond.Cmp(common.BigTrue) >= 0 { jump(pc, pos) continue @@ -642,7 +642,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { context.UseGas(context.Gas) ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value) if suberr != nil { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) self.Printf(" (*) 0x0 %v", suberr) } else { @@ -655,7 +655,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { } addr = ref.Address() - stack.push(ethutil.BigD(addr)) + stack.push(common.BigD(addr)) } @@ -669,7 +669,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { // pop return size and offset retOffset, retSize := stack.pop(), stack.pop() - address := ethutil.Address(addr.Bytes()) + address := common.Address(addr.Bytes()) self.Printf(" => %x", address).Endl() // Get the arguments from the memory @@ -690,11 +690,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { } if err != nil { - stack.push(ethutil.BigFalse) + stack.push(common.BigFalse) self.Printf("%v").Endl() } else { - stack.push(ethutil.BigTrue) + stack.push(common.BigTrue) mem.Set(retOffset.Uint64(), retSize.Uint64(), ret) } @@ -834,21 +834,21 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo x := calcMemSize(stack.data[stack.len()-6], stack.data[stack.len()-7]) y := calcMemSize(stack.data[stack.len()-4], stack.data[stack.len()-5]) - newMemSize = ethutil.BigMax(x, y) + newMemSize = common.BigMax(x, y) } - if newMemSize.Cmp(ethutil.Big0) > 0 { + if newMemSize.Cmp(common.Big0) > 0 { newMemSizeWords := toWordSize(newMemSize) newMemSize.Mul(newMemSizeWords, u256(32)) if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 { oldSize := toWordSize(big.NewInt(int64(mem.Len()))) - pow := new(big.Int).Exp(oldSize, ethutil.Big2, Zero) + pow := new(big.Int).Exp(oldSize, common.Big2, Zero) linCoef := new(big.Int).Mul(oldSize, GasMemWord) quadCoef := new(big.Int).Div(pow, GasQuadCoeffDenom) oldTotalFee := new(big.Int).Add(linCoef, quadCoef) - pow.Exp(newMemSizeWords, ethutil.Big2, Zero) + pow.Exp(newMemSizeWords, common.Big2, Zero) linCoef = new(big.Int).Mul(newMemSizeWords, GasMemWord) quadCoef = new(big.Int).Div(pow, GasQuadCoeffDenom) newTotalFee := new(big.Int).Add(linCoef, quadCoef) diff --git a/whisper/envelope.go b/whisper/envelope.go index d30397c984..5776380468 100644 --- a/whisper/envelope.go +++ b/whisper/envelope.go @@ -8,7 +8,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/ecies" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" ) @@ -28,7 +28,7 @@ type Envelope struct { func (self *Envelope) Hash() Hash { if self.hash == EmptyHash { - self.hash = H(crypto.Sha3(ethutil.Encode(self))) + self.hash = H(crypto.Sha3(common.Encode(self))) } return self.hash @@ -76,14 +76,14 @@ func (self *Envelope) Open(prv *ecdsa.PrivateKey) (msg *Message, err error) { func (self *Envelope) proveWork(dura time.Duration) { var bestBit int d := make([]byte, 64) - copy(d[:32], ethutil.Encode(self.withoutNonce())) + copy(d[:32], common.Encode(self.withoutNonce())) then := time.Now().Add(dura).UnixNano() for n := uint32(0); time.Now().UnixNano() < then; { for i := 0; i < 1024; i++ { binary.BigEndian.PutUint32(d[60:], n) - fbs := ethutil.FirstBitSet(ethutil.BigD(crypto.Sha3(d))) + fbs := common.FirstBitSet(common.BigD(crypto.Sha3(d))) if fbs > bestBit { bestBit = fbs self.Nonce = n @@ -96,17 +96,17 @@ func (self *Envelope) proveWork(dura time.Duration) { func (self *Envelope) valid() bool { d := make([]byte, 64) - copy(d[:32], ethutil.Encode(self.withoutNonce())) + copy(d[:32], common.Encode(self.withoutNonce())) binary.BigEndian.PutUint32(d[60:], self.Nonce) - return ethutil.FirstBitSet(ethutil.BigD(crypto.Sha3(d))) > 0 + return common.FirstBitSet(common.BigD(crypto.Sha3(d))) > 0 } func (self *Envelope) withoutNonce() interface{} { - return []interface{}{self.Expiry, self.Ttl, ethutil.ByteSliceToInterface(self.Topics), self.Data} + return []interface{}{self.Expiry, self.Ttl, common.ByteSliceToInterface(self.Topics), self.Data} } func (self *Envelope) RlpData() interface{} { - return []interface{}{self.Expiry, self.Ttl, ethutil.ByteSliceToInterface(self.Topics), self.Data, self.Nonce} + return []interface{}{self.Expiry, self.Ttl, common.ByteSliceToInterface(self.Topics), self.Data, self.Nonce} } func (self *Envelope) DecodeRLP(s *rlp.Stream) error { @@ -128,7 +128,7 @@ func (self *Envelope) DecodeRLP(s *rlp.Stream) error { self.Nonce = extenv.Nonce // TODO We should use the stream directly here. - self.hash = H(crypto.Sha3(ethutil.Encode(self))) + self.hash = H(crypto.Sha3(common.Encode(self))) return nil } diff --git a/xeth/state.go b/xeth/state.go index bb729db334..7d9ceab1b6 100644 --- a/xeth/state.go +++ b/xeth/state.go @@ -1,7 +1,7 @@ package xeth import ( - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/state" ) @@ -19,7 +19,7 @@ func (self *State) State() *state.StateDB { } func (self *State) Get(addr string) *Object { - return &Object{self.state.GetStateObject(ethutil.FromHex(addr))} + return &Object{self.state.GetStateObject(common.FromHex(addr))} } func (self *State) SafeGet(addr string) *Object { @@ -27,9 +27,9 @@ func (self *State) SafeGet(addr string) *Object { } func (self *State) safeGet(addr string) *state.StateObject { - object := self.state.GetStateObject(ethutil.FromHex(addr)) + object := self.state.GetStateObject(common.FromHex(addr)) if object == nil { - object = state.NewStateObject(ethutil.FromHex(addr), self.xeth.eth.StateDb()) + object = state.NewStateObject(common.FromHex(addr), self.xeth.eth.StateDb()) } return object diff --git a/xeth/types.go b/xeth/types.go index 3dc25a2ea6..e15305481c 100644 --- a/xeth/types.go +++ b/xeth/types.go @@ -8,14 +8,14 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/state" ) func toHex(b []byte) string { - return "0x" + ethutil.Bytes2Hex(b) + return "0x" + common.Bytes2Hex(b) } type Object struct { @@ -26,20 +26,20 @@ func NewObject(state *state.StateObject) *Object { return &Object{state} } -func (self *Object) StorageString(str string) *ethutil.Value { - if ethutil.IsHex(str) { - return self.storage(ethutil.Hex2Bytes(str[2:])) +func (self *Object) StorageString(str string) *common.Value { + if common.IsHex(str) { + return self.storage(common.Hex2Bytes(str[2:])) } else { - return self.storage(ethutil.RightPadBytes([]byte(str), 32)) + return self.storage(common.RightPadBytes([]byte(str), 32)) } } -func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value { +func (self *Object) StorageValue(addr *common.Value) *common.Value { return self.storage(addr.Bytes()) } -func (self *Object) storage(addr []byte) *ethutil.Value { - return self.StateObject.GetStorage(ethutil.BigD(addr)) +func (self *Object) storage(addr []byte) *common.Value { + return self.StateObject.GetStorage(common.BigD(addr)) } func (self *Object) Storage() (storage map[string]string) { @@ -62,8 +62,8 @@ type Block struct { Size string `json:"size"` Number int `json:"number"` Hash string `json:"hash"` - Transactions *ethutil.List `json:"transactions"` - Uncles *ethutil.List `json:"uncles"` + Transactions *common.List `json:"transactions"` + Uncles *common.List `json:"uncles"` Time int64 `json:"time"` Coinbase string `json:"coinbase"` Name string `json:"name"` @@ -84,13 +84,13 @@ func NewBlock(block *types.Block) *Block { for i, tx := range block.Transactions() { ptxs[i] = NewTx(tx) } - txlist := ethutil.NewList(ptxs) + txlist := common.NewList(ptxs) puncles := make([]*Block, len(block.Uncles())) for i, uncle := range block.Uncles() { puncles[i] = NewBlock(types.NewBlockWithHeader(uncle)) } - ulist := ethutil.NewList(puncles) + ulist := common.NewList(puncles) return &Block{ ref: block, Size: block.Size().String(), @@ -114,7 +114,7 @@ func (self *Block) ToString() string { } func (self *Block) GetTransaction(hash string) *Transaction { - tx := self.ref.Transaction(ethutil.FromHex(hash)) + tx := self.ref.Transaction(common.FromHex(hash)) if tx == nil { return nil } @@ -154,7 +154,7 @@ func NewTx(tx *types.Transaction) *Transaction { data = toHex(tx.Data()) } - return &Transaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())} + return &Transaction{ref: tx, Hash: hash, Value: common.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())} } func (self *Transaction) ToString() string { diff --git a/xeth/whisper.go b/xeth/whisper.go index f5c26faaef..76bf8012af 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -5,7 +5,7 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/whisper" ) @@ -29,12 +29,12 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio ttl = 100 } - pk := crypto.ToECDSAPub(ethutil.FromHex(from)) + pk := crypto.ToECDSAPub(common.FromHex(from)) if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 { - msg := whisper.NewMessage(ethutil.FromHex(payload)) + msg := whisper.NewMessage(common.FromHex(payload)) envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{ Ttl: time.Duration(ttl) * time.Second, - To: crypto.ToECDSAPub(ethutil.FromHex(to)), + To: crypto.ToECDSAPub(common.FromHex(to)), From: key, Topics: whisper.TopicsFromString(topics...), }) @@ -60,13 +60,13 @@ func (self *Whisper) NewIdentity() string { } func (self *Whisper) HasIdentity(key string) bool { - return self.Whisper.HasIdentity(crypto.ToECDSAPub(ethutil.FromHex(key))) + return self.Whisper.HasIdentity(crypto.ToECDSAPub(common.FromHex(key))) } func (self *Whisper) Watch(opts *Options) int { filter := whisper.Filter{ - To: crypto.ToECDSAPub(ethutil.FromHex(opts.To)), - From: crypto.ToECDSAPub(ethutil.FromHex(opts.From)), + To: crypto.ToECDSAPub(common.FromHex(opts.To)), + From: crypto.ToECDSAPub(common.FromHex(opts.From)), Topics: whisper.TopicsFromString(opts.Topics...), } diff --git a/xeth/xeth.go b/xeth/xeth.go index cf500cd593..6c7a26c04f 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -11,7 +11,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p" @@ -30,9 +30,9 @@ type Backend interface { PeerCount() int IsListening() bool Peers() []*p2p.Peer - BlockDb() ethutil.Database - StateDb() ethutil.Database - ExtraDb() ethutil.Database + BlockDb() common.Database + StateDb() common.Database + ExtraDb() common.Database EventMux() *event.TypeMux Whisper() *whisper.Whisper @@ -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 := ethutil.FromHex(strHash) + hash := common.FromHex(strHash) block := self.chainManager.GetBlock(hash) return NewBlock(block) } func (self *XEth) EthBlockByHash(strHash string) *types.Block { - hash := ethutil.FromHex(strHash) + hash := common.FromHex(strHash) block := self.chainManager.GetBlock(hash) return block } func (self *XEth) EthTransactionByHash(hash string) *types.Transaction { - data, _ := self.eth.ExtraDb().Get(ethutil.FromHex(hash)) + data, _ := self.eth.ExtraDb().Get(common.FromHex(hash)) if len(data) != 0 { return types.NewTransactionFromBytes(data) } @@ -205,9 +205,9 @@ func (self *XEth) Coinbase() string { } func (self *XEth) NumberToHuman(balance string) string { - b := ethutil.Big(balance) + b := common.Big(balance) - return ethutil.CurrencyToString(b) + return common.CurrencyToString(b) } func (self *XEth) StorageAt(addr, storageAddr string) string { @@ -233,7 +233,7 @@ func (self *XEth) IsContract(address string) bool { } func (self *XEth) SecretToAddress(key string) string { - pair, err := crypto.NewKeyPairFromSec(ethutil.FromHex(key)) + pair, err := crypto.NewKeyPairFromSec(common.FromHex(key)) if err != nil { return "" } @@ -263,29 +263,29 @@ func (self *XEth) EachStorage(addr string) string { } func (self *XEth) ToAscii(str string) string { - padded := ethutil.RightPadBytes([]byte(str), 32) + padded := common.RightPadBytes([]byte(str), 32) return "0x" + toHex(padded) } func (self *XEth) FromAscii(str string) string { - if ethutil.IsHex(str) { + if common.IsHex(str) { str = str[2:] } - return string(bytes.Trim(ethutil.FromHex(str), "\x00")) + return string(bytes.Trim(common.FromHex(str), "\x00")) } func (self *XEth) FromNumber(str string) string { - if ethutil.IsHex(str) { + if common.IsHex(str) { str = str[2:] } - return ethutil.BigD(ethutil.FromHex(str)).String() + return common.BigD(common.FromHex(str)).String() } func (self *XEth) PushTx(encodedTx string) (string, error) { - tx := types.NewTransactionFromBytes(ethutil.FromHex(encodedTx)) + tx := types.NewTransactionFromBytes(common.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(ethutil.FromHex(fromStr)), - to: ethutil.FromHex(toStr), - gas: ethutil.Big(gasStr), - gasPrice: ethutil.Big(gasPriceStr), - value: ethutil.Big(valueStr), - data: ethutil.FromHex(dataStr), + from: statedb.GetOrNewStateObject(common.FromHex(fromStr)), + to: common.FromHex(toStr), + gas: common.Big(gasStr), + gasPrice: common.Big(gasPriceStr), + value: common.Big(valueStr), + data: common.FromHex(dataStr), } if msg.gas.Cmp(big.NewInt(0)) == 0 { msg.gas = defaultGas @@ -332,16 +332,16 @@ func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeSt var ( from []byte to []byte - value = ethutil.NewValue(valueStr) - gas = ethutil.NewValue(gasStr) - price = ethutil.NewValue(gasPriceStr) + value = common.NewValue(valueStr) + gas = common.NewValue(gasStr) + price = common.NewValue(gasPriceStr) data []byte contractCreation bool ) - from = ethutil.FromHex(fromStr) - data = ethutil.FromHex(codeStr) - to = ethutil.FromHex(toStr) + from = common.FromHex(fromStr) + data = common.FromHex(codeStr) + to = common.FromHex(toStr) if len(to) == 0 { contractCreation = true }