From 8ddd4c4c52eef9f382a321fa880adba4a1e35ee2 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Mon, 30 Jun 2014 13:09:04 +0200
Subject: [PATCH] wip

---
 ethchain/state_manager.go    |  3 ++-
 ethchain/state_object.go     |  5 +++-
 ethchain/state_transition.go | 45 ++++++++++++++++++++++++++++++++++++
 ethutil/value.go             |  8 +++++++
 4 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go
index 312ba3084..48c6401e3 100644
--- a/ethchain/state_manager.go
+++ b/ethchain/state_manager.go
@@ -3,6 +3,7 @@ package ethchain
 import (
 	"bytes"
 	"container/list"
+	"fmt"
 	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
@@ -200,7 +201,7 @@ func (sm *StateManager) Process(block *Block, dontReact bool) (err error) {
 	}
 
 	if !block.State().Cmp(state) {
-		statelogger.Errorf("Invalid merkle root.\nrec: %x\nis:  %x", block.State().trie.Root, state.trie.Root)
+		err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis:  %x", block.State().trie.Root, state.trie.Root)
 		return
 	}
 
diff --git a/ethchain/state_object.go b/ethchain/state_object.go
index 480b4055d..edac4f6dc 100644
--- a/ethchain/state_object.go
+++ b/ethchain/state_object.go
@@ -48,7 +48,10 @@ func MakeContract(tx *Transaction, state *State) *StateObject {
 }
 
 func NewStateObject(addr []byte) *StateObject {
-	return &StateObject{address: addr, Amount: new(big.Int), gasPool: new(big.Int)}
+	object := &StateObject{address: addr, Amount: new(big.Int), gasPool: new(big.Int)}
+	object.state = NewState(ethutil.NewTrie(ethutil.Config.Db, ""))
+
+	return object
 }
 
 func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject {
diff --git a/ethchain/state_transition.go b/ethchain/state_transition.go
index f84c3486b..4b4cbeb51 100644
--- a/ethchain/state_transition.go
+++ b/ethchain/state_transition.go
@@ -1,7 +1,9 @@
 package ethchain
 
 import (
+	"bytes"
 	"fmt"
+	"github.com/ethereum/eth-go/ethutil"
 	"math/big"
 )
 
@@ -236,6 +238,8 @@ func (self *StateTransition) transferValue(sender, receiver *StateObject) error
 	return nil
 }
 
+var testAddr = ethutil.FromHex("ec4f34c97e43fbb2816cfd95e388353c7181dab1")
+
 func (self *StateTransition) Eval(script []byte, context *StateObject) (ret []byte, err error, deepErr bool) {
 	var (
 		block     = self.block
@@ -258,5 +262,46 @@ func (self *StateTransition) Eval(script []byte, context *StateObject) (ret []by
 	ret, _, err = closure.Call(vm, self.data, nil)
 	deepErr = vm.err != nil
 
+	/*
+		if bytes.Compare(testAddr, context.Address()) == 0 {
+			trie := context.state.trie
+			trie.NewIterator().Each(func(key string, v *ethutil.Value) {
+				v.Decode()
+				fmt.Printf("%x : %x\n", key, v.Str())
+			})
+			fmt.Println("\n\n")
+		}
+	*/
+
+	Paranoia := true
+	if Paranoia {
+		var (
+			trie  = context.state.trie
+			trie2 = ethutil.NewTrie(ethutil.Config.Db, "")
+		)
+
+		trie.NewIterator().Each(func(key string, v *ethutil.Value) {
+			trie2.Update(key, v.Str())
+		})
+
+		a := ethutil.NewValue(trie2.Root).Bytes()
+		b := ethutil.NewValue(context.state.trie.Root).Bytes()
+		if bytes.Compare(a, b) != 0 {
+			fmt.Printf("original: %x\n", trie.Root)
+			trie.NewIterator().Each(func(key string, v *ethutil.Value) {
+				v.Decode()
+				fmt.Printf("%x : %x\n", key, v.Str())
+			})
+
+			fmt.Printf("new: %x\n", trie2.Root)
+			trie2.NewIterator().Each(func(key string, v *ethutil.Value) {
+				v.Decode()
+				fmt.Printf("%x : %x\n", key, v.Str())
+			})
+
+			return nil, fmt.Errorf("PARANOIA: Different state object roots during copy"), false
+		}
+	}
+
 	return
 }
diff --git a/ethutil/value.go b/ethutil/value.go
index ddd864d8a..b37b33c28 100644
--- a/ethutil/value.go
+++ b/ethutil/value.go
@@ -116,6 +116,8 @@ func (val *Value) Bytes() []byte {
 		return a
 	} else if s, ok := val.Val.(byte); ok {
 		return []byte{s}
+	} else if s, ok := val.Val.(string); ok {
+		return []byte(s)
 	}
 
 	return []byte{}
@@ -196,6 +198,12 @@ func (val *Value) Encode() []byte {
 	return Encode(val.Val)
 }
 
+// Assume that the data we have is encoded
+func (self *Value) Decode() {
+	v, _ := Decode(self.Bytes(), 0)
+	self.Val = v
+}
+
 func NewValueFromBytes(data []byte) *Value {
 	if len(data) != 0 {
 		data, _ := Decode(data, 0)