Merge pull request #28 from ethersphere/feature/keys

Feature/keys

11 files changed, 12 insertions, 3005 deletions

diff --git a/ethutil/bytes.go b/ethutil/bytes.go
index 5e3ee4a6f..c2817946b 100644
--- a/ethutil/bytes.go
+++ b/ethutil/bytes.go
@@ -3,6 +3,7 @@ package ethutil
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
 	"fmt"
 	"math/big"
 	"strings"
@@ -91,9 +92,18 @@ func IsHex(str string) bool {
 	return l >= 4 && l%2 == 0 && str[0:2] == "0x"
 }
 
+func Bytes2Hex(d []byte) string {
+	return hex.EncodeToString(d)
+}
+
+func Hex2Bytes(str string) []byte {
+	h, _ := hex.DecodeString(str)
+	return h
+}
+
 func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) {
 	if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") {
-		ret = FromHex(str[2:])
+		ret = Hex2Bytes(str[2:])
 	} else {
 		ret = cb(str)
 	}
@@ -110,7 +120,7 @@ func FormatData(data string) []byte {
 	if data[0:1] == "\"" && data[len(data)-1:] == "\"" {
 		d.SetBytes([]byte(data[1 : len(data)-1]))
 	} else if len(data) > 1 && data[:2] == "0x" {
-		d.SetBytes(FromHex(data[2:]))
+		d.SetBytes(Hex2Bytes(data[2:]))
 	} else {
 		d.SetString(data, 0)
 	}
diff --git a/ethutil/common.go b/ethutil/common.go
index f63ba5d83..6d88a1ed2 100644
--- a/ethutil/common.go
+++ b/ethutil/common.go
@@ -52,10 +52,3 @@ var (
 	Big32  = big.NewInt(32)
 	Big256 = big.NewInt(0xff)
 )
-
-// Creates an ethereum address given the bytes and the nonce
-func CreateAddress(b []byte, nonce *big.Int) []byte {
-	addrBytes := append(b, nonce.Bytes()...)
-
-	return Sha3Bin(addrBytes)[12:]
-}
diff --git a/ethutil/config.go b/ethutil/config.go
index 6ebb5e8cd..675175cdd 100644
--- a/ethutil/config.go
+++ b/ethutil/config.go
@@ -17,7 +17,6 @@ type config struct {
 	Paranoia     bool
 	Ver          string
 	ClientString string
-	Pubkey       []byte
 	Identifier   string
 
 	conf *globalconf.GlobalConf
diff --git a/ethutil/encoding.go b/ethutil/encoding.go
deleted file mode 100644
index 9fcdf3edf..000000000
--- a/ethutil/encoding.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package ethutil
-
-import (
-	"bytes"
-	"encoding/hex"
-	"strings"
-)
-
-func CompactEncode(hexSlice []int) string {
-	terminator := 0
-	if hexSlice[len(hexSlice)-1] == 16 {
-		terminator = 1
-	}
-
-	if terminator == 1 {
-		hexSlice = hexSlice[:len(hexSlice)-1]
-	}
-
-	oddlen := len(hexSlice) % 2
-	flags := 2*terminator + oddlen
-	if oddlen != 0 {
-		hexSlice = append([]int{flags}, hexSlice...)
-	} else {
-		hexSlice = append([]int{flags, 0}, hexSlice...)
-	}
-
-	var buff bytes.Buffer
-	for i := 0; i < len(hexSlice); i += 2 {
-		buff.WriteByte(byte(16*hexSlice[i] + hexSlice[i+1]))
-	}
-
-	return buff.String()
-}
-
-func CompactDecode(str string) []int {
-	base := CompactHexDecode(str)
-	base = base[:len(base)-1]
-	if base[0] >= 2 {
-		base = append(base, 16)
-	}
-	if base[0]%2 == 1 {
-		base = base[1:]
-	} else {
-		base = base[2:]
-	}
-
-	return base
-}
-
-func CompactHexDecode(str string) []int {
-	base := "0123456789abcdef"
-	hexSlice := make([]int, 0)
-
-	enc := hex.EncodeToString([]byte(str))
-	for _, v := range enc {
-		hexSlice = append(hexSlice, strings.IndexByte(base, byte(v)))
-	}
-	hexSlice = append(hexSlice, 16)
-
-	return hexSlice
-}
-
-func DecodeCompact(key []int) string {
-	base := "0123456789abcdef"
-	var str string
-
-	for _, v := range key {
-		if v < 16 {
-			str += string(base[v])
-		}
-	}
-
-	res, _ := hex.DecodeString(str)
-
-	return string(res)
-}
diff --git a/ethutil/encoding_test.go b/ethutil/encoding_test.go
deleted file mode 100644
index 10e1995c0..000000000
--- a/ethutil/encoding_test.go
+++ /dev/null
@@ -1,67 +0,0 @@
-package ethutil
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestCompactEncode(t *testing.T) {
-	test1 := []int{1, 2, 3, 4, 5}
-	if res := CompactEncode(test1); res != "\x11\x23\x45" {
-		t.Error(fmt.Sprintf("even compact encode failed. Got: %q", res))
-	}
-
-	test2 := []int{0, 1, 2, 3, 4, 5}
-	if res := CompactEncode(test2); res != "\x00\x01\x23\x45" {
-		t.Error(fmt.Sprintf("odd compact encode failed. Got: %q", res))
-	}
-
-	test3 := []int{0, 15, 1, 12, 11, 8 /*term*/, 16}
-	if res := CompactEncode(test3); res != "\x20\x0f\x1c\xb8" {
-		t.Error(fmt.Sprintf("odd terminated compact encode failed. Got: %q", res))
-	}
-
-	test4 := []int{15, 1, 12, 11, 8 /*term*/, 16}
-	if res := CompactEncode(test4); res != "\x3f\x1c\xb8" {
-		t.Error(fmt.Sprintf("even terminated compact encode failed. Got: %q", res))
-	}
-}
-
-func TestCompactHexDecode(t *testing.T) {
-	exp := []int{7, 6, 6, 5, 7, 2, 6, 2, 16}
-	res := CompactHexDecode("verb")
-
-	if !CompareIntSlice(res, exp) {
-		t.Error("Error compact hex decode. Expected", exp, "got", res)
-	}
-}
-
-func TestCompactDecode(t *testing.T) {
-	exp := []int{1, 2, 3, 4, 5}
-	res := CompactDecode("\x11\x23\x45")
-
-	if !CompareIntSlice(res, exp) {
-		t.Error("odd compact decode. Expected", exp, "got", res)
-	}
-
-	exp = []int{0, 1, 2, 3, 4, 5}
-	res = CompactDecode("\x00\x01\x23\x45")
-
-	if !CompareIntSlice(res, exp) {
-		t.Error("even compact decode. Expected", exp, "got", res)
-	}
-
-	exp = []int{0, 15, 1, 12, 11, 8 /*term*/, 16}
-	res = CompactDecode("\x20\x0f\x1c\xb8")
-
-	if !CompareIntSlice(res, exp) {
-		t.Error("even terminated compact decode. Expected", exp, "got", res)
-	}
-
-	exp = []int{15, 1, 12, 11, 8 /*term*/, 16}
-	res = CompactDecode("\x3f\x1c\xb8")
-
-	if !CompareIntSlice(res, exp) {
-		t.Error("even terminated compact decode. Expected", exp, "got", res)
-	}
-}
diff --git a/ethutil/helpers.go b/ethutil/helpers.go
deleted file mode 100644
index aa0f79a04..000000000
--- a/ethutil/helpers.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package ethutil
-
-import (
-	"code.google.com/p/go.crypto/ripemd160"
-	"crypto/sha256"
-	"encoding/hex"
-	"github.com/obscuren/sha3"
-	"strconv"
-)
-
-func Uitoa(i uint32) string {
-	return strconv.FormatUint(uint64(i), 10)
-}
-
-func Sha256Bin(data []byte) []byte {
-	hash := sha256.Sum256(data)
-
-	return hash[:]
-}
-
-func Ripemd160(data []byte) []byte {
-	ripemd := ripemd160.New()
-	ripemd.Write(data)
-
-	return ripemd.Sum(nil)
-}
-
-func Sha3Bin(data []byte) []byte {
-	d := sha3.NewKeccak256()
-	d.Write(data)
-
-	return d.Sum(nil)
-}
-
-// Helper function for comparing slices
-func CompareIntSlice(a, b []int) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i, v := range a {
-		if v != b[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// Returns the amount of nibbles that match each other from 0 ...
-func MatchingNibbleLength(a, b []int) int {
-	i := 0
-	for CompareIntSlice(a[:i+1], b[:i+1]) && i < len(b) {
-		i += 1
-	}
-
-	return i
-}
-
-func Hex(d []byte) string {
-	return hex.EncodeToString(d)
-}
-func FromHex(str string) []byte {
-	h, _ := hex.DecodeString(str)
-	return h
-}
diff --git a/ethutil/keypair.go b/ethutil/keypair.go
deleted file mode 100644
index 29fb1bac5..000000000
--- a/ethutil/keypair.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package ethutil
-
-import (
-	"github.com/obscuren/secp256k1-go"
-)
-
-type KeyPair struct {
-	PrivateKey []byte
-	PublicKey  []byte
-
-	// The associated account
-	account *StateObject
-}
-
-func GenerateNewKeyPair() (*KeyPair, error) {
-	_, prv := secp256k1.GenerateKeyPair()
-
-	return NewKeyPairFromSec(prv)
-}
-
-func NewKeyPairFromSec(seckey []byte) (*KeyPair, error) {
-	pubkey, err := secp256k1.GeneratePubKey(seckey)
-	if err != nil {
-		return nil, err
-	}
-
-	return &KeyPair{PrivateKey: seckey, PublicKey: pubkey}, nil
-}
-
-func NewKeyPairFromValue(val *Value) *KeyPair {
-	v, _ := NewKeyPairFromSec(val.Bytes())
-
-	return v
-}
-
-func (k *KeyPair) Address() []byte {
-	return Sha3Bin(k.PublicKey[1:])[12:]
-}
-
-func (k *KeyPair) RlpEncode() []byte {
-	return k.RlpValue().Encode()
-}
-
-func (k *KeyPair) RlpValue() *Value {
-	return NewValue(k.PrivateKey)
-}
-
-type KeyRing struct {
-	keys []*KeyPair
-}
-
-func (k *KeyRing) Add(pair *KeyPair) {
-	k.keys = append(k.keys, pair)
-}
-
-func (k *KeyRing) Get(i int) *KeyPair {
-	if len(k.keys) > i {
-		return k.keys[i]
-	}
-
-	return nil
-}
-
-func (k *KeyRing) Len() int {
-	return len(k.keys)
-}
-
-func (k *KeyRing) NewKeyPair(sec []byte) (*KeyPair, error) {
-	keyPair, err := NewKeyPairFromSec(sec)
-	if err != nil {
-		return nil, err
-	}
-
-	k.Add(keyPair)
-	Config.Db.Put([]byte("KeyRing"), k.RlpValue().Encode())
-
-	return keyPair, nil
-}
-
-func (k *KeyRing) Reset() {
-	Config.Db.Put([]byte("KeyRing"), nil)
-	k.keys = nil
-}
-
-func (k *KeyRing) RlpValue() *Value {
-	v := EmptyValue()
-	for _, keyPair := range k.keys {
-		v.Append(keyPair.RlpValue())
-	}
-
-	return v
-}
-
-// The public "singleton" keyring
-var keyRing *KeyRing
-
-func GetKeyRing() *KeyRing {
-	if keyRing == nil {
-		keyRing = &KeyRing{}
-
-		data, _ := Config.Db.Get([]byte("KeyRing"))
-		it := NewValueFromBytes(data).NewIterator()
-		for it.Next() {
-			v := it.Value()
-
-			key, err := NewKeyPairFromSec(v.Bytes())
-			if err != nil {
-				panic(err)
-			}
-			keyRing.Add(key)
-		}
-	}
-
-	return keyRing
-}
diff --git a/ethutil/mnemonic.go b/ethutil/mnemonic.go
deleted file mode 100644
index 00f089e3b..000000000
--- a/ethutil/mnemonic.go
+++ /dev/null
@@ -1,1690 +0,0 @@
-package ethutil
-
-import (
-	"fmt"
-	"strconv"
-)
-
-// TODO: See if we can refactor this into a shared util lib if we need it multiple times
-func IndexOf(slice []string, value string) int64 {
-	for p, v := range slice {
-		if v == value {
-			return int64(p)
-		}
-	}
-	return -1
-}
-
-func MnemonicEncode(message string) []string {
-	var out []string
-	n := int64(len(words))
-
-	for i := 0; i < len(message); i += (len(message) / 8) {
-		x := message[i : i+8]
-		bit, _ := strconv.ParseInt(x, 16, 64)
-		w1 := (bit % n)
-		w2 := ((bit / n) + w1) % n
-		w3 := ((bit / n / n) + w2) % n
-		out = append(out, words[w1], words[w2], words[w3])
-	}
-	return out
-}
-
-func MnemonicDecode(wordsar []string) string {
-	var out string
-	n := int64(len(words))
-
-	for i := 0; i < len(wordsar); i += 3 {
-		word1 := wordsar[i]
-		word2 := wordsar[i+1]
-		word3 := wordsar[i+2]
-		w1 := IndexOf(words, word1)
-		w2 := IndexOf(words, word2)
-		w3 := IndexOf(words, word3)
-
-		y := (w2 - w1) % n
-		z := (w3 - w2) % n
-
-		// Golang handles modulo with negative numbers different then most languages
-		// The modulo can be negative, we don't want that.
-		if z < 0 {
-			z += n
-		}
-		if y < 0 {
-			y += n
-		}
-		x := w1 + n*(y) + n*n*(z)
-		out += fmt.Sprintf("%08x", x)
-	}
-	return out
-}
-
-// Electrum word list
-var words []string = []string{
-	"like",
-	"just",
-	"love",
-	"know",
-	"never",
-	"want",
-	"time",
-	"out",
-	"there",
-	"make",
-	"look",
-	"eye",
-	"down",
-	"only",
-	"think",
-	"heart",
-	"back",
-	"then",
-	"into",
-	"about",
-	"more",
-	"away",
-	"still",
-	"them",
-	"take",
-	"thing",
-	"even",
-	"through",
-	"long",
-	"always",
-	"world",
-	"too",
-	"friend",
-	"tell",
-	"try",
-	"hand",
-	"thought",
-	"over",
-	"here",
-	"other",
-	"need",
-	"smile",
-	"again",
-	"much",
-	"cry",
-	"been",
-	"night",
-	"ever",
-	"little",
-	"said",
-	"end",
-	"some",
-	"those",
-	"around",
-	"mind",
-	"people",
-	"girl",
-	"leave",
-	"dream",
-	"left",
-	"turn",
-	"myself",
-	"give",
-	"nothing",
-	"really",
-	"off",
-	"before",
-	"something",
-	"find",
-	"walk",
-	"wish",
-	"good",
-	"once",
-	"place",
-	"ask",
-	"stop",
-	"keep",
-	"watch",
-	"seem",
-	"everything",
-	"wait",
-	"got",
-	"yet",
-	"made",
-	"remember",
-	"start",
-	"alone",
-	"run",
-	"hope",
-	"maybe",
-	"believe",
-	"body",
-	"hate",
-	"after",
-	"close",
-	"talk",
-	"stand",
-	"own",
-	"each",
-	"hurt",
-	"help",
-	"home",
-	"god",
-	"soul",
-	"new",
-	"many",
-	"two",
-	"inside",
-	"should",
-	"true",
-	"first",
-	"fear",
-	"mean",
-	"better",
-	"play",
-	"another",
-	"gone",
-	"change",
-	"use",
-	"wonder",
-	"someone",
-	"hair",
-	"cold",
-	"open",
-	"best",
-	"any",
-	"behind",
-	"happen",
-	"water",
-	"dark",
-	"laugh",
-	"stay",
-	"forever",
-	"name",
-	"work",
-	"show",
-	"sky",
-	"break",
-	"came",
-	"deep",
-	"door",
-	"put",
-	"black",
-	"together",
-	"upon",
-	"happy",
-	"such",
-	"great",
-	"white",
-	"matter",
-	"fill",
-	"past",
-	"please",
-	"burn",
-	"cause",
-	"enough",
-	"touch",
-	"moment",
-	"soon",
-	"voice",
-	"scream",
-	"anything",
-	"stare",
-	"sound",
-	"red",
-	"everyone",
-	"hide",
-	"kiss",
-	"truth",
-	"death",
-	"beautiful",
-	"mine",
-	"blood",
-	"broken",
-	"very",
-	"pass",
-	"next",
-	"forget",
-	"tree",
-	"wrong",
-	"air",
-	"mother",
-	"understand",
-	"lip",
-	"hit",
-	"wall",
-	"memory",
-	"sleep",
-	"free",
-	"high",
-	"realize",
-	"school",
-	"might",
-	"skin",
-	"sweet",
-	"perfect",
-	"blue",
-	"kill",
-	"breath",
-	"dance",
-	"against",
-	"fly",
-	"between",
-	"grow",
-	"strong",
-	"under",
-	"listen",
-	"bring",
-	"sometimes",
-	"speak",
-	"pull",
-	"person",
-	"become",
-	"family",
-	"begin",
-	"ground",
-	"real",
-	"small",
-	"father",
-	"sure",
-	"feet",
-	"rest",
-	"young",
-	"finally",
-	"land",
-	"across",
-	"today",
-	"different",
-	"guy",
-	"line",
-	"fire",
-	"reason",
-	"reach",
-	"second",
-	"slowly",
-	"write",
-	"eat",
-	"smell",
-	"mouth",
-	"step",
-	"learn",
-	"three",
-	"floor",
-	"promise",
-	"breathe",
-	"darkness",
-	"push",
-	"earth",
-	"guess",
-	"save",
-	"song",
-	"above",
-	"along",
-	"both",
-	"color",
-	"house",
-	"almost",
-	"sorry",
-	"anymore",
-	"brother",
-	"okay",
-	"dear",
-	"game",
-	"fade",
-	"already",
-	"apart",
-	"warm",
-	"beauty",
-	"heard",
-	"notice",
-	"question",
-	"shine",
-	"began",
-	"piece",
-	"whole",
-	"shadow",
-	"secret",
-	"street",
-	"within",
-	"finger",
-	"point",
-	"morning",
-	"whisper",
-	"child",
-	"moon",
-	"green",
-	"story",
-	"glass",
-	"kid",
-	"silence",
-	"since",
-	"soft",
-	"yourself",
-	"empty",
-	"shall",
-	"angel",
-	"answer",
-	"baby",
-	"bright",
-	"dad",
-	"path",
-	"worry",
-	"hour",
-	"drop",
-	"follow",
-	"power",
-	"war",
-	"half",
-	"flow",
-	"heaven",
-	"act",
-	"chance",
-	"fact",
-	"least",
-	"tired",
-	"children",
-	"near",
-	"quite",
-	"afraid",
-	"rise",
-	"sea",
-	"taste",
-	"window",
-	"cover",
-	"nice",
-	"trust",
-	"lot",
-	"sad",
-	"cool",
-	"force",
-	"peace",
-	"return",
-	"blind",
-	"easy",
-	"ready",
-	"roll",
-	"rose",
-	"drive",
-	"held",
-	"music",
-	"beneath",
-	"hang",
-	"mom",
-	"paint",
-	"emotion",
-	"quiet",
-	"clear",
-	"cloud",
-	"few",
-	"pretty",
-	"bird",
-	"outside",
-	"paper",
-	"picture",
-	"front",
-	"rock",
-	"simple",
-	"anyone",
-	"meant",
-	"reality",
-	"road",
-	"sense",
-	"waste",
-	"bit",
-	"leaf",
-	"thank",
-	"happiness",
-	"meet",
-	"men",
-	"smoke",
-	"truly",
-	"decide",
-	"self",
-	"age",
-	"book",
-	"form",
-	"alive",
-	"carry",
-	"escape",
-	"damn",
-	"instead",
-	"able",
-	"ice",
-	"minute",
-	"throw",
-	"catch",
-	"leg",
-	"ring",
-	"course",
-	"goodbye",
-	"lead",
-	"poem",
-	"sick",
-	"corner",
-	"desire",
-	"known",
-	"problem",
-	"remind",
-	"shoulder",
-	"suppose",
-	"toward",
-	"wave",
-	"drink",
-	"jump",
-	"woman",
-	"pretend",
-	"sister",
-	"week",
-	"human",
-	"joy",
-	"crack",
-	"grey",
-	"pray",
-	"surprise",
-	"dry",
-	"knee",
-	"less",
-	"search",
-	"bleed",
-	"caught",
-	"clean",
-	"embrace",
-	"future",
-	"king",
-	"son",
-	"sorrow",
-	"chest",
-	"hug",
-	"remain",
-	"sat",
-	"worth",
-	"blow",
-	"daddy",
-	"final",
-	"parent",
-	"tight",
-	"also",
-	"create",
-	"lonely",
-	"safe",
-	"cross",
-	"dress",
-	"evil",
-	"silent",
-	"bone",
-	"fate",
-	"perhaps",
-	"anger",
-	"class",
-	"scar",
-	"snow",
-	"tiny",
-	"tonight",
-	"continue",
-	"control",
-	"dog",
-	"edge",
-	"mirror",
-	"month",
-	"suddenly",
-	"comfort",
-	"given",
-	"loud",
-	"quickly",
-	"gaze",
-	"plan",
-	"rush",
-	"stone",
-	"town",
-	"battle",
-	"ignore",
-	"spirit",
-	"stood",
-	"stupid",
-	"yours",
-	"brown",
-	"build",
-	"dust",
-	"hey",
-	"kept",
-	"pay",
-	"phone",
-	"twist",
-	"although",
-	"ball",
-	"beyond",
-	"hidden",
-	"nose",
-	"taken",
-	"fail",
-	"float",
-	"pure",
-	"somehow",
-	"wash",
-	"wrap",
-	"angry",
-	"cheek",
-	"creature",
-	"forgotten",
-	"heat",
-	"rip",
-	"single",
-	"space",
-	"special",
-	"weak",
-	"whatever",
-	"yell",
-	"anyway",
-	"blame",
-	"job",
-	"choose",
-	"country",
-	"curse",
-	"drift",
-	"echo",
-	"figure",
-	"grew",
-	"laughter",
-	"neck",
-	"suffer",
-	"worse",
-	"yeah",
-	"disappear",
-	"foot",
-	"forward",
-	"knife",
-	"mess",
-	"somewhere",
-	"stomach",
-	"storm",
-	"beg",
-	"idea",
-	"lift",
-	"offer",
-	"breeze",
-	"field",
-	"five",
-	"often",
-	"simply",
-	"stuck",
-	"win",
-	"allow",
-	"confuse",
-	"enjoy",
-	"except",
-	"flower",
-	"seek",
-	"strength",
-	"calm",
-	"grin",
-	"gun",
-	"heavy",
-	"hill",
-	"large",
-	"ocean",
-	"shoe",
-	"sigh",
-	"straight",
-	"summer",
-	"tongue",
-	"accept",
-	"crazy",
-	"everyday",
-	"exist",
-	"grass",
-	"mistake",
-	"sent",
-	"shut",
-	"surround",
-	"table",
-	"ache",
-	"brain",
-	"destroy",
-	"heal",
-	"nature",
-	"shout",
-	"sign",
-	"stain",
-	"choice",
-	"doubt",
-	"glance",
-	"glow",
-	"mountain",
-	"queen",
-	"stranger",
-	"throat",
-	"tomorrow",
-	"city",
-	"either",
-	"fish",
-	"flame",
-	"rather",
-	"shape",
-	"spin",
-	"spread",
-	"ash",
-	"distance",
-	"finish",
-	"image",
-	"imagine",
-	"important",
-	"nobody",
-	"shatter",
-	"warmth",
-	"became",
-	"feed",
-	"flesh",
-	"funny",
-	"lust",
-	"shirt",
-	"trouble",
-	"yellow",
-	"attention",
-	"bare",
-	"bite",
-	"money",
-	"protect",
-	"amaze",
-	"appear",
-	"born",
-	"choke",
-	"completely",
-	"daughter",
-	"fresh",
-	"friendship",
-	"gentle",
-	"probably",
-	"six",
-	"deserve",
-	"expect",
-	"grab",
-	"middle",
-	"nightmare",
-	"river",
-	"thousand",
-	"weight",
-	"worst",
-	"wound",
-	"barely",
-	"bottle",
-	"cream",
-	"regret",
-	"relationship",
-	"stick",
-	"test",
-	"crush",
-	"endless",
-	"fault",
-	"itself",
-	"rule",
-	"spill",
-	"art",
-	"circle",
-	"join",
-	"kick",
-	"mask",
-	"master",
-	"passion",
-	"quick",
-	"raise",
-	"smooth",
-	"unless",
-	"wander",
-	"actually",
-	"broke",
-	"chair",
-	"deal",
-	"favorite",
-	"gift",
-	"note",
-	"number",
-	"sweat",
-	"box",
-	"chill",
-	"clothes",
-	"lady",
-	"mark",
-	"park",
-	"poor",
-	"sadness",
-	"tie",
-	"animal",
-	"belong",
-	"brush",
-	"consume",
-	"dawn",
-	"forest",
-	"innocent",
-	"pen",
-	"pride",
-	"stream",
-	"thick",
-	"clay",
-	"complete",
-	"count",
-	"draw",
-	"faith",
-	"press",
-	"silver",
-	"struggle",
-	"surface",
-	"taught",
-	"teach",
-	"wet",
-	"bless",
-	"chase",
-	"climb",
-	"enter",
-	"letter",
-	"melt",
-	"metal",
-	"movie",
-	"stretch",
-	"swing",
-	"vision",
-	"wife",
-	"beside",
-	"crash",
-	"forgot",
-	"guide",
-	"haunt",
-	"joke",
-	"knock",
-	"plant",
-	"pour",
-	"prove",
-	"reveal",
-	"steal",
-	"stuff",
-	"trip",
-	"wood",
-	"wrist",
-	"bother",
-	"bottom",
-	"crawl",
-	"crowd",
-	"fix",
-	"forgive",
-	"frown",
-	"grace",
-	"loose",
-	"lucky",
-	"party",
-	"release",
-	"surely",
-	"survive",
-	"teacher",
-	"gently",
-	"grip",
-	"speed",
-	"suicide",
-	"travel",
-	"treat",
-	"vein",
-	"written",
-	"cage",
-	"chain",
-	"conversation",
-	"date",
-	"enemy",
-	"however",
-	"interest",
-	"million",
-	"page",
-	"pink",
-	"proud",
-	"sway",
-	"themselves",
-	"winter",
-	"church",
-	"cruel",
-	"cup",
-	"demon",
-	"experience",
-	"freedom",
-	"pair",
-	"pop",
-	"purpose",
-	"respect",
-	"shoot",
-	"softly",
-	"state",
-	"strange",
-	"bar",
-	"birth",
-	"curl",
-	"dirt",
-	"excuse",
-	"lord",
-	"lovely",
-	"monster",
-	"order",
-	"pack",
-	"pants",
-	"pool",
-	"scene",
-	"seven",
-	"shame",
-	"slide",
-	"ugly",
-	"among",
-	"blade",
-	"blonde",
-	"closet",
-	"creek",
-	"deny",
-	"drug",
-	"eternity",
-	"gain",
-	"grade",
-	"handle",
-	"key",
-	"linger",
-	"pale",
-	"prepare",
-	"swallow",
-	"swim",
-	"tremble",
-	"wheel",
-	"won",
-	"cast",
-	"cigarette",
-	"claim",
-	"college",
-	"direction",
-	"dirty",
-	"gather",
-	"ghost",
-	"hundred",
-	"loss",
-	"lung",
-	"orange",
-	"present",
-	"swear",
-	"swirl",
-	"twice",
-	"wild",
-	"bitter",
-	"blanket",
-	"doctor",
-	"everywhere",
-	"flash",
-	"grown",
-	"knowledge",
-	"numb",
-	"pressure",
-	"radio",
-	"repeat",
-	"ruin",
-	"spend",
-	"unknown",
-	"buy",
-	"clock",
-	"devil",
-	"early",
-	"false",
-	"fantasy",
-	"pound",
-	"precious",
-	"refuse",
-	"sheet",
-	"teeth",
-	"welcome",
-	"add",
-	"ahead",
-	"block",
-	"bury",
-	"caress",
-	"content",
-	"depth",
-	"despite",
-	"distant",
-	"marry",
-	"purple",
-	"threw",
-	"whenever",
-	"bomb",
-	"dull",
-	"easily",
-	"grasp",
-	"hospital",
-	"innocence",
-	"normal",
-	"receive",
-	"reply",
-	"rhyme",
-	"shade",
-	"someday",
-	"sword",
-	"toe",
-	"visit",
-	"asleep",
-	"bought",
-	"center",
-	"consider",
-	"flat",
-	"hero",
-	"history",
-	"ink",
-	"insane",
-	"muscle",
-	"mystery",
-	"pocket",
-	"reflection",
-	"shove",
-	"silently",
-	"smart",
-	"soldier",
-	"spot",
-	"stress",
-	"train",
-	"type",
-	"view",
-	"whether",
-	"bus",
-	"energy",
-	"explain",
-	"holy",
-	"hunger",
-	"inch",
-	"magic",
-	"mix",
-	"noise",
-	"nowhere",
-	"prayer",
-	"presence",
-	"shock",
-	"snap",
-	"spider",
-	"study",
-	"thunder",
-	"trail",
-	"admit",
-	"agree",
-	"bag",
-	"bang",
-	"bound",
-	"butterfly",
-	"cute",
-	"exactly",
-	"explode",
-	"familiar",
-	"fold",
-	"further",
-	"pierce",
-	"reflect",
-	"scent",
-	"selfish",
-	"sharp",
-	"sink",
-	"spring",
-	"stumble",
-	"universe",
-	"weep",
-	"women",
-	"wonderful",
-	"action",
-	"ancient",
-	"attempt",
-	"avoid",
-	"birthday",
-	"branch",
-	"chocolate",
-	"core",
-	"depress",
-	"drunk",
-	"especially",
-	"focus",
-	"fruit",
-	"honest",
-	"match",
-	"palm",
-	"perfectly",
-	"pillow",
-	"pity",
-	"poison",
-	"roar",
-	"shift",
-	"slightly",
-	"thump",
-	"truck",
-	"tune",
-	"twenty",
-	"unable",
-	"wipe",
-	"wrote",
-	"coat",
-	"constant",
-	"dinner",
-	"drove",
-	"egg",
-	"eternal",
-	"flight",
-	"flood",
-	"frame",
-	"freak",
-	"gasp",
-	"glad",
-	"hollow",
-	"motion",
-	"peer",
-	"plastic",
-	"root",
-	"screen",
-	"season",
-	"sting",
-	"strike",
-	"team",
-	"unlike",
-	"victim",
-	"volume",
-	"warn",
-	"weird",
-	"attack",
-	"await",
-	"awake",
-	"built",
-	"charm",
-	"crave",
-	"despair",
-	"fought",
-	"grant",
-	"grief",
-	"horse",
-	"limit",
-	"message",
-	"ripple",
-	"sanity",
-	"scatter",
-	"serve",
-	"split",
-	"string",
-	"trick",
-	"annoy",
-	"blur",
-	"boat",
-	"brave",
-	"clearly",
-	"cling",
-	"connect",
-	"fist",
-	"forth",
-	"imagination",
-	"iron",
-	"jock",
-	"judge",
-	"lesson",
-	"milk",
-	"misery",
-	"nail",
-	"naked",
-	"ourselves",
-	"poet",
-	"possible",
-	"princess",
-	"sail",
-	"size",
-	"snake",
-	"society",
-	"stroke",
-	"torture",
-	"toss",
-	"trace",
-	"wise",
-	"bloom",
-	"bullet",
-	"cell",
-	"check",
-	"cost",
-	"darling",
-	"during",
-	"footstep",
-	"fragile",
-	"hallway",
-	"hardly",
-	"horizon",
-	"invisible",
-	"journey",
-	"midnight",
-	"mud",
-	"nod",
-	"pause",
-	"relax",
-	"shiver",
-	"sudden",
-	"value",
-	"youth",
-	"abuse",
-	"admire",
-	"blink",
-	"breast",
-	"bruise",
-	"constantly",
-	"couple",
-	"creep",
-	"curve",
-	"difference",
-	"dumb",
-	"emptiness",
-	"gotta",
-	"honor",
-	"plain",
-	"planet",
-	"recall",
-	"rub",
-	"ship",
-	"slam",
-	"soar",
-	"somebody",
-	"tightly",
-	"weather",
-	"adore",
-	"approach",
-	"bond",
-	"bread",
-	"burst",
-	"candle",
-	"coffee",
-	"cousin",
-	"crime",
-	"desert",
-	"flutter",
-	"frozen",
-	"grand",
-	"heel",
-	"hello",
-	"language",
-	"level",
-	"movement",
-	"pleasure",
-	"powerful",
-	"random",
-	"rhythm",
-	"settle",
-	"silly",
-	"slap",
-	"sort",
-	"spoken",
-	"steel",
-	"threaten",
-	"tumble",
-	"upset",
-	"aside",
-	"awkward",
-	"bee",
-	"blank",
-	"board",
-	"button",
-	"card",
-	"carefully",
-	"complain",
-	"crap",
-	"deeply",
-	"discover",
-	"drag",
-	"dread",
-	"effort",
-	"entire",
-	"fairy",
-	"giant",
-	"gotten",
-	"greet",
-	"illusion",
-	"jeans",
-	"leap",
-	"liquid",
-	"march",
-	"mend",
-	"nervous",
-	"nine",
-	"replace",
-	"rope",
-	"spine",
-	"stole",
-	"terror",
-	"accident",
-	"apple",
-	"balance",
-	"boom",
-	"childhood",
-	"collect",
-	"demand",
-	"depression",
-	"eventually",
-	"faint",
-	"glare",
-	"goal",
-	"group",
-	"honey",
-	"kitchen",
-	"laid",
-	"limb",
-	"machine",
-	"mere",
-	"mold",
-	"murder",
-	"nerve",
-	"painful",
-	"poetry",
-	"prince",
-	"rabbit",
-	"shelter",
-	"shore",
-	"shower",
-	"soothe",
-	"stair",
-	"steady",
-	"sunlight",
-	"tangle",
-	"tease",
-	"treasure",
-	"uncle",
-	"begun",
-	"bliss",
-	"canvas",
-	"cheer",
-	"claw",
-	"clutch",
-	"commit",
-	"crimson",
-	"crystal",
-	"delight",
-	"doll",
-	"existence",
-	"express",
-	"fog",
-	"football",
-	"gay",
-	"goose",
-	"guard",
-	"hatred",
-	"illuminate",
-	"mass",
-	"math",
-	"mourn",
-	"rich",
-	"rough",
-	"skip",
-	"stir",
-	"student",
-	"style",
-	"support",
-	"thorn",
-	"tough",
-	"yard",
-	"yearn",
-	"yesterday",
-	"advice",
-	"appreciate",
-	"autumn",
-	"bank",
-	"beam",
-	"bowl",
-	"capture",
-	"carve",
-	"collapse",
-	"confusion",
-	"creation",
-	"dove",
-	"feather",
-	"girlfriend",
-	"glory",
-	"government",
-	"harsh",
-	"hop",
-	"inner",
-	"loser",
-	"moonlight",
-	"neighbor",
-	"neither",
-	"peach",
-	"pig",
-	"praise",
-	"screw",
-	"shield",
-	"shimmer",
-	"sneak",
-	"stab",
-	"subject",
-	"throughout",
-	"thrown",
-	"tower",
-	"twirl",
-	"wow",
-	"army",
-	"arrive",
-	"bathroom",
-	"bump",
-	"cease",
-	"cookie",
-	"couch",
-	"courage",
-	"dim",
-	"guilt",
-	"howl",
-	"hum",
-	"husband",
-	"insult",
-	"led",
-	"lunch",
-	"mock",
-	"mostly",
-	"natural",
-	"nearly",
-	"needle",
-	"nerd",
-	"peaceful",
-	"perfection",
-	"pile",
-	"price",
-	"remove",
-	"roam",
-	"sanctuary",
-	"serious",
-	"shiny",
-	"shook",
-	"sob",
-	"stolen",
-	"tap",
-	"vain",
-	"void",
-	"warrior",
-	"wrinkle",
-	"affection",
-	"apologize",
-	"blossom",
-	"bounce",
-	"bridge",
-	"cheap",
-	"crumble",
-	"decision",
-	"descend",
-	"desperately",
-	"dig",
-	"dot",
-	"flip",
-	"frighten",
-	"heartbeat",
-	"huge",
-	"lazy",
-	"lick",
-	"odd",
-	"opinion",
-	"process",
-	"puzzle",
-	"quietly",
-	"retreat",
-	"score",
-	"sentence",
-	"separate",
-	"situation",
-	"skill",
-	"soak",
-	"square",
-	"stray",
-	"taint",
-	"task",
-	"tide",
-	"underneath",
-	"veil",
-	"whistle",
-	"anywhere",
-	"bedroom",
-	"bid",
-	"bloody",
-	"burden",
-	"careful",
-	"compare",
-	"concern",
-	"curtain",
-	"decay",
-	"defeat",
-	"describe",
-	"double",
-	"dreamer",
-	"driver",
-	"dwell",
-	"evening",
-	"flare",
-	"flicker",
-	"grandma",
-	"guitar",
-	"harm",
-	"horrible",
-	"hungry",
-	"indeed",
-	"lace",
-	"melody",
-	"monkey",
-	"nation",
-	"object",
-	"obviously",
-	"rainbow",
-	"salt",
-	"scratch",
-	"shown",
-	"shy",
-	"stage",
-	"stun",
-	"third",
-	"tickle",
-	"useless",
-	"weakness",
-	"worship",
-	"worthless",
-	"afternoon",
-	"beard",
-	"boyfriend",
-	"bubble",
-	"busy",
-	"certain",
-	"chin",
-	"concrete",
-	"desk",
-	"diamond",
-	"doom",
-	"drawn",
-	"due",
-	"felicity",
-	"freeze",
-	"frost",
-	"garden",
-	"glide",
-	"harmony",
-	"hopefully",
-	"hunt",
-	"jealous",
-	"lightning",
-	"mama",
-	"mercy",
-	"peel",
-	"physical",
-	"position",
-	"pulse",
-	"punch",
-	"quit",
-	"rant",
-	"respond",
-	"salty",
-	"sane",
-	"satisfy",
-	"savior",
-	"sheep",
-	"slept",
-	"social",
-	"sport",
-	"tuck",
-	"utter",
-	"valley",
-	"wolf",
-	"aim",
-	"alas",
-	"alter",
-	"arrow",
-	"awaken",
-	"beaten",
-	"belief",
-	"brand",
-	"ceiling",
-	"cheese",
-	"clue",
-	"confidence",
-	"connection",
-	"daily",
-	"disguise",
-	"eager",
-	"erase",
-	"essence",
-	"everytime",
-	"expression",
-	"fan",
-	"flag",
-	"flirt",
-	"foul",
-	"fur",
-	"giggle",
-	"glorious",
-	"ignorance",
-	"law",
-	"lifeless",
-	"measure",
-	"mighty",
-	"muse",
-	"north",
-	"opposite",
-	"paradise",
-	"patience",
-	"patient",
-	"pencil",
-	"petal",
-	"plate",
-	"ponder",
-	"possibly",
-	"practice",
-	"slice",
-	"spell",
-	"stock",
-	"strife",
-	"strip",
-	"suffocate",
-	"suit",
-	"tender",
-	"tool",
-	"trade",
-	"velvet",
-	"verse",
-	"waist",
-	"witch",
-	"aunt",
-	"bench",
-	"bold",
-	"cap",
-	"certainly",
-	"click",
-	"companion",
-	"creator",
-	"dart",
-	"delicate",
-	"determine",
-	"dish",
-	"dragon",
-	"drama",
-	"drum",
-	"dude",
-	"everybody",
-	"feast",
-	"forehead",
-	"former",
-	"fright",
-	"fully",
-	"gas",
-	"hook",
-	"hurl",
-	"invite",
-	"juice",
-	"manage",
-	"moral",
-	"possess",
-	"raw",
-	"rebel",
-	"royal",
-	"scale",
-	"scary",
-	"several",
-	"slight",
-	"stubborn",
-	"swell",
-	"talent",
-	"tea",
-	"terrible",
-	"thread",
-	"torment",
-	"trickle",
-	"usually",
-	"vast",
-	"violence",
-	"weave",
-	"acid",
-	"agony",
-	"ashamed",
-	"awe",
-	"belly",
-	"blend",
-	"blush",
-	"character",
-	"cheat",
-	"common",
-	"company",
-	"coward",
-	"creak",
-	"danger",
-	"deadly",
-	"defense",
-	"define",
-	"depend",
-	"desperate",
-	"destination",
-	"dew",
-	"duck",
-	"dusty",
-	"embarrass",
-	"engine",
-	"example",
-	"explore",
-	"foe",
-	"freely",
-	"frustrate",
-	"generation",
-	"glove",
-	"guilty",
-	"health",
-	"hurry",
-	"idiot",
-	"impossible",
-	"inhale",
-	"jaw",
-	"kingdom",
-	"mention",
-	"mist",
-	"moan",
-	"mumble",
-	"mutter",
-	"observe",
-	"ode",
-	"pathetic",
-	"pattern",
-	"pie",
-	"prefer",
-	"puff",
-	"rape",
-	"rare",
-	"revenge",
-	"rude",
-	"scrape",
-	"spiral",
-	"squeeze",
-	"strain",
-	"sunset",
-	"suspend",
-	"sympathy",
-	"thigh",
-	"throne",
-	"total",
-	"unseen",
-	"weapon",
-	"weary",
-}
diff --git a/ethutil/mnemonic_test.go b/ethutil/mnemonic_test.go
deleted file mode 100644
index ccf3f9883..000000000
--- a/ethutil/mnemonic_test.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package ethutil
-
-import (
-	"testing"
-)
-
-func TestMnDecode(t *testing.T) {
-	words := []string{
-		"ink",
-		"balance",
-		"gain",
-		"fear",
-		"happen",
-		"melt",
-		"mom",
-		"surface",
-		"stir",
-		"bottle",
-		"unseen",
-		"expression",
-		"important",
-		"curl",
-		"grant",
-		"fairy",
-		"across",
-		"back",
-		"figure",
-		"breast",
-		"nobody",
-		"scratch",
-		"worry",
-		"yesterday",
-	}
-	encode := "c61d43dc5bb7a4e754d111dae8105b6f25356492df5e50ecb33b858d94f8c338"
-	result := MnemonicDecode(words)
-	if encode != result {
-		t.Error("We expected", encode, "got", result, "instead")
-	}
-}
-func TestMnEncode(t *testing.T) {
-	encode := "c61d43dc5bb7a4e754d111dae8105b6f25356492df5e50ecb33b858d94f8c338"
-	result := []string{
-		"ink",
-		"balance",
-		"gain",
-		"fear",
-		"happen",
-		"melt",
-		"mom",
-		"surface",
-		"stir",
-		"bottle",
-		"unseen",
-		"expression",
-		"important",
-		"curl",
-		"grant",
-		"fairy",
-		"across",
-		"back",
-		"figure",
-		"breast",
-		"nobody",
-		"scratch",
-		"worry",
-		"yesterday",
-	}
-	words := MnemonicEncode(encode)
-	for i, word := range words {
-		if word != result[i] {
-			t.Error("Mnenonic does not match:", words, result)
-		}
-	}
-}
diff --git a/ethutil/trie.go b/ethutil/trie.go
deleted file mode 100644
index 56f1648a6..000000000
--- a/ethutil/trie.go
+++ /dev/null
@@ -1,578 +0,0 @@
-package ethutil
-
-import (
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-func (s *Cache) Len() int {
-	return len(s.nodes)
-}
-
-// TODO
-// A StateObject is an object that has a state root
-// This is goig to be the object for the second level caching (the caching of object which have a state such as contracts)
-type StateObject interface {
-	State() *Trie
-	Sync()
-	Undo()
-}
-
-type Node struct {
-	Key   []byte
-	Value *Value
-	Dirty bool
-}
-
-func NewNode(key []byte, val *Value, dirty bool) *Node {
-	return &Node{Key: key, Value: val, Dirty: dirty}
-}
-
-func (n *Node) Copy() *Node {
-	return NewNode(n.Key, n.Value, n.Dirty)
-}
-
-type Cache struct {
-	nodes   map[string]*Node
-	db      Database
-	IsDirty bool
-}
-
-func NewCache(db Database) *Cache {
-	return &Cache{db: db, nodes: make(map[string]*Node)}
-}
-
-func (cache *Cache) PutValue(v interface{}, force bool) interface{} {
-	value := NewValue(v)
-
-	enc := value.Encode()
-	if len(enc) >= 32 || force {
-		sha := Sha3Bin(enc)
-
-		cache.nodes[string(sha)] = NewNode(sha, value, true)
-		cache.IsDirty = true
-
-		return sha
-	}
-
-	return v
-}
-
-func (cache *Cache) Put(v interface{}) interface{} {
-	return cache.PutValue(v, false)
-}
-
-func (cache *Cache) Get(key []byte) *Value {
-	// First check if the key is the cache
-	if cache.nodes[string(key)] != nil {
-		return cache.nodes[string(key)].Value
-	}
-
-	// Get the key of the database instead and cache it
-	data, _ := cache.db.Get(key)
-	// Create the cached value
-	value := NewValueFromBytes(data)
-	// Create caching node
-	cache.nodes[string(key)] = NewNode(key, value, false)
-
-	return value
-}
-
-func (cache *Cache) Delete(key []byte) {
-	delete(cache.nodes, string(key))
-
-	cache.db.Delete(key)
-}
-
-func (cache *Cache) Commit() {
-	// Don't try to commit if it isn't dirty
-	if !cache.IsDirty {
-		return
-	}
-
-	for key, node := range cache.nodes {
-		if node.Dirty {
-			cache.db.Put([]byte(key), node.Value.Encode())
-			node.Dirty = false
-		}
-	}
-	cache.IsDirty = false
-
-	// If the nodes grows beyond the 200 entries we simple empty it
-	// FIXME come up with something better
-	if len(cache.nodes) > 200 {
-		cache.nodes = make(map[string]*Node)
-	}
-}
-
-func (cache *Cache) Undo() {
-	for key, node := range cache.nodes {
-		if node.Dirty {
-			delete(cache.nodes, key)
-		}
-	}
-	cache.IsDirty = false
-}
-
-// A (modified) Radix Trie implementation. The Trie implements
-// a caching mechanism and will used cached values if they are
-// present. If a node is not present in the cache it will try to
-// fetch it from the database and store the cached value.
-// Please note that the data isn't persisted unless `Sync` is
-// explicitly called.
-type Trie struct {
-	mut      sync.RWMutex
-	prevRoot interface{}
-	Root     interface{}
-	//db   Database
-	cache *Cache
-}
-
-func copyRoot(root interface{}) interface{} {
-	var prevRootCopy interface{}
-	if b, ok := root.([]byte); ok {
-		prevRootCopy = CopyBytes(b)
-	} else {
-		prevRootCopy = root
-	}
-
-	return prevRootCopy
-}
-
-func NewTrie(db Database, Root interface{}) *Trie {
-	// Make absolute sure the root is copied
-	r := copyRoot(Root)
-	p := copyRoot(Root)
-
-	return &Trie{cache: NewCache(db), Root: r, prevRoot: p}
-}
-
-// Save the cached value to the database.
-func (t *Trie) Sync() {
-	t.cache.Commit()
-	t.prevRoot = copyRoot(t.Root)
-}
-
-func (t *Trie) Undo() {
-	t.cache.Undo()
-	t.Root = t.prevRoot
-}
-
-func (t *Trie) Cache() *Cache {
-	return t.cache
-}
-
-/*
- * Public (query) interface functions
- */
-func (t *Trie) Update(key string, value string) {
-	t.mut.Lock()
-	defer t.mut.Unlock()
-
-	k := CompactHexDecode(key)
-
-	root := t.UpdateState(t.Root, k, value)
-	switch root.(type) {
-	case string:
-		t.Root = root
-	case []byte:
-		t.Root = root
-	default:
-		t.Root = t.cache.PutValue(root, true)
-	}
-}
-
-func (t *Trie) Get(key string) string {
-	t.mut.RLock()
-	defer t.mut.RUnlock()
-
-	k := CompactHexDecode(key)
-	c := NewValue(t.GetState(t.Root, k))
-
-	return c.Str()
-}
-
-func (t *Trie) Delete(key string) {
-	t.mut.Lock()
-	defer t.mut.Unlock()
-
-	k := CompactHexDecode(key)
-
-	root := t.DeleteState(t.Root, k)
-	switch root.(type) {
-	case string:
-		t.Root = root
-	case []byte:
-		t.Root = root
-	default:
-		t.Root = t.cache.PutValue(root, true)
-	}
-}
-
-func (t *Trie) GetState(node interface{}, key []int) interface{} {
-	n := NewValue(node)
-	// Return the node if key is empty (= found)
-	if len(key) == 0 || n.IsNil() || n.Len() == 0 {
-		return node
-	}
-
-	currentNode := t.GetNode(node)
-	length := currentNode.Len()
-
-	if length == 0 {
-		return ""
-	} else if length == 2 {
-		// Decode the key
-		k := CompactDecode(currentNode.Get(0).Str())
-		v := currentNode.Get(1).Raw()
-
-		if len(key) >= len(k) && CompareIntSlice(k, key[:len(k)]) {
-			return t.GetState(v, key[len(k):])
-		} else {
-			return ""
-		}
-	} else if length == 17 {
-		return t.GetState(currentNode.Get(key[0]).Raw(), key[1:])
-	}
-
-	// It shouldn't come this far
-	fmt.Println("GetState unexpected return")
-	return ""
-}
-
-func (t *Trie) GetNode(node interface{}) *Value {
-	n := NewValue(node)
-
-	if !n.Get(0).IsNil() {
-		return n
-	}
-
-	str := n.Str()
-	if len(str) == 0 {
-		return n
-	} else if len(str) < 32 {
-		return NewValueFromBytes([]byte(str))
-	}
-
-	return t.cache.Get(n.Bytes())
-}
-
-func (t *Trie) UpdateState(node interface{}, key []int, value string) interface{} {
-	return t.InsertState(node, key, value)
-}
-
-func (t *Trie) Put(node interface{}) interface{} {
-	/*
-		TODO?
-			c := Conv(t.Root)
-			fmt.Println(c.Type(), c.Length())
-			if c.Type() == reflect.String && c.AsString() == "" {
-				return enc
-			}
-	*/
-
-	return t.cache.Put(node)
-
-}
-
-func EmptyStringSlice(l int) []interface{} {
-	slice := make([]interface{}, l)
-	for i := 0; i < l; i++ {
-		slice[i] = ""
-	}
-	return slice
-}
-
-func (t *Trie) InsertState(node interface{}, key []int, value interface{}) interface{} {
-	if len(key) == 0 {
-		return value
-	}
-
-	// New node
-	n := NewValue(node)
-	if node == nil || (n.Type() == reflect.String && (n.Str() == "" || n.Get(0).IsNil())) || n.Len() == 0 {
-		newNode := []interface{}{CompactEncode(key), value}
-
-		return t.Put(newNode)
-	}
-
-	currentNode := t.GetNode(node)
-	// Check for "special" 2 slice type node
-	if currentNode.Len() == 2 {
-		// Decode the key
-
-		k := CompactDecode(currentNode.Get(0).Str())
-		v := currentNode.Get(1).Raw()
-
-		// Matching key pair (ie. there's already an object with this key)
-		if CompareIntSlice(k, key) {
-			newNode := []interface{}{CompactEncode(key), value}
-			return t.Put(newNode)
-		}
-
-		var newHash interface{}
-		matchingLength := MatchingNibbleLength(key, k)
-		if matchingLength == len(k) {
-			// Insert the hash, creating a new node
-			newHash = t.InsertState(v, key[matchingLength:], value)
-		} else {
-			// Expand the 2 length slice to a 17 length slice
-			oldNode := t.InsertState("", k[matchingLength+1:], v)
-			newNode := t.InsertState("", key[matchingLength+1:], value)
-			// Create an expanded slice
-			scaledSlice := EmptyStringSlice(17)
-			// Set the copied and new node
-			scaledSlice[k[matchingLength]] = oldNode
-			scaledSlice[key[matchingLength]] = newNode
-
-			newHash = t.Put(scaledSlice)
-		}
-
-		if matchingLength == 0 {
-			// End of the chain, return
-			return newHash
-		} else {
-			newNode := []interface{}{CompactEncode(key[:matchingLength]), newHash}
-			return t.Put(newNode)
-		}
-	} else {
-
-		// Copy the current node over to the new node and replace the first nibble in the key
-		newNode := EmptyStringSlice(17)
-
-		for i := 0; i < 17; i++ {
-			cpy := currentNode.Get(i).Raw()
-			if cpy != nil {
-				newNode[i] = cpy
-			}
-		}
-
-		newNode[key[0]] = t.InsertState(currentNode.Get(key[0]).Raw(), key[1:], value)
-
-		return t.Put(newNode)
-	}
-
-	return ""
-}
-
-func (t *Trie) DeleteState(node interface{}, key []int) interface{} {
-	if len(key) == 0 {
-		return ""
-	}
-
-	// New node
-	n := NewValue(node)
-	if node == nil || (n.Type() == reflect.String && (n.Str() == "" || n.Get(0).IsNil())) || n.Len() == 0 {
-		return ""
-	}
-
-	currentNode := t.GetNode(node)
-	// Check for "special" 2 slice type node
-	if currentNode.Len() == 2 {
-		// Decode the key
-		k := CompactDecode(currentNode.Get(0).Str())
-		v := currentNode.Get(1).Raw()
-
-		// Matching key pair (ie. there's already an object with this key)
-		if CompareIntSlice(k, key) {
-			return ""
-		} else if CompareIntSlice(key[:len(k)], k) {
-			hash := t.DeleteState(v, key[len(k):])
-			child := t.GetNode(hash)
-
-			var newNode []interface{}
-			if child.Len() == 2 {
-				newKey := append(k, CompactDecode(child.Get(0).Str())...)
-				newNode = []interface{}{CompactEncode(newKey), child.Get(1).Raw()}
-			} else {
-				newNode = []interface{}{currentNode.Get(0).Str(), hash}
-			}
-
-			return t.Put(newNode)
-		} else {
-			return node
-		}
-	} else {
-		// Copy the current node over to the new node and replace the first nibble in the key
-		n := EmptyStringSlice(17)
-		var newNode []interface{}
-
-		for i := 0; i < 17; i++ {
-			cpy := currentNode.Get(i).Raw()
-			if cpy != nil {
-				n[i] = cpy
-			}
-		}
-
-		n[key[0]] = t.DeleteState(n[key[0]], key[1:])
-		amount := -1
-		for i := 0; i < 17; i++ {
-			if n[i] != "" {
-				if amount == -1 {
-					amount = i
-				} else {
-					amount = -2
-				}
-			}
-		}
-		if amount == 16 {
-			newNode = []interface{}{CompactEncode([]int{16}), n[amount]}
-		} else if amount >= 0 {
-			child := t.GetNode(n[amount])
-			if child.Len() == 17 {
-				newNode = []interface{}{CompactEncode([]int{amount}), n[amount]}
-			} else if child.Len() == 2 {
-				key := append([]int{amount}, CompactDecode(child.Get(0).Str())...)
-				newNode = []interface{}{CompactEncode(key), child.Get(1).Str()}
-			}
-
-		} else {
-			newNode = n
-		}
-
-		return t.Put(newNode)
-	}
-
-	return ""
-}
-
-// Simple compare function which creates a rlp value out of the evaluated objects
-func (t *Trie) Cmp(trie *Trie) bool {
-	return NewValue(t.Root).Cmp(NewValue(trie.Root))
-}
-
-// Returns a copy of this trie
-func (t *Trie) Copy() *Trie {
-	trie := NewTrie(t.cache.db, t.Root)
-	for key, node := range t.cache.nodes {
-		trie.cache.nodes[key] = node.Copy()
-	}
-
-	return trie
-}
-
-type TrieIterator struct {
-	trie  *Trie
-	key   string
-	value string
-
-	shas   [][]byte
-	values []string
-
-	lastNode []byte
-}
-
-func (t *Trie) NewIterator() *TrieIterator {
-	return &TrieIterator{trie: t}
-}
-
-// Some time in the near future this will need refactoring :-)
-// XXX Note to self, IsSlice == inline node. Str == sha3 to node
-func (it *TrieIterator) workNode(currentNode *Value) {
-	if currentNode.Len() == 2 {
-		k := CompactDecode(currentNode.Get(0).Str())
-
-		if currentNode.Get(1).Str() == "" {
-			it.workNode(currentNode.Get(1))
-		} else {
-			if k[len(k)-1] == 16 {
-				it.values = append(it.values, currentNode.Get(1).Str())
-			} else {
-				it.shas = append(it.shas, currentNode.Get(1).Bytes())
-				it.getNode(currentNode.Get(1).Bytes())
-			}
-		}
-	} else {
-		for i := 0; i < currentNode.Len(); i++ {
-			if i == 16 && currentNode.Get(i).Len() != 0 {
-				it.values = append(it.values, currentNode.Get(i).Str())
-			} else {
-				if currentNode.Get(i).Str() == "" {
-					it.workNode(currentNode.Get(i))
-				} else {
-					val := currentNode.Get(i).Str()
-					if val != "" {
-						it.shas = append(it.shas, currentNode.Get(1).Bytes())
-						it.getNode([]byte(val))
-					}
-				}
-			}
-		}
-	}
-}
-
-func (it *TrieIterator) getNode(node []byte) {
-	currentNode := it.trie.cache.Get(node)
-	it.workNode(currentNode)
-}
-
-func (it *TrieIterator) Collect() [][]byte {
-	if it.trie.Root == "" {
-		return nil
-	}
-
-	it.getNode(NewValue(it.trie.Root).Bytes())
-
-	return it.shas
-}
-
-func (it *TrieIterator) Purge() int {
-	shas := it.Collect()
-	for _, sha := range shas {
-		it.trie.cache.Delete(sha)
-	}
-	return len(it.values)
-}
-
-func (it *TrieIterator) Key() string {
-	return ""
-}
-
-func (it *TrieIterator) Value() string {
-	return ""
-}
-
-type EachCallback func(key string, node *Value)
-
-func (it *TrieIterator) Each(cb EachCallback) {
-	it.fetchNode(nil, NewValue(it.trie.Root).Bytes(), cb)
-}
-
-func (it *TrieIterator) fetchNode(key []int, node []byte, cb EachCallback) {
-	it.iterateNode(key, it.trie.cache.Get(node), cb)
-}
-
-func (it *TrieIterator) iterateNode(key []int, currentNode *Value, cb EachCallback) {
-	if currentNode.Len() == 2 {
-		k := CompactDecode(currentNode.Get(0).Str())
-
-		pk := append(key, k...)
-		if currentNode.Get(1).Len() != 0 && currentNode.Get(1).Str() == "" {
-			it.iterateNode(pk, currentNode.Get(1), cb)
-		} else {
-
-			if k[len(k)-1] == 16 {
-				cb(DecodeCompact(pk), currentNode.Get(1))
-			} else {
-				it.fetchNode(pk, currentNode.Get(1).Bytes(), cb)
-			}
-		}
-	} else {
-		for i := 0; i < currentNode.Len(); i++ {
-			pk := append(key, i)
-			if i == 16 && currentNode.Get(i).Len() != 0 {
-				cb(DecodeCompact(pk), currentNode.Get(i))
-			} else {
-				if currentNode.Get(i).Len() != 0 && currentNode.Get(i).Str() == "" {
-					it.iterateNode(pk, currentNode.Get(i), cb)
-				} else {
-					val := currentNode.Get(i).Str()
-					if val != "" {
-						it.fetchNode(pk, []byte(val), cb)
-					}
-				}
-			}
-		}
-	}
-}
diff --git a/ethutil/trie_test.go b/ethutil/trie_test.go
deleted file mode 100644
index 01207dbc3..000000000
--- a/ethutil/trie_test.go
+++ /dev/null
@@ -1,331 +0,0 @@
-package ethutil
-
-import (
-	"bytes"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"net/http"
-	"reflect"
-	"testing"
-	"time"
-)
-
-const LONG_WORD = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ"
-
-type MemDatabase struct {
-	db map[string][]byte
-}
-
-func NewMemDatabase() (*MemDatabase, error) {
-	db := &MemDatabase{db: make(map[string][]byte)}
-	return db, nil
-}
-func (db *MemDatabase) Put(key []byte, value []byte) {
-	db.db[string(key)] = value
-}
-func (db *MemDatabase) Get(key []byte) ([]byte, error) {
-	return db.db[string(key)], nil
-}
-func (db *MemDatabase) Delete(key []byte) error {
-	delete(db.db, string(key))
-	return nil
-}
-func (db *MemDatabase) Print()              {}
-func (db *MemDatabase) Close()              {}
-func (db *MemDatabase) LastKnownTD() []byte { return nil }
-
-func New() (*MemDatabase, *Trie) {
-	db, _ := NewMemDatabase()
-	return db, NewTrie(db, "")
-}
-
-func TestTrieSync(t *testing.T) {
-	db, trie := New()
-
-	trie.Update("dog", LONG_WORD)
-	if len(db.db) != 0 {
-		t.Error("Expected no data in database")
-	}
-
-	trie.Sync()
-	if len(db.db) == 0 {
-		t.Error("Expected data to be persisted")
-	}
-}
-
-func TestTrieDirtyTracking(t *testing.T) {
-	_, trie := New()
-	trie.Update("dog", LONG_WORD)
-	if !trie.cache.IsDirty {
-		t.Error("Expected trie to be dirty")
-	}
-
-	trie.Sync()
-	if trie.cache.IsDirty {
-		t.Error("Expected trie not to be dirty")
-	}
-
-	trie.Update("test", LONG_WORD)
-	trie.cache.Undo()
-	if trie.cache.IsDirty {
-		t.Error("Expected trie not to be dirty")
-	}
-
-}
-
-func TestTrieReset(t *testing.T) {
-	_, trie := New()
-
-	trie.Update("cat", LONG_WORD)
-	if len(trie.cache.nodes) == 0 {
-		t.Error("Expected cached nodes")
-	}
-
-	trie.cache.Undo()
-
-	if len(trie.cache.nodes) != 0 {
-		t.Error("Expected no nodes after undo")
-	}
-}
-
-func TestTrieGet(t *testing.T) {
-	_, trie := New()
-
-	trie.Update("cat", LONG_WORD)
-	x := trie.Get("cat")
-	if x != LONG_WORD {
-		t.Error("expected %s, got %s", LONG_WORD, x)
-	}
-}
-
-func TestTrieUpdating(t *testing.T) {
-	_, trie := New()
-	trie.Update("cat", LONG_WORD)
-	trie.Update("cat", LONG_WORD+"1")
-	x := trie.Get("cat")
-	if x != LONG_WORD+"1" {
-		t.Error("expected %S, got %s", LONG_WORD+"1", x)
-	}
-}
-
-func TestTrieCmp(t *testing.T) {
-	_, trie1 := New()
-	_, trie2 := New()
-
-	trie1.Update("doge", LONG_WORD)
-	trie2.Update("doge", LONG_WORD)
-	if !trie1.Cmp(trie2) {
-		t.Error("Expected tries to be equal")
-	}
-
-	trie1.Update("dog", LONG_WORD)
-	trie2.Update("cat", LONG_WORD)
-	if trie1.Cmp(trie2) {
-		t.Errorf("Expected tries not to be equal %x %x", trie1.Root, trie2.Root)
-	}
-}
-
-func TestTrieDelete(t *testing.T) {
-	_, trie := New()
-	trie.Update("cat", LONG_WORD)
-	exp := trie.Root
-	trie.Update("dog", LONG_WORD)
-	trie.Delete("dog")
-	if !reflect.DeepEqual(exp, trie.Root) {
-		t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
-	}
-
-	trie.Update("dog", LONG_WORD)
-	exp = trie.Root
-	trie.Update("dude", LONG_WORD)
-	trie.Delete("dude")
-	if !reflect.DeepEqual(exp, trie.Root) {
-		t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
-	}
-}
-
-func TestTrieDeleteWithValue(t *testing.T) {
-	_, trie := New()
-	trie.Update("c", LONG_WORD)
-	exp := trie.Root
-	trie.Update("ca", LONG_WORD)
-	trie.Update("cat", LONG_WORD)
-	trie.Delete("ca")
-	trie.Delete("cat")
-	if !reflect.DeepEqual(exp, trie.Root) {
-		t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
-	}
-
-}
-
-func TestTriePurge(t *testing.T) {
-	_, trie := New()
-	trie.Update("c", LONG_WORD)
-	trie.Update("ca", LONG_WORD)
-	trie.Update("cat", LONG_WORD)
-
-	lenBefore := len(trie.cache.nodes)
-	it := trie.NewIterator()
-	if num := it.Purge(); num != 3 {
-		t.Errorf("Expected purge to return 3, got %d", num)
-	}
-
-	if lenBefore == len(trie.cache.nodes) {
-		t.Errorf("Expected cached nodes to be deleted")
-	}
-}
-
-func h(str string) string {
-	d, err := hex.DecodeString(str)
-	if err != nil {
-		panic(err)
-	}
-
-	return string(d)
-}
-
-func get(in string) (out string) {
-	if len(in) > 2 && in[:2] == "0x" {
-		out = h(in[2:])
-	} else {
-		out = in
-	}
-
-	return
-}
-
-type Test struct {
-	Name string
-	In   map[string]string
-	Root string
-}
-
-func CreateTest(name string, data []byte) (Test, error) {
-	t := Test{Name: name}
-	err := json.Unmarshal(data, &t)
-	if err != nil {
-		return Test{}, fmt.Errorf("%v", err)
-	}
-
-	return t, nil
-}
-
-func CreateTests(uri string, cb func(Test)) map[string]Test {
-	resp, err := http.Get(uri)
-	if err != nil {
-		panic(err)
-	}
-	defer resp.Body.Close()
-
-	data, err := ioutil.ReadAll(resp.Body)
-
-	var objmap map[string]*json.RawMessage
-	err = json.Unmarshal(data, &objmap)
-	if err != nil {
-		panic(err)
-	}
-
-	tests := make(map[string]Test)
-	for name, testData := range objmap {
-		test, err := CreateTest(name, *testData)
-		if err != nil {
-			panic(err)
-		}
-
-		if cb != nil {
-			cb(test)
-		}
-		tests[name] = test
-	}
-
-	return tests
-}
-
-func TestRemote(t *testing.T) {
-	CreateTests("https://raw.githubusercontent.com/ethereum/tests/develop/trietest.json", func(test Test) {
-		_, trie := New()
-		for key, value := range test.In {
-			trie.Update(get(key), get(value))
-		}
-
-		a := NewValue(h(test.Root)).Bytes()
-		b := NewValue(trie.Root).Bytes()
-		if bytes.Compare(a, b) != 0 {
-			t.Errorf("%-10s: %x %x", test.Name, a, b)
-		}
-	})
-}
-
-func TestTrieReplay(t *testing.T) {
-	CreateTests("https://raw.githubusercontent.com/ethereum/tests/develop/trietest.json", func(test Test) {
-		_, trie := New()
-		for key, value := range test.In {
-			trie.Update(get(key), get(value))
-		}
-
-		_, trie2 := New()
-		trie.NewIterator().Each(func(key string, v *Value) {
-			trie2.Update(key, v.Str())
-		})
-
-		a := NewValue(trie.Root).Bytes()
-		b := NewValue(trie2.Root).Bytes()
-		if bytes.Compare(a, b) != 0 {
-			t.Errorf("%s %x %x\n", test.Name, trie.Root, trie2.Root)
-		}
-	})
-}
-
-func RandomData() [][]string {
-	data := [][]string{
-		{"0x000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1", "0x4e616d6552656700000000000000000000000000000000000000000000000000"},
-		{"0x0000000000000000000000000000000000000000000000000000000000000045", "0x22b224a1420a802ab51d326e29fa98e34c4f24ea"},
-		{"0x0000000000000000000000000000000000000000000000000000000000000046", "0x67706c2076330000000000000000000000000000000000000000000000000000"},
-		{"0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6", "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000"},
-		{"0x0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2", "0x4655474156000000000000000000000000000000000000000000000000000000"},
-		{"0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000", "0x697c7b8c961b56f675d570498424ac8de1a918f6"},
-		{"0x4655474156000000000000000000000000000000000000000000000000000000", "0x7ef9e639e2733cb34e4dfc576d4b23f72db776b2"},
-		{"0x4e616d6552656700000000000000000000000000000000000000000000000000", "0xec4f34c97e43fbb2816cfd95e388353c7181dab1"},
-	}
-
-	var c [][]string
-	for len(data) != 0 {
-		e := rand.Intn(len(data))
-		c = append(c, data[e])
-
-		copy(data[e:], data[e+1:])
-		data[len(data)-1] = nil
-		data = data[:len(data)-1]
-	}
-
-	return c
-}
-
-const MaxTest = 1000
-
-// This test insert data in random order and seeks to find indifferences between the different tries
-func TestRegression(t *testing.T) {
-	rand.Seed(time.Now().Unix())
-
-	roots := make(map[string]int)
-	for i := 0; i < MaxTest; i++ {
-		_, trie := New()
-		data := RandomData()
-
-		for _, test := range data {
-			trie.Update(test[0], test[1])
-		}
-		trie.Delete("0x4e616d6552656700000000000000000000000000000000000000000000000000")
-
-		roots[string(trie.Root.([]byte))] += 1
-	}
-
-	if len(roots) > 1 {
-		for root, num := range roots {
-			t.Errorf("%x => %d\n", root, num)
-		}
-	}
-}