moved state and vm to core

9 files changed, 1159 insertions, 0 deletions

diff --git a/core/state/dump.go b/core/state/dump.go
new file mode 100644
index 000000000..712f8da1f
--- /dev/null
+++ b/core/state/dump.go
@@ -0,0 +1,62 @@
+package state
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type Account struct {
+	Balance  string            `json:"balance"`
+	Nonce    uint64            `json:"nonce"`
+	Root     string            `json:"root"`
+	CodeHash string            `json:"codeHash"`
+	Storage  map[string]string `json:"storage"`
+}
+
+type World struct {
+	Root     string             `json:"root"`
+	Accounts map[string]Account `json:"accounts"`
+}
+
+func (self *StateDB) RawDump() World {
+	world := World{
+		Root:     common.Bytes2Hex(self.trie.Root()),
+		Accounts: make(map[string]Account),
+	}
+
+	it := self.trie.Iterator()
+	for it.Next() {
+		stateObject := NewStateObjectFromBytes(common.BytesToAddress(it.Key), it.Value, self.db)
+
+		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() {
+			fmt.Println("value", storageIt.Value)
+			account.Storage[common.Bytes2Hex(storageIt.Key)] = common.Bytes2Hex(storageIt.Value)
+		}
+		world.Accounts[common.Bytes2Hex(it.Key)] = account
+	}
+	return world
+}
+
+func (self *StateDB) Dump() []byte {
+	json, err := json.MarshalIndent(self.RawDump(), "", "    ")
+	if err != nil {
+		fmt.Println("dump err", err)
+	}
+
+	return json
+}
+
+// Debug stuff
+func (self *StateObject) CreateOutputForDiff() {
+	fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.balance.Bytes(), self.nonce)
+	it := self.State.trie.Iterator()
+	for it.Next() {
+		fmt.Printf("%x %x\n", it.Key, it.Value)
+	}
+}
diff --git a/core/state/errors.go b/core/state/errors.go
new file mode 100644
index 000000000..5a847d38b
--- /dev/null
+++ b/core/state/errors.go
@@ -0,0 +1,23 @@
+package state
+
+import (
+	"fmt"
+	"math/big"
+)
+
+type GasLimitErr struct {
+	Message string
+	Is, Max *big.Int
+}
+
+func IsGasLimitErr(err error) bool {
+	_, ok := err.(*GasLimitErr)
+
+	return ok
+}
+func (err *GasLimitErr) Error() string {
+	return err.Message
+}
+func GasLimitError(is, max *big.Int) *GasLimitErr {
+	return &GasLimitErr{Message: fmt.Sprintf("GasLimit error. Max %s, transaction would take it to %s", max, is), Is: is, Max: max}
+}
diff --git a/core/state/log.go b/core/state/log.go
new file mode 100644
index 000000000..f8aa4c08c
--- /dev/null
+++ b/core/state/log.go
@@ -0,0 +1,99 @@
+package state
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+type Log interface {
+	Address() common.Address
+	Topics() []common.Hash
+	Data() []byte
+
+	Number() uint64
+}
+
+type StateLog struct {
+	address common.Address
+	topics  []common.Hash
+	data    []byte
+	number  uint64
+}
+
+func NewLog(address common.Address, topics []common.Hash, data []byte, number uint64) *StateLog {
+	return &StateLog{address, topics, data, number}
+}
+
+func (self *StateLog) Address() common.Address {
+	return self.address
+}
+
+func (self *StateLog) Topics() []common.Hash {
+	return self.topics
+}
+
+func (self *StateLog) Data() []byte {
+	return self.data
+}
+
+func (self *StateLog) Number() uint64 {
+	return self.number
+}
+
+/*
+func NewLogFromValue(decoder *common.Value) *StateLog {
+	var extlog struct {
+
+	}
+
+	log := &StateLog{
+		address: decoder.Get(0).Bytes(),
+		data:    decoder.Get(2).Bytes(),
+	}
+
+	it := decoder.Get(1).NewIterator()
+	for it.Next() {
+		log.topics = append(log.topics, it.Value().Bytes())
+	}
+
+	return log
+}
+*/
+
+func (self *StateLog) EncodeRLP(w io.Writer) error {
+	return rlp.Encode(w, []interface{}{self.address, self.topics, self.data})
+}
+
+/*
+func (self *StateLog) RlpData() interface{} {
+	return []interface{}{self.address, common.ByteSliceToInterface(self.topics), self.data}
+}
+*/
+
+func (self *StateLog) String() string {
+	return fmt.Sprintf(`log: %x %x %x`, self.address, self.topics, self.data)
+}
+
+type Logs []Log
+
+/*
+func (self Logs) RlpData() interface{} {
+	data := make([]interface{}, len(self))
+	for i, log := range self {
+		data[i] = log.RlpData()
+	}
+
+	return data
+}
+*/
+
+func (self Logs) String() (ret string) {
+	for _, log := range self {
+		ret += fmt.Sprintf("%v", log)
+	}
+
+	return "[" + ret + "]"
+}
diff --git a/core/state/main_test.go b/core/state/main_test.go
new file mode 100644
index 000000000..f3d3f7e23
--- /dev/null
+++ b/core/state/main_test.go
@@ -0,0 +1,9 @@
+package state
+
+import (
+	"testing"
+
+	checker "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { checker.TestingT(t) }
diff --git a/core/state/managed_state.go b/core/state/managed_state.go
new file mode 100644
index 000000000..0fcc1be67
--- /dev/null
+++ b/core/state/managed_state.go
@@ -0,0 +1,89 @@
+package state
+
+import (
+	"sync"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type account struct {
+	stateObject *StateObject
+	nstart      uint64
+	nonces      []bool
+}
+
+type ManagedState struct {
+	*StateDB
+
+	mu sync.RWMutex
+
+	accounts map[string]*account
+}
+
+func ManageState(statedb *StateDB) *ManagedState {
+	return &ManagedState{
+		StateDB:  statedb,
+		accounts: make(map[string]*account),
+	}
+}
+
+func (ms *ManagedState) SetState(statedb *StateDB) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	ms.StateDB = statedb
+}
+
+func (ms *ManagedState) RemoveNonce(addr common.Address, n uint64) {
+	if ms.hasAccount(addr) {
+		ms.mu.Lock()
+		defer ms.mu.Unlock()
+
+		account := ms.getAccount(addr)
+		if n-account.nstart <= uint64(len(account.nonces)) {
+			reslice := make([]bool, n-account.nstart)
+			copy(reslice, account.nonces[:n-account.nstart])
+			account.nonces = reslice
+		}
+	}
+}
+
+func (ms *ManagedState) NewNonce(addr common.Address) uint64 {
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	account := ms.getAccount(addr)
+	for i, nonce := range account.nonces {
+		if !nonce {
+			return account.nstart + uint64(i)
+		}
+	}
+	account.nonces = append(account.nonces, true)
+	return uint64(len(account.nonces)) + account.nstart
+}
+
+func (ms *ManagedState) hasAccount(addr common.Address) bool {
+	_, ok := ms.accounts[addr.Str()]
+	return ok
+}
+
+func (ms *ManagedState) getAccount(addr common.Address) *account {
+	straddr := addr.Str()
+	if account, ok := ms.accounts[straddr]; !ok {
+		so := ms.GetOrNewStateObject(addr)
+		ms.accounts[straddr] = newAccount(so)
+	} else {
+		// Always make sure the state account nonce isn't actually higher
+		// than the tracked one.
+		so := ms.StateDB.GetStateObject(addr)
+		if so != nil && uint64(len(account.nonces))+account.nstart < so.nonce {
+			ms.accounts[straddr] = newAccount(so)
+		}
+
+	}
+
+	return ms.accounts[straddr]
+}
+
+func newAccount(so *StateObject) *account {
+	return &account{so, so.nonce - 1, nil}
+}
diff --git a/core/state/managed_state_test.go b/core/state/managed_state_test.go
new file mode 100644
index 000000000..b61f59e6d
--- /dev/null
+++ b/core/state/managed_state_test.go
@@ -0,0 +1,89 @@
+package state
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var addr = common.BytesToAddress([]byte("test"))
+
+func create() (*ManagedState, *account) {
+	ms := ManageState(&StateDB{stateObjects: make(map[string]*StateObject)})
+	so := &StateObject{address: addr, nonce: 100}
+	ms.StateDB.stateObjects[addr.Str()] = so
+	ms.accounts[addr.Str()] = newAccount(so)
+
+	return ms, ms.accounts[addr.Str()]
+}
+
+func TestNewNonce(t *testing.T) {
+	ms, _ := create()
+
+	nonce := ms.NewNonce(addr)
+	if nonce != 100 {
+		t.Error("expected nonce 100. got", nonce)
+	}
+
+	nonce = ms.NewNonce(addr)
+	if nonce != 101 {
+		t.Error("expected nonce 101. got", nonce)
+	}
+}
+
+func TestRemove(t *testing.T) {
+	ms, account := create()
+
+	nn := make([]bool, 10)
+	for i, _ := range nn {
+		nn[i] = true
+	}
+	account.nonces = append(account.nonces, nn...)
+
+	i := uint64(5)
+	ms.RemoveNonce(addr, account.nstart+i)
+	if len(account.nonces) != 5 {
+		t.Error("expected", i, "'th index to be false")
+	}
+}
+
+func TestReuse(t *testing.T) {
+	ms, account := create()
+
+	nn := make([]bool, 10)
+	for i, _ := range nn {
+		nn[i] = true
+	}
+	account.nonces = append(account.nonces, nn...)
+
+	i := uint64(5)
+	ms.RemoveNonce(addr, account.nstart+i)
+	nonce := ms.NewNonce(addr)
+	if nonce != 105 {
+		t.Error("expected nonce to be 105. got", nonce)
+	}
+}
+
+func TestRemoteNonceChange(t *testing.T) {
+	ms, account := create()
+	nn := make([]bool, 10)
+	for i, _ := range nn {
+		nn[i] = true
+	}
+	account.nonces = append(account.nonces, nn...)
+	nonce := ms.NewNonce(addr)
+
+	ms.StateDB.stateObjects[addr.Str()].nonce = 200
+	nonce = ms.NewNonce(addr)
+	if nonce != 200 {
+		t.Error("expected nonce after remote update to be", 201, "got", nonce)
+	}
+	ms.NewNonce(addr)
+	ms.NewNonce(addr)
+	ms.NewNonce(addr)
+	ms.StateDB.stateObjects[addr.Str()].nonce = 200
+	nonce = ms.NewNonce(addr)
+	if nonce != 204 {
+		t.Error("expected nonce after remote update to be", 201, "got", nonce)
+	}
+}
diff --git a/core/state/state_object.go b/core/state/state_object.go
new file mode 100644
index 000000000..a7c20722c
--- /dev/null
+++ b/core/state/state_object.go
@@ -0,0 +1,357 @@
+package state
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+type Code []byte
+
+func (self Code) String() string {
+	return string(self) //strings.Join(Disassemble(self), " ")
+}
+
+type Storage map[string]*common.Value
+
+func (self Storage) String() (str string) {
+	for key, value := range self {
+		str += fmt.Sprintf("%X : %X\n", key, value.Bytes())
+	}
+
+	return
+}
+
+func (self Storage) Copy() Storage {
+	cpy := make(Storage)
+	for key, value := range self {
+		// XXX Do we need a 'value' copy or is this sufficient?
+		cpy[key] = value
+	}
+
+	return cpy
+}
+
+type StateObject struct {
+	// State database for storing state changes
+	db common.Database
+	// The state object
+	State *StateDB
+
+	// Address belonging to this account
+	address common.Address
+	// The balance of the account
+	balance *big.Int
+	// The nonce of the account
+	nonce uint64
+	// The code hash if code is present (i.e. a contract)
+	codeHash []byte
+	// The code for this account
+	code Code
+	// Temporarily initialisation code
+	initCode Code
+	// Cached storage (flushed when updated)
+	storage Storage
+	// Temporary prepaid gas, reward after transition
+	prepaid *big.Int
+
+	// Total gas pool is the total amount of gas currently
+	// left if this object is the coinbase. Gas is directly
+	// purchased of the coinbase.
+	gasPool *big.Int
+
+	// Mark for deletion
+	// When an object is marked for deletion it will be delete from the trie
+	// during the "update" phase of the state transition
+	remove bool
+	dirty  bool
+}
+
+func (self *StateObject) Reset() {
+	self.storage = make(Storage)
+	self.State.Reset()
+}
+
+func NewStateObject(address common.Address, 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 := common.ToAddress(addr)
+
+	object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int), dirty: true}
+	object.State = New(common.Hash{}, db) //New(trie.New(common.Config.Db, ""))
+	object.storage = make(Storage)
+	object.gasPool = new(big.Int)
+	object.prepaid = new(big.Int)
+
+	return object
+}
+
+func NewStateObjectFromBytes(address common.Address, data []byte, db common.Database) *StateObject {
+	// TODO clean me up
+	var extobject struct {
+		Nonce    uint64
+		Balance  *big.Int
+		Root     common.Hash
+		CodeHash []byte
+	}
+	err := rlp.Decode(bytes.NewReader(data), &extobject)
+	if err != nil {
+		fmt.Println(err)
+		return nil
+	}
+
+	object := &StateObject{address: address, db: db}
+	//object.RlpDecode(data)
+	object.nonce = extobject.Nonce
+	object.balance = extobject.Balance
+	object.codeHash = extobject.CodeHash
+	object.State = New(extobject.Root, db)
+	object.storage = make(map[string]*common.Value)
+	object.gasPool = new(big.Int)
+	object.prepaid = new(big.Int)
+	object.code, _ = db.Get(extobject.CodeHash)
+
+	return object
+}
+
+func (self *StateObject) MarkForDeletion() {
+	self.remove = true
+	self.dirty = true
+	statelogger.Debugf("%x: #%d %v X\n", self.Address(), self.nonce, self.balance)
+}
+
+func (c *StateObject) getAddr(addr common.Hash) *common.Value {
+	return common.NewValueFromBytes([]byte(c.State.trie.Get(addr[:])))
+}
+
+func (c *StateObject) setAddr(addr []byte, value interface{}) {
+	c.State.trie.Update(addr, common.Encode(value))
+}
+
+func (self *StateObject) GetStorage(key *big.Int) *common.Value {
+	return self.GetState(common.BytesToHash(key.Bytes()))
+}
+func (self *StateObject) SetStorage(key *big.Int, value *common.Value) {
+	self.SetState(common.BytesToHash(key.Bytes()), value)
+}
+
+func (self *StateObject) Storage() Storage {
+	return self.storage
+}
+
+func (self *StateObject) GetState(key common.Hash) *common.Value {
+	strkey := key.Str()
+	value := self.storage[strkey]
+	if value == nil {
+		value = self.getAddr(key)
+
+		if !value.IsNil() {
+			self.storage[strkey] = value
+		}
+	}
+
+	return value
+}
+
+func (self *StateObject) SetState(k common.Hash, value *common.Value) {
+	self.storage[k.Str()] = value.Copy()
+	self.dirty = true
+}
+
+func (self *StateObject) Sync() {
+	for key, value := range self.storage {
+		if value.Len() == 0 {
+			self.State.trie.Delete([]byte(key))
+			continue
+		}
+
+		self.setAddr([]byte(key), value)
+	}
+	self.storage = make(Storage)
+}
+
+func (c *StateObject) GetInstr(pc *big.Int) *common.Value {
+	if int64(len(c.code)-1) < pc.Int64() {
+		return common.NewValue(0)
+	}
+
+	return common.NewValueFromBytes([]byte{c.code[pc.Int64()]})
+}
+
+func (c *StateObject) AddBalance(amount *big.Int) {
+	c.SetBalance(new(big.Int).Add(c.balance, amount))
+
+	statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.nonce, c.balance, amount)
+}
+
+func (c *StateObject) SubBalance(amount *big.Int) {
+	c.SetBalance(new(big.Int).Sub(c.balance, amount))
+
+	statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.nonce, c.balance, amount)
+}
+
+func (c *StateObject) SetBalance(amount *big.Int) {
+	c.balance = amount
+	c.dirty = true
+}
+
+func (c *StateObject) St() Storage {
+	return c.storage
+}
+
+//
+// Gas setters and getters
+//
+
+// Return the gas back to the origin. Used by the Virtual machine or Closures
+func (c *StateObject) ReturnGas(gas, price *big.Int) {}
+func (c *StateObject) ConvertGas(gas, price *big.Int) error {
+	total := new(big.Int).Mul(gas, price)
+	if total.Cmp(c.balance) > 0 {
+		return fmt.Errorf("insufficient amount: %v, %v", c.balance, total)
+	}
+
+	c.SubBalance(total)
+
+	c.dirty = true
+
+	return nil
+}
+
+func (self *StateObject) SetGasPool(gasLimit *big.Int) {
+	self.gasPool = new(big.Int).Set(gasLimit)
+
+	statelogger.Debugf("%x: gas (+ %v)", self.Address(), self.gasPool)
+}
+
+func (self *StateObject) BuyGas(gas, price *big.Int) error {
+	if self.gasPool.Cmp(gas) < 0 {
+		return GasLimitError(self.gasPool, gas)
+	}
+
+	self.gasPool.Sub(self.gasPool, gas)
+
+	rGas := new(big.Int).Set(gas)
+	rGas.Mul(rGas, price)
+
+	self.dirty = true
+
+	return nil
+}
+
+func (self *StateObject) RefundGas(gas, price *big.Int) {
+	self.gasPool.Add(self.gasPool, gas)
+}
+
+func (self *StateObject) Copy() *StateObject {
+	stateObject := NewStateObject(self.Address(), self.db)
+	stateObject.balance.Set(self.balance)
+	stateObject.codeHash = common.CopyBytes(self.codeHash)
+	stateObject.nonce = self.nonce
+	if self.State != nil {
+		stateObject.State = self.State.Copy()
+	}
+	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
+	stateObject.dirty = self.dirty
+
+	return stateObject
+}
+
+func (self *StateObject) Set(stateObject *StateObject) {
+	*self = *stateObject
+}
+
+//
+// Attribute accessors
+//
+
+func (self *StateObject) Balance() *big.Int {
+	return self.balance
+}
+
+func (c *StateObject) N() *big.Int {
+	return big.NewInt(int64(c.nonce))
+}
+
+// Returns the address of the contract/account
+func (c *StateObject) Address() common.Address {
+	return c.address
+}
+
+// Returns the initialization Code
+func (c *StateObject) Init() Code {
+	return c.initCode
+}
+
+func (self *StateObject) Trie() *trie.SecureTrie {
+	return self.State.trie
+}
+
+func (self *StateObject) Root() []byte {
+	return self.Trie().Root()
+}
+
+func (self *StateObject) Code() []byte {
+	return self.code
+}
+
+func (self *StateObject) SetCode(code []byte) {
+	self.code = code
+	self.dirty = true
+}
+
+func (self *StateObject) SetInitCode(code []byte) {
+	self.initCode = code
+	self.dirty = true
+}
+
+func (self *StateObject) SetNonce(nonce uint64) {
+	self.nonce = nonce
+	self.dirty = true
+}
+
+func (self *StateObject) Nonce() uint64 {
+	return self.nonce
+}
+
+//
+// Encoding
+//
+
+// State object encoding methods
+func (c *StateObject) RlpEncode() []byte {
+	return common.Encode([]interface{}{c.nonce, c.balance, c.Root(), c.CodeHash()})
+}
+
+func (c *StateObject) CodeHash() common.Bytes {
+	return crypto.Sha3(c.code)
+}
+
+func (c *StateObject) RlpDecode(data []byte) {
+	decoder := common.NewValueFromBytes(data)
+	c.nonce = decoder.Get(0).Uint()
+	c.balance = decoder.Get(1).BigInt()
+	c.State = New(common.BytesToHash(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()
+
+	c.code, _ = c.db.Get(c.codeHash)
+}
+
+// Storage change object. Used by the manifest for notifying changes to
+// the sub channels.
+type StorageState struct {
+	StateAddress []byte
+	Address      []byte
+	Value        *big.Int
+}
diff --git a/core/state/state_test.go b/core/state/state_test.go
new file mode 100644
index 000000000..a3d3973de
--- /dev/null
+++ b/core/state/state_test.go
@@ -0,0 +1,106 @@
+package state
+
+import (
+	"math/big"
+	"testing"
+
+	checker "gopkg.in/check.v1"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
+)
+
+type StateSuite struct {
+	state *StateDB
+}
+
+var _ = checker.Suite(&StateSuite{})
+
+var toAddr = common.BytesToAddress
+
+func (s *StateSuite) TestDump(c *checker.C) {
+	return
+	// generate a few entries
+	obj1 := s.state.GetOrNewStateObject(toAddr([]byte{0x01}))
+	obj1.AddBalance(big.NewInt(22))
+	obj2 := s.state.GetOrNewStateObject(toAddr([]byte{0x01, 0x02}))
+	obj2.SetCode([]byte{3, 3, 3, 3, 3, 3, 3})
+	obj3 := s.state.GetOrNewStateObject(toAddr([]byte{0x02}))
+	obj3.SetBalance(big.NewInt(44))
+
+	// write some of them to the trie
+	s.state.UpdateStateObject(obj1)
+	s.state.UpdateStateObject(obj2)
+
+	// check that dump contains the state objects that are in trie
+	got := string(s.state.Dump())
+	want := `{
+    "root": "6e277ae8357d013e50f74eedb66a991f6922f93ae03714de58b3d0c5e9eee53f",
+    "accounts": {
+        "1468288056310c82aa4c01a7e12a10f8111a0560e72b700555479031b86c357d": {
+            "balance": "22",
+            "nonce": 0,
+            "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+            "storage": {}
+        },
+        "a17eacbc25cda025e81db9c5c62868822c73ce097cee2a63e33a2e41268358a1": {
+            "balance": "0",
+            "nonce": 0,
+            "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
+            "storage": {}
+        }
+    }
+}`
+	if got != want {
+		c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", got, want)
+	}
+}
+
+func (s *StateSuite) SetUpTest(c *checker.C) {
+	db, _ := ethdb.NewMemDatabase()
+	s.state = New(common.Hash{}, db)
+}
+
+func TestNull(t *testing.T) {
+	db, _ := ethdb.NewMemDatabase()
+	state := New(common.Hash{}, db)
+
+	address := common.HexToAddress("0x823140710bf13990e4500136726d8b55")
+	state.NewStateObject(address)
+	//value := common.FromHex("0x823140710bf13990e4500136726d8b55")
+	value := make([]byte, 16)
+	state.SetState(address, common.Hash{}, value)
+	state.Update(nil)
+	state.Sync()
+	value = state.GetState(address, common.Hash{})
+}
+
+func (s *StateSuite) TestSnapshot(c *checker.C) {
+	stateobjaddr := toAddr([]byte("aa"))
+	storageaddr := common.Big("0")
+	data1 := common.NewValue(42)
+	data2 := common.NewValue(43)
+
+	// get state object
+	stateObject := s.state.GetOrNewStateObject(stateobjaddr)
+	// set inital state object value
+	stateObject.SetStorage(storageaddr, data1)
+	// get snapshot of current state
+	snapshot := s.state.Copy()
+
+	// get state object. is this strictly necessary?
+	stateObject = s.state.GetStateObject(stateobjaddr)
+	// set new state object value
+	stateObject.SetStorage(storageaddr, data2)
+	// restore snapshot
+	s.state.Set(snapshot)
+
+	// get state object
+	stateObject = s.state.GetStateObject(stateobjaddr)
+	// get state storage value
+	res := stateObject.GetStorage(storageaddr)
+
+	c.Assert(data1, checker.DeepEquals, res)
+}
diff --git a/core/state/statedb.go b/core/state/statedb.go
new file mode 100644
index 000000000..6fcd39dbc
--- /dev/null
+++ b/core/state/statedb.go
@@ -0,0 +1,325 @@
+package state
+
+import (
+	"bytes"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+var statelogger = logger.NewLogger("STATE")
+
+// StateDBs within the ethereum protocol are used to store anything
+// within the merkle trie. StateDBs take care of caching and storing
+// nested states. It's the general query interface to retrieve:
+// * Contracts
+// * Accounts
+type StateDB struct {
+	db   common.Database
+	trie *trie.SecureTrie
+
+	stateObjects map[string]*StateObject
+
+	refund map[string]*big.Int
+
+	logs Logs
+}
+
+// Create a new state from a given trie
+func New(root common.Hash, db common.Database) *StateDB {
+	trie := trie.NewSecure(root[:], db)
+	return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), refund: make(map[string]*big.Int)}
+}
+
+func (self *StateDB) PrintRoot() {
+	self.trie.Trie.PrintRoot()
+}
+
+func (self *StateDB) EmptyLogs() {
+	self.logs = nil
+}
+
+func (self *StateDB) AddLog(log Log) {
+	self.logs = append(self.logs, log)
+}
+
+func (self *StateDB) Logs() Logs {
+	return self.logs
+}
+
+func (self *StateDB) Refund(address common.Address, gas *big.Int) {
+	addr := address.Str()
+	if self.refund[addr] == nil {
+		self.refund[addr] = new(big.Int)
+	}
+	self.refund[addr].Add(self.refund[addr], gas)
+}
+
+// Retrieve the balance from the given address or 0 if object not found
+func (self *StateDB) GetBalance(addr common.Address) *big.Int {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.balance
+	}
+
+	return common.Big0
+}
+
+func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.AddBalance(amount)
+	}
+}
+
+func (self *StateDB) GetNonce(addr common.Address) uint64 {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.nonce
+	}
+
+	return 0
+}
+
+func (self *StateDB) GetCode(addr common.Address) []byte {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.code
+	}
+
+	return nil
+}
+
+func (self *StateDB) GetState(a common.Address, b common.Hash) []byte {
+	stateObject := self.GetStateObject(a)
+	if stateObject != nil {
+		return stateObject.GetState(b).Bytes()
+	}
+
+	return nil
+}
+
+func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetNonce(nonce)
+	}
+}
+
+func (self *StateDB) SetCode(addr common.Address, code []byte) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetCode(code)
+	}
+}
+
+func (self *StateDB) SetState(addr common.Address, key common.Hash, value interface{}) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetState(key, common.NewValue(value))
+	}
+}
+
+func (self *StateDB) Delete(addr common.Address) bool {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.MarkForDeletion()
+		stateObject.balance = new(big.Int)
+
+		return true
+	}
+
+	return false
+}
+
+func (self *StateDB) IsDeleted(addr common.Address) bool {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.remove
+	}
+	return false
+}
+
+//
+// Setting, updating & deleting state object methods
+//
+
+// Update the given state object and apply it to state trie
+func (self *StateDB) UpdateStateObject(stateObject *StateObject) {
+	//addr := stateObject.Address()
+
+	if len(stateObject.CodeHash()) > 0 {
+		self.db.Put(stateObject.CodeHash(), stateObject.code)
+	}
+
+	addr := stateObject.Address()
+	self.trie.Update(addr[:], stateObject.RlpEncode())
+}
+
+// Delete the given state object and delete it from the state trie
+func (self *StateDB) DeleteStateObject(stateObject *StateObject) {
+	addr := stateObject.Address()
+	self.trie.Delete(addr[:])
+
+	delete(self.stateObjects, addr.Str())
+}
+
+// Retrieve a state object given my the address. Nil if not found
+func (self *StateDB) GetStateObject(addr common.Address) *StateObject {
+	//addr = common.Address(addr)
+
+	stateObject := self.stateObjects[addr.Str()]
+	if stateObject != nil {
+		return stateObject
+	}
+
+	data := self.trie.Get(addr[:])
+	if len(data) == 0 {
+		return nil
+	}
+
+	stateObject = NewStateObjectFromBytes(addr, []byte(data), self.db)
+	self.SetStateObject(stateObject)
+
+	return stateObject
+}
+
+func (self *StateDB) SetStateObject(object *StateObject) {
+	self.stateObjects[object.Address().Str()] = object
+}
+
+// Retrieve a state object or create a new state object if nil
+func (self *StateDB) GetOrNewStateObject(addr common.Address) *StateObject {
+	stateObject := self.GetStateObject(addr)
+	if stateObject == nil {
+		stateObject = self.NewStateObject(addr)
+	}
+
+	return stateObject
+}
+
+// Create a state object whether it exist in the trie or not
+func (self *StateDB) NewStateObject(addr common.Address) *StateObject {
+	//addr = common.Address(addr)
+
+	statelogger.Debugf("(+) %x\n", addr)
+
+	stateObject := NewStateObject(addr, self.db)
+	self.stateObjects[addr.Str()] = stateObject
+
+	return stateObject
+}
+
+// Deprecated
+func (self *StateDB) GetAccount(addr common.Address) *StateObject {
+	return self.GetOrNewStateObject(addr)
+}
+
+//
+// Setting, copying of the state methods
+//
+
+func (s *StateDB) Cmp(other *StateDB) bool {
+	return bytes.Equal(s.trie.Root(), other.trie.Root())
+}
+
+func (self *StateDB) Copy() *StateDB {
+	state := New(common.Hash{}, self.db)
+	state.trie = self.trie.Copy()
+	for k, stateObject := range self.stateObjects {
+		state.stateObjects[k] = stateObject.Copy()
+	}
+
+	for addr, refund := range self.refund {
+		state.refund[addr] = new(big.Int).Set(refund)
+	}
+
+	logs := make(Logs, len(self.logs))
+	copy(logs, self.logs)
+	state.logs = logs
+
+	return state
+}
+
+func (self *StateDB) Set(state *StateDB) {
+	self.trie = state.trie
+	self.stateObjects = state.stateObjects
+
+	self.refund = state.refund
+	self.logs = state.logs
+}
+
+func (s *StateDB) Root() common.Hash {
+	return common.BytesToHash(s.trie.Root())
+}
+
+func (s *StateDB) Trie() *trie.SecureTrie {
+	return s.trie
+}
+
+// Resets the trie and all siblings
+func (s *StateDB) Reset() {
+	s.trie.Reset()
+
+	// Reset all nested states
+	for _, stateObject := range s.stateObjects {
+		if stateObject.State == nil {
+			continue
+		}
+
+		stateObject.Reset()
+	}
+
+	s.Empty()
+}
+
+// Syncs the trie and all siblings
+func (s *StateDB) Sync() {
+	// Sync all nested states
+	for _, stateObject := range s.stateObjects {
+		if stateObject.State == nil {
+			continue
+		}
+
+		stateObject.State.Sync()
+	}
+
+	s.trie.Commit()
+
+	s.Empty()
+}
+
+func (self *StateDB) Empty() {
+	self.stateObjects = make(map[string]*StateObject)
+	self.refund = make(map[string]*big.Int)
+}
+
+func (self *StateDB) Refunds() map[string]*big.Int {
+	return self.refund
+}
+
+func (self *StateDB) Update(gasUsed *big.Int) {
+	self.refund = make(map[string]*big.Int)
+
+	for _, stateObject := range self.stateObjects {
+		if stateObject.dirty {
+			if stateObject.remove {
+				self.DeleteStateObject(stateObject)
+			} else {
+				stateObject.Sync()
+
+				self.UpdateStateObject(stateObject)
+			}
+			stateObject.dirty = false
+		}
+	}
+}
+
+// Debug stuff
+func (self *StateDB) CreateOutputForDiff() {
+	for _, stateObject := range self.stateObjects {
+		stateObject.CreateOutputForDiff()
+	}
+}