8 files changed, 927 insertions, 0 deletions
diff --git a/state/dump.go b/state/dump.go
new file mode 100644
index 000000000..c1f5ecf3a
--- /dev/null
+++ b/state/dump.go
@@ -0,0 +1,56 @@
+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) Dump() []byte {
+	world := World{
+		Root:     ethutil.Bytes2Hex(self.Trie.GetRoot()),
+		Accounts: make(map[string]Account),
+	}
+
+	self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) {
+		stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes())
+
+		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)
+
+		stateObject.EachStorage(func(key string, value *ethutil.Value) {
+			value.Decode()
+			account.Storage[ethutil.Bytes2Hex([]byte(key))] = ethutil.Bytes2Hex(value.Bytes())
+		})
+		world.Accounts[ethutil.Bytes2Hex([]byte(key))] = account
+	})
+
+	json, err := json.MarshalIndent(world, "", "    ")
+	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)
+	self.EachStorage(func(addr string, value *ethutil.Value) {
+		fmt.Printf("%x %x\n", addr, value.Bytes())
+	})
+}
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..46360f4aa
--- /dev/null
+++ b/state/log.go
@@ -0,0 +1,78 @@
+package state
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Log interface {
+	ethutil.RlpEncodable
+
+	Address() []byte
+	Topics() [][]byte
+	Data() []byte
+}
+
+type StateLog struct {
+	address []byte
+	topics  [][]byte
+	data    []byte
+}
+
+func NewLog(address []byte, topics [][]byte, data []byte) *StateLog {
+	return &StateLog{address, topics, data}
+}
+
+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 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/manifest.go b/state/manifest.go
new file mode 100644
index 000000000..21cd04a1a
--- /dev/null
+++ b/state/manifest.go
@@ -0,0 +1,55 @@
+package state
+
+import (
+	"fmt"
+	"math/big"
+)
+
+// Object manifest
+//
+// The object manifest is used to keep changes to the state so we can keep track of the changes
+// that occurred during a state transitioning phase.
+type Manifest struct {
+	Messages Messages
+}
+
+func NewManifest() *Manifest {
+	m := &Manifest{}
+	m.Reset()
+
+	return m
+}
+
+func (m *Manifest) Reset() {
+	m.Messages = nil
+}
+
+func (self *Manifest) AddMessage(msg *Message) *Message {
+	self.Messages = append(self.Messages, msg)
+
+	return msg
+}
+
+type Messages []*Message
+type Message struct {
+	To, From  []byte
+	Input     []byte
+	Output    []byte
+	Path      int
+	Origin    []byte
+	Timestamp int64
+	Coinbase  []byte
+	Block     []byte
+	Number    *big.Int
+	Value     *big.Int
+
+	ChangedAddresses [][]byte
+}
+
+func (self *Message) AddStorageChange(addr []byte) {
+	self.ChangedAddresses = append(self.ChangedAddresses, addr)
+}
+
+func (self *Message) String() string {
+	return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d value: %v", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path, self.Value)
+}
diff --git a/state/state.go b/state/state.go
new file mode 100644
index 000000000..f77da72f0
--- /dev/null
+++ b/state/state.go
@@ -0,0 +1,325 @@
+package state
+
+import (
+	"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 {
+	// The trie for this structure
+	Trie *trie.Trie
+
+	stateObjects map[string]*StateObject
+
+	manifest *Manifest
+
+	refund map[string]*big.Int
+
+	logs Logs
+}
+
+// Create a new state from a given trie
+func New(trie *trie.Trie) *StateDB {
+	return &StateDB{Trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest(), 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
+}
+
+// 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) 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)
+}
+
+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) SetNonce(addr []byte, nonce uint64) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.Nonce = nonce
+	}
+}
+
+func (self *StateDB) GetCode(addr []byte) []byte {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return stateObject.Code
+	}
+
+	return nil
+}
+
+func (self *StateDB) SetCode(addr, code []byte) {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		stateObject.SetCode(code)
+	}
+}
+
+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) 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 {
+		ethutil.Config.Db.Put(stateObject.CodeHash(), stateObject.Code)
+	}
+
+	self.Trie.Update(string(addr), string(stateObject.RlpEncode()))
+}
+
+// Delete the given state object and delete it from the state trie
+func (self *StateDB) DeleteStateObject(stateObject *StateObject) {
+	self.Trie.Delete(string(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(string(addr))
+	if len(data) == 0 {
+		return nil
+	}
+
+	stateObject = NewStateObjectFromBytes(addr, []byte(data))
+	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.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 s.Trie.Cmp(other.Trie)
+}
+
+func (self *StateDB) Copy() *StateDB {
+	if self.Trie != nil {
+		state := New(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
+	}
+
+	return nil
+}
+
+func (self *StateDB) Set(state *StateDB) {
+	if state == nil {
+		panic("Tried setting 'state' to nil through 'Set'")
+	}
+
+	self.Trie = state.Trie
+	self.stateObjects = state.stateObjects
+	self.refund = state.refund
+	self.logs = state.logs
+}
+
+func (s *StateDB) Root() []byte {
+	return s.Trie.GetRoot()
+}
+
+// Resets the trie and all siblings
+func (s *StateDB) Reset() {
+	s.Trie.Undo()
+
+	// 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.Sync()
+
+	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) {
+	var deleted bool
+
+	self.refund = make(map[string]*big.Int)
+
+	for _, stateObject := range self.stateObjects {
+		if stateObject.remove {
+			self.DeleteStateObject(stateObject)
+			deleted = true
+		} else {
+			stateObject.Sync()
+
+			self.UpdateStateObject(stateObject)
+		}
+	}
+
+	// FIXME trie delete is broken
+	if deleted {
+		valid, t2 := trie.ParanoiaCheck(self.Trie)
+		if !valid {
+			statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.Trie.GetRoot(), t2.GetRoot())
+
+			self.Trie = t2
+		}
+	}
+}
+
+func (self *StateDB) Manifest() *Manifest {
+	return self.manifest
+}
+
+// Debug stuff
+func (self *StateDB) CreateOutputForDiff() {
+	for _, stateObject := range self.stateObjects {
+		stateObject.CreateOutputForDiff()
+	}
+}
diff --git a/state/state_object.go b/state/state_object.go
new file mode 100644
index 000000000..b8af4e702
--- /dev/null
+++ b/state/state_object.go
@@ -0,0 +1,320 @@
+package state
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"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) 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 {
+	// 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
+}
+
+func (self *StateObject) Reset() {
+	self.storage = make(Storage)
+	self.State.Reset()
+}
+
+func NewStateObject(addr []byte) *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{address: address, balance: new(big.Int), gasPool: new(big.Int)}
+	object.State = New(trie.New(ethutil.Config.Db, ""))
+	object.storage = make(Storage)
+	object.gasPool = new(big.Int)
+
+	return object
+}
+
+func NewContract(address []byte, balance *big.Int, root []byte) *StateObject {
+	contract := NewStateObject(address)
+	contract.balance = balance
+	contract.State = New(trie.New(ethutil.Config.Db, string(root)))
+
+	return contract
+}
+
+func NewStateObjectFromBytes(address, data []byte) *StateObject {
+	object := &StateObject{address: address}
+	object.RlpDecode(data)
+
+	return object
+}
+
+func (self *StateObject) MarkForDeletion() {
+	self.remove = 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(string(addr))))
+}
+
+func (c *StateObject) SetAddr(addr []byte, value interface{}) {
+	c.State.Trie.Update(string(addr), string(ethutil.NewValue(value).Encode()))
+}
+
+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() map[string]*ethutil.Value {
+	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()
+}
+
+// Iterate over each storage address and yield callback
+func (self *StateObject) EachStorage(cb trie.EachCallback) {
+	// First loop over the uncommit/cached values in storage
+	for key, value := range self.storage {
+		// XXX Most iterators Fns as it stands require encoded values
+		encoded := ethutil.NewValue(value.Encode())
+		cb(key, encoded)
+	}
+
+	it := self.State.Trie.NewIterator()
+	it.Each(func(key string, value *ethutil.Value) {
+		// If it's cached don't call the callback.
+		if self.storage[key] == nil {
+			cb(key, value)
+		}
+	})
+}
+
+func (self *StateObject) Sync() {
+	for key, value := range self.storage {
+		if value.Len() == 0 {
+			self.State.Trie.Delete(string(key))
+			continue
+		}
+
+		self.SetAddr([]byte(key), value)
+	}
+
+	valid, t2 := trie.ParanoiaCheck(self.State.Trie)
+	if !valid {
+		statelogger.Infof("Warn: PARANOIA: Different state storage root during copy %x vs %x\n", self.State.Root(), t2.GetRoot())
+
+		self.State.Trie = t2
+	}
+}
+
+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) AddAmount(amount *big.Int) { c.AddBalance(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) SubAmount(amount *big.Int) { c.SubBalance(amount) }
+
+func (c *StateObject) SetBalance(amount *big.Int) {
+	c.balance = amount
+}
+
+func (self *StateObject) Balance() *big.Int { return self.balance }
+
+//
+// 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.SubAmount(total)
+
+	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)
+	}
+
+	rGas := new(big.Int).Set(gas)
+	rGas.Mul(rGas, price)
+
+	self.AddAmount(rGas)
+
+	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())
+	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
+
+	return stateObject
+}
+
+func (self *StateObject) Set(stateObject *StateObject) {
+	*self = *stateObject
+}
+
+//
+// Attribute accessors
+//
+
+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) Root() []byte {
+	return self.State.Trie.GetRoot()
+}
+
+func (self *StateObject) SetCode(code []byte) {
+	self.Code = code
+}
+
+//
+// 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(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, _ = ethutil.Config.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..28e4fc5da
--- /dev/null
+++ b/state/state_test.go
@@ -0,0 +1,61 @@
+package state
+
+import (
+	checker "gopkg.in/check.v1"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+type StateSuite struct {
+	state *StateDB
+}
+
+var _ = checker.Suite(&StateSuite{})
+
+// var ZeroHash256 = make([]byte, 32)
+
+func (s *StateSuite) TestDump(c *checker.C) {
+	key := []byte{0x01}
+	value := "foo"
+	node := []interface{}{key, value}
+	s.state.Trie.Put(node)
+	dump := s.state.Dump()
+	c.Assert(dump, checker.NotNil)
+}
+
+func (s *StateSuite) SetUpTest(c *checker.C) {
+	db, _ := ethdb.NewMemDatabase()
+	ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+	ethutil.Config.Db = db
+	s.state = New(trie.New(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)
+}