7 files changed, 930 insertions, 0 deletions
diff --git a/state/dump.go b/state/dump.go
new file mode 100644
index 000000000..2c611d76b
--- /dev/null
+++ b/state/dump.go
@@ -0,0 +1,61 @@
+package state
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+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:     ethutil.Bytes2Hex(self.trie.Root()),
+		Accounts: make(map[string]Account),
+	}
+
+	it := self.trie.Iterator()
+	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.Storage = make(map[string]string)
+
+		storageIt := stateObject.State.trie.Iterator()
+		for storageIt.Next() {
+			account.Storage[ethutil.Bytes2Hex(storageIt.Key)] = ethutil.Bytes2Hex(storageIt.Value)
+		}
+		world.Accounts[ethutil.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/state/errors.go b/state/errors.go
new file mode 100644
index 000000000..5a847d38b
--- /dev/null
+++ b/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/state/log.go b/state/log.go
new file mode 100644
index 000000000..d503bd1a0
--- /dev/null
+++ b/state/log.go
@@ -0,0 +1,85 @@
+package state
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Log interface {
+	ethutil.RlpEncodable
+
+	Address() []byte
+	Topics() [][]byte
+	Data() []byte
+
+	Number() uint64
+}
+
+type StateLog struct {
+	address []byte
+	topics  [][]byte
+	data    []byte
+	number  uint64
+}
+
+func NewLog(address []byte, topics [][]byte, data []byte, number uint64) *StateLog {
+	return &StateLog{address, topics, data, number}
+}
+
+func (self *StateLog) Address() []byte {
+	return self.address
+}
+
+func (self *StateLog) Topics() [][]byte {
+	return self.topics
+}
+
+func (self *StateLog) Data() []byte {
+	return self.data
+}
+
+func (self *StateLog) Number() uint64 {
+	return self.number
+}
+
+func NewLogFromValue(decoder *ethutil.Value) *StateLog {
+	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) RlpData() interface{} {
+	return []interface{}{self.address, ethutil.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/state/main_test.go b/state/main_test.go
new file mode 100644
index 000000000..f3d3f7e23
--- /dev/null
+++ b/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/state/state_object.go b/state/state_object.go
new file mode 100644
index 000000000..51ec95efa
--- /dev/null
+++ b/state/state_object.go
@@ -0,0 +1,356 @@
+package state
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"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]*ethutil.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 {
+	db ethutil.Database
+	// Address of the object
+	address []byte
+	// Shared attributes
+	balance  *big.Int
+	codeHash []byte
+	nonce    uint64
+	// Contract related attributes
+	State    *StateDB
+	code     Code
+	initCode Code
+
+	storage Storage
+
+	// 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(addr []byte, db ethutil.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)
+
+	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.storage = make(Storage)
+	object.gasPool = new(big.Int)
+
+	return object
+}
+
+func NewStateObjectFromBytes(address, data []byte, db ethutil.Database) *StateObject {
+	// TODO clean me up
+	var extobject struct {
+		Nonce    uint64
+		Balance  *big.Int
+		Root     []byte
+		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]*ethutil.Value)
+	object.gasPool = new(big.Int)
+	object.code, _ = db.Get(extobject.CodeHash)
+
+	return object
+}
+
+func (self *StateObject) MarkForDeletion() {
+	self.remove = true
+	self.dirty = true
+	statelogger.DebugDetailf("%x: #%d %v (deletion)\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) setAddr(addr []byte, value interface{}) {
+	c.State.trie.Update(addr, ethutil.Encode(value))
+}
+
+func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value {
+	return self.GetState(key.Bytes())
+}
+func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) {
+	self.SetState(key.Bytes(), value)
+}
+
+func (self *StateObject) Storage() Storage {
+	return self.storage
+}
+
+func (self *StateObject) GetState(k []byte) *ethutil.Value {
+	key := ethutil.LeftPadBytes(k, 32)
+
+	value := self.storage[string(key)]
+	if value == nil {
+		value = self.getAddr(key)
+
+		if !value.IsNil() {
+			self.storage[string(key)] = value
+		}
+	}
+
+	return value
+}
+
+func (self *StateObject) SetState(k []byte, value *ethutil.Value) {
+	key := ethutil.LeftPadBytes(k, 32)
+	self.storage[string(key)] = 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) *ethutil.Value {
+	if int64(len(c.code)-1) < pc.Int64() {
+		return ethutil.NewValue(0)
+	}
+
+	return ethutil.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.AddBalance(rGas)
+
+	self.dirty = true
+
+	return nil
+}
+
+func (self *StateObject) RefundGas(gas, price *big.Int) {
+	self.gasPool.Add(self.gasPool, gas)
+
+	rGas := new(big.Int).Set(gas)
+	rGas.Mul(rGas, price)
+
+	self.balance.Sub(self.balance, rGas)
+}
+
+func (self *StateObject) Copy() *StateObject {
+	stateObject := NewStateObject(self.Address(), self.db)
+	stateObject.balance.Set(self.balance)
+	stateObject.codeHash = ethutil.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.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() []byte {
+	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 ethutil.Encode([]interface{}{c.nonce, c.balance, c.Root(), c.CodeHash()})
+}
+
+func (c *StateObject) CodeHash() ethutil.Bytes {
+	return crypto.Sha3(c.code)
+}
+
+func (c *StateObject) RlpDecode(data []byte) {
+	decoder := ethutil.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.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/state/state_test.go b/state/state_test.go
new file mode 100644
index 000000000..ee1cf9286
--- /dev/null
+++ b/state/state_test.go
@@ -0,0 +1,91 @@
+package state
+
+import (
+	"math/big"
+
+	checker "gopkg.in/check.v1"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+type StateSuite struct {
+	state *StateDB
+}
+
+var _ = checker.Suite(&StateSuite{})
+
+// var ZeroHash256 = make([]byte, 32)
+
+func (s *StateSuite) TestDump(c *checker.C) {
+	// generate a few entries
+	obj1 := s.state.GetOrNewStateObject([]byte{0x01})
+	obj1.AddBalance(big.NewInt(22))
+	obj2 := s.state.GetOrNewStateObject([]byte{0x01, 0x02})
+	obj2.SetCode([]byte{3, 3, 3, 3, 3, 3, 3})
+	obj3 := s.state.GetOrNewStateObject([]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": "4e3a59299745ba6752247c8b91d0f716dac9ec235861c91f5ac1894a361d87ba",
+    "accounts": {
+        "0000000000000000000000000000000000000001": {
+            "balance": "22",
+            "nonce": 0,
+            "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+            "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+            "storage": {}
+        },
+        "0000000000000000000000000000000000000102": {
+            "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) {
+	ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+	db, _ := ethdb.NewMemDatabase()
+	s.state = New(nil, db)
+}
+
+func (s *StateSuite) TestSnapshot(c *checker.C) {
+	stateobjaddr := []byte("aa")
+	storageaddr := ethutil.Big("0")
+	data1 := ethutil.NewValue(42)
+	data2 := ethutil.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/state/statedb.go b/state/statedb.go
new file mode 100644
index 000000000..ee37c2e68
--- /dev/null
+++ b/state/statedb.go
@@ -0,0 +1,305 @@
+package state
+
+import (
+	"bytes"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+	"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   ethutil.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 []byte, db ethutil.Database) *StateDB {
+	trie := trie.NewSecure(ethutil.CopyBytes(root), db)
+	return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), refund: make(map[string]*big.Int)}
+}
+
+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(addr []byte, gas *big.Int) {
+	if self.refund[string(addr)] == nil {
+		self.refund[string(addr)] = new(big.Int)
+	}
+	self.refund[string(addr)].Add(self.refund[string(addr)], gas)
+}
+
+// Retrieve the balance from the given address or 0 if object not found
+func (self *StateDB) GetBalance(addr []byte) *big.Int {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.balance
+	}
+
+	return ethutil.Big0
+}
+
+func (self *StateDB) AddBalance(addr []byte, amount *big.Int) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.AddBalance(amount)
+	}
+}
+
+func (self *StateDB) GetNonce(addr []byte) uint64 {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.nonce
+	}
+
+	return 0
+}
+
+func (self *StateDB) GetCode(addr []byte) []byte {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.code
+	}
+
+	return nil
+}
+
+func (self *StateDB) GetState(a, b []byte) []byte {
+	stateObject := self.GetStateObject(a)
+	if stateObject != nil {
+		return stateObject.GetState(b).Bytes()
+	}
+
+	return nil
+}
+
+func (self *StateDB) SetNonce(addr []byte, nonce uint64) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetNonce(nonce)
+	}
+}
+
+func (self *StateDB) SetCode(addr, code []byte) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetCode(code)
+	}
+}
+
+func (self *StateDB) SetState(addr, key []byte, value interface{}) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetState(key, ethutil.NewValue(value))
+	}
+}
+
+func (self *StateDB) Delete(addr []byte) bool {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.MarkForDeletion()
+
+		return true
+	}
+
+	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)
+	}
+
+	self.trie.Update(addr, stateObject.RlpEncode())
+}
+
+// Delete the given state object and delete it from the state trie
+func (self *StateDB) DeleteStateObject(stateObject *StateObject) {
+	self.trie.Delete(stateObject.Address())
+
+	delete(self.stateObjects, string(stateObject.Address()))
+}
+
+// Retrieve a state object given my the address. Nil if not found
+func (self *StateDB) GetStateObject(addr []byte) *StateObject {
+	addr = ethutil.Address(addr)
+
+	stateObject := self.stateObjects[string(addr)]
+	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[string(object.address)] = object
+}
+
+// Retrieve a state object or create a new state object if nil
+func (self *StateDB) GetOrNewStateObject(addr []byte) *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 []byte) *StateObject {
+	addr = ethutil.Address(addr)
+
+	statelogger.Debugf("(+) %x\n", addr)
+
+	stateObject := NewStateObject(addr, self.db)
+	self.stateObjects[string(addr)] = stateObject
+
+	return stateObject
+}
+
+// Deprecated
+func (self *StateDB) GetAccount(addr []byte) *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(nil, 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() []byte {
+	return s.trie.Root()
+}
+
+// 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()
+	}
+}