Merge branch 'release/0.6.5'

10 files changed, 172 insertions, 14 deletions

diff --git a/ethutil/bytes.go b/ethutil/bytes.go
index e38f89454..f151d16ee 100644
--- a/ethutil/bytes.go
+++ b/ethutil/bytes.go
@@ -9,6 +9,22 @@ import (
 	"strings"
 )
 
+type Bytes []byte
+
+func (self Bytes) String() string {
+	return string(self)
+}
+
+func DeleteFromByteSlice(s [][]byte, hash []byte) [][]byte {
+	for i, h := range s {
+		if bytes.Compare(h, hash) == 0 {
+			return append(s[:i], s[i+1:]...)
+		}
+	}
+
+	return s
+}
+
 // Number to bytes
 //
 // Returns the number in bytes with the specified base
diff --git a/ethutil/list.go b/ethutil/list.go
new file mode 100644
index 000000000..9db96cf18
--- /dev/null
+++ b/ethutil/list.go
@@ -0,0 +1,61 @@
+package ethutil
+
+import (
+	"encoding/json"
+	"reflect"
+)
+
+// The list type is an anonymous slice handler which can be used
+// for containing any slice type to use in an environment which
+// does not support slice types (e.g., JavaScript, QML)
+type List struct {
+	list   reflect.Value
+	Length int
+}
+
+// Initialise a new list. Panics if non-slice type is given.
+func NewList(t interface{}) *List {
+	list := reflect.ValueOf(t)
+	if list.Kind() != reflect.Slice {
+		panic("list container initialized with a non-slice type")
+	}
+
+	return &List{list, list.Len()}
+}
+
+func EmptyList() *List {
+	return NewList([]interface{}{})
+}
+
+// Get N element from the embedded slice. Returns nil if OOB.
+func (self *List) Get(i int) interface{} {
+	if self.list.Len() > i {
+		return self.list.Index(i).Interface()
+	}
+
+	return nil
+}
+
+// Appends value at the end of the slice. Panics when incompatible value
+// is given.
+func (self *List) Append(v interface{}) {
+	self.list = reflect.Append(self.list, reflect.ValueOf(v))
+	self.Length = self.list.Len()
+}
+
+// Returns the underlying slice as interface.
+func (self *List) Interface() interface{} {
+	return self.list.Interface()
+}
+
+// For JavaScript <3
+func (self *List) ToJSON() string {
+	var list []interface{}
+	for i := 0; i < self.Length; i++ {
+		list = append(list, self.Get(i))
+	}
+
+	data, _ := json.Marshal(list)
+
+	return string(data)
+}
diff --git a/ethutil/path.go b/ethutil/path.go
index 27022bcfa..cfbc38950 100644
--- a/ethutil/path.go
+++ b/ethutil/path.go
@@ -45,7 +45,7 @@ func ReadAllFile(filePath string) (string, error) {
 }
 
 func WriteFile(filePath string, content []byte) error {
-	fh, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, os.ModePerm)
+	fh, err := os.OpenFile(filePath, os.O_TRUNC|os.O_RDWR|os.O_CREATE, os.ModePerm)
 	if err != nil {
 		return err
 	}
diff --git a/ethutil/rlp.go b/ethutil/rlp.go
index 17ff627eb..55406133b 100644
--- a/ethutil/rlp.go
+++ b/ethutil/rlp.go
@@ -15,6 +15,10 @@ type RlpEncodeDecode interface {
 	RlpValue() []interface{}
 }
 
+func Rlp(encoder RlpEncode) []byte {
+	return encoder.RlpEncode()
+}
+
 type RlpEncoder struct {
 	rlpData []byte
 }
@@ -124,6 +128,8 @@ func Encode(object interface{}) []byte {
 			} else {
 				buff.Write(Encode(t.Bytes()))
 			}
+		case Bytes:
+			buff.Write(Encode([]byte(t)))
 		case []byte:
 			if len(t) == 1 && t[0] <= 0x7f {
 				buff.Write(t)
diff --git a/ethutil/script.go b/ethutil/script.go
index b796e7c1e..bd087e7e0 100644
--- a/ethutil/script.go
+++ b/ethutil/script.go
@@ -2,9 +2,11 @@ package ethutil
 
 import (
 	"fmt"
+	"strings"
+
 	"github.com/obscuren/mutan"
 	"github.com/obscuren/mutan/backends"
-	"strings"
+	"github.com/obscuren/serpent-go"
 )
 
 // General compile function
@@ -14,15 +16,13 @@ func Compile(script string, silent bool) (ret []byte, err error) {
 
 		if len(line) > 1 && line[0:2] == "#!" {
 			switch line {
-			/*
-				case "#!serpent":
-					byteCode, err := serpent.Compile(script)
-					if err != nil {
-						return nil, err
-					}
+			case "#!serpent":
+				byteCode, err := serpent.Compile(script)
+				if err != nil {
+					return nil, err
+				}
 
-					return byteCode, nil
-			*/
+				return byteCode, nil
 			}
 		} else {
 
diff --git a/ethutil/set.go b/ethutil/set.go
new file mode 100644
index 000000000..7955edac0
--- /dev/null
+++ b/ethutil/set.go
@@ -0,0 +1,36 @@
+package ethutil
+
+type Settable interface {
+	AsSet() UniqueSet
+}
+
+type Stringable interface {
+	String() string
+}
+
+type UniqueSet map[string]struct{}
+
+func NewSet(v ...Stringable) UniqueSet {
+	set := make(UniqueSet)
+	for _, val := range v {
+		set.Insert(val)
+	}
+
+	return set
+}
+
+func (self UniqueSet) Insert(k Stringable) UniqueSet {
+	self[k.String()] = struct{}{}
+
+	return self
+}
+
+func (self UniqueSet) Include(k Stringable) bool {
+	_, ok := self[k.String()]
+
+	return ok
+}
+
+func Set(s Settable) UniqueSet {
+	return s.AsSet()
+}
diff --git a/ethutil/size.go b/ethutil/size.go
new file mode 100644
index 000000000..b4426465e
--- /dev/null
+++ b/ethutil/size.go
@@ -0,0 +1,15 @@
+package ethutil
+
+import "fmt"
+
+type StorageSize float64
+
+func (self StorageSize) String() string {
+	if self > 1000000 {
+		return fmt.Sprintf("%.2f mB", self/1000000)
+	} else if self > 1000 {
+		return fmt.Sprintf("%.2f kB", self/1000)
+	} else {
+		return fmt.Sprintf("%.2f B", self)
+	}
+}
diff --git a/ethutil/size_test.go b/ethutil/size_test.go
new file mode 100644
index 000000000..82aa1c653
--- /dev/null
+++ b/ethutil/size_test.go
@@ -0,0 +1,12 @@
+package ethutil
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSize(t *testing.T) {
+	fmt.Println(StorageSize(2381273))
+	fmt.Println(StorageSize(2192))
+	fmt.Println(StorageSize(12))
+}
diff --git a/ethutil/value.go b/ethutil/value.go
index 608d332ba..b1f887f29 100644
--- a/ethutil/value.go
+++ b/ethutil/value.go
@@ -1,9 +1,11 @@
 package ethutil
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"reflect"
+	"strconv"
 )
 
 // Data values are returned by the rlp decoder. The data values represents
@@ -93,6 +95,9 @@ func (val *Value) Int() int64 {
 		return new(big.Int).SetBytes(Val).Int64()
 	} else if Val, ok := val.Val.(*big.Int); ok {
 		return Val.Int64()
+	} else if Val, ok := val.Val.(string); ok {
+		n, _ := strconv.Atoi(Val)
+		return int64(n)
 	}
 
 	return 0
@@ -113,6 +118,8 @@ func (val *Value) BigInt() *big.Int {
 		return b
 	} else if a, ok := val.Val.(*big.Int); ok {
 		return a
+	} else if a, ok := val.Val.(string); ok {
+		return Big(a)
 	} else {
 		return big.NewInt(int64(val.Uint()))
 	}
@@ -141,6 +148,8 @@ func (val *Value) Bytes() []byte {
 		return []byte(s)
 	} else if s, ok := val.Val.(*big.Int); ok {
 		return s.Bytes()
+	} else {
+		return big.NewInt(val.Int()).Bytes()
 	}
 
 	return []byte{}
@@ -244,10 +253,7 @@ func (val *Value) Cmp(o *Value) bool {
 }
 
 func (self *Value) DeepCmp(o *Value) bool {
-	a := NewValue(self.BigInt())
-	b := NewValue(o.BigInt())
-
-	return a.Cmp(b)
+	return bytes.Compare(self.Bytes(), o.Bytes()) == 0
 }
 
 func (val *Value) Encode() []byte {
diff --git a/ethutil/value_test.go b/ethutil/value_test.go
index 710cbd887..5452a0790 100644
--- a/ethutil/value_test.go
+++ b/ethutil/value_test.go
@@ -2,6 +2,7 @@ package ethutil
 
 import (
 	"bytes"
+	"fmt"
 	"math/big"
 	"testing"
 )
@@ -78,3 +79,8 @@ func TestMath(t *testing.T) {
 		t.Error("Expected 0, got", a)
 	}
 }
+
+func TestString(t *testing.T) {
+	a := NewValue("10")
+	fmt.Println("VALUE WITH STRING:", a.Int())
+}