ethstate => state

36 files changed, 167 insertions, 167 deletions

diff --git a/chain/block.go b/chain/block.go
index abad6f3d2..7e39aa2c9 100644
--- a/chain/block.go
+++ b/chain/block.go
@@ -8,9 +8,9 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethtrie"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type BlockInfo struct {
@@ -77,7 +77,7 @@ type Block struct {
 	Coinbase []byte
 	// Block Trie state
 	//state *ethutil.Trie
-	state *ethstate.State
+	state *state.State
 	// Difficulty for the current block
 	Difficulty *big.Int
 	// Creation time
@@ -137,7 +137,7 @@ func CreateBlock(root interface{},
 	}
 	block.SetUncles([]*Block{})
 
-	block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, root))
+	block.state = state.New(ethtrie.New(ethutil.Config.Db, root))
 
 	return block
 }
@@ -152,7 +152,7 @@ func (block *Block) HashNoNonce() []byte {
 	return crypto.Sha3(ethutil.Encode(block.miningHeader()))
 }
 
-func (block *Block) State() *ethstate.State {
+func (block *Block) State() *state.State {
 	return block.state
 }
 
@@ -294,7 +294,7 @@ func (self *Block) setHeader(header *ethutil.Value) {
 	self.PrevHash = header.Get(0).Bytes()
 	self.UncleSha = header.Get(1).Bytes()
 	self.Coinbase = header.Get(2).Bytes()
-	self.state = ethstate.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
+	self.state = state.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
 	self.TxSha = header.Get(4).Bytes()
 	self.ReceiptSha = header.Get(5).Bytes()
 	self.LogsBloom = header.Get(6).Bytes()
diff --git a/chain/bloom9.go b/chain/bloom9.go
index 60cafdb4b..ced31cc30 100644
--- a/chain/bloom9.go
+++ b/chain/bloom9.go
@@ -3,8 +3,8 @@ package chain
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 func CreateBloom(block *Block) []byte {
@@ -17,7 +17,7 @@ func CreateBloom(block *Block) []byte {
 	return bin.Bytes()
 }
 
-func LogsBloom(logs ethstate.Logs) *big.Int {
+func LogsBloom(logs state.Logs) *big.Int {
 	bin := new(big.Int)
 	for _, log := range logs {
 		data := [][]byte{log.Address}
diff --git a/chain/filter.go b/chain/filter.go
index 2aecb4f58..0265a60fa 100644
--- a/chain/filter.go
+++ b/chain/filter.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"math"
 
-	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type AccountChange struct {
@@ -23,7 +23,7 @@ type Filter struct {
 	Altered []AccountChange
 
 	BlockCallback   func(*Block)
-	MessageCallback func(ethstate.Messages)
+	MessageCallback func(state.Messages)
 }
 
 // Create a new filter which uses a bloom filter on blocks to figure out whether a particular block
@@ -72,7 +72,7 @@ func (self *Filter) SetSkip(skip int) {
 }
 
 // Run filters messages with the current parameters set
-func (self *Filter) Find() []*ethstate.Message {
+func (self *Filter) Find() []*state.Message {
 	var earliestBlockNo uint64 = uint64(self.earliest)
 	if self.earliest == -1 {
 		earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
@@ -83,7 +83,7 @@ func (self *Filter) Find() []*ethstate.Message {
 	}
 
 	var (
-		messages []*ethstate.Message
+		messages []*state.Message
 		block    = self.eth.ChainManager().GetBlockByNumber(latestBlockNo)
 		quit     bool
 	)
@@ -128,8 +128,8 @@ func includes(addresses [][]byte, a []byte) (found bool) {
 	return
 }
 
-func (self *Filter) FilterMessages(msgs []*ethstate.Message) []*ethstate.Message {
-	var messages []*ethstate.Message
+func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message {
+	var messages []*state.Message
 
 	// Filter the messages for interesting stuff
 	for _, message := range msgs {
diff --git a/chain/state_manager.go b/chain/state_manager.go
index 8266726f5..b6bfbc22f 100644
--- a/chain/state_manager.go
+++ b/chain/state_manager.go
@@ -10,11 +10,11 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 var statelogger = logger.NewLogger("BLOCK")
@@ -61,10 +61,10 @@ type StateManager struct {
 	// Transiently state. The trans state isn't ever saved, validated and
 	// it could be used for setting account nonces without effecting
 	// the main states.
-	transState *ethstate.State
+	transState *state.State
 	// Mining state. The mining state is used purely and solely by the mining
 	// operation.
-	miningState *ethstate.State
+	miningState *state.State
 
 	// The last attempted block is mainly used for debugging purposes
 	// This does not have to be a valid block and will be set during
@@ -112,19 +112,19 @@ func (self *StateManager) updateThread() {
 	}
 }
 
-func (sm *StateManager) CurrentState() *ethstate.State {
+func (sm *StateManager) CurrentState() *state.State {
 	return sm.eth.ChainManager().CurrentBlock.State()
 }
 
-func (sm *StateManager) TransState() *ethstate.State {
+func (sm *StateManager) TransState() *state.State {
 	return sm.transState
 }
 
-func (sm *StateManager) MiningState() *ethstate.State {
+func (sm *StateManager) MiningState() *state.State {
 	return sm.miningState
 }
 
-func (sm *StateManager) NewMiningState() *ethstate.State {
+func (sm *StateManager) NewMiningState() *state.State {
 	sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy()
 
 	return sm.miningState
@@ -134,7 +134,7 @@ func (sm *StateManager) ChainManager() *ChainManager {
 	return sm.bc
 }
 
-func (self *StateManager) ProcessTransactions(coinbase *ethstate.StateObject, state *ethstate.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
+func (self *StateManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
 	var (
 		receipts           Receipts
 		handled, unhandled Transactions
@@ -296,7 +296,7 @@ func (sm *StateManager) Process(block *Block) (err error) {
 	return nil
 }
 
-func (sm *StateManager) ApplyDiff(state *ethstate.State, parent, block *Block) (receipts Receipts, err error) {
+func (sm *StateManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) {
 	coinbase := state.GetOrNewStateObject(block.Coinbase)
 	coinbase.SetGasPool(block.CalcGasLimit(parent))
 
@@ -372,7 +372,7 @@ func (sm *StateManager) ValidateBlock(block *Block) error {
 	return nil
 }
 
-func (sm *StateManager) AccumelateRewards(state *ethstate.State, block, parent *Block) error {
+func (sm *StateManager) AccumelateRewards(state *state.State, block, parent *Block) error {
 	reward := new(big.Int).Set(BlockReward)
 
 	knownUncles := ethutil.Set(parent.Uncles)
@@ -416,7 +416,7 @@ func (sm *StateManager) AccumelateRewards(state *ethstate.State, block, parent *
 }
 
 // Manifest will handle both creating notifications and generating bloom bin data
-func (sm *StateManager) createBloomFilter(state *ethstate.State) *BloomFilter {
+func (sm *StateManager) createBloomFilter(state *state.State) *BloomFilter {
 	bloomf := NewBloomFilter(nil)
 
 	for _, msg := range state.Manifest().Messages {
@@ -429,7 +429,7 @@ func (sm *StateManager) createBloomFilter(state *ethstate.State) *BloomFilter {
 	return bloomf
 }
 
-func (sm *StateManager) GetMessages(block *Block) (messages []*ethstate.Message, err error) {
+func (sm *StateManager) GetMessages(block *Block) (messages []*state.Message, err error) {
 	if !sm.bc.HasBlock(block.PrevHash) {
 		return nil, ParentError(block.PrevHash)
 	}
diff --git a/chain/state_transition.go b/chain/state_transition.go
index 4c62633c5..41bdadedb 100644
--- a/chain/state_transition.go
+++ b/chain/state_transition.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
@@ -31,17 +31,17 @@ type StateTransition struct {
 	gas, gasPrice      *big.Int
 	value              *big.Int
 	data               []byte
-	state              *ethstate.State
+	state              *state.State
 	block              *Block
 
-	cb, rec, sen *ethstate.StateObject
+	cb, rec, sen *state.StateObject
 }
 
-func NewStateTransition(coinbase *ethstate.StateObject, tx *Transaction, state *ethstate.State, block *Block) *StateTransition {
+func NewStateTransition(coinbase *state.StateObject, tx *Transaction, state *state.State, block *Block) *StateTransition {
 	return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil}
 }
 
-func (self *StateTransition) Coinbase() *ethstate.StateObject {
+func (self *StateTransition) Coinbase() *state.StateObject {
 	if self.cb != nil {
 		return self.cb
 	}
@@ -49,7 +49,7 @@ func (self *StateTransition) Coinbase() *ethstate.StateObject {
 	self.cb = self.state.GetOrNewStateObject(self.coinbase)
 	return self.cb
 }
-func (self *StateTransition) Sender() *ethstate.StateObject {
+func (self *StateTransition) Sender() *state.StateObject {
 	if self.sen != nil {
 		return self.sen
 	}
@@ -58,7 +58,7 @@ func (self *StateTransition) Sender() *ethstate.StateObject {
 
 	return self.sen
 }
-func (self *StateTransition) Receiver() *ethstate.StateObject {
+func (self *StateTransition) Receiver() *state.StateObject {
 	if self.tx != nil && self.tx.CreatesContract() {
 		return nil
 	}
@@ -143,7 +143,7 @@ func (self *StateTransition) TransitionState() (err error) {
 	var (
 		tx       = self.tx
 		sender   = self.Sender()
-		receiver *ethstate.StateObject
+		receiver *state.StateObject
 	)
 
 	defer self.RefundGas()
@@ -167,7 +167,7 @@ func (self *StateTransition) TransitionState() (err error) {
 		return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Balance)
 	}
 
-	var snapshot *ethstate.State
+	var snapshot *state.State
 	// If the receiver is nil it's a contract (\0*32).
 	if tx.CreatesContract() {
 		// Subtract the (irreversible) amount from the senders account
@@ -195,7 +195,7 @@ func (self *StateTransition) TransitionState() (err error) {
 		snapshot = self.state.Copy()
 	}
 
-	msg := self.state.Manifest().AddMessage(&ethstate.Message{
+	msg := self.state.Manifest().AddMessage(&state.Message{
 		To: receiver.Address(), From: sender.Address(),
 		Input:  self.tx.Data,
 		Origin: sender.Address(),
@@ -232,14 +232,14 @@ func (self *StateTransition) TransitionState() (err error) {
 		} else {
 			// Add default LOG. Default = big(sender.addr) + 1
 			addr := ethutil.BigD(receiver.Address())
-			self.state.AddLog(ethstate.Log{sender.Address(), [][]byte{ethutil.U256(addr.Add(addr, ethutil.Big1)).Bytes()}, nil})
+			self.state.AddLog(state.Log{sender.Address(), [][]byte{ethutil.U256(addr.Add(addr, ethutil.Big1)).Bytes()}, nil})
 		}
 	}
 
 	return
 }
 
-func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context *ethstate.StateObject) (ret []byte, err error) {
+func (self *StateTransition) Eval(msg *state.Message, script []byte, context *state.StateObject) (ret []byte, err error) {
 	var (
 		transactor    = self.Sender()
 		state         = self.state
@@ -254,7 +254,7 @@ func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context
 }
 
 // Converts an transaction in to a state object
-func MakeContract(tx *Transaction, state *ethstate.State) *ethstate.StateObject {
+func MakeContract(tx *Transaction, state *state.State) *state.StateObject {
 	addr := tx.CreationAddress(state)
 
 	contract := state.GetOrNewStateObject(addr)
diff --git a/chain/transaction.go b/chain/transaction.go
index 416ffbc6c..d393f0384 100644
--- a/chain/transaction.go
+++ b/chain/transaction.go
@@ -6,8 +6,8 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/obscuren/secp256k1-go"
 )
 
@@ -78,7 +78,7 @@ func (tx *Transaction) IsContract() bool {
 	return tx.CreatesContract()
 }
 
-func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
+func (tx *Transaction) CreationAddress(state *state.State) []byte {
 	// Generate a new address
 	addr := crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
 	//for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
@@ -205,7 +205,7 @@ type Receipt struct {
 	PostState         []byte
 	CumulativeGasUsed *big.Int
 	Bloom             []byte
-	logs              ethstate.Logs
+	logs              state.Logs
 }
 
 func NewRecieptFromValue(val *ethutil.Value) *Receipt {
@@ -222,7 +222,7 @@ func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) {
 
 	it := decoder.Get(3).NewIterator()
 	for it.Next() {
-		self.logs = append(self.logs, ethstate.NewLogFromValue(it.Value()))
+		self.logs = append(self.logs, state.NewLogFromValue(it.Value()))
 	}
 }
 
diff --git a/chain/transaction_pool.go b/chain/transaction_pool.go
index 21d501dfc..3e3787eed 100644
--- a/chain/transaction_pool.go
+++ b/chain/transaction_pool.go
@@ -7,9 +7,9 @@ import (
 	"math/big"
 	"sync"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 var txplogger = logger.NewLogger("TXP")
@@ -193,7 +193,7 @@ func (pool *TxPool) CurrentTransactions() []*Transaction {
 	return txList
 }
 
-func (pool *TxPool) RemoveInvalid(state *ethstate.State) {
+func (pool *TxPool) RemoveInvalid(state *state.State) {
 	pool.mutex.Lock()
 	defer pool.mutex.Unlock()
 
diff --git a/chain/vm_env.go b/chain/vm_env.go
index d42351713..53092bd10 100644
--- a/chain/vm_env.go
+++ b/chain/vm_env.go
@@ -3,17 +3,17 @@ package chain
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
-	state *ethstate.State
+	state *state.State
 	block *Block
 	tx    *Transaction
 }
 
-func NewEnv(state *ethstate.State, tx *Transaction, block *Block) *VMEnv {
+func NewEnv(state *state.State, tx *Transaction, block *Block) *VMEnv {
 	return &VMEnv{
 		state: state,
 		block: block,
@@ -21,17 +21,17 @@ func NewEnv(state *ethstate.State, tx *Transaction, block *Block) *VMEnv {
 	}
 }
 
-func (self *VMEnv) Origin() []byte         { return self.tx.Sender() }
-func (self *VMEnv) BlockNumber() *big.Int  { return self.block.Number }
-func (self *VMEnv) PrevHash() []byte       { return self.block.PrevHash }
-func (self *VMEnv) Coinbase() []byte       { return self.block.Coinbase }
-func (self *VMEnv) Time() int64            { return self.block.Time }
-func (self *VMEnv) Difficulty() *big.Int   { return self.block.Difficulty }
-func (self *VMEnv) BlockHash() []byte      { return self.block.Hash() }
-func (self *VMEnv) Value() *big.Int        { return self.tx.Value }
-func (self *VMEnv) State() *ethstate.State { return self.state }
-func (self *VMEnv) GasLimit() *big.Int     { return self.block.GasLimit }
-func (self *VMEnv) AddLog(log ethstate.Log) {
+func (self *VMEnv) Origin() []byte        { return self.tx.Sender() }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte      { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase }
+func (self *VMEnv) Time() int64           { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte     { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int       { return self.tx.Value }
+func (self *VMEnv) State() *state.State   { return self.state }
+func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit }
+func (self *VMEnv) AddLog(log state.Log) {
 	self.state.AddLog(log)
 }
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
diff --git a/cmd/mist/debugger.go b/cmd/mist/debugger.go
index fadc241ff..3fd48eec6 100644
--- a/cmd/mist/debugger.go
+++ b/cmd/mist/debugger.go
@@ -26,8 +26,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 	"gopkg.in/qml.v1"
 )
@@ -40,7 +40,7 @@ type DebuggerWindow struct {
 	vm *vm.DebugVm
 	Db *Debugger
 
-	state *ethstate.State
+	state *state.State
 }
 
 func NewDebuggerWindow(lib *UiLib) *DebuggerWindow {
@@ -141,17 +141,17 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
 		keyPair = self.lib.eth.KeyManager().KeyPair()
 	)
 
-	state := self.lib.eth.StateManager().TransState()
+	statedb := self.lib.eth.StateManager().TransState()
 	account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
-	contract := ethstate.NewStateObject([]byte{0})
+	contract := statedb.NewStateObject([]byte{0})
 	contract.SetBalance(value)
 
 	self.SetAsm(script)
 
 	block := self.lib.eth.ChainManager().CurrentBlock
 
-	callerClosure := vm.NewClosure(&ethstate.Message{}, account, contract, script, gas, gasPrice)
-	env := utils.NewEnv(state, block, account.Address(), value)
+	callerClosure := vm.NewClosure(&state.Message{}, account, contract, script, gas, gasPrice)
+	env := utils.NewEnv(statedb, block, account.Address(), value)
 	evm := vm.NewDebugVm(env)
 	evm.Dbg = self.Db
 
@@ -172,7 +172,7 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
 			}
 		}
 
-		state.Reset()
+		statedb.Reset()
 
 		if !self.Db.interrupt {
 			self.Db.done = true
@@ -267,13 +267,13 @@ type storeVal struct {
 	Key, Value string
 }
 
-func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
+func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
 	self.main.Logln("break on instr:", pc)
 
 	return self.halting(pc, op, mem, stack, stateObject)
 }
 
-func (self *Debugger) StepHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
+func (self *Debugger) StepHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
 	return self.halting(pc, op, mem, stack, stateObject)
 }
 
@@ -285,7 +285,7 @@ func (self *Debugger) BreakPoints() []int64 {
 	return self.breakPoints
 }
 
-func (d *Debugger) halting(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
+func (d *Debugger) halting(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
 	d.win.Root().Call("setInstruction", pc)
 	d.win.Root().Call("clearMem")
 	d.win.Root().Call("clearStack")
diff --git a/cmd/mist/ext_app.go b/cmd/mist/ext_app.go
index 4a3ab1d2c..d004f98c5 100644
--- a/cmd/mist/ext_app.go
+++ b/cmd/mist/ext_app.go
@@ -21,9 +21,9 @@ import (
 	"encoding/json"
 
 	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/ui/qt"
 	"github.com/ethereum/go-ethereum/xeth"
 	"gopkg.in/qml.v1"
@@ -38,7 +38,7 @@ type AppContainer interface {
 
 	NewBlock(*chain.Block)
 	NewWatcher(chan bool)
-	Messages(ethstate.Messages, string)
+	Messages(state.Messages, string)
 	Post(string, int)
 }
 
@@ -80,7 +80,7 @@ func (app *ExtApplication) run() {
 
 	// Subscribe to events
 	mux := app.lib.eth.EventMux()
-	app.events = mux.Subscribe(chain.NewBlockEvent{}, ethstate.Messages(nil))
+	app.events = mux.Subscribe(chain.NewBlockEvent{}, state.Messages(nil))
 
 	// Call the main loop
 	go app.mainLoop()
@@ -109,7 +109,7 @@ func (app *ExtApplication) mainLoop() {
 		case chain.NewBlockEvent:
 			app.container.NewBlock(ev.Block)
 
-		case ethstate.Messages:
+		case state.Messages:
 			for id, filter := range app.filters {
 				msgs := filter.FilterMessages(ev)
 				if len(msgs) > 0 {
diff --git a/cmd/mist/html_container.go b/cmd/mist/html_container.go
index 082d65f67..35e351b02 100644
--- a/cmd/mist/html_container.go
+++ b/cmd/mist/html_container.go
@@ -28,9 +28,9 @@ import (
 	"path/filepath"
 
 	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
 	"github.com/howeyc/fsnotify"
 	"gopkg.in/qml.v1"
@@ -143,7 +143,7 @@ func (app *HtmlApplication) NewBlock(block *chain.Block) {
 	app.webView.Call("onNewBlockCb", b)
 }
 
-func (self *HtmlApplication) Messages(messages ethstate.Messages, id string) {
+func (self *HtmlApplication) Messages(messages state.Messages, id string) {
 	var msgs []javascript.JSMessage
 	for _, m := range messages {
 		msgs = append(msgs, javascript.NewJSMessage(m))
diff --git a/cmd/mist/qml_container.go b/cmd/mist/qml_container.go
index 4f6ca0b7f..60013ec2b 100644
--- a/cmd/mist/qml_container.go
+++ b/cmd/mist/qml_container.go
@@ -22,8 +22,8 @@ import (
 	"runtime"
 
 	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
 	"gopkg.in/qml.v1"
 )
@@ -70,7 +70,7 @@ func (app *QmlApplication) NewBlock(block *chain.Block) {
 	app.win.Call("onNewBlockCb", pblock)
 }
 
-func (self *QmlApplication) Messages(msgs ethstate.Messages, id string) {
+func (self *QmlApplication) Messages(msgs state.Messages, id string) {
 	fmt.Println("IMPLEMENT QML APPLICATION MESSAGES METHOD")
 }
 
diff --git a/cmd/mist/ui_lib.go b/cmd/mist/ui_lib.go
index 9d2554cf4..db299f18d 100644
--- a/cmd/mist/ui_lib.go
+++ b/cmd/mist/ui_lib.go
@@ -27,9 +27,9 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/ui/qt"
 	"github.com/ethereum/go-ethereum/xeth"
 	"gopkg.in/qml.v1"
@@ -213,7 +213,7 @@ func (self *UiLib) StartDebugger() {
 
 func (self *UiLib) NewFilter(object map[string]interface{}) (id int) {
 	filter := qt.NewFilterFromMap(object, self.eth)
-	filter.MessageCallback = func(messages ethstate.Messages) {
+	filter.MessageCallback = func(messages state.Messages) {
 		self.win.Root().Call("invokeFilterCallback", xeth.ToJSMessages(messages), id)
 	}
 	id = self.eth.InstallFilter(filter)
diff --git a/cmd/utils/vm_env.go b/cmd/utils/vm_env.go
index 0a7b589ee..b06611cdd 100644
--- a/cmd/utils/vm_env.go
+++ b/cmd/utils/vm_env.go
@@ -4,19 +4,19 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
-	state *ethstate.State
+	state *state.State
 	block *chain.Block
 
 	transactor []byte
 	value      *big.Int
 }
 
-func NewEnv(state *ethstate.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
+func NewEnv(state *state.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
 	return &VMEnv{
 		state:      state,
 		block:      block,
@@ -25,17 +25,17 @@ func NewEnv(state *ethstate.State, block *chain.Block, transactor []byte, value
 	}
 }
 
-func (self *VMEnv) Origin() []byte         { return self.transactor }
-func (self *VMEnv) BlockNumber() *big.Int  { return self.block.Number }
-func (self *VMEnv) PrevHash() []byte       { return self.block.PrevHash }
-func (self *VMEnv) Coinbase() []byte       { return self.block.Coinbase }
-func (self *VMEnv) Time() int64            { return self.block.Time }
-func (self *VMEnv) Difficulty() *big.Int   { return self.block.Difficulty }
-func (self *VMEnv) BlockHash() []byte      { return self.block.Hash() }
-func (self *VMEnv) Value() *big.Int        { return self.value }
-func (self *VMEnv) State() *ethstate.State { return self.state }
-func (self *VMEnv) GasLimit() *big.Int     { return self.block.GasLimit }
-func (self *VMEnv) AddLog(ethstate.Log)    {}
+func (self *VMEnv) Origin() []byte        { return self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte      { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase }
+func (self *VMEnv) Time() int64           { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte     { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int       { return self.value }
+func (self *VMEnv) State() *state.State   { return self.state }
+func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit }
+func (self *VMEnv) AddLog(state.Log)      {}
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
 	return vm.Transfer(from, to, amount)
 }
diff --git a/ethereum.go b/ethereum.go
index 9b456ad7c..d6f664349 100644
--- a/ethereum.go
+++ b/ethereum.go
@@ -16,12 +16,12 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/ethwire"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 const (
@@ -615,7 +615,7 @@ func (self *Ethereum) GetFilter(id int) *chain.Filter {
 
 func (self *Ethereum) filterLoop() {
 	// Subscribe to events
-	events := self.eventMux.Subscribe(chain.NewBlockEvent{}, ethstate.Messages(nil))
+	events := self.eventMux.Subscribe(chain.NewBlockEvent{}, state.Messages(nil))
 	for event := range events.Chan() {
 		switch event := event.(type) {
 		case chain.NewBlockEvent:
@@ -627,7 +627,7 @@ func (self *Ethereum) filterLoop() {
 			}
 			self.filterMu.RUnlock()
 
-		case ethstate.Messages:
+		case state.Messages:
 			self.filterMu.RLock()
 			for _, filter := range self.filters {
 				if filter.MessageCallback != nil {
diff --git a/ethstate/.ethtest b/ethstate/.ethtest
deleted file mode 100644
index e69de29bb..000000000
--- a/ethstate/.ethtest
+++ /dev/null
diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go
index 5885e5c6e..ea3cb6071 100644
--- a/javascript/javascript_runtime.go
+++ b/javascript/javascript_runtime.go
@@ -10,10 +10,10 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
 	"github.com/obscuren/otto"
 )
@@ -127,7 +127,7 @@ func (self *JSRE) initStdFuncs() {
  */
 
 func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
-	var state *ethstate.State
+	var state *state.State
 
 	if len(call.ArgumentList) > 0 {
 		var block *chain.Block
diff --git a/javascript/types.go b/javascript/types.go
index a98c48905..d5acaecce 100644
--- a/javascript/types.go
+++ b/javascript/types.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/ui"
 	"github.com/ethereum/go-ethereum/xeth"
 	"github.com/obscuren/otto"
@@ -51,7 +51,7 @@ type JSMessage struct {
 	Number    int32  `json:"number"`
 }
 
-func NewJSMessage(message *ethstate.Message) JSMessage {
+func NewJSMessage(message *state.Message) JSMessage {
 	return JSMessage{
 		To:        ethutil.Bytes2Hex(message.To),
 		From:      ethutil.Bytes2Hex(message.From),
diff --git a/ethstate/dump.go b/state/dump.go
index fd92ac4df..de356f476 100644
--- a/ethstate/dump.go
+++ b/state/dump.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"encoding/json"
diff --git a/ethstate/errors.go b/state/errors.go
index d5d7db86b..5a847d38b 100644
--- a/ethstate/errors.go
+++ b/state/errors.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"fmt"
diff --git a/ethstate/log.go b/state/log.go
index a2e9ca041..73039d7ce 100644
--- a/ethstate/log.go
+++ b/state/log.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import "github.com/ethereum/go-ethereum/ethutil"
 
diff --git a/ethstate/manifest.go b/state/manifest.go
index 945de22ab..21cd04a1a 100644
--- a/ethstate/manifest.go
+++ b/state/manifest.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"fmt"
diff --git a/ethstate/state.go b/state/state.go
index 9025194e5..298cf9680 100644
--- a/ethstate/state.go
+++ b/state/state.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"math/big"
diff --git a/ethstate/state_object.go b/state/state_object.go
index d28a2b80d..fb568e543 100644
--- a/ethstate/state_object.go
+++ b/state/state_object.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"fmt"
diff --git a/ethstate/state_test.go b/state/state_test.go
index 2454fce84..42f434ef0 100644
--- a/ethstate/state_test.go
+++ b/state/state_test.go
@@ -1,4 +1,4 @@
-package ethstate
+package state
 
 import (
 	"testing"
diff --git a/vm/closure.go b/vm/closure.go
index b556bc03d..8e54e9ce6 100644
--- a/vm/closure.go
+++ b/vm/closure.go
@@ -5,14 +5,14 @@ package vm
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type ClosureRef interface {
 	ReturnGas(*big.Int, *big.Int)
 	Address() []byte
-	Object() *ethstate.StateObject
+	Object() *state.StateObject
 	GetStorage(*big.Int) *ethutil.Value
 	SetStorage(*big.Int, *ethutil.Value)
 }
@@ -20,9 +20,9 @@ type ClosureRef interface {
 // Basic inline closure object which implement the 'closure' interface
 type Closure struct {
 	caller  ClosureRef
-	object  *ethstate.StateObject
+	object  *state.StateObject
 	Code    []byte
-	message *ethstate.Message
+	message *state.Message
 	exe     *Execution
 
 	Gas, UsedGas, Price *big.Int
@@ -31,7 +31,7 @@ type Closure struct {
 }
 
 // Create a new closure for the given data items
-func NewClosure(msg *ethstate.Message, caller ClosureRef, object *ethstate.StateObject, code []byte, gas, price *big.Int) *Closure {
+func NewClosure(msg *state.Message, caller ClosureRef, object *state.StateObject, code []byte, gas, price *big.Int) *Closure {
 	c := &Closure{message: msg, caller: caller, object: object, Code: code, Args: nil}
 
 	// Gas should be a pointer so it can safely be reduced through the run
@@ -131,7 +131,7 @@ func (c *Closure) ReturnGas(gas, price *big.Int) {
 	c.UsedGas.Sub(c.UsedGas, gas)
 }
 
-func (c *Closure) Object() *ethstate.StateObject {
+func (c *Closure) Object() *state.StateObject {
 	return c.object
 }
 
diff --git a/vm/debugger.go b/vm/debugger.go
index b0d0e545d..9b08634c6 100644
--- a/vm/debugger.go
+++ b/vm/debugger.go
@@ -1,10 +1,10 @@
 package vm
 
-import "github.com/ethereum/go-ethereum/ethstate"
+import "github.com/ethereum/go-ethereum/state"
 
 type Debugger interface {
-	BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
-	StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
+	BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
+	StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
 	BreakPoints() []int64
 	SetCode(byteCode []byte)
 }
diff --git a/vm/environment.go b/vm/environment.go
index deb46b77f..dea86c66c 100644
--- a/vm/environment.go
+++ b/vm/environment.go
@@ -4,12 +4,12 @@ import (
 	"errors"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type Environment interface {
-	State() *ethstate.State
+	State() *state.State
 
 	Origin() []byte
 	BlockNumber() *big.Int
@@ -20,7 +20,7 @@ type Environment interface {
 	BlockHash() []byte
 	GasLimit() *big.Int
 	Transfer(from, to Account, amount *big.Int) error
-	AddLog(ethstate.Log)
+	AddLog(state.Log)
 }
 
 type Object interface {
diff --git a/vm/execution.go b/vm/execution.go
index 8da0469de..401157808 100644
--- a/vm/execution.go
+++ b/vm/execution.go
@@ -4,15 +4,15 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type Execution struct {
 	vm                VirtualMachine
 	address, input    []byte
 	Gas, price, value *big.Int
-	object            *ethstate.StateObject
+	object            *state.StateObject
 	SkipTransfer      bool
 }
 
@@ -41,7 +41,7 @@ func (self *Execution) exec(code, caddr []byte, caller ClosureRef) (ret []byte,
 		}
 	}()
 
-	msg := env.State().Manifest().AddMessage(&ethstate.Message{
+	msg := env.State().Manifest().AddMessage(&state.Message{
 		To: self.address, From: caller.Address(),
 		Input:  self.input,
 		Origin: env.Origin(),
diff --git a/vm/vm_debug.go b/vm/vm_debug.go
index 1cf243e16..0942636d6 100644
--- a/vm/vm_debug.go
+++ b/vm/vm_debug.go
@@ -5,8 +5,8 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type DebugVm struct {
@@ -49,7 +49,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 		pc       = big.NewInt(0)
 		step     = 0
 		prevStep = 0
-		state    = self.env.State()
+		statedb  = self.env.State()
 		require  = func(m int) {
 			if stack.Len() < m {
 				panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
@@ -115,7 +115,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 		if self.logTy == LogTyDiff {
 			switch op {
 			case STOP, RETURN, SUICIDE:
-				state.GetStateObject(closure.Address()).EachStorage(func(key string, value *ethutil.Value) {
+				statedb.GetStateObject(closure.Address()).EachStorage(func(key string, value *ethutil.Value) {
 					value.Decode()
 					fmt.Printf("%x %x\n", new(big.Int).SetBytes([]byte(key)).Bytes(), value.Bytes())
 				})
@@ -184,7 +184,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 				// 0 => non 0
 				mult = ethutil.Big3
 			} else if val.BigInt().Cmp(ethutil.Big0) != 0 && len(y.Bytes()) == 0 {
-				state.Refund(closure.caller.Address(), GasSStoreRefund, closure.Price)
+				statedb.Refund(closure.caller.Address(), GasSStoreRefund, closure.Price)
 
 				mult = ethutil.Big0
 			} else {
@@ -532,7 +532,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 		case BALANCE:
 
 			addr := stack.Pop().Bytes()
-			balance := state.GetBalance(addr)
+			balance := statedb.GetBalance(addr)
 
 			stack.Push(balance)
 
@@ -599,7 +599,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			if op == EXTCODESIZE {
 				addr := stack.Pop().Bytes()
 
-				code = state.GetCode(addr)
+				code = statedb.GetCode(addr)
 			} else {
 				code = closure.Code
 			}
@@ -613,7 +613,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			if op == EXTCODECOPY {
 				addr := stack.Pop().Bytes()
 
-				code = state.GetCode(addr)
+				code = statedb.GetCode(addr)
 			} else {
 				code = closure.Code
 			}
@@ -711,7 +711,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			for i := 0; i < n; i++ {
 				topics[i] = stack.Pop().Bytes()
 			}
-			self.env.AddLog(ethstate.Log{closure.Address(), topics, data})
+			self.env.AddLog(state.Log{closure.Address(), topics, data})
 		case MLOAD:
 			offset := stack.Pop()
 			val := ethutil.BigD(mem.Get(offset.Int64(), 32))
@@ -733,13 +733,13 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			self.Printf(" => [%v] 0x%x", off, val)
 		case SLOAD:
 			loc := stack.Pop()
-			val := ethutil.BigD(state.GetState(closure.Address(), loc.Bytes()))
+			val := ethutil.BigD(statedb.GetState(closure.Address(), loc.Bytes()))
 			stack.Push(val)
 
 			self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
 		case SSTORE:
 			val, loc := stack.Popn()
-			state.SetState(closure.Address(), loc.Bytes(), val)
+			statedb.SetState(closure.Address(), loc.Bytes(), val)
 
 			// Debug sessions are allowed to run without message
 			if closure.message != nil {
@@ -784,9 +784,9 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			)
 
 			// Generate a new address
-			n := state.GetNonce(closure.Address())
+			n := statedb.GetNonce(closure.Address())
 			addr := crypto.CreateAddress(closure.Address(), n)
-			state.SetNonce(closure.Address(), n+1)
+			statedb.SetNonce(closure.Address(), n+1)
 
 			self.Printf(" (*) %x", addr).Endl()
 
@@ -861,10 +861,10 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 			return closure.Return(ret), nil
 		case SUICIDE:
 
-			receiver := state.GetOrNewStateObject(stack.Pop().Bytes())
+			receiver := statedb.GetOrNewStateObject(stack.Pop().Bytes())
 
-			receiver.AddAmount(state.GetBalance(closure.Address()))
-			state.Delete(closure.Address())
+			receiver.AddAmount(statedb.GetBalance(closure.Address()))
+			statedb.Delete(closure.Address())
 
 			fallthrough
 		case STOP: // Stop the closure
@@ -889,11 +889,11 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
 				if pc.Cmp(big.NewInt(instrNo)) == 0 {
 					self.Stepping = true
 
-					if !self.Dbg.BreakHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
+					if !self.Dbg.BreakHook(prevStep, op, mem, stack, statedb.GetStateObject(closure.Address())) {
 						return nil, nil
 					}
 				} else if self.Stepping {
-					if !self.Dbg.StepHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
+					if !self.Dbg.StepHook(prevStep, op, mem, stack, statedb.GetStateObject(closure.Address())) {
 						return nil, nil
 					}
 				}
diff --git a/xeth/hexface.go b/xeth/hexface.go
index 829f530f4..5c8e7a3c7 100644
--- a/xeth/hexface.go
+++ b/xeth/hexface.go
@@ -7,8 +7,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type JSXEth struct {
@@ -254,7 +254,7 @@ func (self *JSXEth) CompileMutan(code string) string {
 	return ethutil.Bytes2Hex(data)
 }
 
-func ToJSMessages(messages ethstate.Messages) *ethutil.List {
+func ToJSMessages(messages state.Messages) *ethutil.List {
 	var msgs []JSMessage
 	for _, m := range messages {
 		msgs = append(msgs, NewJSMessage(m))
diff --git a/xeth/js_types.go b/xeth/js_types.go
index 058bfe0dd..9f8f12e7f 100644
--- a/xeth/js_types.go
+++ b/xeth/js_types.go
@@ -7,8 +7,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 // Block interface exposed to QML
@@ -90,7 +90,7 @@ type JSTransaction struct {
 	Confirmations   int    `json:"confirmations"`
 }
 
-func NewJSTx(tx *chain.Transaction, state *ethstate.State) *JSTransaction {
+func NewJSTx(tx *chain.Transaction, state *state.State) *JSTransaction {
 	hash := ethutil.Bytes2Hex(tx.Hash())
 	receiver := ethutil.Bytes2Hex(tx.Recipient)
 	if receiver == "0000000000000000000000000000000000000000" {
@@ -212,7 +212,7 @@ type JSMessage struct {
 	Value     string `json:"value"`
 }
 
-func NewJSMessage(message *ethstate.Message) JSMessage {
+func NewJSMessage(message *state.Message) JSMessage {
 	return JSMessage{
 		To:        ethutil.Bytes2Hex(message.To),
 		From:      ethutil.Bytes2Hex(message.From),
diff --git a/xeth/object.go b/xeth/object.go
index fe4e84a4a..a4ac41e89 100644
--- a/xeth/object.go
+++ b/xeth/object.go
@@ -1,12 +1,12 @@
 package xeth
 
 import (
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type Object struct {
-	*ethstate.StateObject
+	*state.StateObject
 }
 
 func (self *Object) StorageString(str string) *ethutil.Value {
diff --git a/xeth/pipe.go b/xeth/pipe.go
index f2759d660..25a69137d 100644
--- a/xeth/pipe.go
+++ b/xeth/pipe.go
@@ -10,16 +10,16 @@ import (
 
 	"github.com/ethereum/go-ethereum/chain"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethstate"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 var pipelogger = logger.NewLogger("XETH")
 
 type VmVars struct {
-	State *ethstate.State
+	State *state.State
 }
 
 type XEth struct {
@@ -56,7 +56,7 @@ func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.V
 
 func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
 	var (
-		initiator = ethstate.NewStateObject(self.obj.KeyManager().KeyPair().Address())
+		initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address())
 		block     = self.blockChain.CurrentBlock
 	)
 
diff --git a/xeth/vm_env.go b/xeth/vm_env.go
index 952101f68..2c36444e9 100644
--- a/xeth/vm_env.go
+++ b/xeth/vm_env.go
@@ -4,18 +4,18 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/chain"
-	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
 
 type VMEnv struct {
-	state  *ethstate.State
+	state  *state.State
 	block  *chain.Block
 	value  *big.Int
 	sender []byte
 }
 
-func NewEnv(state *ethstate.State, block *chain.Block, value *big.Int, sender []byte) *VMEnv {
+func NewEnv(state *state.State, block *chain.Block, value *big.Int, sender []byte) *VMEnv {
 	return &VMEnv{
 		state:  state,
 		block:  block,
@@ -24,17 +24,17 @@ func NewEnv(state *ethstate.State, block *chain.Block, value *big.Int, sender []
 	}
 }
 
-func (self *VMEnv) Origin() []byte         { return self.sender }
-func (self *VMEnv) BlockNumber() *big.Int  { return self.block.Number }
-func (self *VMEnv) PrevHash() []byte       { return self.block.PrevHash }
-func (self *VMEnv) Coinbase() []byte       { return self.block.Coinbase }
-func (self *VMEnv) Time() int64            { return self.block.Time }
-func (self *VMEnv) Difficulty() *big.Int   { return self.block.Difficulty }
-func (self *VMEnv) BlockHash() []byte      { return self.block.Hash() }
-func (self *VMEnv) Value() *big.Int        { return self.value }
-func (self *VMEnv) State() *ethstate.State { return self.state }
-func (self *VMEnv) GasLimit() *big.Int     { return self.block.GasLimit }
-func (self *VMEnv) AddLog(ethstate.Log)    {}
+func (self *VMEnv) Origin() []byte        { return self.sender }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte      { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase }
+func (self *VMEnv) Time() int64           { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte     { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int       { return self.value }
+func (self *VMEnv) State() *state.State   { return self.state }
+func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit }
+func (self *VMEnv) AddLog(state.Log)      {}
 func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
 	return vm.Transfer(from, to, amount)
 }
diff --git a/xeth/world.go b/xeth/world.go
index daeb59e1c..dda2df274 100644
--- a/xeth/world.go
+++ b/xeth/world.go
@@ -3,7 +3,7 @@ package xeth
 import (
 	"container/list"
 
-	"github.com/ethereum/go-ethereum/ethstate"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 type World struct {
@@ -22,7 +22,7 @@ func (self *XEth) World() *World {
 	return self.world
 }
 
-func (self *World) State() *ethstate.State {
+func (self *World) State() *state.State {
 	return self.pipe.stateManager.CurrentState()
 }
 
@@ -34,16 +34,16 @@ func (self *World) SafeGet(addr []byte) *Object {
 	return &Object{self.safeGet(addr)}
 }
 
-func (self *World) safeGet(addr []byte) *ethstate.StateObject {
+func (self *World) safeGet(addr []byte) *state.StateObject {
 	object := self.State().GetStateObject(addr)
 	if object == nil {
-		object = ethstate.NewStateObject(addr)
+		object = state.NewStateObject(addr)
 	}
 
 	return object
 }
 
-func (self *World) Coinbase() *ethstate.StateObject {
+func (self *World) Coinbase() *state.StateObject {
 	return nil
 }