Merge branch 'qt5.4' of github.com:ethereum/go-ethereum into qt5.4

10 years ago · 1cfea1113a
parent 726852e3d3 6488a392a3
commit 1cfea1113a
72 changed files with 1736 additions and 3144 deletions
--- a/6
+++ b/6
@ -13,9 +13,9 @@ RUN apt-get update && apt-get upgrade -y
 RUN apt-get install -y git mercurial build-essential software-properties-common pkg-config libgmp3-dev libreadline6-dev libpcre3-dev libpcre++-dev

 ## Build and install Go
-RUN git clone https://go.googlesource.com/go
-RUN cd go && git checkout go1.4.1
-RUN cd go/src && ./all.bash && go version
+RUN git clone https://go.googlesource.com/go golang
+RUN cd golang && git checkout go1.4.1
+RUN cd golang/src && ./all.bash && go version

 ## Install GUI dependencies
 RUN add-apt-repository ppa:ubuntu-sdk-team/ppa -y
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -0,0 +1,155 @@
+package abi
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// Callable method given a `Name` and whether the method is a constant.
+// If the method is `Const` no transaction needs to be created for this
+// particular Method call. It can easily be simulated using a local VM.
+// For example a `Balance()` method only needs to retrieve something
+// from the storage and therefor requires no Tx to be send to the
+// network. A method such as `Transact` does require a Tx and thus will
+// be flagged `true`.
+// Input specifies the required input parameters for this gives method.
+type Method struct {
+	Name   string
+	Const  bool
+	Input  []Argument
+	Return Type // not yet implemented
+}
+
+// Returns the methods string signature according to the ABI spec.
+//
+// Example
+//
+//     function foo(uint32 a, int b)    =    "foo(uint32,int256)"
+//
+// Please note that "int" is substitute for its canonical representation "int256"
+func (m Method) String() (out string) {
+	out += m.Name
+	types := make([]string, len(m.Input))
+	i := 0
+	for _, input := range m.Input {
+		types[i] = input.Type.String()
+		i++
+	}
+	out += "(" + strings.Join(types, ",") + ")"
+
+	return
+}
+
+func (m Method) Id() []byte {
+	return crypto.Sha3([]byte(m.String()))[:4]
+}
+
+// Argument holds the name of the argument and the corresponding type.
+// Types are used when packing and testing arguments.
+type Argument struct {
+	Name string
+	Type Type
+}
+
+func (a *Argument) UnmarshalJSON(data []byte) error {
+	var extarg struct {
+		Name string
+		Type string
+	}
+	err := json.Unmarshal(data, &extarg)
+	if err != nil {
+		return fmt.Errorf("argument json err: %v", err)
+	}
+
+	a.Type, err = NewType(extarg.Type)
+	if err != nil {
+		return err
+	}
+	a.Name = extarg.Name
+
+	return nil
+}
+
+// The ABI holds information about a contract's context and available
+// invokable methods. It will allow you to type check function calls and
+// packs data accordingly.
+type ABI struct {
+	Methods map[string]Method
+}
+
+// tests, tests whether the given input would result in a successful
+// call. Checks argument list count and matches input to `input`.
+func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) {
+	method := abi.Methods[name]
+
+	var ret []byte
+	for i, a := range args {
+		input := method.Input[i]
+
+		packed, err := input.Type.pack(a)
+		if err != nil {
+			return nil, fmt.Errorf("`%s` %v", name, err)
+		}
+		ret = append(ret, packed...)
+
+	}
+
+	return ret, nil
+}
+
+// Pack the given method name to conform the ABI. Method call's data
+// will consist of method_id, args0, arg1, ... argN. Method id consists
+// of 4 bytes and arguments are all 32 bytes.
+// Method ids are created from the first 4 bytes of the hash of the
+// methods string signature. (signature = baz(uint32,string32))
+func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
+	method, exist := abi.Methods[name]
+	if !exist {
+		return nil, fmt.Errorf("method '%s' not found", name)
+	}
+
+	// start with argument count match
+	if len(args) != len(method.Input) {
+		return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Input))
+	}
+
+	arguments, err := abi.pack(name, args...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set function id
+	packed := abi.Methods[name].Id()
+	packed = append(packed, arguments...)
+
+	return packed, nil
+}
+
+func (abi *ABI) UnmarshalJSON(data []byte) error {
+	var methods []Method
+	if err := json.Unmarshal(data, &methods); err != nil {
+		return err
+	}
+
+	abi.Methods = make(map[string]Method)
+	for _, method := range methods {
+		abi.Methods[method.Name] = method
+	}
+
+	return nil
+}
+
+func JSON(reader io.Reader) (ABI, error) {
+	dec := json.NewDecoder(reader)
+
+	var abi ABI
+	if err := dec.Decode(&abi); err != nil {
+		return ABI{}, err
+	}
+
+	return abi, nil
+}
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@ -0,0 +1,330 @@
+package abi
+
+import (
+	"bytes"
+	"math/big"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const jsondata = `
+[
+	{ "name" : "balance", "const" : true },
+	{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] }
+]`
+
+const jsondata2 = `
+[
+	{ "name" : "balance", "const" : true },
+	{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] },
+	{ "name" : "test", "const" : false, "input" : [ { "name" : "number", "type" : "uint32" } ] },
+	{ "name" : "string", "const" : false, "input" : [ { "name" : "input", "type" : "string" } ] },
+	{ "name" : "bool", "const" : false, "input" : [ { "name" : "input", "type" : "bool" } ] },
+	{ "name" : "address", "const" : false, "input" : [ { "name" : "input", "type" : "address" } ] },
+	{ "name" : "string32", "const" : false, "input" : [ { "name" : "input", "type" : "string32" } ] },
+	{ "name" : "uint64[2]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[2]" } ] },
+	{ "name" : "uint64[]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[]" } ] },
+	{ "name" : "foo", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" } ] },
+	{ "name" : "bar", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] },
+	{ "name" : "slice", "const" : false, "input" : [ { "name" : "input", "type" : "uint32[2]" } ] },
+	{ "name" : "slice256", "const" : false, "input" : [ { "name" : "input", "type" : "uint256[2]" } ] }
+]`
+
+func TestType(t *testing.T) {
+	typ, err := NewType("uint32")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Ptr {
+		t.Error("expected uint32 to have kind Ptr")
+	}
+
+	typ, err = NewType("uint32[]")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Slice {
+		t.Error("expected uint32[] to have type slice")
+	}
+	if typ.Type != ubig_ts {
+		t.Error("expcted uith32[] to have type uint64")
+	}
+
+	typ, err = NewType("uint32[2]")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Slice {
+		t.Error("expected uint32[2] to have kind slice")
+	}
+	if typ.Type != ubig_ts {
+		t.Error("expcted uith32[2] to have type uint64")
+	}
+	if typ.Size != 2 {
+		t.Error("expected uint32[2] to have a size of 2")
+	}
+}
+
+func TestReader(t *testing.T) {
+	Uint256, _ := NewType("uint256")
+	exp := ABI{
+		Methods: map[string]Method{
+			"balance": Method{
+				"balance", true, nil, Type{},
+			},
+			"send": Method{
+				"send", false, []Argument{
+					Argument{"amount", Uint256},
+				}, Type{},
+			},
+		},
+	}
+
+	abi, err := JSON(strings.NewReader(jsondata))
+	if err != nil {
+		t.Error(err)
+	}
+
+	// deep equal fails for some reason
+	t.Skip()
+	if !reflect.DeepEqual(abi, exp) {
+		t.Errorf("\nabi: %v\ndoes not match exp: %v", abi, exp)
+	}
+}
+
+func TestTestNumbers(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("balance"); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := abi.Pack("balance", 1); err == nil {
+		t.Error("expected error for balance(1)")
+	}
+
+	if _, err := abi.Pack("doesntexist", nil); err == nil {
+		t.Errorf("doesntexist shouldn't exist")
+	}
+
+	if _, err := abi.Pack("doesntexist", 1); err == nil {
+		t.Errorf("doesntexist(1) shouldn't exist")
+	}
+
+	if _, err := abi.Pack("send", big.NewInt(1000)); err != nil {
+		t.Error(err)
+	}
+
+	i := new(int)
+	*i = 1000
+	if _, err := abi.Pack("send", i); err == nil {
+		t.Errorf("expected send( ptr ) to throw, requires *big.Int instead of *int")
+	}
+
+	if _, err := abi.Pack("send", 1000); err != nil {
+		t.Error("expected send(1000) to cast to big")
+	}
+
+	if _, err := abi.Pack("test", uint32(1000)); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestString(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("string", "hello world"); err != nil {
+		t.Error(err)
+	}
+
+	str10 := string(make([]byte, 10))
+	if _, err := abi.Pack("string32", str10); err != nil {
+		t.Error(err)
+	}
+
+	str32 := string(make([]byte, 32))
+	if _, err := abi.Pack("string32", str32); err != nil {
+		t.Error(err)
+	}
+
+	str33 := string(make([]byte, 33))
+	if _, err := abi.Pack("string32", str33); err == nil {
+		t.Error("expected str33 to throw out of bound error")
+	}
+}
+
+func TestTestBool(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("bool", true); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestSlice(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	addr := make([]byte, 20)
+	if _, err := abi.Pack("address", addr); err != nil {
+		t.Error(err)
+	}
+
+	addr = make([]byte, 21)
+	if _, err := abi.Pack("address", addr); err == nil {
+		t.Error("expected address of 21 width to throw")
+	}
+
+	slice := make([]byte, 2)
+	if _, err := abi.Pack("uint64[2]", slice); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := abi.Pack("uint64[]", slice); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestAddress(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	addr := make([]byte, 20)
+	if _, err := abi.Pack("address", addr); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestMethodSignature(t *testing.T) {
+	String, _ := NewType("string")
+	String32, _ := NewType("string32")
+	m := Method{"foo", false, []Argument{Argument{"bar", String32}, Argument{"baz", String}}, Type{}}
+	exp := "foo(string32,string)"
+	if m.String() != exp {
+		t.Error("signature mismatch", exp, "!=", m.String())
+	}
+
+	idexp := crypto.Sha3([]byte(exp))[:4]
+	if !bytes.Equal(m.Id(), idexp) {
+		t.Errorf("expected ids to match %x != %x", m.Id(), idexp)
+	}
+
+	uintt, _ := NewType("uint")
+	m = Method{"foo", false, []Argument{Argument{"bar", uintt}}, Type{}}
+	exp = "foo(uint256)"
+	if m.String() != exp {
+		t.Error("signature mismatch", exp, "!=", m.String())
+	}
+}
+
+func TestPack(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("foo(uint32)"))[:4]
+	sig = append(sig, make([]byte, 32)...)
+	sig[35] = 10
+
+	packed, err := abi.Pack("foo", uint32(10))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestMultiPack(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("bar(uint32,uint16)"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 10
+	sig[67] = 11
+
+	packed, err := abi.Pack("bar", uint32(10), uint16(11))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestPackSlice(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("slice(uint32[2])"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 1
+	sig[67] = 2
+
+	packed, err := abi.Pack("slice", []uint32{1, 2})
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestPackSliceBig(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("slice256(uint256[2])"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 1
+	sig[67] = 2
+
+	packed, err := abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)})
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
--- a/accounts/abi/doc.go
+++ b/accounts/abi/doc.go
@ -0,0 +1,10 @@
+// Package abi implements the Ethereum ABI (Application Binary
+// Interface).
+//
+// The Ethereum ABI is strongly typed, known at compile time
+// and static. This ABI will handle basic type casting; unsigned
+// to signed and visa versa. It does not handle slice casting such
+// as unsigned slice to signed slice. Bit size type casting is also
+// handled. ints with a bit size of 32 will be properly cast to int256,
+// etc.
+package abi
--- a/accounts/abi/numbers.go
+++ b/accounts/abi/numbers.go
@ -0,0 +1,106 @@
+package abi
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+var big_t = reflect.TypeOf(&big.Int{})
+var ubig_t = reflect.TypeOf(&big.Int{})
+var byte_t = reflect.TypeOf(byte(0))
+var byte_ts = reflect.TypeOf([]byte(nil))
+var uint_t = reflect.TypeOf(uint(0))
+var uint8_t = reflect.TypeOf(uint8(0))
+var uint16_t = reflect.TypeOf(uint16(0))
+var uint32_t = reflect.TypeOf(uint32(0))
+var uint64_t = reflect.TypeOf(uint64(0))
+var int_t = reflect.TypeOf(int(0))
+var int8_t = reflect.TypeOf(int8(0))
+var int16_t = reflect.TypeOf(int16(0))
+var int32_t = reflect.TypeOf(int32(0))
+var int64_t = reflect.TypeOf(int64(0))
+
+var uint_ts = reflect.TypeOf([]uint(nil))
+var uint8_ts = reflect.TypeOf([]uint8(nil))
+var uint16_ts = reflect.TypeOf([]uint16(nil))
+var uint32_ts = reflect.TypeOf([]uint32(nil))
+var uint64_ts = reflect.TypeOf([]uint64(nil))
+var ubig_ts = reflect.TypeOf([]*big.Int(nil))
+
+var int_ts = reflect.TypeOf([]int(nil))
+var int8_ts = reflect.TypeOf([]int8(nil))
+var int16_ts = reflect.TypeOf([]int16(nil))
+var int32_ts = reflect.TypeOf([]int32(nil))
+var int64_ts = reflect.TypeOf([]int64(nil))
+var big_ts = reflect.TypeOf([]*big.Int(nil))
+
+// U256 will ensure unsigned 256bit on big nums
+func U256(n *big.Int) []byte {
+	return ethutil.LeftPadBytes(ethutil.U256(n).Bytes(), 32)
+}
+
+func S256(n *big.Int) []byte {
+	sint := ethutil.S256(n)
+	ret := ethutil.LeftPadBytes(sint.Bytes(), 32)
+	if sint.Cmp(ethutil.Big0) < 0 {
+		for i, b := range ret {
+			if b == 0 {
+				ret[i] = 1
+				continue
+			}
+			break
+		}
+	}
+
+	return ret
+}
+
+// S256 will ensure signed 256bit on big nums
+func U2U256(n uint64) []byte {
+	return U256(big.NewInt(int64(n)))
+}
+
+func S2S256(n int64) []byte {
+	return S256(big.NewInt(n))
+}
+
+// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
+func packNum(value reflect.Value, to byte) []byte {
+	switch kind := value.Kind(); kind {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if to == UintTy {
+			return U2U256(value.Uint())
+		} else {
+			return S2S256(int64(value.Uint()))
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if to == UintTy {
+			return U2U256(uint64(value.Int()))
+		} else {
+			return S2S256(value.Int())
+		}
+	case reflect.Ptr:
+		// This only takes care of packing and casting. No type checking is done here. It should be done prior to using this function.
+		if to == UintTy {
+			return U256(value.Interface().(*big.Int))
+		} else {
+			return S256(value.Interface().(*big.Int))
+		}
+
+	}
+
+	return nil
+}
+
+// checks whether the given reflect value is signed. This also works for slices with a number type
+func isSigned(v reflect.Value) bool {
+	switch v.Type() {
+	case ubig_ts, big_ts, big_t, ubig_t:
+		return true
+	case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t:
+		return true
+	}
+	return false
+}
--- a/accounts/abi/numbers_test.go
+++ b/accounts/abi/numbers_test.go
@ -0,0 +1,72 @@
+package abi
+
+import (
+	"bytes"
+	"math/big"
+	"reflect"
+	"testing"
+)
+
+func TestNumberTypes(t *testing.T) {
+	ubytes := make([]byte, 32)
+	ubytes[31] = 1
+	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+
+	unsigned := U256(big.NewInt(1))
+	if !bytes.Equal(unsigned, ubytes) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+
+	signed := S256(big.NewInt(1))
+	if !bytes.Equal(signed, ubytes) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+
+	signed = S256(big.NewInt(-1))
+	if !bytes.Equal(signed, sbytesmin) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+}
+
+func TestPackNumber(t *testing.T) {
+	ubytes := make([]byte, 32)
+	ubytes[31] = 1
+	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+	maxunsigned := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
+
+	packed := packNum(reflect.ValueOf(1), IntTy)
+	if !bytes.Equal(packed, ubytes) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(-1), IntTy)
+	if !bytes.Equal(packed, sbytesmin) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(1), UintTy)
+	if !bytes.Equal(packed, ubytes) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(-1), UintTy)
+	if !bytes.Equal(packed, maxunsigned) {
+		t.Errorf("expected %x got %x", maxunsigned, packed)
+	}
+
+	packed = packNum(reflect.ValueOf("string"), UintTy)
+	if packed != nil {
+		t.Errorf("expected 'string' to pack to nil. got %x instead", packed)
+	}
+}
+
+func TestSigned(t *testing.T) {
+	if isSigned(reflect.ValueOf(uint(10))) {
+		t.Error()
+	}
+
+	if !isSigned(reflect.ValueOf(int(10))) {
+		t.Error()
+	}
+
+	if !isSigned(reflect.ValueOf(big.NewInt(10))) {
+		t.Error()
+	}
+}
--- a/accounts/abi/profile.cov
+++ b/accounts/abi/profile.cov
@ -0,0 +1,106 @@
+mode: set
+github.com/ethereum/go-ethereum/abi/abi.go:27.39,31.32 4 1
+github.com/ethereum/go-ethereum/abi/abi.go:35.2,37.8 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:31.32,34.3 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:40.29,42.2 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:51.53,57.16 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:61.2,62.16 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:65.2,67.12 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:57.16,59.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:62.16,64.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:79.71,83.25 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:94.2,94.17 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:83.25,87.17 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:90.3,90.31 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:87.17,89.4 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:102.71,104.12 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:109.2,109.36 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:113.2,114.16 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:119.2,122.20 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:104.12,106.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:109.36,111.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:114.16,116.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:125.50,127.55 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:131.2,132.33 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:136.2,136.12 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:127.55,129.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:132.33,134.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:139.42,143.41 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:147.2,147.17 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:143.41,145.3 1 0
+github.com/ethereum/go-ethereum/abi/numbers.go:39.30,41.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:43.30,46.32 3 1
+github.com/ethereum/go-ethereum/abi/numbers.go:56.2,56.12 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:46.32,47.25 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:47.25,48.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:52.4,52.9 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:48.14,50.13 2 1
+github.com/ethereum/go-ethereum/abi/numbers.go:59.30,61.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:63.29,65.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:67.51,68.36 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:91.2,91.12 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:69.2,70.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:75.2,76.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:81.2,83.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:70.19,72.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:72.4,74.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:76.19,78.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:78.4,80.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:83.19,85.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:85.4,87.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:94.37,95.18 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:101.2,101.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:96.2,97.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:98.2,99.14 1 1
+github.com/ethereum/go-ethereum/abi/type.go:32.46,35.16 2 1
+github.com/ethereum/go-ethereum/abi/type.go:38.2,43.9 3 1
+github.com/ethereum/go-ethereum/abi/type.go:55.2,56.16 2 1
+github.com/ethereum/go-ethereum/abi/type.go:60.2,64.55 4 1
+github.com/ethereum/go-ethereum/abi/type.go:69.2,69.13 1 1
+github.com/ethereum/go-ethereum/abi/type.go:111.2,113.8 2 1
+github.com/ethereum/go-ethereum/abi/type.go:35.16,37.3 1 0
+github.com/ethereum/go-ethereum/abi/type.go:44.2,47.17 2 1
+github.com/ethereum/go-ethereum/abi/type.go:48.2,50.12 2 1
+github.com/ethereum/go-ethereum/abi/type.go:51.2,52.60 1 0
+github.com/ethereum/go-ethereum/abi/type.go:56.16,58.3 1 0
+github.com/ethereum/go-ethereum/abi/type.go:64.55,67.3 2 1
+github.com/ethereum/go-ethereum/abi/type.go:69.13,72.16 3 1
+github.com/ethereum/go-ethereum/abi/type.go:73.3,74.21 1 0
+github.com/ethereum/go-ethereum/abi/type.go:75.3,76.22 1 1
+github.com/ethereum/go-ethereum/abi/type.go:77.3,78.66 1 0
+github.com/ethereum/go-ethereum/abi/type.go:80.3,81.16 1 1
+github.com/ethereum/go-ethereum/abi/type.go:82.3,86.17 4 0
+github.com/ethereum/go-ethereum/abi/type.go:87.3,91.18 4 1
+github.com/ethereum/go-ethereum/abi/type.go:92.3,93.27 1 1
+github.com/ethereum/go-ethereum/abi/type.go:94.3,95.30 1 0
+github.com/ethereum/go-ethereum/abi/type.go:96.3,100.21 4 1
+github.com/ethereum/go-ethereum/abi/type.go:101.3,104.17 3 1
+github.com/ethereum/go-ethereum/abi/type.go:107.3,108.60 1 0
+github.com/ethereum/go-ethereum/abi/type.go:104.17,106.5 1 1
+github.com/ethereum/go-ethereum/abi/type.go:116.37,118.2 1 1
+github.com/ethereum/go-ethereum/abi/type.go:126.51,128.36 2 1
+github.com/ethereum/go-ethereum/abi/type.go:179.2,179.20 1 0
+github.com/ethereum/go-ethereum/abi/type.go:129.2,130.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:133.3,133.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:134.2,135.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:138.3,138.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:139.2,142.49 1 1
+github.com/ethereum/go-ethereum/abi/type.go:145.3,145.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:146.2,147.42 1 1
+github.com/ethereum/go-ethereum/abi/type.go:150.3,150.60 1 1
+github.com/ethereum/go-ethereum/abi/type.go:151.2,152.42 1 1
+github.com/ethereum/go-ethereum/abi/type.go:157.3,157.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:162.3,162.78 1 1
+github.com/ethereum/go-ethereum/abi/type.go:166.3,167.36 2 1
+github.com/ethereum/go-ethereum/abi/type.go:170.3,170.21 1 1
+github.com/ethereum/go-ethereum/abi/type.go:171.2,172.19 1 1
+github.com/ethereum/go-ethereum/abi/type.go:130.23,132.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:135.23,137.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:142.49,144.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:147.42,149.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:152.42,154.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:157.23,159.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:162.78,164.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:167.36,169.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:172.19,174.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:174.4,176.4 1 0
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -0,0 +1,190 @@
+package abi
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+const (
+	IntTy byte = iota
+	UintTy
+	BoolTy
+	SliceTy
+	AddressTy
+	RealTy
+)
+
+// Type is the reflection of the supported argument type
+type Type struct {
+	Kind       reflect.Kind
+	Type       reflect.Type
+	Size       int
+	T          byte   // Our own type checking
+	stringKind string // holds the unparsed string for deriving signatures
+}
+
+// New type returns a fully parsed Type given by the input string or an error if it  can't be parsed.
+//
+// Strings can be in the format of:
+//
+// 	Input  = Type [ "[" [ Number ] "]" ] Name .
+// 	Type   = [ "u" ] "int" [ Number ] .
+//
+// Examples:
+//
+//      string     int       uint       real
+//      string32   int8      uint8      uint[]
+//      address    int256    uint256    real[2]
+func NewType(t string) (typ Type, err error) {
+	// 1. full string 2. type 3. (opt.) is slice 4. (opt.) size
+	freg, err := regexp.Compile("([a-zA-Z0-9]+)(\\[([0-9]*)?\\])?")
+	if err != nil {
+		return Type{}, err
+	}
+	res := freg.FindAllStringSubmatch(t, -1)[0]
+	var (
+		isslice bool
+		size    int
+	)
+	switch {
+	case res[3] != "":
+		// err is ignored. Already checked for number through the regexp
+		size, _ = strconv.Atoi(res[3])
+		isslice = true
+	case res[2] != "":
+		isslice = true
+		size = -1
+	case res[0] == "":
+		return Type{}, fmt.Errorf("type parse error for `%s`", t)
+	}
+
+	treg, err := regexp.Compile("([a-zA-Z]+)([0-9]*)?")
+	if err != nil {
+		return Type{}, err
+	}
+
+	parsedType := treg.FindAllStringSubmatch(res[1], -1)[0]
+	vsize, _ := strconv.Atoi(parsedType[2])
+	vtype := parsedType[1]
+	// substitute canonical representation
+	if vsize == 0 && (vtype == "int" || vtype == "uint") {
+		vsize = 256
+		t += "256"
+	}
+
+	if isslice {
+		typ.Kind = reflect.Slice
+		typ.Size = size
+		switch vtype {
+		case "int":
+			typ.Type = big_ts
+		case "uint":
+			typ.Type = ubig_ts
+		default:
+			return Type{}, fmt.Errorf("unsupported arg slice type: %s", t)
+		}
+	} else {
+		switch vtype {
+		case "int":
+			typ.Kind = reflect.Ptr
+			typ.Type = big_t
+			typ.Size = 256
+			typ.T = IntTy
+		case "uint":
+			typ.Kind = reflect.Ptr
+			typ.Type = ubig_t
+			typ.Size = 256
+			typ.T = UintTy
+		case "bool":
+			typ.Kind = reflect.Bool
+		case "real": // TODO
+			typ.Kind = reflect.Invalid
+		case "address":
+			typ.Kind = reflect.Slice
+			typ.Type = byte_ts
+			typ.Size = 20
+			typ.T = AddressTy
+		case "string":
+			typ.Kind = reflect.String
+			typ.Size = -1
+			if vsize > 0 {
+				typ.Size = 32
+			}
+		default:
+			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
+		}
+	}
+	typ.stringKind = t
+
+	return
+}
+
+func (t Type) String() (out string) {
+	return t.stringKind
+}
+
+// Test the given input parameter `v` and checks if it matches certain
+// criteria
+// * Big integers are checks for ptr types and if the given value is
+//   assignable
+// * Integer are checked for size
+// * Strings, addresses and bytes are checks for type and size
+func (t Type) pack(v interface{}) ([]byte, error) {
+	value := reflect.ValueOf(v)
+	switch kind := value.Kind(); kind {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if t.Type != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if t.Type != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.Ptr:
+		// If the value is a ptr do a assign check (only used by
+		// big.Int for now)
+		if t.Type == ubig_t && value.Type() != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.String:
+		if t.Size > -1 && value.Len() > t.Size {
+			return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size)
+		}
+		return []byte(ethutil.LeftPadString(t.String(), 32)), nil
+	case reflect.Slice:
+		if t.Size > -1 && value.Len() > t.Size {
+			return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size)
+		}
+
+		// Address is a special slice. The slice acts as one rather than a list of elements.
+		if t.T == AddressTy {
+			return ethutil.LeftPadBytes(v.([]byte), 32), nil
+		}
+
+		// Signed / Unsigned check
+		if (t.T != IntTy && isSigned(value)) || (t.T == UintTy && isSigned(value)) {
+			return nil, fmt.Errorf("slice of incompatible types.")
+		}
+
+		var packed []byte
+		for i := 0; i < value.Len(); i++ {
+			packed = append(packed, packNum(value.Index(i), t.T)...)
+		}
+		return packed, nil
+	case reflect.Bool:
+		if value.Bool() {
+			return ethutil.LeftPadBytes(ethutil.Big1.Bytes(), 32), nil
+		} else {
+			return ethutil.LeftPadBytes(ethutil.Big0.Bytes(), 32), nil
+		}
+	}
+
+	panic("unreached")
+}
--- a/accounts/account_manager.go
+++ b/accounts/account_manager.go
@ -0,0 +1,95 @@
+/*
+	This file is part of go-ethereum
+
+	go-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	go-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @authors
+ * 	Gustav Simonsson <gustav.simonsson@gmail.com>
+ * @date 2015
+ *
+ */
+/*
+
+This abstracts part of a user's interaction with an account she controls.
+It's not an abstraction of core Ethereum accounts data type / logic -
+for that see the core processing code of blocks / txs.
+
+Currently this is pretty much a passthrough to the KeyStore2 interface,
+and accounts persistence is derived from stored keys' addresses
+
+*/
+package accounts
+
+import (
+	crand "crypto/rand"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// TODO: better name for this struct?
+type Account struct {
+	Address []byte
+}
+
+type AccountManager struct {
+	keyStore crypto.KeyStore2
+}
+
+// TODO: get key by addr - modify KeyStore2 GetKey to work with addr
+
+// TODO: pass through passphrase for APIs which require access to private key?
+func NewAccountManager(keyStore crypto.KeyStore2) AccountManager {
+	am := &AccountManager{
+		keyStore: keyStore,
+	}
+	return *am
+}
+
+func (am *AccountManager) Sign(fromAccount *Account, keyAuth string, toSign []byte) (signature []byte, err error) {
+	key, err := am.keyStore.GetKey(fromAccount.Address, keyAuth)
+	if err != nil {
+		return nil, err
+	}
+	signature, err = crypto.Sign(toSign, key.PrivateKey)
+	return signature, err
+}
+
+func (am AccountManager) NewAccount(auth string) (*Account, error) {
+	key, err := am.keyStore.GenerateNewKey(crand.Reader, auth)
+	if err != nil {
+		return nil, err
+	}
+	ua := &Account{
+		Address: key.Address,
+	}
+	return ua, err
+}
+
+// set of accounts == set of keys in given key store
+// TODO: do we need persistence of accounts as well?
+func (am *AccountManager) Accounts() ([]Account, error) {
+	addresses, err := am.keyStore.GetKeyAddresses()
+	if err != nil {
+		return nil, err
+	}
+
+	accounts := make([]Account, len(addresses))
+
+	for i, addr := range addresses {
+		accounts[i] = Account{
+			Address: addr,
+		}
+	}
+	return accounts, err
+}
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@ -0,0 +1,18 @@
+package accounts
+
+import (
+	"github.com/ethereum/go-ethereum/crypto"
+	"testing"
+)
+
+func TestAccountManager(t *testing.T) {
+	ks := crypto.NewKeyStorePlain(crypto.DefaultDataDir())
+	am := NewAccountManager(ks)
+	pass := "" // not used but required by API
+	a1, err := am.NewAccount(pass)
+	toSign := crypto.GetEntropyCSPRNG(32)
+	_, err = am.Sign(a1, pass, toSign)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
--- a/cmd/disasm/main.go
+++ b/cmd/disasm/main.go
@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+func main() {
+	code, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	code = ethutil.Hex2Bytes(string(code[:len(code)-1]))
+	fmt.Printf("%x\n", code)
+
+	for pc := uint64(0); pc < uint64(len(code)); pc++ {
+		op := vm.OpCode(code[pc])
+		fmt.Printf("%-5d  %v", pc, op)
+
+		switch op {
+		case vm.PUSH1, vm.PUSH2, vm.PUSH3, vm.PUSH4, vm.PUSH5, vm.PUSH6, vm.PUSH7, vm.PUSH8, vm.PUSH9, vm.PUSH10, vm.PUSH11, vm.PUSH12, vm.PUSH13, vm.PUSH14, vm.PUSH15, vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32:
+			a := uint64(op) - uint64(vm.PUSH1) + 1
+			fmt.Printf("  => %x", code[pc+1:pc+1+a])
+
+			pc += a
+		}
+		fmt.Println()
+	}
+}
--- a/cmd/mist/assets/examples/abi.html
+++ b/cmd/mist/assets/examples/abi.html
@ -0,0 +1,55 @@
+<!doctype>
+<html>
+<head>
+<title>Hello world</title>
+<script src="../ext/bignumber.min.js"></script>
+<script src="../ext/ethereum.js/dist/ethereum.js"></script>
+<script>
+	var web3 = require('web3');
+	web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+	var eth = web3.eth;
+	var desc =  [{
+		"name": "multiply(uint256)",
+		"inputs": [{
+			"name": "a",
+			"type": "uint256"
+		}],
+		"outputs": [{
+			"name": "d",
+			"type": "uint256"
+		}]
+	}];
+	var address = web3.eth.transact({
+		data: "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056",
+		gasprice: "1000000000000000",
+		gas: "10000",
+	});
+	var contract = web3.eth.contract(address, desc);
+
+	function calculate() {
+		var param = parseInt(document.getElementById('value').value);
+
+		var res = contract.call().multiply(param);
+		document.getElementById('result').innerText = res.toString(10);
+	}
+</script>
+</head>
+<body>
+<h3>Contract content</h3>
+<textarea style="height:100px; width: 300px;" disabled="disabled">
+contract test {
+    function multiply(uint a) returns(uint d) {
+        return a * 7;
+    }
+}
+</textarea>
+<code><pre>
+603880600c6000396000f3006001600060e060020a600035048063c6888fa1140
+05b6021600435602b565b8060005260206000f35b600081600702905091905056</pre></code>
+
+<hr>
+<div>7 x <input type="number" id="value" onkeyup='calculate()'></input> = 
+<span id="result"></spa>
+
+</body>
+</html>
--- a/cmd/mist/assets/examples/balance.html
+++ b/cmd/mist/assets/examples/balance.html
@ -0,0 +1,40 @@
+<!doctype>
+<html>
+
+<head>
+<script src="../ext/bignumber.min.js"></script>
+<script src="../ext/ethereum.js/dist/ethereum.js"></script>
+<script type="text/javascript">
+   
+    var web3 = require('web3');
+    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+    function watchBalance() {
+        var coinbase = web3.eth.coinbase;
+        var originalBalance = 0;
+
+        var balance = web3.eth.balanceAt(coinbase);
+        var originalBalance = web3.toDecimal(balance);
+        document.getElementById('original').innerText = 'original balance: ' + originalBalance + '    watching...';
+
+        web3.eth.watch({altered: coinbase}).changed(function() {
+            balance = web3.eth.balanceAt(coinbase)
+            var currentBalance = web3.toDecimal(balance);
+            document.getElementById("current").innerText = 'current: ' + currentBalance;
+            document.getElementById("diff").innerText = 'diff:    ' + (currentBalance - originalBalance);
+        });
+    }
+
+</script>
+</head>
+<body>
+    <h1>coinbase balance</h1>
+    <button type="button" onClick="watchBalance();">watch balance</button>
+    <div></div>
+    <div id="original"></div>
+    <div id="current"></div>
+    <div id="diff"></div>
+</body>
+</html>
+
+
--- a/cmd/mist/assets/ext/big.js
+++ b/cmd/mist/assets/ext/big.js
@ -1,397 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-var BigNumber = (function () {
-    var base = 10000000, logBase = 7;
-    var sign = {
-        positive: false,
-        negative: true
-    };
-
-    var normalize = function (first, second) {
-        var a = first.value, b = second.value;
-        var length = a.length > b.length ? a.length : b.length;
-        for (var i = 0; i < length; i++) {
-            a[i] = a[i] || 0;
-            b[i] = b[i] || 0;
-        }
-        for (var i = length - 1; i >= 0; i--) {
-            if (a[i] === 0 && b[i] === 0) {
-                a.pop();
-                b.pop();
-            } else break;
-        }
-        if (!a.length) a = [0], b = [0];
-        first.value = a;
-        second.value = b;
-    };
-
-    var parse = function (text, first) {
-        if (typeof text === "object") return text;
-        text += "";
-        var s = sign.positive, value = [];
-        if (text[0] === "-") {
-            s = sign.negative;
-            text = text.slice(1);
-        }
-	var base = 10;
-        if (text.slice(0, 2) == "0x") {
-            base = 16;
-            text = text.slice(2);
-        }
-	else {
-	        var texts = text.split("e");
-		if (texts.length > 2) throw new Error("Invalid integer");
-		if (texts[1]) {
-		    var exp = texts[1];
-		    if (exp[0] === "+") exp = exp.slice(1);
-		    exp = parse(exp);
-		    if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers");
-		    while (exp.notEquals(0)) {
-		        texts[0] += "0";
-		        exp = exp.prev();
-		    }
-		}
-	        text = texts[0];
-	}
-        if (text === "-0") text = "0";
-	text = text.toUpperCase();
-        var isValid = (base == 16 ? /^[0-9A-F]*$/ : /^[0-9]+$/).test(text);
-        if (!isValid) throw new Error("Invalid integer");
-	if (base == 16) {
-		var val = BigNumber(0);
-		while (text.length) {
-			v = text.charCodeAt(0) - 48;
-			if (v > 9)
-				v -= 7;
-			text = text.slice(1);
-			val = val.times(16).plus(v);
-		}
-		return val;
-	}
-	else {
-		while (text.length) {
-		    var divider = text.length > logBase ? text.length - logBase : 0;
-		    value.push(+text.slice(divider));
-		    text = text.slice(0, divider);
-		}
-	        var val = BigNumber(value, s);
-	        if (first) normalize(first, val);
-        	return val;
-	}
-    };
-
-    var goesInto = function (a, b) {
-        var a = BigNumber(a, sign.positive), b = BigNumber(b, sign.positive);
-        if (a.equals(0)) throw new Error("Cannot divide by 0");
-        var n = 0;
-        do {
-            var inc = 1;
-            var c = BigNumber(a.value, sign.positive), t = c.times(10);
-            while (t.lesser(b)) {
-                c = t;
-                inc *= 10;
-                t = t.times(10);
-            }
-            while (c.lesserOrEquals(b)) {
-                b = b.minus(c);
-                n += inc;
-            }
-        } while (a.lesserOrEquals(b));
-
-        return {
-            remainder: b.value,
-            result: n
-        };
-    };
-
-    var BigNumber = function (value, s) {
-        var self = {
-            value: value,
-            sign: s
-        };
-        var o = {
-            value: value,
-            sign: s,
-            negate: function (m) {
-                var first = m || self;
-                return BigNumber(first.value, !first.sign);
-            },
-            abs: function (m) {
-                var first = m || self;
-                return BigNumber(first.value, sign.positive);
-            },
-            add: function (n, m) {
-                var s, first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m));
-                else second = parse(n, first);
-                s = first.sign;
-                if (first.sign !== second.sign) {
-                    first = BigNumber(first.value, sign.positive);
-                    second = BigNumber(second.value, sign.positive);
-                    return s === sign.positive ?
-						o.subtract(first, second) :
-						o.subtract(second, first);
-                }
-                normalize(first, second);
-                var a = first.value, b = second.value;
-                var result = [],
-					carry = 0;
-                for (var i = 0; i < a.length || carry > 0; i++) {
-                    var sum = (a[i] || 0) + (b[i] || 0) + carry;
-                    carry = sum >= base ? 1 : 0;
-                    sum -= carry * base;
-                    result.push(sum);
-                }
-                return BigNumber(result, s);
-            },
-            plus: function (n, m) {
-                return o.add(n, m);
-            },
-            subtract: function (n, m) {
-                var first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m));
-                else second = parse(n, first);
-                if (first.sign !== second.sign) return o.add(first, o.negate(second));
-                if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first));
-                if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first));
-                var a = first.value, b = second.value;
-                var result = [],
-					borrow = 0;
-                for (var i = 0; i < a.length; i++) {
-                    var tmp = a[i] - borrow;
-                    borrow = tmp < b[i] ? 1 : 0;
-                    var minuend = (borrow * base) + tmp - b[i];
-                    result.push(minuend);
-                }
-                return BigNumber(result, sign.positive);
-            },
-            minus: function (n, m) {
-                return o.subtract(n, m);
-            },
-            multiply: function (n, m) {
-                var s, first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m));
-                else second = parse(n, first);
-                s = first.sign !== second.sign;
-                var a = first.value, b = second.value;
-                var resultSum = [];
-                for (var i = 0; i < a.length; i++) {
-                    resultSum[i] = [];
-                    var j = i;
-                    while (j--) {
-                        resultSum[i].push(0);
-                    }
-                }
-                var carry = 0;
-                for (var i = 0; i < a.length; i++) {
-                    var x = a[i];
-                    for (var j = 0; j < b.length || carry > 0; j++) {
-                        var y = b[j];
-                        var product = y ? (x * y) + carry : carry;
-                        carry = product > base ? Math.floor(product / base) : 0;
-                        product -= carry * base;
-                        resultSum[i].push(product);
-                    }
-                }
-                var max = -1;
-                for (var i = 0; i < resultSum.length; i++) {
-                    var len = resultSum[i].length;
-                    if (len > max) max = len;
-                }
-                var result = [], carry = 0;
-                for (var i = 0; i < max || carry > 0; i++) {
-                    var sum = carry;
-                    for (var j = 0; j < resultSum.length; j++) {
-                        sum += resultSum[j][i] || 0;
-                    }
-                    carry = sum > base ? Math.floor(sum / base) : 0;
-                    sum -= carry * base;
-                    result.push(sum);
-                }
-                return BigNumber(result, s);
-            },
-            times: function (n, m) {
-                return o.multiply(n, m);
-            },
-            divmod: function (n, m) {
-                var s, first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m));
-                else second = parse(n, first);
-                s = first.sign !== second.sign;
-                if (BigNumber(first.value, first.sign).equals(0)) return {
-                    quotient: BigNumber([0], sign.positive),
-                    remainder: BigNumber([0], sign.positive)
-                };
-                if (second.equals(0)) throw new Error("Cannot divide by zero");
-                var a = first.value, b = second.value;
-                var result = [], remainder = [];
-                for (var i = a.length - 1; i >= 0; i--) {
-                    var n = [a[i]].concat(remainder);
-                    var quotient = goesInto(b, n);
-                    result.push(quotient.result);
-                    remainder = quotient.remainder;
-                }
-                result.reverse();
-                return {
-                    quotient: BigNumber(result, s),
-                    remainder: BigNumber(remainder, first.sign)
-                };
-            },
-            divide: function (n, m) {
-                return o.divmod(n, m).quotient;
-            },
-            over: function (n, m) {
-                return o.divide(n, m);
-            },
-            mod: function (n, m) {
-                return o.divmod(n, m).remainder;
-            },
-            pow: function (n, m) {
-                var first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m));
-                else second = parse(n, first);
-                var a = first, b = second;
-                if (b.lesser(0)) return ZERO;
-                if (b.equals(0)) return ONE;
-                var result = BigNumber(a.value, a.sign);
-
-                if (b.mod(2).equals(0)) {
-                    var c = result.pow(b.over(2));
-                    return c.times(c);
-                } else {
-                    return result.times(result.pow(b.minus(1)));
-                }
-            },
-            next: function (m) {
-                var first = m || self;
-                return o.add(first, 1);
-            },
-            prev: function (m) {
-                var first = m || self;
-                return o.subtract(first, 1);
-            },
-            compare: function (n, m) {
-                var first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m, first));
-                else second = parse(n, first);
-                normalize(first, second);
-                if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0;
-                if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1;
-                var multiplier = first.sign === sign.positive ? 1 : -1;
-                var a = first.value, b = second.value;
-                for (var i = a.length - 1; i >= 0; i--) {
-                    if (a[i] > b[i]) return 1 * multiplier;
-                    if (b[i] > a[i]) return -1 * multiplier;
-                }
-                return 0;
-            },
-            compareAbs: function (n, m) {
-                var first = self, second;
-                if (m) (first = parse(n)) && (second = parse(m, first));
-                else second = parse(n, first);
-                first.sign = second.sign = sign.positive;
-                return o.compare(first, second);
-            },
-            equals: function (n, m) {
-                return o.compare(n, m) === 0;
-            },
-            notEquals: function (n, m) {
-                return !o.equals(n, m);
-            },
-            lesser: function (n, m) {
-                return o.compare(n, m) < 0;
-            },
-            greater: function (n, m) {
-                return o.compare(n, m) > 0;
-            },
-            greaterOrEquals: function (n, m) {
-                return o.compare(n, m) >= 0;
-            },
-            lesserOrEquals: function (n, m) {
-                return o.compare(n, m) <= 0;
-            },
-            isPositive: function (m) {
-                var first = m || self;
-                return first.sign === sign.positive;
-            },
-            isNegative: function (m) {
-                var first = m || self;
-                return first.sign === sign.negative;
-            },
-            isEven: function (m) {
-                var first = m || self;
-                return first.value[0] % 2 === 0;
-            },
-            isOdd: function (m) {
-                var first = m || self;
-                return first.value[0] % 2 === 1;
-            },
-            toString: function (m) {
-                var first = m || self;
-                var str = "", len = first.value.length;
-                while (len--) {
-                    if (first.value[len].toString().length === 8) str += first.value[len];
-                    else str += (base.toString() + first.value[len]).slice(-logBase);
-                }
-                while (str[0] === "0") {
-                    str = str.slice(1);
-                }
-                if (!str.length) str = "0";
-                var s = (first.sign === sign.positive || str == "0") ? "" : "-";
-                return s + str;
-            },
-            toHex: function (m) {
-                var first = m || self;
-                var str = "";
-				var l = this.abs();
-                while (l > 0) {
-					var qr = l.divmod(256);
-					var b = qr.remainder.toJSNumber();
-					str = (b >> 4).toString(16) + (b & 15).toString(16) + str;
-                    l = qr.quotient;
-                }
-                return (this.isNegative() ? "-" : "") + "0x" + str;
-            },
-            toJSNumber: function (m) {
-                return +o.toString(m);
-            },
-            valueOf: function (m) {
-                return o.toJSNumber(m);
-            }
-        };
-        return o;
-    };
-
-    var ZERO = BigNumber([0], sign.positive);
-    var ONE = BigNumber([1], sign.positive);
-    var MINUS_ONE = BigNumber([1], sign.negative);
-
-    var fnReturn = function (a) {
-        if (typeof a === "undefined") return ZERO;
-        return parse(a);
-    };
-    fnReturn.zero = ZERO;
-    fnReturn.one = ONE;
-    fnReturn.minusOne = MINUS_ONE;
-    return fnReturn;
-})();
-
-if (typeof module !== "undefined") {
-    module.exports = BigNumber;
-}
-
--- a/cmd/mist/assets/ext/ethereum.js/.bowerrc
+++ b/cmd/mist/assets/ext/ethereum.js/.bowerrc
@ -0,0 +1,5 @@
+{
+  "directory": "example/js/",
+  "cwd": "./",
+  "analytics": false
+}
--- a/cmd/mist/assets/ext/ethereum.js/.editorconfig
+++ b/cmd/mist/assets/ext/ethereum.js/.editorconfig
@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
--- a/cmd/mist/assets/ext/ethereum.js/.gitignore
+++ b/cmd/mist/assets/ext/ethereum.js/.gitignore
@ -0,0 +1,18 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+*.swp
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+ethereum/ethereum
+ethereal/ethereal
+example/js
+node_modules
+bower_components
+npm-debug.log
--- a/cmd/mist/assets/ext/ethereum.js/.jshintrc
+++ b/cmd/mist/assets/ext/ethereum.js/.jshintrc
@ -0,0 +1,50 @@
+{
+    "predef": [
+        "console",
+        "require",
+        "equal",
+        "test",
+        "testBoth",
+        "testWithDefault",
+        "raises",
+        "deepEqual",
+        "start",
+        "stop",
+        "ok",
+        "strictEqual",
+        "module",
+        "expect",
+        "reject",
+        "impl"
+    ],
+
+    "esnext": true,
+    "proto": true,
+    "node" : true,
+    "browser" : true,
+    "browserify" : true,
+
+    "boss" : true,
+    "curly": false,
+    "debug": true,
+    "devel": true,
+    "eqeqeq": true,
+    "evil": true,
+    "forin": false,
+    "immed": false,
+    "laxbreak": false,
+    "newcap": true,
+    "noarg": true,
+    "noempty": false,
+    "nonew": false,
+    "nomen": false,
+    "onevar": false,
+    "plusplus": false,
+    "regexp": false,
+    "undef": true,
+    "sub": true,
+    "strict": false,
+    "white": false,
+    "shadow": true,
+    "eqnull": true
+}
--- a/cmd/mist/assets/ext/ethereum.js/.npmignore
+++ b/cmd/mist/assets/ext/ethereum.js/.npmignore
@ -0,0 +1,9 @@
+example/js
+node_modules
+test
+.gitignore
+.editorconfig
+.travis.yml
+.npmignore
+component.json
+testling.html
--- a/cmd/mist/assets/ext/ethereum.js/.travis.yml
+++ b/cmd/mist/assets/ext/ethereum.js/.travis.yml
@ -0,0 +1,13 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+before_script:
+  - npm install
+  - npm install jshint
+script:
+   - "jshint *.js lib"
+after_script:
+  - npm run-script build
+  - npm test
+
--- a/cmd/mist/assets/ext/ethereum.js/LICENSE
+++ b/cmd/mist/assets/ext/ethereum.js/LICENSE
--- a/cmd/mist/assets/ext/ethereum.js/README.md
+++ b/cmd/mist/assets/ext/ethereum.js/README.md
--- a/cmd/mist/assets/ext/ethereum.js/bower.json
+++ b/cmd/mist/assets/ext/ethereum.js/bower.json
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
--- a/cmd/mist/assets/ext/ethereum.js/example/balance.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/balance.html
@ -2,13 +2,11 @@
 <html>

 <head>
-<script type="text/javascript" src="../bignumber.min.js"></script>
+<script type="text/javascript" src="js/bignumber.js/bignumber.min.js"></script>
 <script type="text/javascript" src="../dist/ethereum.js"></script>
 <script type="text/javascript">
   
-console.log("hello world");
    var web3 = require('web3');
-console.log(web3)
    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));

    function watchBalance() {
@ -19,7 +17,7 @@ console.log(web3)
        var originalBalance = web3.toDecimal(balance);
        document.getElementById('original').innerText = 'original balance: ' + originalBalance + '    watching...';

-        web3.eth.watch({altered: coinbase}).changed(function() {
+        var filter = web3.eth.watch({address: coinbase}).changed(function() {
            balance = web3.eth.balanceAt(coinbase)
            var currentBalance = web3.toDecimal(balance);
            document.getElementById("current").innerText = 'current: ' + currentBalance;
@ -27,11 +25,6 @@ console.log(web3)
        });
    }

-var request = new XMLHttpRequest();
-request.open('POST', "http://localhost:8080", false);
-request.send({});
-
-
 </script>
 </head>
 <body>
--- a/cmd/mist/assets/ext/ethereum.js/example/contract.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/contract.html
--- a/cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
--- a/cmd/mist/assets/ext/ethereum.js/example/node-app.js
+++ b/cmd/mist/assets/ext/ethereum.js/example/node-app.js
--- a/cmd/mist/assets/ext/ethereum.js/gulpfile.js
+++ b/cmd/mist/assets/ext/ethereum.js/gulpfile.js
--- a/cmd/mist/assets/ext/ethereum.js/index.js
+++ b/cmd/mist/assets/ext/ethereum.js/index.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/abi.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/abi.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/contract.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/contract.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/filter.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/filter.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/local.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/local.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
--- a/cmd/mist/assets/ext/ethereum.js/lib/web3.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/web3.js
--- a/cmd/mist/assets/ext/ethereum.js/package.json
+++ b/cmd/mist/assets/ext/ethereum.js/package.json
--- a/cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
--- a/cmd/mist/assets/ext/ethereum.js/test/db.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/db.methods.js
--- a/cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
--- a/cmd/mist/assets/ext/ethereum.js/test/mocha.opts
+++ b/cmd/mist/assets/ext/ethereum.js/test/mocha.opts
--- a/cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
--- a/cmd/mist/assets/ext/ethereum.js/test/utils.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/utils.js
--- a/cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
--- a/cmd/mist/assets/ext/home.html
+++ b/cmd/mist/assets/ext/home.html
@ -1,22 +0,0 @@
-<!doctype>
-<html>
-<head>
-<title>Ethereum</title>
-
-<style type="text/css">
-h1 {
-    text-align: center;
-    font-family: Courier;
-    font-size: 50pt;
-}
-</style>
-</head>
-
-<body>
-<h1>... Ethereum ...</h1>
-<ul>
-	<li><a href="http://std.eth">std::Service</a></li>
-</ul>
-</body>
-</html>
-
--- a/cmd/mist/assets/ext/html_messaging.js
+++ b/cmd/mist/assets/ext/html_messaging.js
@ -1,481 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-// The magic return variable. The magic return variable will be set during the execution of the QML call.
-(function(window) {
-	var Promise = window.Promise;
-	if(typeof(Promise) === "undefined") {
-		var Promise = Q.Promise;
-	}
-
-	function isPromise(o) {
-		return typeof o === "object" && o.then
-	}
-
-	window.eth = {
-		_callbacks: {},
-		_events: {},
-		prototype: Object(),
-
-		toHex: function(str) {
-			var hex = "";
-			for(var i = 0; i < str.length; i++) {
-				var n = str.charCodeAt(i).toString(16);
-				hex += n.length < 2 ? '0' + n : n;
-			}
-
-			return hex;
-		},
-
-		toAscii: function(hex) {
-			// Find termination
-			var str = "";
-			var i = 0, l = hex.length;
-			for(; i < l; i+=2) {
-				var code = hex.charCodeAt(i)
-				if(code == 0) {
-					break;
-				}
-
-				str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
-			}
-
-			return str;
-		},
-
-		fromAscii: function(str, pad) {
-			if(pad === undefined) {
-				pad = 32
-			}
-
-			var hex = this.toHex(str);
-
-			while(hex.length < pad*2)
-				hex += "00";
-
-			return hex
-		},
-
-		block: function(numberOrHash) {
-			return new Promise(function(resolve, reject) {
-				var func;
-				if(typeof numberOrHash == "string") {
-					func =  "getBlockByHash";
-				} else {
-					func =  "getBlockByNumber";
-				}
-
-				postData({call: func, args: [numberOrHash]}, function(block) {
-					if(block)
-						resolve(block);
-					else
-						reject("not found");
-
-				});
-			});
-		},
-
-		transact: function(params) {
-			if(params === undefined) {
-				params = {};
-			}
-
-			if(params.endowment !== undefined)
-				params.value = params.endowment;
-			if(params.code !== undefined)
-				params.data = params.code;
-
-
-			var promises = []
-			if(isPromise(params.to)) {
-				promises.push(params.to.then(function(_to) { params.to = _to; }));
-			}
-			if(isPromise(params.from)) {
-				promises.push(params.from.then(function(_from) { params.from = _from; }));
-			}
-
-            if(typeof params.data !== "object" || isPromise(params.data)) {
-                params.data = [params.data]
-            }
-
-            var data = params.data;
-            for(var i = 0; i < params.data.length; i++) {
-                if(isPromise(params.data[i])) {
-                    var promise = params.data[i];
-                    var _i = i;
-                    promises.push(promise.then(function(_arg) { params.data[_i] = _arg; }));
-                }
-            }
-                
-			// Make sure everything is string
-			var fields = ["value", "gas", "gasPrice"];
-			for(var i = 0; i < fields.length; i++) {
-				if(params[fields[i]] === undefined) {
-					params[fields[i]] = "";
-				}
-				params[fields[i]] = params[fields[i]].toString();
-			}
-
-			// Load promises then call the last "transact".
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-                    params.data = params.data.join("");
-					postData({call: "transact", args: params}, function(data) {
-						if(data[1])
-							reject(data[0]);
-						else
-							resolve(data[0]);
-					});
-				});
-			})
-		},
-
-		compile: function(code) {
-			return new Promise(function(resolve, reject) {
-				postData({call: "compile", args: [code]}, function(data) {
-					if(data[1])
-						reject(data[0]);
-					else
-						resolve(data[0]);
-				});
-			});
-		},
-
-		balanceAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getBalanceAt", args: [address]}, function(balance) {
-						resolve(balance);
-					});
-				});
-			});
-		},
-
-		countAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getCountAt", args: [address]}, function(count) {
-						resolve(count);
-					});
-				});
-			});
-		},
-
-		codeAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getCodeAt", args: [address]}, function(code) {
-						resolve(code);
-					});
-				});
-			});
-		},
-
-		storageAt: function(address, storageAddress) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			if(isPromise(storageAddress)) {
-				promises.push(storageAddress.then(function(_sa) { storageAddress = _sa; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getStorageAt", args: [address, storageAddress]}, function(entry) {
-						resolve(entry);
-					});
-				});
-			});
-		},
-
-		stateAt: function(address, storageAddress) {
-			return this.storageAt(address, storageAddress);
-		},
-
-		call: function(params) {
-			if(params === undefined) {
-				params = {};
-			}
-
-			if(params.endowment !== undefined)
-				params.value = params.endowment;
-			if(params.code !== undefined)
-				params.data = params.code;
-
-
-			var promises = []
-			if(isPromise(params.to)) {
-				promises.push(params.to.then(function(_to) { params.to = _to; }));
-			}
-			if(isPromise(params.from)) {
-				promises.push(params.from.then(function(_from) { params.from = _from; }));
-			}
-
-			if(isPromise(params.data)) {
-				promises.push(params.data.then(function(_code) { params.data = _code; }));
-			} else {
-				if(typeof params.data === "object") {
-					data = "";
-					for(var i = 0; i < params.data.length; i++) {
-						data += params.data[i]
-					}
-				} else {
-					data = params.data;
-				}
-			}
-
-			// Make sure everything is string
-			var fields = ["value", "gas", "gasPrice"];
-			for(var i = 0; i < fields.length; i++) {
-				if(params[fields[i]] === undefined) {
-					params[fields[i]] = "";
-				}
-				params[fields[i]] = params[fields[i]].toString();
-			}
-
-			// Load promises then call the last "transact".
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "call", args: params}, function(data) {
-						if(data[1])
-							reject(data[0]);
-						else
-							resolve(data[0]);
-					});
-				});
-			})
-		},
-
-		watch: function(params) {
-			return new Filter(params);
-		},
-
-		secretToAddress: function(key) {
-			var promises = [];
-			if(isPromise(key)) {
-				promises.push(key.then(function(_key) { key = _key; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getSecretToAddress", args: [key]}, function(address) {
-						resolve(address);
-					});
-				});
-			});
-		},
-
-		on: function(event, cb) {
-			if(eth._events[event] === undefined) {
-				eth._events[event] = [];
-			}
-
-			eth._events[event].push(cb);
-
-			return this
-		},
-
-		off: function(event, cb) {
-			if(eth._events[event] !== undefined) {
-				var callbacks = eth._events[event];
-				for(var i = 0; i < callbacks.length; i++) {
-					if(callbacks[i] === cb) {
-						delete callbacks[i];
-					}
-				}
-			}
-
-			return this
-		},
-
-		trigger: function(event, data) {
-			var callbacks = eth._events[event];
-			if(callbacks !== undefined) {
-				for(var i = 0; i < callbacks.length; i++) {
-					// Figure out whether the returned data was an array
-					// array means multiple return arguments (multiple params)
-					if(data instanceof Array) {
-						callbacks[i].apply(this, data);
-					} else {
-						callbacks[i].call(this, data);
-					}
-				}
-			}
-		},
-	};
-
-	// Eth object properties
-	Object.defineProperty(eth, "key", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getKey"}, function(k) {
-					resolve(k);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "gasPrice", {
-		get: function() {
-			return "10000000000000"
-		}
-	});
-
-	Object.defineProperty(eth, "coinbase", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getCoinBase"}, function(coinbase) {
-					resolve(coinbase);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "listening", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getIsListening"}, function(listening) {
-					resolve(listening);
-				});
-			});
-		},
-	});
-
-
-	Object.defineProperty(eth, "mining", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getIsMining"}, function(mining) {
-					resolve(mining);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "peerCount", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getPeerCount"}, function(peerCount) {
-					resolve(peerCount);
-				});
-			});
-		},
-	});
-
-	var filters = [];
-	var Filter = function(options) {
-		filters.push(this);
-
-		this.callbacks = [];
-		this.options = options;
-
-		var call;
-		if(options === "chain") {
-			call = "newFilterString"
-		} else if(typeof options === "object") {
-			call = "newFilter"
-		}
-
-		var self = this; // Cheaper than binding
-		this.promise = new Promise(function(resolve, reject) {
-			postData({call: call, args: [options]}, function(id) {
-				self.id = id;
-
-				resolve(id);
-			});
-		});
-	};
-
-	Filter.prototype.changed = function(callback) {
-		var self = this;
-		this.promise.then(function(id) {
-			self.callbacks.push(callback);
-		});
-	};
-
-	Filter.prototype.trigger = function(messages, id) {
-		if(id == this.id) {
-			for(var i = 0; i < this.callbacks.length; i++) {
-				this.callbacks[i].call(this, messages);
-			}
-		}
-	};
-
-	Filter.prototype.uninstall = function() {
-		this.promise.then(function(id) {
-			postData({call: "uninstallFilter", args:[id]});
-		});
-	};
-
-	Filter.prototype.messages = function() {
-		var self=this;
-		return Q.all([this.promise]).then(function() {
-			var id = self.id
-			return new Promise(function(resolve, reject) {
-				postData({call: "getMessages", args: [id]}, function(messages) {
-					resolve(messages);
-				});
-			});
-		});
-	};
-
-	// Register to the messages callback. "messages" will be emitted when new messages
-	// from the client have been created.
-	eth.on("messages", function(messages, id) {
-		for(var i = 0; i < filters.length; i++) {
-			filters[i].trigger(messages, id);
-		}
-	});
-
-
-	var g_seed = 1;
-	function postData(data, cb) {
-		data._seed = g_seed;
-		if(cb) {
-			eth._callbacks[data._seed] = cb;
-		}
-
-		if(data.args === undefined) {
-			data.args = [];
-		}
-
-		g_seed++;
-
-		window._messagingAdapter.call(this, JSON.stringify(data))
-	}
-})(this);
--- a/cmd/mist/assets/ext/q.js
+++ b/cmd/mist/assets/ext/q.js
--- a/cmd/mist/assets/ext/qml_messaging.js
+++ b/cmd/mist/assets/ext/qml_messaging.js
@ -1,30 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-function HandleMessage(data) {
-	var message;
-	try { message = JSON.parse(data) } catch(e) {};
-
-	if(message) {
-		switch(message.type) {
-			case "coinbase":
-				return eth.coinBase();
-			case "block":
-				return eth.blockByNumber(0);
-		}
-	}
-}
--- a/cmd/mist/assets/ext/qt_messaging_adapter.js
+++ b/cmd/mist/assets/ext/qt_messaging_adapter.js
@ -1,38 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-window._messagingAdapter = function(data) {
-	navigator.qt.postMessage(data);
-};
-
-navigator.qt.onmessage = function(ev) {
-	var data = JSON.parse(ev.data)
-
-	if(data._event !== undefined) {
-		eth.trigger(data._event, data.data);
-	} else {
-		if(data._seed) {
-			var cb = eth._callbacks[data._seed];
-			if(cb) {
-				cb.call(this, data.data)
-
-				// Remove the "trigger" callback
-				delete eth._callbacks[ev._seed];
-			}
-		}
-	}
-}
--- a/cmd/mist/assets/ext/setup.js
+++ b/cmd/mist/assets/ext/setup.js
@ -1,8 +0,0 @@
-(function() {
-    if (typeof(Promise) === "undefined")
-        window.Promise = Q.Promise;
-
-    var eth = web3.eth;
-
-    web3.setProvider(new web3.providers.QtProvider());
-})()
--- a/cmd/mist/assets/ext/string.js
+++ b/cmd/mist/assets/ext/string.js
@ -1,75 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-String.prototype.pad = function(l, r) {
-	if (r === undefined) {
-		r = l
-		if (!(this.substr(0, 2) == "0x" || /^\d+$/.test(this)))
-			l = 0
-	}
-	var ret = this.bin();
-	while (ret.length < l)
-		ret = "\0" + ret
-	while (ret.length < r)
-		ret = ret + "\0"
-	return ret;
-}
-
-String.prototype.unpad = function() {
-	var i = this.length;
-	while (i && this[i - 1] == "\0")
-		--i
-	return this.substr(0, i)
-}
-
-String.prototype.bin = function() {
-	if (this.substr(0, 2) == "0x") {
-		bytes = []
-		var i = 2;
-
-		// Check if it's odd - pad with a zero if so.
-		if (this.length % 2)
-			bytes.push(parseInt(this.substr(i++, 1), 16))
-
-		for (; i < this.length - 1; i += 2)
-			bytes.push(parseInt(this.substr(i, 2), 16));
-
-		return String.fromCharCode.apply(String, bytes);
-	} else if (/^\d+$/.test(this))
-		return bigInt(this.substr(0)).toHex().bin()
-
-	// Otherwise we'll return the "String" object instead of an actual string
-	return this.substr(0, this.length)
-}
-
-String.prototype.unbin = function() {
-	var i, l, o = '';
-	for(i = 0, l = this.length; i < l; i++) {
-		var n = this.charCodeAt(i).toString(16);
-		o += n.length < 2 ? '0' + n : n;
-	}
-
-	return "0x" + o;
-}
-
-String.prototype.dec = function() {
-	return bigInt(this.substr(0)).toString()
-}
-
-String.prototype.hex = function() {
-	return bigInt(this.substr(0)).toHex()
-}
--- a/cmd/mist/assets/ext/test.html
+++ b/cmd/mist/assets/ext/test.html
@ -1,44 +0,0 @@
-<!doctype>
-<html>
-<head>
-<title>Tests</title>
-</head>
-
-<body>
-<button onclick="test();">Test me</button>
-
-<script type="text/javascript">
-function test() {
-	var filter = eth.watch({
-		latest: -1,
-		from: "e6716f9544a56c530d868e4bfbacb172315bdead",
-		altered: ["aabb", {id: "eeff", "at": "aabb"}],
-	});
-
-	filter.changed(function(messages) {
-		console.log("messages", messages)
-	})
-
-	filter.getMessages(function(messages) {
-			console.log("getMessages", messages)
-			});
-
-	eth.getEachStorageAt("9ef0f0d81e040012600b0c1abdef7c48f720f88a", function(entries) {
-			for(var i = 0; i < entries.length; i++) {
-				console.log(entries[i].key, " : ", entries[i].value)
-			}
-	})
-
-	eth.getBlock("f70097659f329a09642a27f11338d9269de64f1d4485786e36bfc410832148cd", function(block) {
-			console.log(block)
-	})
-
-	eth.mutan("var a = 10", function(code) {
-			console.log("code", code)
-	});
-}
-</script>
-
-</body>
-
-</html>
--- a/cmd/mist/assets/qml/main.qml
+++ b/cmd/mist/assets/qml/main.qml
@ -45,7 +45,6 @@ ApplicationWindow {

 		mainSplit.setView(wallet.view, wallet.menuItem);

-		console.log("starting browser")
 		newBrowserTab("http://etherian.io");

 		// Command setup
--- a/cmd/mist/assets/qml/views/browser.qml
+++ b/cmd/mist/assets/qml/views/browser.qml
@ -155,7 +155,7 @@ Rectangle {
 			onLoadingChanged: {
 				if (loadRequest.status == WebEngineView.LoadSucceededStatus) {
 					webview.runJavaScript(eth.readFile("bignumber.min.js"));
-					webview.runJavaScript(eth.readFile("dist/ethereum.js"));
+					webview.runJavaScript(eth.readFile("ethereum.js/dist/ethereum.js"));
 				}
 			}
 			onJavaScriptConsoleMessage: {
--- a/cmd/mist/flags.go
+++ b/cmd/mist/flags.go
@ -113,7 +113,7 @@ func Init() {
 	flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
 	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
 	flag.IntVar(&WsPort, "wsport", 40404, "port to start websocket rpc server on")
-	flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
+	flag.BoolVar(&StartRpc, "rpc", true, "start rpc server")
 	flag.BoolVar(&StartWebSockets, "ws", false, "start websocket server")
 	flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
 	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
--- a/core/filter.go
+++ b/core/filter.go
@ -12,6 +12,17 @@ type AccountChange struct {
 	Address, StateAddress []byte
 }

+type FilterOptions struct {
+	Earliest int64
+	Latest   int64
+
+	Address []byte
+	Topics  [][]byte
+
+	Skip int
+	Max  int
+}
+
 // Filtering interface
 type Filter struct {
 	eth      EthManager
@ -32,6 +43,16 @@ func NewFilter(eth EthManager) *Filter {
 	return &Filter{eth: eth}
 }

+func (self *Filter) SetOptions(options FilterOptions) {
+	self.earliest = options.Earliest
+	self.latest = options.Latest
+	self.skip = options.Skip
+	self.max = options.Max
+	self.address = options.Address
+	self.topics = options.Topics
+
+}
+
 // Set the earliest and latest block for filtering.
 // -1 = latest block (i.e., the current block)
 // hash = particular hash from-to
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@ -133,8 +133,7 @@ func ImportPreSaleKey(keyStore KeyStore2, keyJSON []byte, password string) (*Key
 	if err != nil {
 		return nil, err
 	}
-	id := uuid.NewRandom()
-	key.Id = &id
+	key.Id = uuid.NewRandom()
 	err = keyStore.StoreKey(key, password)
 	return key, err
 }
@ -167,9 +166,10 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error
 	ecKey := ToECDSA(ethPriv)
 	key = &Key{
 		Id:         nil,
+		Address:    PubkeyToAddress(ecKey.PublicKey),
 		PrivateKey: ecKey,
 	}
-	derivedAddr := ethutil.Bytes2Hex(key.Address())
+	derivedAddr := ethutil.Bytes2Hex(key.Address)
 	expectedAddr := preSaleKeyStruct.EthAddr
 	if derivedAddr != expectedAddr {
 		err = errors.New("decrypted addr not equal to expected addr")
@ -223,3 +223,8 @@ func PKCS7Unpad(in []byte) []byte {
 	}
 	return in[:len(in)-int(padding)]
 }
+
+func PubkeyToAddress(p ecdsa.PublicKey) []byte {
+	pubBytes := FromECDSAPub(&p)
+	return Sha3(pubBytes[1:])[12:]
+}
--- a/crypto/key.go
+++ b/crypto/key.go
@ -33,7 +33,9 @@ import (
 )

 type Key struct {
-	Id *uuid.UUID // Version 4 "random" for unique id not derived from key data
+	Id uuid.UUID // Version 4 "random" for unique id not derived from key data
+	// to simplify lookups we also store the address
+	Address []byte
 	// we only store privkey as pubkey/address can be derived from it
 	// privkey in this struct is always in plaintext
 	PrivateKey *ecdsa.PrivateKey
@ -41,6 +43,7 @@ type Key struct {

 type plainKeyJSON struct {
 	Id         []byte
+	Address    []byte
 	PrivateKey []byte
 }

@ -52,17 +55,14 @@ type cipherJSON struct {

 type encryptedKeyJSON struct {
 	Id      []byte
+	Address []byte
 	Crypto  cipherJSON
 }

-func (k *Key) Address() []byte {
-	pubBytes := FromECDSAPub(&k.PrivateKey.PublicKey)
-	return Sha3(pubBytes[1:])[12:]
-}
-
 func (k *Key) MarshalJSON() (j []byte, err error) {
 	jStruct := plainKeyJSON{
-		*k.Id,
+		k.Id,
+		k.Address,
 		FromECDSA(k.PrivateKey),
 	}
 	j, err = json.Marshal(jStruct)
@ -78,8 +78,8 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) {

 	u := new(uuid.UUID)
 	*u = keyJSON.Id
-	k.Id = u
-
+	k.Id = *u
+	k.Address = keyJSON.Address
 	k.PrivateKey = ToECDSA(keyJSON.PrivateKey)

 	return err
@ -101,7 +101,8 @@ func NewKey(rand io.Reader) *Key {

 	id := uuid.NewRandom()
 	key := &Key{
-		Id:         &id,
+		Id:         id,
+		Address:    PubkeyToAddress(privateKeyECDSA.PublicKey),
 		PrivateKey: privateKeyECDSA,
 	}
 	return key
--- a/crypto/key_store_passphrase.go
+++ b/crypto/key_store_passphrase.go
@ -69,6 +69,7 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	crand "crypto/rand"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"io"
@ -96,21 +97,26 @@ func (ks keyStorePassphrase) GenerateNewKey(rand io.Reader, auth string) (key *K
 	return GenerateNewKeyDefault(ks, rand, auth)
 }

-func (ks keyStorePassphrase) GetKey(keyId *uuid.UUID, auth string) (key *Key, err error) {
-	keyBytes, err := DecryptKey(ks, keyId, auth)
+func (ks keyStorePassphrase) GetKey(keyAddr []byte, auth string) (key *Key, err error) {
+	keyBytes, keyId, err := DecryptKey(ks, keyAddr, auth)
 	if err != nil {
 		return nil, err
 	}
 	key = &Key{
-		Id:         keyId,
+		Id:         uuid.UUID(keyId),
+		Address:    keyAddr,
 		PrivateKey: ToECDSA(keyBytes),
 	}
 	return key, err
 }

+func (ks keyStorePassphrase) GetKeyAddresses() (addresses [][]byte, err error) {
+	return GetKeyAddresses(ks.keysDirPath)
+}
+
 func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
 	authArray := []byte(auth)
-	salt := getEntropyCSPRNG(32)
+	salt := GetEntropyCSPRNG(32)
 	derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptr, scryptp, scryptdkLen)
 	if err != nil {
 		return err
@ -125,7 +131,7 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
 		return err
 	}

-	iv := getEntropyCSPRNG(aes.BlockSize) // 16
+	iv := GetEntropyCSPRNG(aes.BlockSize) // 16
 	AES256CBCEncrypter := cipher.NewCBCEncrypter(AES256Block, iv)
 	cipherText := make([]byte, len(toEncrypt))
 	AES256CBCEncrypter.CryptBlocks(cipherText, toEncrypt)
@ -136,7 +142,8 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
 		cipherText,
 	}
 	keyStruct := encryptedKeyJSON{
-		*key.Id,
+		key.Id,
+		key.Address,
 		cipherStruct,
 	}
 	keyJSON, err := json.Marshal(keyStruct)
@ -144,54 +151,53 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
 		return err
 	}

-	return WriteKeyFile(key.Id.String(), ks.keysDirPath, keyJSON)
+	return WriteKeyFile(key.Address, ks.keysDirPath, keyJSON)
 }

-func (ks keyStorePassphrase) DeleteKey(keyId *uuid.UUID, auth string) (err error) {
+func (ks keyStorePassphrase) DeleteKey(keyAddr []byte, auth string) (err error) {
 	// only delete if correct passphrase is given
-	_, err = DecryptKey(ks, keyId, auth)
+	_, _, err = DecryptKey(ks, keyAddr, auth)
 	if err != nil {
 		return err
 	}

-	keyDirPath := path.Join(ks.keysDirPath, keyId.String())
+	keyDirPath := path.Join(ks.keysDirPath, hex.EncodeToString(keyAddr))
 	return os.RemoveAll(keyDirPath)
 }

-func DecryptKey(ks keyStorePassphrase, keyId *uuid.UUID, auth string) (keyBytes []byte, err error) {
-	fileContent, err := GetKeyFile(ks.keysDirPath, keyId)
+func DecryptKey(ks keyStorePassphrase, keyAddr []byte, auth string) (keyBytes []byte, keyId []byte, err error) {
+	fileContent, err := GetKeyFile(ks.keysDirPath, keyAddr)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}

 	keyProtected := new(encryptedKeyJSON)
 	err = json.Unmarshal(fileContent, keyProtected)

+	keyId = keyProtected.Id
 	salt := keyProtected.Crypto.Salt
-
 	iv := keyProtected.Crypto.IV
-
 	cipherText := keyProtected.Crypto.CipherText

 	authArray := []byte(auth)
 	derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptr, scryptp, scryptdkLen)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	plainText, err := aesCBCDecrypt(derivedKey, cipherText, iv)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	keyBytes = plainText[:len(plainText)-32]
 	keyBytesHash := plainText[len(plainText)-32:]
 	if !bytes.Equal(Sha3(keyBytes), keyBytesHash) {
 		err = errors.New("Decryption failed: checksum mismatch")
-		return nil, err
+		return nil, nil, err
 	}
-	return keyBytes, err
+	return keyBytes, keyId, err
 }

-func getEntropyCSPRNG(n int) []byte {
+func GetEntropyCSPRNG(n int) []byte {
 	mainBuff := make([]byte, n)
 	_, err := io.ReadFull(crand.Reader, mainBuff)
 	if err != nil {
--- a/crypto/key_store_plain.go
+++ b/crypto/key_store_plain.go
@ -24,7 +24,7 @@
 package crypto

 import (
-	"code.google.com/p/go-uuid/uuid"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"io"
@ -38,9 +38,10 @@ import (
 type KeyStore2 interface {
 	// create new key using io.Reader entropy source and optionally using auth string
 	GenerateNewKey(io.Reader, string) (*Key, error)
-	GetKey(*uuid.UUID, string) (*Key, error) // key from id and auth string
+	GetKey([]byte, string) (*Key, error) // key from addr and auth string
+	GetKeyAddresses() ([][]byte, error)  // get all addresses
 	StoreKey(*Key, string) error         // store key optionally using auth string
-	DeleteKey(*uuid.UUID, string) error      // delete key by id and auth string
+	DeleteKey([]byte, string) error      // delete key by addr and auth string
 }

 type keyStorePlain struct {
@ -72,8 +73,8 @@ func GenerateNewKeyDefault(ks KeyStore2, rand io.Reader, auth string) (key *Key,
 	return key, err
 }

-func (ks keyStorePlain) GetKey(keyId *uuid.UUID, auth string) (key *Key, err error) {
-	fileContent, err := GetKeyFile(ks.keysDirPath, keyId)
+func (ks keyStorePlain) GetKey(keyAddr []byte, auth string) (key *Key, err error) {
+	fileContent, err := GetKeyFile(ks.keysDirPath, keyAddr)
 	if err != nil {
 		return nil, err
 	}
@ -83,32 +84,50 @@ func (ks keyStorePlain) GetKey(keyId *uuid.UUID, auth string) (key *Key, err err
 	return key, err
 }

+func (ks keyStorePlain) GetKeyAddresses() (addresses [][]byte, err error) {
+	return GetKeyAddresses(ks.keysDirPath)
+}
+
 func (ks keyStorePlain) StoreKey(key *Key, auth string) (err error) {
 	keyJSON, err := json.Marshal(key)
 	if err != nil {
 		return err
 	}
-	err = WriteKeyFile(key.Id.String(), ks.keysDirPath, keyJSON)
+	err = WriteKeyFile(key.Address, ks.keysDirPath, keyJSON)
 	return err
 }

-func (ks keyStorePlain) DeleteKey(keyId *uuid.UUID, auth string) (err error) {
-	keyDirPath := path.Join(ks.keysDirPath, keyId.String())
+func (ks keyStorePlain) DeleteKey(keyAddr []byte, auth string) (err error) {
+	keyDirPath := path.Join(ks.keysDirPath, hex.EncodeToString(keyAddr))
 	err = os.RemoveAll(keyDirPath)
 	return err
 }

-func GetKeyFile(keysDirPath string, keyId *uuid.UUID) (fileContent []byte, err error) {
-	id := keyId.String()
-	return ioutil.ReadFile(path.Join(keysDirPath, id, id))
+func GetKeyFile(keysDirPath string, keyAddr []byte) (fileContent []byte, err error) {
+	fileName := hex.EncodeToString(keyAddr)
+	return ioutil.ReadFile(path.Join(keysDirPath, fileName, fileName))
 }

-func WriteKeyFile(id string, keysDirPath string, content []byte) (err error) {
-	keyDirPath := path.Join(keysDirPath, id)
-	keyFilePath := path.Join(keyDirPath, id)
+func WriteKeyFile(addr []byte, keysDirPath string, content []byte) (err error) {
+	addrHex := hex.EncodeToString(addr)
+	keyDirPath := path.Join(keysDirPath, addrHex)
+	keyFilePath := path.Join(keyDirPath, addrHex)
 	err = os.MkdirAll(keyDirPath, 0700) // read, write and dir search for user
 	if err != nil {
 		return err
 	}
 	return ioutil.WriteFile(keyFilePath, content, 0600) // read, write for user
 }
+
+func GetKeyAddresses(keysDirPath string) (addresses [][]byte, err error) {
+	fileInfos, err := ioutil.ReadDir(keysDirPath)
+	if err != nil {
+		return nil, err
+	}
+	addresses = make([][]byte, len(fileInfos))
+	for i, fileInfo := range fileInfos {
+		addresses[i] = make([]byte, 40)
+		addresses[i] = []byte(fileInfo.Name())
+	}
+	return addresses, err
+}
--- a/crypto/key_store_test.go
+++ b/crypto/key_store_test.go
@ -15,12 +15,12 @@ func TestKeyStorePlain(t *testing.T) {
 	}

 	k2 := new(Key)
-	k2, err = ks.GetKey(k1.Id, pass)
+	k2, err = ks.GetKey(k1.Address, pass)
 	if err != nil {
 		t.Fatal(err)
 	}

-	if !reflect.DeepEqual(k1.Id, k2.Id) {
+	if !reflect.DeepEqual(k1.Address, k2.Address) {
 		t.Fatal(err)
 	}

@ -28,7 +28,7 @@ func TestKeyStorePlain(t *testing.T) {
 		t.Fatal(err)
 	}

-	err = ks.DeleteKey(k2.Id, pass)
+	err = ks.DeleteKey(k2.Address, pass)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -42,11 +42,11 @@ func TestKeyStorePassphrase(t *testing.T) {
 		t.Fatal(err)
 	}
 	k2 := new(Key)
-	k2, err = ks.GetKey(k1.Id, pass)
+	k2, err = ks.GetKey(k1.Address, pass)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(k1.Id, k2.Id) {
+	if !reflect.DeepEqual(k1.Address, k2.Address) {
 		t.Fatal(err)
 	}

@ -54,7 +54,7 @@ func TestKeyStorePassphrase(t *testing.T) {
 		t.Fatal(err)
 	}

-	err = ks.DeleteKey(k2.Id, pass) // also to clean up created files
+	err = ks.DeleteKey(k2.Address, pass) // also to clean up created files
 	if err != nil {
 		t.Fatal(err)
 	}
@ -68,17 +68,17 @@ func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
 		t.Fatal(err)
 	}

-	_, err = ks.GetKey(k1.Id, "bar") // wrong passphrase
+	_, err = ks.GetKey(k1.Address, "bar") // wrong passphrase
 	if err == nil {
 		t.Fatal(err)
 	}

-	err = ks.DeleteKey(k1.Id, "bar") // wrong passphrase
+	err = ks.DeleteKey(k1.Address, "bar") // wrong passphrase
 	if err == nil {
 		t.Fatal(err)
 	}

-	err = ks.DeleteKey(k1.Id, pass) // to clean up
+	err = ks.DeleteKey(k1.Address, pass) // to clean up
 	if err != nil {
 		t.Fatal(err)
 	}
--- a/gocoverage.sh
+++ b/gocoverage.sh
@ -15,7 +15,7 @@ if ls $dir/*.go &> /dev/null; then
    # echo $dir
    if [[ $dir != "./tests/vm" ]]
    then
-        go test -covermode=count -coverprofile=$dir/profile.tmp $dir
+        $GOROOT/bin/go test -covermode=count -coverprofile=$dir/profile.tmp $dir
    fi
    if [ -f $dir/profile.tmp ]
    then
@ -25,7 +25,7 @@ if ls $dir/*.go &> /dev/null; then
 fi
 done

-go tool cover -func profile.cov
+$GOROOT/bin/go tool cover -func profile.cov

 # To submit the test coverage result to coveralls.io,
 # use goveralls (https://github.com/mattn/goveralls)
--- a/javascript/javascript_runtime.go
+++ b/javascript/javascript_runtime.go
@ -58,8 +58,7 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
 	re.Vm.Run(jsLib)

 	// Load extra javascript files
-	re.LoadIntFile("string.js")
-	re.LoadIntFile("big.js")
+	re.LoadIntFile("bignumber.min.js")

 	// Subscribe to events
 	mux := ethereum.EventMux()
--- a/rpc/args.go
+++ b/rpc/args.go
@ -1,8 +1,7 @@
 package rpc

-import (
-	"encoding/json"
-)
+import "encoding/json"
+import "github.com/ethereum/go-ethereum/core"

 type GetBlockArgs struct {
 	BlockNumber int32
@ -30,33 +29,15 @@ func (obj *GetBlockArgs) requirements() error {
 }

 type NewTxArgs struct {
-	Sec       string `json:"sec"`
-	Recipient string `json:"recipient"`
+	From     string `json:"from"`
+	To       string `json:"to"`
 	Value    string `json:"value"`
 	Gas      string `json:"gas"`
-	GasPrice  string `json:"gasprice"`
-	Init      string `json:"init"`
-	Body      string `json:"body"`
-}
-
-// type TxResponse struct {
-//  Hash string
-// }
-
-func (obj *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
-	if err = json.Unmarshal(b, obj); err == nil {
-		return
-	}
-	return NewErrorResponse(ErrorDecodeArgs)
+	GasPrice string `json:"gasPrice"`
+	Data     string `json:"data"`
 }

 func (a *NewTxArgs) requirements() error {
-	if a.Recipient == "" {
-		return NewErrorResponse("Transact requires a 'recipient' address as argument")
-	}
-	if a.Value == "" {
-		return NewErrorResponse("Transact requires a 'value' as argument")
-	}
 	if a.Gas == "" {
 		return NewErrorResponse("Transact requires a 'gas' value as argument")
 	}
@ -66,22 +47,6 @@ func (a *NewTxArgs) requirements() error {
 	return nil
 }

-func (a *NewTxArgs) requirementsContract() error {
-	if a.Value == "" {
-		return NewErrorResponse("Create requires a 'value' as argument")
-	}
-	if a.Gas == "" {
-		return NewErrorResponse("Create requires a 'gas' value as argument")
-	}
-	if a.GasPrice == "" {
-		return NewErrorResponse("Create requires a 'gasprice' value as argument")
-	}
-	if a.Body == "" {
-		return NewErrorResponse("Create requires a 'body' value as argument")
-	}
-	return nil
-}
-
 type PushTxArgs struct {
 	Tx string `json:"tx"`
 }
@ -216,3 +181,40 @@ func (a *GetCodeAtArgs) requirements() error {
 	}
 	return nil
 }
+
+type Sha3Args struct {
+	Data string
+}
+
+func (obj *Sha3Args) UnmarshalJSON(b []byte) (err error) {
+	if err = json.Unmarshal(b, &obj.Data); err != nil {
+		return NewErrorResponse(ErrorDecodeArgs)
+	}
+	return
+}
+
+type FilterOptions struct {
+	Earliest int64
+	Latest   int64
+	Address  string
+	Topics   []string
+	Skip     int
+	Max      int
+}
+
+func toFilterOptions(options *FilterOptions) core.FilterOptions {
+	var opts core.FilterOptions
+	opts.Earliest = options.Earliest
+	opts.Latest = options.Latest
+	opts.Address = fromHex(options.Address)
+	opts.Topics = make([][]byte, len(options.Topics))
+	for i, topic := range options.Topics {
+		opts.Topics[i] = fromHex(topic)
+	}
+
+	return opts
+}
+
+type FilterChangedArgs struct {
+	n int
+}
--- a/rpc/message.go
+++ b/rpc/message.go
@ -20,6 +20,9 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/state"
 )

 const (
@ -56,6 +59,28 @@ type RpcRequest struct {
 	Params  []json.RawMessage `json:"params"`
 }

+func NewErrorResponse(msg string) error {
+	return errors.New(msg)
+}
+
+func NewErrorResponseWithError(msg string, err error) error {
+	return fmt.Errorf("%s: %v", msg, err)
+}
+
+func (req *RpcRequest) ToSha3Args() (*Sha3Args, error) {
+	if len(req.Params) < 1 {
+		return nil, NewErrorResponse(ErrorArguments)
+	}
+
+	args := new(Sha3Args)
+	r := bytes.NewReader(req.Params[0])
+	if err := json.NewDecoder(r).Decode(args); err != nil {
+		return nil, NewErrorResponse(ErrorDecodeArgs)
+	}
+	rpclogger.DebugDetailf("%T %v", args, args)
+	return args, nil
+}
+
 func (req *RpcRequest) ToGetBlockArgs() (*GetBlockArgs, error) {
 	if len(req.Params) < 1 {
 		return nil, NewErrorResponse(ErrorArguments)
@ -72,7 +97,7 @@ func (req *RpcRequest) ToGetBlockArgs() (*GetBlockArgs, error) {
 }

 func (req *RpcRequest) ToNewTxArgs() (*NewTxArgs, error) {
-	if len(req.Params) < 7 {
+	if len(req.Params) < 1 {
 		return nil, NewErrorResponse(ErrorArguments)
 	}

@ -80,7 +105,7 @@ func (req *RpcRequest) ToNewTxArgs() (*NewTxArgs, error) {
 	r := bytes.NewReader(req.Params[0])
 	err := json.NewDecoder(r).Decode(args)
 	if err != nil {
-		return nil, NewErrorResponse(ErrorDecodeArgs)
+		return nil, NewErrorResponseWithError(ErrorDecodeArgs, err)
 	}
 	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
@ -162,6 +187,55 @@ func (req *RpcRequest) ToGetCodeAtArgs() (*GetCodeAtArgs, error) {
 	return args, nil
 }

-func NewErrorResponse(msg string) error {
-	return errors.New(msg)
+func (req *RpcRequest) ToFilterArgs() (*FilterOptions, error) {
+	if len(req.Params) < 1 {
+		return nil, NewErrorResponse(ErrorArguments)
+	}
+
+	args := new(FilterOptions)
+	r := bytes.NewReader(req.Params[0])
+	err := json.NewDecoder(r).Decode(args)
+	if err != nil {
+		return nil, NewErrorResponse(ErrorDecodeArgs)
+	}
+	rpclogger.DebugDetailf("%T %v", args, args)
+	return args, nil
+}
+
+func (req *RpcRequest) ToFilterChangedArgs() (int, error) {
+	if len(req.Params) < 1 {
+		return 0, NewErrorResponse(ErrorArguments)
+	}
+
+	var id int
+	r := bytes.NewReader(req.Params[0])
+	err := json.NewDecoder(r).Decode(&id)
+	if err != nil {
+		return 0, NewErrorResponse(ErrorDecodeArgs)
+	}
+	rpclogger.DebugDetailf("%T %v", id, id)
+	return id, nil
+}
+
+type Log struct {
+	Address string   `json:"address"`
+	Topics  []string `json:"topics"`
+	Data    string   `json:"data"`
+}
+
+func toLogs(logs state.Logs) (ls []Log) {
+	ls = make([]Log, len(logs))
+
+	for i, log := range logs {
+		var l Log
+		l.Topics = make([]string, len(log.Topics()))
+		l.Address = toHex(log.Address())
+		l.Data = toHex(log.Data())
+		for j, topic := range log.Topics() {
+			l.Topics[j] = toHex(topic)
+		}
+		ls[i] = l
+	}
+
+	return
 }
--- a/rpc/packages.go
+++ b/rpc/packages.go
@ -26,24 +26,110 @@ For each request type, define the following:
 package rpc

 import (
+	"fmt"
 	"math/big"
 	"strings"
+	"sync"

+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/event/filter"
+	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/xeth"
 )

+func toHex(b []byte) string {
+	return "0x" + ethutil.Bytes2Hex(b)
+}
+func fromHex(s string) []byte {
+	if len(s) > 1 {
+		if s[0:2] == "0x" {
+			s = s[2:]
+		}
+		return ethutil.Hex2Bytes(s)
+	}
+	return nil
+}
+
 type RpcServer interface {
 	Start()
 	Stop()
 }

+type EthereumApi struct {
+	xeth          *xeth.XEth
+	filterManager *filter.FilterManager
+
+	mut  sync.RWMutex
+	logs map[int]state.Logs
+}
+
 func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
-	return &EthereumApi{xeth: xeth}
+	api := &EthereumApi{
+		xeth:          xeth,
+		filterManager: filter.NewFilterManager(xeth.Backend().EventMux()),
+		logs:          make(map[int]state.Logs),
+	}
+	go api.filterManager.Start()
+
+	return api
 }

-type EthereumApi struct {
-	xeth *xeth.XEth
+func (self *EthereumApi) NewFilter(args *FilterOptions, reply *interface{}) error {
+	var id int
+	filter := core.NewFilter(self.xeth.Backend())
+	filter.LogsCallback = func(logs state.Logs) {
+		self.mut.Lock()
+		defer self.mut.Unlock()
+
+		self.logs[id] = append(self.logs[id], logs...)
+	}
+	id = self.filterManager.InstallFilter(filter)
+	*reply = id
+
+	return nil
+}
+
+type Log struct {
+	Address string   `json:"address"`
+	Topics  []string `json:"topics"`
+	Data    string   `json:"data"`
+}
+
+func toLogs(logs state.Logs) (ls []Log) {
+	ls = make([]Log, len(logs))
+
+	for i, log := range logs {
+		var l Log
+		l.Topics = make([]string, len(log.Topics()))
+		l.Address = toHex(log.Address())
+		l.Data = toHex(log.Data())
+		for j, topic := range log.Topics() {
+			l.Topics[j] = toHex(topic)
+		}
+		ls[i] = l
+	}
+
+	return
+}
+
+func (self *EthereumApi) FilterChanged(id int, reply *interface{}) error {
+	self.mut.RLock()
+	defer self.mut.RUnlock()
+
+	*reply = toLogs(self.logs[id])
+
+	self.logs[id] = nil // empty the logs
+
+	return nil
+}
+
+func (self *EthereumApi) Logs(id int, reply *interface{}) error {
+	filter := self.filterManager.GetFilter(id)
+	*reply = toLogs(filter.Find())
+
+	return nil
 }

 func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
@ -65,18 +151,17 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
 	if err != nil {
 		return err
 	}
-	result, _ := p.xeth.Transact( /* TODO specify account */ args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
+	result, _ := p.xeth.Transact( /* TODO specify account */ args.To, args.Value, args.Gas, args.GasPrice, args.Data)
 	*reply = result
 	return nil
 }

-func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
-	err := args.requirementsContract()
+func (p *EthereumApi) Call(args *NewTxArgs, reply *interface{}) error {
+	result, err := p.xeth.Call( /* TODO specify account */ args.To, args.Value, args.Gas, args.GasPrice, args.Data)
 	if err != nil {
 		return err
 	}

-	result, _ := p.xeth.Transact( /* TODO specify account */ "", args.Value, args.Gas, args.GasPrice, args.Body)
 	*reply = result
 	return nil
 }
@ -148,7 +233,7 @@ func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) err
 		return err
 	}
 	state := p.xeth.State().SafeGet(args.Address)
-	*reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
+	*reply = toHex(state.Balance().Bytes())
 	return nil
 }

@ -161,6 +246,11 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
 	return nil
 }

+func (p *EthereumApi) Sha3(args *Sha3Args, reply *interface{}) error {
+	*reply = toHex(crypto.Sha3(fromHex(args.Data)))
+	return nil
+}
+
 func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
 	// Spec at https://github.com/ethereum/wiki/wiki/Generic-ON-RPC
 	rpclogger.DebugDetailf("%T %s", req.Params, req.Params)
@ -203,8 +293,38 @@ func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error
 			return err
 		}
 		return p.GetBlock(args, reply)
+	case "eth_transact":
+		args, err := req.ToNewTxArgs()
+		if err != nil {
+			return err
+		}
+		return p.Transact(args, reply)
+	case "eth_call":
+		args, err := req.ToNewTxArgs()
+		if err != nil {
+			return err
+		}
+		return p.Call(args, reply)
+	case "eth_newFilter":
+		args, err := req.ToFilterArgs()
+		if err != nil {
+			return err
+		}
+		return p.NewFilter(args, reply)
+	case "eth_changed":
+		args, err := req.ToFilterChangedArgs()
+		if err != nil {
+			return err
+		}
+		return p.FilterChanged(args, reply)
+	case "web3_sha3":
+		args, err := req.ToSha3Args()
+		if err != nil {
+			return err
+		}
+		return p.Sha3(args, reply)
 	default:
-		return NewErrorResponse(ErrorNotImplemented)
+		return NewErrorResponse(fmt.Sprintf("%v %s", ErrorNotImplemented, req.Method))
 	}

 	rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
--- a/vm/vm.go
+++ b/vm/vm.go
@ -634,6 +634,8 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I
 				continue
 			}

+			self.Printf(" ~> false")
+
 		case JUMPDEST:
 		case PC:
 			stack.Push(big.NewInt(int64(pc)))
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@ -12,7 +12,9 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/state"
 )

@ -22,19 +24,22 @@ var pipelogger = logger.NewLogger("XETH")
 type Backend interface {
 	BlockProcessor() *core.BlockProcessor
 	ChainManager() *core.ChainManager
-	KeyManager() *crypto.KeyManager
+	TxPool() *core.TxPool
+	PeerCount() int
 	IsMining() bool
 	IsListening() bool
-	PeerCount() int
+	Peers() []*p2p.Peer
+	KeyManager() *crypto.KeyManager
+	ClientIdentity() p2p.ClientIdentity
 	Db() ethutil.Database
-	TxPool() *core.TxPool
+	EventMux() *event.TypeMux
 }

 type XEth struct {
 	eth            Backend
 	blockProcessor *core.BlockProcessor
 	chainManager   *core.ChainManager
-	world          *State
+	state          *State
 }

 func New(eth Backend) *XEth {
@ -43,12 +48,16 @@ func New(eth Backend) *XEth {
 		blockProcessor: eth.BlockProcessor(),
 		chainManager:   eth.ChainManager(),
 	}
-	xeth.world = NewState(xeth)
+	xeth.state = NewState(xeth)

 	return xeth
 }

-func (self *XEth) State() *State { return self.world }
+func (self *XEth) Backend() Backend {
+	return self.eth
+}
+
+func (self *XEth) State() *State { return self.state }

 func (self *XEth) BlockByHash(strHash string) *Block {
 	hash := fromHex(strHash)
@ -204,6 +213,34 @@ func (self *XEth) PushTx(encodedTx string) (string, error) {
 	return toHex(tx.Hash()), nil
 }

+func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
+	if len(gasStr) == 0 {
+		gasStr = "100000"
+	}
+	if len(gasPriceStr) == 0 {
+		gasPriceStr = "1"
+	}
+
+	var (
+		statedb   = self.chainManager.TransState()
+		initiator = state.NewStateObject(self.eth.KeyManager().KeyPair().Address(), self.eth.Db())
+		block     = self.chainManager.CurrentBlock()
+		to        = statedb.GetOrNewStateObject(fromHex(toStr))
+		data      = fromHex(dataStr)
+		gas       = ethutil.Big(gasStr)
+		price     = ethutil.Big(gasPriceStr)
+		value     = ethutil.Big(valueStr)
+	)
+
+	vmenv := NewEnv(self.chainManager, statedb, block, value, initiator.Address())
+	res, err := vmenv.Call(initiator, to.Address(), data, gas, price, value)
+	if err != nil {
+		return "", err
+	}
+
+	return toHex(res), nil
+}
+
 func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {

 	var (