Moved ethutil => common

116 files changed, 610 insertions, 604 deletions

diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go
index 1f615058d..7328bc922 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 378f6541e..9205c005e 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 b2d4abbd3..56520b672 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 bca48c6ca..411779057 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 8f0c8baa0..9ac996bca 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 d56e270ab..5f4889792 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 c07246b00..5d42121b6 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 1bb3809cf..e6d701d2c 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 3b98b588e..a3c5f5d2d 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 53746627a..1efea927f 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 bbcde4c56..23ae9e525 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 960558bb4..af15dd4d4 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 b56c0dddf..1371c752c 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 a49e9f6f8..476b441c8 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 e4ea57b9b..195e81073 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 4116783c9..256c08691 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 16a055bc0..778ef0e40 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 cc213b49a..b33b81267 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 6b99b841f..74fd5334e 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 6bcd7e811..95666e3c9 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 &eth.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
index f725d58d1..f725d58d1 100644
--- a/ethutil/.gitignore
+++ b/common/.gitignore
diff --git a/ethutil/.travis.yml b/common/.travis.yml
index 69359072d..69359072d 100644
--- a/ethutil/.travis.yml
+++ b/common/.travis.yml
diff --git a/ethutil/README.md b/common/README.md
index 1ed56b71b..1ed56b71b 100644
--- a/ethutil/README.md
+++ b/common/README.md
diff --git a/ethutil/big.go b/common/big.go
index b77e0af8c..750b28f85 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
index bf3c96c6d..cedbaf144 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
index bd294f28a..4aef9a223 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
index 179a8c7ef..ec106bf4b 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
index 29854c882..1371d18d4 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
index 20064b1e7..c7ba87f90 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
index c45c310ce..23a902bc1 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
index e02a80fca..6505e61c6 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
index db276f1e3..594a8a24b 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
index fd4278ce7..2bed278e6 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
index 262aa8591..0a0731971 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
index 90e302f44..90e302f44 100644
--- a/ethutil/math/dist_test.go
+++ b/common/math/dist_test.go
diff --git a/ethutil/natspec/natspec.go b/common/natspec/natspec.go
index 793bf59ae..793bf59ae 100644
--- a/ethutil/natspec/natspec.go
+++ b/common/natspec/natspec.go
diff --git a/ethutil/natspec/natspec_js.go b/common/natspec/natspec_js.go
index 96d8204fb..96d8204fb 100644
--- a/ethutil/natspec/natspec_js.go
+++ b/common/natspec/natspec_js.go
diff --git a/ethutil/natspec/natspec_test.go b/common/natspec/natspec_test.go
index 330dc831d..330dc831d 100644
--- a/ethutil/natspec/natspec_test.go
+++ b/common/natspec/natspec_test.go
diff --git a/ethutil/number/int.go b/common/number/int.go
index 9a41fe3e5..6cc5e68b4 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
index c42989465..262d584ed 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
index e5df989d2..7f38d8e4d 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
index e545c8731..680c8366c 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
index 908c94ee7..4af1bd7af 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
index 0cb0d611c..602f13202 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
index ff98d3269..16a3553d7 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
index b4426465e..80a17279b 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
index e0f28abc5..c90eabc26 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 000000000..7646b2c34
--- /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
index 7d4a7d98c..72a123772 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
index 861d35184..09d37802d 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 a8b3023f4..fc3493fe1 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 f421c3539..f67d6d006 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 f140b5c7e..59c297dbe 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 0b7dcf293..ff91b0427 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 9c82a28c8..bfd51f196 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 b7f05db64..1e0ed178b 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 c4052cc05..9b5407a9e 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 f49aed874..279abee62 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 bd377f679..515cc2040 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 b2d981f01..418cb0415 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 ba6ef6014..2d65cdca6 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 578265a34..af76f226f 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 74e00cac6..0841bb859 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 b2c442210..593a31f1c 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 49e68e233..be14d0e0e 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 88a718f93..dcd48af11 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 90e2c8939..bc72928ac 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 c68856622..754287641 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 85b43c406..6e5b40a37 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 11531d460..f0a1e567b 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 da5788437..6702e6595 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 346fc43bc..42f2b5808 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 6cf80cde2..18fef0ab5 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 708e22087..e368bbec5 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 f499d033e..a2b59f117 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 4e3d01da0..cc2df5fa0 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 48aa830e7..d914f47f8 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 5f47c1735..a6a0bc8e2 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 baa3dfaf2..2dbec86de 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 5c4a13698..10fc6f508 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 f88c31d1d..14e4404c9 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 9762fcc6d..02f1b8572 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 3da7683d5..f2d65e8ef 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 f3a71d1eb..f53f4bac9 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 3ca502d06..7eba95784 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 2137de356..1846e7db5 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 b935c5007..7ed482c30 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 4acd90284..08f404c99 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 2c611d76b..c5f556e1a 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 d503bd1a0..a0859aaf2 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 f819d8ad3..4aad1e1e3 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 dccbe8dad..8be9e28fc 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 07e35f7e2..3ecc03ae0 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 a0dc7732f..80bbe2afd 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 6a9cf5f6d..0b923f08b 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 6a071968d..21ea2261f 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 f1aaf74b8..a7fd98696 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 1e8cd5b51..24718de7b 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 e46628368..8125cc3c9 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 d96492958..edd490b4d 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 9087f7bda..1c1112a7f 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 b6a260483..1393e0c97 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 8912b1c82..7bf8ff06e 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 26e72ac93..f8bed8a2d 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 7fef1929f..90ec822aa 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 b1345da8f..215f4bc8f 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 a94f01d3d..83fcb0e08 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 1cb549228..1f07ec8a2 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 78712f561..6edde0824 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 69832241f..83faaa23e 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 58aebeedb..4d9e88e1a 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 d30397c98..577638046 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 bb729db33..7d9ceab1b 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 3dc25a2ea..e15305481 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 f5c26faae..76bf8012a 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 cf500cd59..6c7a26c04 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
 	}