Merge pull request #3 from ethereum/develop

Update to develop

7 files changed, 176 insertions, 166 deletions

diff --git a/state/dump.go b/state/dump.go
index a7057b445..ac646480c 100644
--- a/state/dump.go
+++ b/state/dump.go
@@ -20,24 +20,25 @@ type World struct {
 	Accounts map[string]Account `json:"accounts"`
 }
 
-func (self *State) Dump() []byte {
+func (self *StateDB) Dump() []byte {
 	world := World{
-		Root:     ethutil.Bytes2Hex(self.Trie.Root.([]byte)),
+		Root:     ethutil.Bytes2Hex(self.trie.Root()),
 		Accounts: make(map[string]Account),
 	}
 
-	self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) {
-		stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes())
+	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)
 
-		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
-	})
+		storageIt := stateObject.State.trie.Iterator()
+		for storageIt.Next() {
+			account.Storage[ethutil.Bytes2Hex(it.Key)] = ethutil.Bytes2Hex(it.Value)
+		}
+		world.Accounts[ethutil.Bytes2Hex(it.Key)] = account
+	}
 
 	json, err := json.MarshalIndent(world, "", "    ")
 	if err != nil {
@@ -46,3 +47,12 @@ func (self *State) Dump() []byte {
 
 	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/log.go b/state/log.go
index 73039d7ce..46360f4aa 100644
--- a/state/log.go
+++ b/state/log.go
@@ -1,29 +1,61 @@
 package state
 
-import "github.com/ethereum/go-ethereum/ethutil"
+import (
+	"fmt"
 
-type Log struct {
-	Address []byte
-	Topics  [][]byte
-	Data    []byte
+	"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) Log {
-	log := Log{
-		Address: decoder.Get(0).Bytes(),
-		Data:    decoder.Get(2).Bytes(),
+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())
+		log.topics = append(log.topics, it.Value().Bytes())
 	}
 
 	return log
 }
 
-func (self Log) RlpData() interface{} {
-	return []interface{}{self.Address, ethutil.ByteSliceToInterface(self.Topics), self.Data}
+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
@@ -36,3 +68,11 @@ func (self Logs) RlpData() interface{} {
 
 	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
index 973a7c373..f3d3f7e23 100644
--- a/state/main_test.go
+++ b/state/main_test.go
@@ -1,8 +1,9 @@
 package state
 
 import (
-	checker "gopkg.in/check.v1"
 	"testing"
+
+	checker "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { checker.TestingT(t) }
diff --git a/state/manifest.go b/state/manifest.go
index 21cd04a1a..994019a08 100644
--- a/state/manifest.go
+++ b/state/manifest.go
@@ -30,6 +30,12 @@ func (self *Manifest) AddMessage(msg *Message) *Message {
 	return msg
 }
 
+func (self *Manifest) SetHash(hash []byte) {
+	for _, message := range self.Messages {
+		message.Block = hash
+	}
+}
+
 type Messages []*Message
 type Message struct {
 	To, From  []byte
diff --git a/state/state_object.go b/state/state_object.go
index dde058e12..340939a5d 100644
--- a/state/state_object.go
+++ b/state/state_object.go
@@ -28,6 +28,7 @@ func (self Storage) Copy() Storage {
 }
 
 type StateObject struct {
+	db ethutil.Database
 	// Address of the object
 	address []byte
 	// Shared attributes
@@ -35,7 +36,7 @@ type StateObject struct {
 	codeHash []byte
 	Nonce    uint64
 	// Contract related attributes
-	State    *State
+	State    *StateDB
 	Code     Code
 	InitCode Code
 
@@ -57,28 +58,20 @@ func (self *StateObject) Reset() {
 	self.State.Reset()
 }
 
-func NewStateObject(addr []byte) *StateObject {
+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{address: address, balance: new(big.Int), gasPool: new(big.Int)}
-	object.State = New(trie.New(ethutil.Config.Db, ""))
+	object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int)}
+	object.State = New(nil, db) //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}
+func NewStateObjectFromBytes(address, data []byte, db ethutil.Database) *StateObject {
+	object := &StateObject{address: address, db: db}
 	object.RlpDecode(data)
 
 	return object
@@ -89,12 +82,12 @@ func (self *StateObject) MarkForDeletion() {
 	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) 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(string(addr), string(ethutil.NewValue(value).Encode()))
+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 {
@@ -113,7 +106,7 @@ func (self *StateObject) GetState(k []byte) *ethutil.Value {
 
 	value := self.storage[string(key)]
 	if value == nil {
-		value = self.GetAddr(key)
+		value = self.getAddr(key)
 
 		if !value.IsNil() {
 			self.storage[string(key)] = value
@@ -128,41 +121,14 @@ func (self *StateObject) SetState(k []byte, value *ethutil.Value) {
 	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 { // value.BigInt().Cmp(ethutil.Big0) == 0 {
-			//data := self.getStorage([]byte(key))
-			//fmt.Printf("deleting %x %x 0x%x\n", self.Address(), []byte(key), data)
-			self.State.Trie.Delete(string(key))
+		if value.Len() == 0 {
+			self.State.trie.Delete([]byte(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.Trie.Root, t2.Root)
-
-		self.State.Trie = t2
+		self.setAddr([]byte(key), value)
 	}
 }
 
@@ -214,7 +180,7 @@ func (c *StateObject) ConvertGas(gas, price *big.Int) error {
 func (self *StateObject) SetGasPool(gasLimit *big.Int) {
 	self.gasPool = new(big.Int).Set(gasLimit)
 
-	statelogger.DebugDetailf("%x: fuel (+ %v)", self.Address(), self.gasPool)
+	statelogger.Debugf("%x: gas (+ %v)", self.Address(), self.gasPool)
 }
 
 func (self *StateObject) BuyGas(gas, price *big.Int) error {
@@ -240,7 +206,7 @@ func (self *StateObject) RefundGas(gas, price *big.Int) {
 }
 
 func (self *StateObject) Copy() *StateObject {
-	stateObject := NewStateObject(self.Address())
+	stateObject := NewStateObject(self.Address(), self.db)
 	stateObject.balance.Set(self.balance)
 	stateObject.codeHash = ethutil.CopyBytes(self.codeHash)
 	stateObject.Nonce = self.Nonce
@@ -278,21 +244,16 @@ func (c *StateObject) Init() Code {
 	return c.InitCode
 }
 
-// To satisfy ClosureRef
-func (self *StateObject) Object() *StateObject {
-	return self
+func (self *StateObject) Trie() *trie.Trie {
+	return self.State.trie
 }
 
 func (self *StateObject) Root() []byte {
-	return self.State.Trie.GetRoot()
+	return self.Trie().Root()
 }
 
-// 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())
-	})
+func (self *StateObject) SetCode(code []byte) {
+	self.Code = code
 }
 
 //
@@ -301,7 +262,7 @@ func (self *StateObject) CreateOutputForDiff() {
 
 // State object encoding methods
 func (c *StateObject) RlpEncode() []byte {
-	return ethutil.Encode([]interface{}{c.Nonce, c.balance, c.State.Trie.Root, c.CodeHash()})
+	return ethutil.Encode([]interface{}{c.Nonce, c.balance, c.Root(), c.CodeHash()})
 }
 
 func (c *StateObject) CodeHash() ethutil.Bytes {
@@ -313,13 +274,13 @@ func (c *StateObject) RlpDecode(data []byte) {
 
 	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.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, _ = ethutil.Config.Db.Get(c.codeHash)
+	c.Code, _ = c.db.Get(c.codeHash)
 }
 
 // Storage change object. Used by the manifest for notifying changes to
diff --git a/state/state_test.go b/state/state_test.go
index 825d21fcc..7c54cedc0 100644
--- a/state/state_test.go
+++ b/state/state_test.go
@@ -5,11 +5,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/trie"
 )
 
 type StateSuite struct {
-	state *State
+	state *StateDB
 }
 
 var _ = checker.Suite(&StateSuite{})
@@ -18,18 +17,16 @@ var _ = checker.Suite(&StateSuite{})
 
 func (s *StateSuite) TestDump(c *checker.C) {
 	key := []byte{0x01}
-	value := "foo"
-	node := []interface{}{key, value}
-	s.state.Trie.Put(node)
+	value := []byte("foo")
+	s.state.trie.Update(key, value)
 	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, ""))
+	db, _ := ethdb.NewMemDatabase()
+	s.state = New(nil, db)
 }
 
 func (s *StateSuite) TestSnapshot(c *checker.C) {
diff --git a/state/state.go b/state/statedb.go
index e1b73a6ab..1b6e274de 100644
--- a/state/state.go
+++ b/state/statedb.go
@@ -1,6 +1,7 @@
 package state
 
 import (
+	"bytes"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/ethutil"
@@ -10,14 +11,14 @@ import (
 
 var statelogger = logger.NewLogger("STATE")
 
-// States within the ethereum protocol are used to store anything
-// within the merkle trie. States take care of caching and storing
+// 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 State struct {
-	// The trie for this structure
-	Trie *trie.Trie
+type StateDB struct {
+	db   ethutil.Database
+	trie *trie.Trie
 
 	stateObjects map[string]*StateObject
 
@@ -29,24 +30,25 @@ type State struct {
 }
 
 // Create a new state from a given trie
-func New(trie *trie.Trie) *State {
-	return &State{Trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest(), refund: make(map[string]*big.Int)}
+func New(root []byte, db ethutil.Database) *StateDB {
+	trie := trie.New(root, db)
+	return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest(), refund: make(map[string]*big.Int)}
 }
 
-func (self *State) EmptyLogs() {
+func (self *StateDB) EmptyLogs() {
 	self.logs = nil
 }
 
-func (self *State) AddLog(log Log) {
+func (self *StateDB) AddLog(log Log) {
 	self.logs = append(self.logs, log)
 }
 
-func (self *State) Logs() Logs {
+func (self *StateDB) Logs() Logs {
 	return self.logs
 }
 
 // Retrieve the balance from the given address or 0 if object not found
-func (self *State) GetBalance(addr []byte) *big.Int {
+func (self *StateDB) GetBalance(addr []byte) *big.Int {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		return stateObject.balance
@@ -55,24 +57,21 @@ func (self *State) GetBalance(addr []byte) *big.Int {
 	return ethutil.Big0
 }
 
-func (self *State) Refund(addr []byte, gas, price *big.Int) {
-	amount := new(big.Int).Mul(gas, price)
-
+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)] = new(big.Int).Add(self.refund[string(addr)], amount)
+	self.refund[string(addr)].Add(self.refund[string(addr)], gas)
 }
 
-func (self *State) AddBalance(addr []byte, amount *big.Int) {
+func (self *StateDB) AddBalance(addr []byte, amount *big.Int) {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		stateObject.AddBalance(amount)
 	}
 }
 
-func (self *State) GetNonce(addr []byte) uint64 {
+func (self *StateDB) GetNonce(addr []byte) uint64 {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		return stateObject.Nonce
@@ -81,14 +80,14 @@ func (self *State) GetNonce(addr []byte) uint64 {
 	return 0
 }
 
-func (self *State) SetNonce(addr []byte, nonce uint64) {
+func (self *StateDB) SetNonce(addr []byte, nonce uint64) {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		stateObject.Nonce = nonce
 	}
 }
 
-func (self *State) GetCode(addr []byte) []byte {
+func (self *StateDB) GetCode(addr []byte) []byte {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		return stateObject.Code
@@ -97,7 +96,14 @@ func (self *State) GetCode(addr []byte) []byte {
 	return nil
 }
 
-func (self *State) GetState(a, b []byte) []byte {
+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()
@@ -106,14 +112,14 @@ func (self *State) GetState(a, b []byte) []byte {
 	return nil
 }
 
-func (self *State) SetState(addr, key []byte, value interface{}) {
+func (self *StateDB) SetState(addr, key []byte, value interface{}) {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		stateObject.SetState(key, ethutil.NewValue(value))
 	}
 }
 
-func (self *State) Delete(addr []byte) bool {
+func (self *StateDB) Delete(addr []byte) bool {
 	stateObject := self.GetStateObject(addr)
 	if stateObject != nil {
 		stateObject.MarkForDeletion()
@@ -129,25 +135,25 @@ func (self *State) Delete(addr []byte) bool {
 //
 
 // Update the given state object and apply it to state trie
-func (self *State) UpdateStateObject(stateObject *StateObject) {
+func (self *StateDB) UpdateStateObject(stateObject *StateObject) {
 	addr := stateObject.Address()
 
 	if len(stateObject.CodeHash()) > 0 {
-		ethutil.Config.Db.Put(stateObject.CodeHash(), stateObject.Code)
+		self.db.Put(stateObject.CodeHash(), stateObject.Code)
 	}
 
-	self.Trie.Update(string(addr), string(stateObject.RlpEncode()))
+	self.trie.Update(addr, stateObject.RlpEncode())
 }
 
 // Delete the given state object and delete it from the state trie
-func (self *State) DeleteStateObject(stateObject *StateObject) {
-	self.Trie.Delete(string(stateObject.Address()))
+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 *State) GetStateObject(addr []byte) *StateObject {
+func (self *StateDB) GetStateObject(addr []byte) *StateObject {
 	addr = ethutil.Address(addr)
 
 	stateObject := self.stateObjects[string(addr)]
@@ -155,23 +161,23 @@ func (self *State) GetStateObject(addr []byte) *StateObject {
 		return stateObject
 	}
 
-	data := self.Trie.Get(string(addr))
+	data := self.trie.Get(addr)
 	if len(data) == 0 {
 		return nil
 	}
 
-	stateObject = NewStateObjectFromBytes(addr, []byte(data))
+	stateObject = NewStateObjectFromBytes(addr, []byte(data), self.db)
 	self.SetStateObject(stateObject)
 
 	return stateObject
 }
 
-func (self *State) SetStateObject(object *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 *State) GetOrNewStateObject(addr []byte) *StateObject {
+func (self *StateDB) GetOrNewStateObject(addr []byte) *StateObject {
 	stateObject := self.GetStateObject(addr)
 	if stateObject == nil {
 		stateObject = self.NewStateObject(addr)
@@ -181,19 +187,19 @@ func (self *State) GetOrNewStateObject(addr []byte) *StateObject {
 }
 
 // Create a state object whether it exist in the trie or not
-func (self *State) NewStateObject(addr []byte) *StateObject {
+func (self *StateDB) NewStateObject(addr []byte) *StateObject {
 	addr = ethutil.Address(addr)
 
 	statelogger.Debugf("(+) %x\n", addr)
 
-	stateObject := NewStateObject(addr)
+	stateObject := NewStateObject(addr, self.db)
 	self.stateObjects[string(addr)] = stateObject
 
 	return stateObject
 }
 
 // Deprecated
-func (self *State) GetAccount(addr []byte) *StateObject {
+func (self *StateDB) GetAccount(addr []byte) *StateObject {
 	return self.GetOrNewStateObject(addr)
 }
 
@@ -201,19 +207,20 @@ func (self *State) GetAccount(addr []byte) *StateObject {
 // Setting, copying of the state methods
 //
 
-func (s *State) Cmp(other *State) bool {
-	return s.Trie.Cmp(other.Trie)
+func (s *StateDB) Cmp(other *StateDB) bool {
+	return bytes.Equal(s.trie.Root(), other.trie.Root())
 }
 
-func (self *State) Copy() *State {
-	if self.Trie != nil {
-		state := New(self.Trie.Copy())
+func (self *StateDB) Copy() *StateDB {
+	if self.trie != nil {
+		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] = refund
+			state.refund[addr] = new(big.Int).Set(refund)
 		}
 
 		logs := make(Logs, len(self.logs))
@@ -226,24 +233,24 @@ func (self *State) Copy() *State {
 	return nil
 }
 
-func (self *State) Set(state *State) {
+func (self *StateDB) Set(state *StateDB) {
 	if state == nil {
 		panic("Tried setting 'state' to nil through 'Set'")
 	}
 
-	self.Trie = state.Trie
+	self.trie = state.trie
 	self.stateObjects = state.stateObjects
 	self.refund = state.refund
 	self.logs = state.logs
 }
 
-func (s *State) Root() interface{} {
-	return s.Trie.Root
+func (s *StateDB) Root() []byte {
+	return s.trie.Root()
 }
 
 // Resets the trie and all siblings
-func (s *State) Reset() {
-	s.Trie.Undo()
+func (s *StateDB) Reset() {
+	s.trie.Reset()
 
 	// Reset all nested states
 	for _, stateObject := range s.stateObjects {
@@ -251,7 +258,6 @@ func (s *State) Reset() {
 			continue
 		}
 
-		//stateObject.state.Reset()
 		stateObject.Reset()
 	}
 
@@ -259,7 +265,7 @@ func (s *State) Reset() {
 }
 
 // Syncs the trie and all siblings
-func (s *State) Sync() {
+func (s *StateDB) Sync() {
 	// Sync all nested states
 	for _, stateObject := range s.stateObjects {
 		if stateObject.State == nil {
@@ -269,52 +275,41 @@ func (s *State) Sync() {
 		stateObject.State.Sync()
 	}
 
-	s.Trie.Sync()
+	s.trie.Commit()
 
 	s.Empty()
 }
 
-func (self *State) Empty() {
+func (self *StateDB) Empty() {
 	self.stateObjects = make(map[string]*StateObject)
 	self.refund = make(map[string]*big.Int)
 }
 
-func (self *State) Update() {
-	var deleted bool
+func (self *StateDB) Refunds() map[string]*big.Int {
+	return self.refund
+}
 
-	// Refund any gas that's left
-	for addr, amount := range self.refund {
-		self.GetStateObject([]byte(addr)).AddBalance(amount)
-	}
+func (self *StateDB) Update(gasUsed *big.Int) {
+
+	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.Root, t2.Root)
-
-			self.Trie = t2
-		}
-	}
 }
 
-func (self *State) Manifest() *Manifest {
+func (self *StateDB) Manifest() *Manifest {
 	return self.manifest
 }
 
 // Debug stuff
-func (self *State) CreateOutputForDiff() {
+func (self *StateDB) CreateOutputForDiff() {
 	for _, stateObject := range self.stateObjects {
 		stateObject.CreateOutputForDiff()
 	}