diff --git a/Dockerfile b/Dockerfile
index 726e6b71f..94a8f098f 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -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
diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go
new file mode 100644
index 000000000..067381a48
--- /dev/null
+++ 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
+}
diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go
new file mode 100644
index 000000000..f47fa80f0
--- /dev/null
+++ 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)
+	}
+}
diff --git a/accounts/abi/doc.go b/accounts/abi/doc.go
new file mode 100644
index 000000000..648c971e1
--- /dev/null
+++ 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
diff --git a/accounts/abi/numbers.go b/accounts/abi/numbers.go
new file mode 100644
index 000000000..378f6541e
--- /dev/null
+++ 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
+}
diff --git a/accounts/abi/numbers_test.go b/accounts/abi/numbers_test.go
new file mode 100644
index 000000000..319d7fb51
--- /dev/null
+++ 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()
+	}
+}
diff --git a/accounts/abi/profile.cov b/accounts/abi/profile.cov
new file mode 100644
index 000000000..d11179d05
--- /dev/null
+++ 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
diff --git a/accounts/abi/type.go b/accounts/abi/type.go
new file mode 100644
index 000000000..b2d4abbd3
--- /dev/null
+++ 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")
+}
diff --git a/accounts/account_manager.go b/accounts/account_manager.go
new file mode 100644
index 000000000..da0bd8900
--- /dev/null
+++ 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
+}
diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go
new file mode 100644
index 000000000..da9406ebe
--- /dev/null
+++ 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)
+	}
+}
diff --git a/cmd/disasm/main.go b/cmd/disasm/main.go
new file mode 100644
index 000000000..c07246b00
--- /dev/null
+++ 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()
+	}
+}
diff --git a/cmd/mist/assets/examples/abi.html b/cmd/mist/assets/examples/abi.html
new file mode 100644
index 000000000..8d172482c
--- /dev/null
+++ 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>
diff --git a/cmd/mist/assets/examples/balance.html b/cmd/mist/assets/examples/balance.html
new file mode 100644
index 000000000..bc483a879
--- /dev/null
+++ 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>
+
+
diff --git a/cmd/mist/assets/ext/big.js b/cmd/mist/assets/ext/big.js
deleted file mode 100644
index 145a6aa6c..000000000
--- a/cmd/mist/assets/ext/big.js
+++ /dev/null
@@ -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;
-}
-
diff --git a/cmd/mist/assets/ext/ethereum.js/.bowerrc b/cmd/mist/assets/ext/ethereum.js/.bowerrc
new file mode 100644
index 000000000..c3a8813e8
--- /dev/null
+++ b/cmd/mist/assets/ext/ethereum.js/.bowerrc
@@ -0,0 +1,5 @@
+{
+  "directory": "example/js/",
+  "cwd": "./",
+  "analytics": false
+}
\ No newline at end of file
diff --git a/cmd/mist/assets/ext/ethereum.js/.editorconfig b/cmd/mist/assets/ext/ethereum.js/.editorconfig
new file mode 100644
index 000000000..60a2751d3
--- /dev/null
+++ 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
\ No newline at end of file
diff --git a/cmd/mist/assets/ext/ethereum.js/.gitignore b/cmd/mist/assets/ext/ethereum.js/.gitignore
new file mode 100644
index 000000000..399b6dc88
--- /dev/null
+++ 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
diff --git a/cmd/mist/assets/ext/ethereum.js/.jshintrc b/cmd/mist/assets/ext/ethereum.js/.jshintrc
new file mode 100644
index 000000000..c0ec5f89d
--- /dev/null
+++ 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
+}
\ No newline at end of file
diff --git a/cmd/mist/assets/ext/ethereum.js/.npmignore b/cmd/mist/assets/ext/ethereum.js/.npmignore
new file mode 100644
index 000000000..5bbffe4fd
--- /dev/null
+++ 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
\ No newline at end of file
diff --git a/cmd/mist/assets/ext/ethereum.js/.travis.yml b/cmd/mist/assets/ext/ethereum.js/.travis.yml
new file mode 100644
index 000000000..83b21d840
--- /dev/null
+++ 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
+
diff --git a/cmd/mist/assets/ext/LICENSE b/cmd/mist/assets/ext/ethereum.js/LICENSE
similarity index 100%
rename from cmd/mist/assets/ext/LICENSE
rename to cmd/mist/assets/ext/ethereum.js/LICENSE
diff --git a/cmd/mist/assets/ext/README.md b/cmd/mist/assets/ext/ethereum.js/README.md
similarity index 100%
rename from cmd/mist/assets/ext/README.md
rename to cmd/mist/assets/ext/ethereum.js/README.md
diff --git a/cmd/mist/assets/ext/bower.json b/cmd/mist/assets/ext/ethereum.js/bower.json
similarity index 100%
rename from cmd/mist/assets/ext/bower.json
rename to cmd/mist/assets/ext/ethereum.js/bower.json
diff --git a/cmd/mist/assets/ext/dist/ethereum.js b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
similarity index 100%
rename from cmd/mist/assets/ext/dist/ethereum.js
rename to cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
diff --git a/cmd/mist/assets/ext/dist/ethereum.js.map b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
similarity index 100%
rename from cmd/mist/assets/ext/dist/ethereum.js.map
rename to cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
diff --git a/cmd/mist/assets/ext/dist/ethereum.min.js b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
similarity index 100%
rename from cmd/mist/assets/ext/dist/ethereum.min.js
rename to cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
diff --git a/cmd/mist/assets/ext/example/balance.html b/cmd/mist/assets/ext/ethereum.js/example/balance.html
similarity index 79%
rename from cmd/mist/assets/ext/example/balance.html
rename to cmd/mist/assets/ext/ethereum.js/example/balance.html
index 75c41dc8e..4b51c5a7d 100644
--- a/cmd/mist/assets/ext/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>
diff --git a/cmd/mist/assets/ext/example/contract.html b/cmd/mist/assets/ext/ethereum.js/example/contract.html
similarity index 100%
rename from cmd/mist/assets/ext/example/contract.html
rename to cmd/mist/assets/ext/ethereum.js/example/contract.html
diff --git a/cmd/mist/assets/ext/example/natspec_contract.html b/cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
similarity index 100%
rename from cmd/mist/assets/ext/example/natspec_contract.html
rename to cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
diff --git a/cmd/mist/assets/ext/example/node-app.js b/cmd/mist/assets/ext/ethereum.js/example/node-app.js
similarity index 100%
rename from cmd/mist/assets/ext/example/node-app.js
rename to cmd/mist/assets/ext/ethereum.js/example/node-app.js
diff --git a/cmd/mist/assets/ext/gulpfile.js b/cmd/mist/assets/ext/ethereum.js/gulpfile.js
similarity index 100%
rename from cmd/mist/assets/ext/gulpfile.js
rename to cmd/mist/assets/ext/ethereum.js/gulpfile.js
diff --git a/cmd/mist/assets/ext/index.js b/cmd/mist/assets/ext/ethereum.js/index.js
similarity index 100%
rename from cmd/mist/assets/ext/index.js
rename to cmd/mist/assets/ext/ethereum.js/index.js
diff --git a/cmd/mist/assets/ext/lib/abi.js b/cmd/mist/assets/ext/ethereum.js/lib/abi.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/abi.js
rename to cmd/mist/assets/ext/ethereum.js/lib/abi.js
diff --git a/cmd/mist/assets/ext/lib/contract.js b/cmd/mist/assets/ext/ethereum.js/lib/contract.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/contract.js
rename to cmd/mist/assets/ext/ethereum.js/lib/contract.js
diff --git a/cmd/mist/assets/ext/lib/filter.js b/cmd/mist/assets/ext/ethereum.js/lib/filter.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/filter.js
rename to cmd/mist/assets/ext/ethereum.js/lib/filter.js
diff --git a/cmd/mist/assets/ext/lib/httpsync.js b/cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/httpsync.js
rename to cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
diff --git a/cmd/mist/assets/ext/lib/local.js b/cmd/mist/assets/ext/ethereum.js/lib/local.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/local.js
rename to cmd/mist/assets/ext/ethereum.js/lib/local.js
diff --git a/cmd/mist/assets/ext/lib/providermanager.js b/cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/providermanager.js
rename to cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
diff --git a/cmd/mist/assets/ext/lib/qtsync.js b/cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/qtsync.js
rename to cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
diff --git a/cmd/mist/assets/ext/lib/web3.js b/cmd/mist/assets/ext/ethereum.js/lib/web3.js
similarity index 100%
rename from cmd/mist/assets/ext/lib/web3.js
rename to cmd/mist/assets/ext/ethereum.js/lib/web3.js
diff --git a/cmd/mist/assets/ext/package.json b/cmd/mist/assets/ext/ethereum.js/package.json
similarity index 100%
rename from cmd/mist/assets/ext/package.json
rename to cmd/mist/assets/ext/ethereum.js/package.json
diff --git a/cmd/mist/assets/ext/test/abi.parsers.js b/cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
similarity index 100%
rename from cmd/mist/assets/ext/test/abi.parsers.js
rename to cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
diff --git a/cmd/mist/assets/ext/test/db.methods.js b/cmd/mist/assets/ext/ethereum.js/test/db.methods.js
similarity index 100%
rename from cmd/mist/assets/ext/test/db.methods.js
rename to cmd/mist/assets/ext/ethereum.js/test/db.methods.js
diff --git a/cmd/mist/assets/ext/test/eth.methods.js b/cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
similarity index 100%
rename from cmd/mist/assets/ext/test/eth.methods.js
rename to cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
diff --git a/cmd/mist/assets/ext/test/mocha.opts b/cmd/mist/assets/ext/ethereum.js/test/mocha.opts
similarity index 100%
rename from cmd/mist/assets/ext/test/mocha.opts
rename to cmd/mist/assets/ext/ethereum.js/test/mocha.opts
diff --git a/cmd/mist/assets/ext/test/shh.methods.js b/cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
similarity index 100%
rename from cmd/mist/assets/ext/test/shh.methods.js
rename to cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
diff --git a/cmd/mist/assets/ext/test/utils.js b/cmd/mist/assets/ext/ethereum.js/test/utils.js
similarity index 100%
rename from cmd/mist/assets/ext/test/utils.js
rename to cmd/mist/assets/ext/ethereum.js/test/utils.js
diff --git a/cmd/mist/assets/ext/test/web3.methods.js b/cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
similarity index 100%
rename from cmd/mist/assets/ext/test/web3.methods.js
rename to cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
diff --git a/cmd/mist/assets/ext/home.html b/cmd/mist/assets/ext/home.html
deleted file mode 100644
index a524e8403..000000000
--- a/cmd/mist/assets/ext/home.html
+++ /dev/null
@@ -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>
-
diff --git a/cmd/mist/assets/ext/html_messaging.js b/cmd/mist/assets/ext/html_messaging.js
deleted file mode 100644
index f58eb7c29..000000000
--- a/cmd/mist/assets/ext/html_messaging.js
+++ /dev/null
@@ -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);
diff --git a/cmd/mist/assets/ext/q.js b/cmd/mist/assets/ext/q.js
deleted file mode 100644
index 23c4245ee..000000000
--- a/cmd/mist/assets/ext/q.js
+++ /dev/null
@@ -1,1909 +0,0 @@
-// vim:ts=4:sts=4:sw=4:
-/*!
- *
- * Copyright 2009-2012 Kris Kowal under the terms of the MIT
- * license found at http://github.com/kriskowal/q/raw/master/LICENSE
- *
- * With parts by Tyler Close
- * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
- * at http://www.opensource.org/licenses/mit-license.html
- * Forked at ref_send.js version: 2009-05-11
- *
- * With parts by Mark Miller
- * Copyright (C) 2011 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-(function (definition) {
-    // Turn off strict mode for this function so we can assign to global.Q
-    /* jshint strict: false */
-
-    // This file will function properly as a <script> tag, or a module
-    // using CommonJS and NodeJS or RequireJS module formats.  In
-    // Common/Node/RequireJS, the module exports the Q API and when
-    // executed as a simple <script>, it creates a Q global instead.
-
-    // Montage Require
-    if (typeof bootstrap === "function") {
-        bootstrap("promise", definition);
-
-    // CommonJS
-    } else if (typeof exports === "object" && typeof module === "object") {
-        module.exports = definition();
-
-    // RequireJS
-    } else if (typeof define === "function" && define.amd) {
-        define(definition);
-
-    // SES (Secure EcmaScript)
-    } else if (typeof ses !== "undefined") {
-        if (!ses.ok()) {
-            return;
-        } else {
-            ses.makeQ = definition;
-        }
-
-    // <script>
-    } else {
-        Q = definition();
-    }
-
-})(function () {
-"use strict";
-
-var hasStacks = false;
-try {
-    throw new Error();
-} catch (e) {
-    hasStacks = !!e.stack;
-}
-
-// All code after this point will be filtered from stack traces reported
-// by Q.
-var qStartingLine = captureLine();
-var qFileName;
-
-// shims
-
-// used for fallback in "allResolved"
-var noop = function () {};
-
-// Use the fastest possible means to execute a task in a future turn
-// of the event loop.
-var nextTick =(function () {
-    // linked list of tasks (single, with head node)
-    var head = {task: void 0, next: null};
-    var tail = head;
-    var flushing = false;
-    var requestTick = void 0;
-    var isNodeJS = false;
-
-    function flush() {
-        /* jshint loopfunc: true */
-
-        while (head.next) {
-            head = head.next;
-            var task = head.task;
-            head.task = void 0;
-            var domain = head.domain;
-
-            if (domain) {
-                head.domain = void 0;
-                domain.enter();
-            }
-
-            try {
-                task();
-
-            } catch (e) {
-                if (isNodeJS) {
-                    // In node, uncaught exceptions are considered fatal errors.
-                    // Re-throw them synchronously to interrupt flushing!
-
-                    // Ensure continuation if the uncaught exception is suppressed
-                    // listening "uncaughtException" events (as domains does).
-                    // Continue in next event to avoid tick recursion.
-                    if (domain) {
-                        domain.exit();
-                    }
-                    setTimeout(flush, 0);
-                    if (domain) {
-                        domain.enter();
-                    }
-
-                    throw e;
-
-                } else {
-                    // In browsers, uncaught exceptions are not fatal.
-                    // Re-throw them asynchronously to avoid slow-downs.
-                    setTimeout(function() {
-                       throw e;
-                    }, 0);
-                }
-            }
-
-            if (domain) {
-                domain.exit();
-            }
-        }
-
-        flushing = false;
-    }
-
-    nextTick = function (task) {
-        tail = tail.next = {
-            task: task,
-            domain: isNodeJS && process.domain,
-            next: null
-        };
-
-        if (!flushing) {
-            flushing = true;
-            requestTick();
-        }
-    };
-
-    if (typeof process !== "undefined" && process.nextTick) {
-        // Node.js before 0.9. Note that some fake-Node environments, like the
-        // Mocha test runner, introduce a `process` global without a `nextTick`.
-        isNodeJS = true;
-
-        requestTick = function () {
-            process.nextTick(flush);
-        };
-
-    } else if (typeof setImmediate === "function") {
-        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
-        if (typeof window !== "undefined") {
-            requestTick = setImmediate.bind(window, flush);
-        } else {
-            requestTick = function () {
-                setImmediate(flush);
-            };
-        }
-
-    } else if (typeof MessageChannel !== "undefined") {
-        // modern browsers
-        // http://www.nonblocking.io/2011/06/windownexttick.html
-        var channel = new MessageChannel();
-        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
-        // working message ports the first time a page loads.
-        channel.port1.onmessage = function () {
-            requestTick = requestPortTick;
-            channel.port1.onmessage = flush;
-            flush();
-        };
-        var requestPortTick = function () {
-            // Opera requires us to provide a message payload, regardless of
-            // whether we use it.
-            channel.port2.postMessage(0);
-        };
-        requestTick = function () {
-            setTimeout(flush, 0);
-            requestPortTick();
-        };
-
-    } else {
-        // old browsers
-        requestTick = function () {
-            setTimeout(flush, 0);
-        };
-    }
-
-    return nextTick;
-})();
-
-// Attempt to make generics safe in the face of downstream
-// modifications.
-// There is no situation where this is necessary.
-// If you need a security guarantee, these primordials need to be
-// deeply frozen anyway, and if you don’t need a security guarantee,
-// this is just plain paranoid.
-// However, this **might** have the nice side-effect of reducing the size of
-// the minified code by reducing x.call() to merely x()
-// See Mark Miller’s explanation of what this does.
-// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
-var call = Function.call;
-function uncurryThis(f) {
-    return function () {
-        return call.apply(f, arguments);
-    };
-}
-// This is equivalent, but slower:
-// uncurryThis = Function_bind.bind(Function_bind.call);
-// http://jsperf.com/uncurrythis
-
-var array_slice = uncurryThis(Array.prototype.slice);
-
-var array_reduce = uncurryThis(
-    Array.prototype.reduce || function (callback, basis) {
-        var index = 0,
-            length = this.length;
-        // concerning the initial value, if one is not provided
-        if (arguments.length === 1) {
-            // seek to the first value in the array, accounting
-            // for the possibility that is is a sparse array
-            do {
-                if (index in this) {
-                    basis = this[index++];
-                    break;
-                }
-                if (++index >= length) {
-                    throw new TypeError();
-                }
-            } while (1);
-        }
-        // reduce
-        for (; index < length; index++) {
-            // account for the possibility that the array is sparse
-            if (index in this) {
-                basis = callback(basis, this[index], index);
-            }
-        }
-        return basis;
-    }
-);
-
-var array_indexOf = uncurryThis(
-    Array.prototype.indexOf || function (value) {
-        // not a very good shim, but good enough for our one use of it
-        for (var i = 0; i < this.length; i++) {
-            if (this[i] === value) {
-                return i;
-            }
-        }
-        return -1;
-    }
-);
-
-var array_map = uncurryThis(
-    Array.prototype.map || function (callback, thisp) {
-        var self = this;
-        var collect = [];
-        array_reduce(self, function (undefined, value, index) {
-            collect.push(callback.call(thisp, value, index, self));
-        }, void 0);
-        return collect;
-    }
-);
-
-var object_create = Object.create || function (prototype) {
-    function Type() { }
-    Type.prototype = prototype;
-    return new Type();
-};
-
-var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
-
-var object_keys = Object.keys || function (object) {
-    var keys = [];
-    for (var key in object) {
-        if (object_hasOwnProperty(object, key)) {
-            keys.push(key);
-        }
-    }
-    return keys;
-};
-
-var object_toString = uncurryThis(Object.prototype.toString);
-
-function isObject(value) {
-    return value === Object(value);
-}
-
-// generator related shims
-
-// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
-function isStopIteration(exception) {
-    return (
-        object_toString(exception) === "[object StopIteration]" ||
-        exception instanceof QReturnValue
-    );
-}
-
-// FIXME: Remove this helper and Q.return once ES6 generators are in
-// SpiderMonkey.
-var QReturnValue;
-if (typeof ReturnValue !== "undefined") {
-    QReturnValue = ReturnValue;
-} else {
-    QReturnValue = function (value) {
-        this.value = value;
-    };
-}
-
-// long stack traces
-
-var STACK_JUMP_SEPARATOR = "From previous event:";
-
-function makeStackTraceLong(error, promise) {
-    // If possible, transform the error stack trace by removing Node and Q
-    // cruft, then concatenating with the stack trace of `promise`. See #57.
-    if (hasStacks &&
-        promise.stack &&
-        typeof error === "object" &&
-        error !== null &&
-        error.stack &&
-        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
-    ) {
-        var stacks = [];
-        for (var p = promise; !!p; p = p.source) {
-            if (p.stack) {
-                stacks.unshift(p.stack);
-            }
-        }
-        stacks.unshift(error.stack);
-
-        var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
-        error.stack = filterStackString(concatedStacks);
-    }
-}
-
-function filterStackString(stackString) {
-    var lines = stackString.split("\n");
-    var desiredLines = [];
-    for (var i = 0; i < lines.length; ++i) {
-        var line = lines[i];
-
-        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
-            desiredLines.push(line);
-        }
-    }
-    return desiredLines.join("\n");
-}
-
-function isNodeFrame(stackLine) {
-    return stackLine.indexOf("(module.js:") !== -1 ||
-           stackLine.indexOf("(node.js:") !== -1;
-}
-
-function getFileNameAndLineNumber(stackLine) {
-    // Named functions: "at functionName (filename:lineNumber:columnNumber)"
-    // In IE10 function name can have spaces ("Anonymous function") O_o
-    var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
-    if (attempt1) {
-        return [attempt1[1], Number(attempt1[2])];
-    }
-
-    // Anonymous functions: "at filename:lineNumber:columnNumber"
-    var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
-    if (attempt2) {
-        return [attempt2[1], Number(attempt2[2])];
-    }
-
-    // Firefox style: "function@filename:lineNumber or @filename:lineNumber"
-    var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
-    if (attempt3) {
-        return [attempt3[1], Number(attempt3[2])];
-    }
-}
-
-function isInternalFrame(stackLine) {
-    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
-
-    if (!fileNameAndLineNumber) {
-        return false;
-    }
-
-    var fileName = fileNameAndLineNumber[0];
-    var lineNumber = fileNameAndLineNumber[1];
-
-    return fileName === qFileName &&
-        lineNumber >= qStartingLine &&
-        lineNumber <= qEndingLine;
-}
-
-// discover own file name and line number range for filtering stack
-// traces
-function captureLine() {
-    if (!hasStacks) {
-        return;
-    }
-
-    try {
-        throw new Error();
-    } catch (e) {
-        var lines = e.stack.split("\n");
-        var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
-        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
-        if (!fileNameAndLineNumber) {
-            return;
-        }
-
-        qFileName = fileNameAndLineNumber[0];
-        return fileNameAndLineNumber[1];
-    }
-}
-
-function deprecate(callback, name, alternative) {
-    return function () {
-        if (typeof console !== "undefined" &&
-            typeof console.warn === "function") {
-            console.warn(name + " is deprecated, use " + alternative +
-                         " instead.", new Error("").stack);
-        }
-        return callback.apply(callback, arguments);
-    };
-}
-
-// end of shims
-// beginning of real work
-
-/**
- * Constructs a promise for an immediate reference, passes promises through, or
- * coerces promises from different systems.
- * @param value immediate reference or promise
- */
-function Q(value) {
-    // If the object is already a Promise, return it directly.  This enables
-    // the resolve function to both be used to created references from objects,
-    // but to tolerably coerce non-promises to promises.
-    if (value instanceof Promise) {
-        return value;
-    }
-
-    // assimilate thenables
-    if (isPromiseAlike(value)) {
-        return coerce(value);
-    } else {
-        return fulfill(value);
-    }
-}
-Q.resolve = Q;
-
-/**
- * Performs a task in a future turn of the event loop.
- * @param {Function} task
- */
-Q.nextTick = nextTick;
-
-/**
- * Controls whether or not long stack traces will be on
- */
-Q.longStackSupport = false;
-
-/**
- * Constructs a {promise, resolve, reject} object.
- *
- * `resolve` is a callback to invoke with a more resolved value for the
- * promise. To fulfill the promise, invoke `resolve` with any value that is
- * not a thenable. To reject the promise, invoke `resolve` with a rejected
- * thenable, or invoke `reject` with the reason directly. To resolve the
- * promise to another thenable, thus putting it in the same state, invoke
- * `resolve` with that other thenable.
- */
-Q.defer = defer;
-function defer() {
-    // if "messages" is an "Array", that indicates that the promise has not yet
-    // been resolved.  If it is "undefined", it has been resolved.  Each
-    // element of the messages array is itself an array of complete arguments to
-    // forward to the resolved promise.  We coerce the resolution value to a
-    // promise using the `resolve` function because it handles both fully
-    // non-thenable values and other thenables gracefully.
-    var messages = [], progressListeners = [], resolvedPromise;
-
-    var deferred = object_create(defer.prototype);
-    var promise = object_create(Promise.prototype);
-
-    promise.promiseDispatch = function (resolve, op, operands) {
-        var args = array_slice(arguments);
-        if (messages) {
-            messages.push(args);
-            if (op === "when" && operands[1]) { // progress operand
-                progressListeners.push(operands[1]);
-            }
-        } else {
-            nextTick(function () {
-                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
-            });
-        }
-    };
-
-    // XXX deprecated
-    promise.valueOf = function () {
-        if (messages) {
-            return promise;
-        }
-        var nearerValue = nearer(resolvedPromise);
-        if (isPromise(nearerValue)) {
-            resolvedPromise = nearerValue; // shorten chain
-        }
-        return nearerValue;
-    };
-
-    promise.inspect = function () {
-        if (!resolvedPromise) {
-            return { state: "pending" };
-        }
-        return resolvedPromise.inspect();
-    };
-
-    if (Q.longStackSupport && hasStacks) {
-        try {
-            throw new Error();
-        } catch (e) {
-            // NOTE: don't try to use `Error.captureStackTrace` or transfer the
-            // accessor around; that causes memory leaks as per GH-111. Just
-            // reify the stack trace as a string ASAP.
-            //
-            // At the same time, cut off the first line; it's always just
-            // "[object Promise]\n", as per the `toString`.
-            promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
-        }
-    }
-
-    // NOTE: we do the checks for `resolvedPromise` in each method, instead of
-    // consolidating them into `become`, since otherwise we'd create new
-    // promises with the lines `become(whatever(value))`. See e.g. GH-252.
-
-    function become(newPromise) {
-        resolvedPromise = newPromise;
-        promise.source = newPromise;
-
-        array_reduce(messages, function (undefined, message) {
-            nextTick(function () {
-                newPromise.promiseDispatch.apply(newPromise, message);
-            });
-        }, void 0);
-
-        messages = void 0;
-        progressListeners = void 0;
-    }
-
-    deferred.promise = promise;
-    deferred.resolve = function (value) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(Q(value));
-    };
-
-    deferred.fulfill = function (value) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(fulfill(value));
-    };
-    deferred.reject = function (reason) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(reject(reason));
-    };
-    deferred.notify = function (progress) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        array_reduce(progressListeners, function (undefined, progressListener) {
-            nextTick(function () {
-                progressListener(progress);
-            });
-        }, void 0);
-    };
-
-    return deferred;
-}
-
-/**
- * Creates a Node-style callback that will resolve or reject the deferred
- * promise.
- * @returns a nodeback
- */
-defer.prototype.makeNodeResolver = function () {
-    var self = this;
-    return function (error, value) {
-        if (error) {
-            self.reject(error);
-        } else if (arguments.length > 2) {
-            self.resolve(array_slice(arguments, 1));
-        } else {
-            self.resolve(value);
-        }
-    };
-};
-
-/**
- * @param resolver {Function} a function that returns nothing and accepts
- * the resolve, reject, and notify functions for a deferred.
- * @returns a promise that may be resolved with the given resolve and reject
- * functions, or rejected by a thrown exception in resolver
- */
-Q.Promise = promise; // ES6
-Q.promise = promise;
-function promise(resolver) {
-    if (typeof resolver !== "function") {
-        throw new TypeError("resolver must be a function.");
-    }
-    var deferred = defer();
-    try {
-        resolver(deferred.resolve, deferred.reject, deferred.notify);
-    } catch (reason) {
-        deferred.reject(reason);
-    }
-    return deferred.promise;
-}
-
-promise.race = race; // ES6
-promise.all = all; // ES6
-promise.reject = reject; // ES6
-promise.resolve = Q; // ES6
-
-// XXX experimental.  This method is a way to denote that a local value is
-// serializable and should be immediately dispatched to a remote upon request,
-// instead of passing a reference.
-Q.passByCopy = function (object) {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return object;
-};
-
-Promise.prototype.passByCopy = function () {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return this;
-};
-
-/**
- * If two promises eventually fulfill to the same value, promises that value,
- * but otherwise rejects.
- * @param x {Any*}
- * @param y {Any*}
- * @returns {Any*} a promise for x and y if they are the same, but a rejection
- * otherwise.
- *
- */
-Q.join = function (x, y) {
-    return Q(x).join(y);
-};
-
-Promise.prototype.join = function (that) {
-    return Q([this, that]).spread(function (x, y) {
-        if (x === y) {
-            // TODO: "===" should be Object.is or equiv
-            return x;
-        } else {
-            throw new Error("Can't join: not the same: " + x + " " + y);
-        }
-    });
-};
-
-/**
- * Returns a promise for the first of an array of promises to become fulfilled.
- * @param answers {Array[Any*]} promises to race
- * @returns {Any*} the first promise to be fulfilled
- */
-Q.race = race;
-function race(answerPs) {
-    return promise(function(resolve, reject) {
-        // Switch to this once we can assume at least ES5
-        // answerPs.forEach(function(answerP) {
-        //     Q(answerP).then(resolve, reject);
-        // });
-        // Use this in the meantime
-        for (var i = 0, len = answerPs.length; i < len; i++) {
-            Q(answerPs[i]).then(resolve, reject);
-        }
-    });
-}
-
-Promise.prototype.race = function () {
-    return this.then(Q.race);
-};
-
-/**
- * Constructs a Promise with a promise descriptor object and optional fallback
- * function.  The descriptor contains methods like when(rejected), get(name),
- * set(name, value), post(name, args), and delete(name), which all
- * return either a value, a promise for a value, or a rejection.  The fallback
- * accepts the operation name, a resolver, and any further arguments that would
- * have been forwarded to the appropriate method above had a method been
- * provided with the proper name.  The API makes no guarantees about the nature
- * of the returned object, apart from that it is usable whereever promises are
- * bought and sold.
- */
-Q.makePromise = Promise;
-function Promise(descriptor, fallback, inspect) {
-    if (fallback === void 0) {
-        fallback = function (op) {
-            return reject(new Error(
-                "Promise does not support operation: " + op
-            ));
-        };
-    }
-    if (inspect === void 0) {
-        inspect = function () {
-            return {state: "unknown"};
-        };
-    }
-
-    var promise = object_create(Promise.prototype);
-
-    promise.promiseDispatch = function (resolve, op, args) {
-        var result;
-        try {
-            if (descriptor[op]) {
-                result = descriptor[op].apply(promise, args);
-            } else {
-                result = fallback.call(promise, op, args);
-            }
-        } catch (exception) {
-            result = reject(exception);
-        }
-        if (resolve) {
-            resolve(result);
-        }
-    };
-
-    promise.inspect = inspect;
-
-    // XXX deprecated `valueOf` and `exception` support
-    if (inspect) {
-        var inspected = inspect();
-        if (inspected.state === "rejected") {
-            promise.exception = inspected.reason;
-        }
-
-        promise.valueOf = function () {
-            var inspected = inspect();
-            if (inspected.state === "pending" ||
-                inspected.state === "rejected") {
-                return promise;
-            }
-            return inspected.value;
-        };
-    }
-
-    return promise;
-}
-
-Promise.prototype.toString = function () {
-    return "[object Promise]";
-};
-
-Promise.prototype.then = function (fulfilled, rejected, progressed) {
-    var self = this;
-    var deferred = defer();
-    var done = false;   // ensure the untrusted promise makes at most a
-                        // single call to one of the callbacks
-
-    function _fulfilled(value) {
-        try {
-            return typeof fulfilled === "function" ? fulfilled(value) : value;
-        } catch (exception) {
-            return reject(exception);
-        }
-    }
-
-    function _rejected(exception) {
-        if (typeof rejected === "function") {
-            makeStackTraceLong(exception, self);
-            try {
-                return rejected(exception);
-            } catch (newException) {
-                return reject(newException);
-            }
-        }
-        return reject(exception);
-    }
-
-    function _progressed(value) {
-        return typeof progressed === "function" ? progressed(value) : value;
-    }
-
-    nextTick(function () {
-        self.promiseDispatch(function (value) {
-            if (done) {
-                return;
-            }
-            done = true;
-
-            deferred.resolve(_fulfilled(value));
-        }, "when", [function (exception) {
-            if (done) {
-                return;
-            }
-            done = true;
-
-            deferred.resolve(_rejected(exception));
-        }]);
-    });
-
-    // Progress propagator need to be attached in the current tick.
-    self.promiseDispatch(void 0, "when", [void 0, function (value) {
-        var newValue;
-        var threw = false;
-        try {
-            newValue = _progressed(value);
-        } catch (e) {
-            threw = true;
-            if (Q.onerror) {
-                Q.onerror(e);
-            } else {
-                throw e;
-            }
-        }
-
-        if (!threw) {
-            deferred.notify(newValue);
-        }
-    }]);
-
-    return deferred.promise;
-};
-
-/**
- * Registers an observer on a promise.
- *
- * Guarantees:
- *
- * 1. that fulfilled and rejected will be called only once.
- * 2. that either the fulfilled callback or the rejected callback will be
- *    called, but not both.
- * 3. that fulfilled and rejected will not be called in this turn.
- *
- * @param value      promise or immediate reference to observe
- * @param fulfilled  function to be called with the fulfilled value
- * @param rejected   function to be called with the rejection exception
- * @param progressed function to be called on any progress notifications
- * @return promise for the return value from the invoked callback
- */
-Q.when = when;
-function when(value, fulfilled, rejected, progressed) {
-    return Q(value).then(fulfilled, rejected, progressed);
-}
-
-Promise.prototype.thenResolve = function (value) {
-    return this.then(function () { return value; });
-};
-
-Q.thenResolve = function (promise, value) {
-    return Q(promise).thenResolve(value);
-};
-
-Promise.prototype.thenReject = function (reason) {
-    return this.then(function () { throw reason; });
-};
-
-Q.thenReject = function (promise, reason) {
-    return Q(promise).thenReject(reason);
-};
-
-/**
- * If an object is not a promise, it is as "near" as possible.
- * If a promise is rejected, it is as "near" as possible too.
- * If it’s a fulfilled promise, the fulfillment value is nearer.
- * If it’s a deferred promise and the deferred has been resolved, the
- * resolution is "nearer".
- * @param object
- * @returns most resolved (nearest) form of the object
- */
-
-// XXX should we re-do this?
-Q.nearer = nearer;
-function nearer(value) {
-    if (isPromise(value)) {
-        var inspected = value.inspect();
-        if (inspected.state === "fulfilled") {
-            return inspected.value;
-        }
-    }
-    return value;
-}
-
-/**
- * @returns whether the given object is a promise.
- * Otherwise it is a fulfilled value.
- */
-Q.isPromise = isPromise;
-function isPromise(object) {
-    return isObject(object) &&
-        typeof object.promiseDispatch === "function" &&
-        typeof object.inspect === "function";
-}
-
-Q.isPromiseAlike = isPromiseAlike;
-function isPromiseAlike(object) {
-    return isObject(object) && typeof object.then === "function";
-}
-
-/**
- * @returns whether the given object is a pending promise, meaning not
- * fulfilled or rejected.
- */
-Q.isPending = isPending;
-function isPending(object) {
-    return isPromise(object) && object.inspect().state === "pending";
-}
-
-Promise.prototype.isPending = function () {
-    return this.inspect().state === "pending";
-};
-
-/**
- * @returns whether the given object is a value or fulfilled
- * promise.
- */
-Q.isFulfilled = isFulfilled;
-function isFulfilled(object) {
-    return !isPromise(object) || object.inspect().state === "fulfilled";
-}
-
-Promise.prototype.isFulfilled = function () {
-    return this.inspect().state === "fulfilled";
-};
-
-/**
- * @returns whether the given object is a rejected promise.
- */
-Q.isRejected = isRejected;
-function isRejected(object) {
-    return isPromise(object) && object.inspect().state === "rejected";
-}
-
-Promise.prototype.isRejected = function () {
-    return this.inspect().state === "rejected";
-};
-
-//// BEGIN UNHANDLED REJECTION TRACKING
-
-// This promise library consumes exceptions thrown in handlers so they can be
-// handled by a subsequent promise.  The exceptions get added to this array when
-// they are created, and removed when they are handled.  Note that in ES6 or
-// shimmed environments, this would naturally be a `Set`.
-var unhandledReasons = [];
-var unhandledRejections = [];
-var trackUnhandledRejections = true;
-
-function resetUnhandledRejections() {
-    unhandledReasons.length = 0;
-    unhandledRejections.length = 0;
-
-    if (!trackUnhandledRejections) {
-        trackUnhandledRejections = true;
-    }
-}
-
-function trackRejection(promise, reason) {
-    if (!trackUnhandledRejections) {
-        return;
-    }
-
-    unhandledRejections.push(promise);
-    if (reason && typeof reason.stack !== "undefined") {
-        unhandledReasons.push(reason.stack);
-    } else {
-        unhandledReasons.push("(no stack) " + reason);
-    }
-}
-
-function untrackRejection(promise) {
-    if (!trackUnhandledRejections) {
-        return;
-    }
-
-    var at = array_indexOf(unhandledRejections, promise);
-    if (at !== -1) {
-        unhandledRejections.splice(at, 1);
-        unhandledReasons.splice(at, 1);
-    }
-}
-
-Q.resetUnhandledRejections = resetUnhandledRejections;
-
-Q.getUnhandledReasons = function () {
-    // Make a copy so that consumers can't interfere with our internal state.
-    return unhandledReasons.slice();
-};
-
-Q.stopUnhandledRejectionTracking = function () {
-    resetUnhandledRejections();
-    trackUnhandledRejections = false;
-};
-
-resetUnhandledRejections();
-
-//// END UNHANDLED REJECTION TRACKING
-
-/**
- * Constructs a rejected promise.
- * @param reason value describing the failure
- */
-Q.reject = reject;
-function reject(reason) {
-    var rejection = Promise({
-        "when": function (rejected) {
-            // note that the error has been handled
-            if (rejected) {
-                untrackRejection(this);
-            }
-            return rejected ? rejected(reason) : this;
-        }
-    }, function fallback() {
-        return this;
-    }, function inspect() {
-        return { state: "rejected", reason: reason };
-    });
-
-    // Note that the reason has not been handled.
-    trackRejection(rejection, reason);
-
-    return rejection;
-}
-
-/**
- * Constructs a fulfilled promise for an immediate reference.
- * @param value immediate reference
- */
-Q.fulfill = fulfill;
-function fulfill(value) {
-    return Promise({
-        "when": function () {
-            return value;
-        },
-        "get": function (name) {
-            return value[name];
-        },
-        "set": function (name, rhs) {
-            value[name] = rhs;
-        },
-        "delete": function (name) {
-            delete value[name];
-        },
-        "post": function (name, args) {
-            // Mark Miller proposes that post with no name should apply a
-            // promised function.
-            if (name === null || name === void 0) {
-                return value.apply(void 0, args);
-            } else {
-                return value[name].apply(value, args);
-            }
-        },
-        "apply": function (thisp, args) {
-            return value.apply(thisp, args);
-        },
-        "keys": function () {
-            return object_keys(value);
-        }
-    }, void 0, function inspect() {
-        return { state: "fulfilled", value: value };
-    });
-}
-
-/**
- * Converts thenables to Q promises.
- * @param promise thenable promise
- * @returns a Q promise
- */
-function coerce(promise) {
-    var deferred = defer();
-    nextTick(function () {
-        try {
-            promise.then(deferred.resolve, deferred.reject, deferred.notify);
-        } catch (exception) {
-            deferred.reject(exception);
-        }
-    });
-    return deferred.promise;
-}
-
-/**
- * Annotates an object such that it will never be
- * transferred away from this process over any promise
- * communication channel.
- * @param object
- * @returns promise a wrapping of that object that
- * additionally responds to the "isDef" message
- * without a rejection.
- */
-Q.master = master;
-function master(object) {
-    return Promise({
-        "isDef": function () {}
-    }, function fallback(op, args) {
-        return dispatch(object, op, args);
-    }, function () {
-        return Q(object).inspect();
-    });
-}
-
-/**
- * Spreads the values of a promised array of arguments into the
- * fulfillment callback.
- * @param fulfilled callback that receives variadic arguments from the
- * promised array
- * @param rejected callback that receives the exception if the promise
- * is rejected.
- * @returns a promise for the return value or thrown exception of
- * either callback.
- */
-Q.spread = spread;
-function spread(value, fulfilled, rejected) {
-    return Q(value).spread(fulfilled, rejected);
-}
-
-Promise.prototype.spread = function (fulfilled, rejected) {
-    return this.all().then(function (array) {
-        return fulfilled.apply(void 0, array);
-    }, rejected);
-};
-
-/**
- * The async function is a decorator for generator functions, turning
- * them into asynchronous generators.  Although generators are only part
- * of the newest ECMAScript 6 drafts, this code does not cause syntax
- * errors in older engines.  This code should continue to work and will
- * in fact improve over time as the language improves.
- *
- * ES6 generators are currently part of V8 version 3.19 with the
- * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
- * for longer, but under an older Python-inspired form.  This function
- * works on both kinds of generators.
- *
- * Decorates a generator function such that:
- *  - it may yield promises
- *  - execution will continue when that promise is fulfilled
- *  - the value of the yield expression will be the fulfilled value
- *  - it returns a promise for the return value (when the generator
- *    stops iterating)
- *  - the decorated function returns a promise for the return value
- *    of the generator or the first rejected promise among those
- *    yielded.
- *  - if an error is thrown in the generator, it propagates through
- *    every following yield until it is caught, or until it escapes
- *    the generator function altogether, and is translated into a
- *    rejection for the promise returned by the decorated generator.
- */
-Q.async = async;
-function async(makeGenerator) {
-    return function () {
-        // when verb is "send", arg is a value
-        // when verb is "throw", arg is an exception
-        function continuer(verb, arg) {
-            var result;
-
-            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
-            // engine that has a deployed base of browsers that support generators.
-            // However, SM's generators use the Python-inspired semantics of
-            // outdated ES6 drafts.  We would like to support ES6, but we'd also
-            // like to make it possible to use generators in deployed browsers, so
-            // we also support Python-style generators.  At some point we can remove
-            // this block.
-
-            if (typeof StopIteration === "undefined") {
-                // ES6 Generators
-                try {
-                    result = generator[verb](arg);
-                } catch (exception) {
-                    return reject(exception);
-                }
-                if (result.done) {
-                    return Q(result.value);
-                } else {
-                    return when(result.value, callback, errback);
-                }
-            } else {
-                // SpiderMonkey Generators
-                // FIXME: Remove this case when SM does ES6 generators.
-                try {
-                    result = generator[verb](arg);
-                } catch (exception) {
-                    if (isStopIteration(exception)) {
-                        return Q(exception.value);
-                    } else {
-                        return reject(exception);
-                    }
-                }
-                return when(result, callback, errback);
-            }
-        }
-        var generator = makeGenerator.apply(this, arguments);
-        var callback = continuer.bind(continuer, "next");
-        var errback = continuer.bind(continuer, "throw");
-        return callback();
-    };
-}
-
-/**
- * The spawn function is a small wrapper around async that immediately
- * calls the generator and also ends the promise chain, so that any
- * unhandled errors are thrown instead of forwarded to the error
- * handler. This is useful because it's extremely common to run
- * generators at the top-level to work with libraries.
- */
-Q.spawn = spawn;
-function spawn(makeGenerator) {
-    Q.done(Q.async(makeGenerator)());
-}
-
-// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
-/**
- * Throws a ReturnValue exception to stop an asynchronous generator.
- *
- * This interface is a stop-gap measure to support generator return
- * values in older Firefox/SpiderMonkey.  In browsers that support ES6
- * generators like Chromium 29, just use "return" in your generator
- * functions.
- *
- * @param value the return value for the surrounding generator
- * @throws ReturnValue exception with the value.
- * @example
- * // ES6 style
- * Q.async(function* () {
- *      var foo = yield getFooPromise();
- *      var bar = yield getBarPromise();
- *      return foo + bar;
- * })
- * // Older SpiderMonkey style
- * Q.async(function () {
- *      var foo = yield getFooPromise();
- *      var bar = yield getBarPromise();
- *      Q.return(foo + bar);
- * })
- */
-Q["return"] = _return;
-function _return(value) {
-    throw new QReturnValue(value);
-}
-
-/**
- * The promised function decorator ensures that any promise arguments
- * are settled and passed as values (`this` is also settled and passed
- * as a value).  It will also ensure that the result of a function is
- * always a promise.
- *
- * @example
- * var add = Q.promised(function (a, b) {
- *     return a + b;
- * });
- * add(Q(a), Q(B));
- *
- * @param {function} callback The function to decorate
- * @returns {function} a function that has been decorated.
- */
-Q.promised = promised;
-function promised(callback) {
-    return function () {
-        return spread([this, all(arguments)], function (self, args) {
-            return callback.apply(self, args);
-        });
-    };
-}
-
-/**
- * sends a message to a value in a future turn
- * @param object* the recipient
- * @param op the name of the message operation, e.g., "when",
- * @param args further arguments to be forwarded to the operation
- * @returns result {Promise} a promise for the result of the operation
- */
-Q.dispatch = dispatch;
-function dispatch(object, op, args) {
-    return Q(object).dispatch(op, args);
-}
-
-Promise.prototype.dispatch = function (op, args) {
-    var self = this;
-    var deferred = defer();
-    nextTick(function () {
-        self.promiseDispatch(deferred.resolve, op, args);
-    });
-    return deferred.promise;
-};
-
-/**
- * Gets the value of a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to get
- * @return promise for the property value
- */
-Q.get = function (object, key) {
-    return Q(object).dispatch("get", [key]);
-};
-
-Promise.prototype.get = function (key) {
-    return this.dispatch("get", [key]);
-};
-
-/**
- * Sets the value of a property in a future turn.
- * @param object    promise or immediate reference for object object
- * @param name      name of property to set
- * @param value     new value of property
- * @return promise for the return value
- */
-Q.set = function (object, key, value) {
-    return Q(object).dispatch("set", [key, value]);
-};
-
-Promise.prototype.set = function (key, value) {
-    return this.dispatch("set", [key, value]);
-};
-
-/**
- * Deletes a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to delete
- * @return promise for the return value
- */
-Q.del = // XXX legacy
-Q["delete"] = function (object, key) {
-    return Q(object).dispatch("delete", [key]);
-};
-
-Promise.prototype.del = // XXX legacy
-Promise.prototype["delete"] = function (key) {
-    return this.dispatch("delete", [key]);
-};
-
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param value     a value to post, typically an array of
- *                  invocation arguments for promises that
- *                  are ultimately backed with `resolve` values,
- *                  as opposed to those backed with URLs
- *                  wherein the posted value can be any
- *                  JSON serializable object.
- * @return promise for the return value
- */
-// bound locally because it is used by other methods
-Q.mapply = // XXX As proposed by "Redsandro"
-Q.post = function (object, name, args) {
-    return Q(object).dispatch("post", [name, args]);
-};
-
-Promise.prototype.mapply = // XXX As proposed by "Redsandro"
-Promise.prototype.post = function (name, args) {
-    return this.dispatch("post", [name, args]);
-};
-
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param ...args   array of invocation arguments
- * @return promise for the return value
- */
-Q.send = // XXX Mark Miller's proposed parlance
-Q.mcall = // XXX As proposed by "Redsandro"
-Q.invoke = function (object, name /*...args*/) {
-    return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
-};
-
-Promise.prototype.send = // XXX Mark Miller's proposed parlance
-Promise.prototype.mcall = // XXX As proposed by "Redsandro"
-Promise.prototype.invoke = function (name /*...args*/) {
-    return this.dispatch("post", [name, array_slice(arguments, 1)]);
-};
-
-/**
- * Applies the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param args      array of application arguments
- */
-Q.fapply = function (object, args) {
-    return Q(object).dispatch("apply", [void 0, args]);
-};
-
-Promise.prototype.fapply = function (args) {
-    return this.dispatch("apply", [void 0, args]);
-};
-
-/**
- * Calls the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q["try"] =
-Q.fcall = function (object /* ...args*/) {
-    return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
-};
-
-Promise.prototype.fcall = function (/*...args*/) {
-    return this.dispatch("apply", [void 0, array_slice(arguments)]);
-};
-
-/**
- * Binds the promised function, transforming return values into a fulfilled
- * promise and thrown errors into a rejected one.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q.fbind = function (object /*...args*/) {
-    var promise = Q(object);
-    var args = array_slice(arguments, 1);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
-Promise.prototype.fbind = function (/*...args*/) {
-    var promise = this;
-    var args = array_slice(arguments);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
-
-/**
- * Requests the names of the owned properties of a promised
- * object in a future turn.
- * @param object    promise or immediate reference for target object
- * @return promise for the keys of the eventually settled object
- */
-Q.keys = function (object) {
-    return Q(object).dispatch("keys", []);
-};
-
-Promise.prototype.keys = function () {
-    return this.dispatch("keys", []);
-};
-
-/**
- * Turns an array of promises into a promise for an array.  If any of
- * the promises gets rejected, the whole array is rejected immediately.
- * @param {Array*} an array (or promise for an array) of values (or
- * promises for values)
- * @returns a promise for an array of the corresponding values
- */
-// By Mark Miller
-// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
-Q.all = all;
-function all(promises) {
-    return when(promises, function (promises) {
-        var countDown = 0;
-        var deferred = defer();
-        array_reduce(promises, function (undefined, promise, index) {
-            var snapshot;
-            if (
-                isPromise(promise) &&
-                (snapshot = promise.inspect()).state === "fulfilled"
-            ) {
-                promises[index] = snapshot.value;
-            } else {
-                ++countDown;
-                when(
-                    promise,
-                    function (value) {
-                        promises[index] = value;
-                        if (--countDown === 0) {
-                            deferred.resolve(promises);
-                        }
-                    },
-                    deferred.reject,
-                    function (progress) {
-                        deferred.notify({ index: index, value: progress });
-                    }
-                );
-            }
-        }, void 0);
-        if (countDown === 0) {
-            deferred.resolve(promises);
-        }
-        return deferred.promise;
-    });
-}
-
-Promise.prototype.all = function () {
-    return all(this);
-};
-
-/**
- * Waits for all promises to be settled, either fulfilled or
- * rejected.  This is distinct from `all` since that would stop
- * waiting at the first rejection.  The promise returned by
- * `allResolved` will never be rejected.
- * @param promises a promise for an array (or an array) of promises
- * (or values)
- * @return a promise for an array of promises
- */
-Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
-function allResolved(promises) {
-    return when(promises, function (promises) {
-        promises = array_map(promises, Q);
-        return when(all(array_map(promises, function (promise) {
-            return when(promise, noop, noop);
-        })), function () {
-            return promises;
-        });
-    });
-}
-
-Promise.prototype.allResolved = function () {
-    return allResolved(this);
-};
-
-/**
- * @see Promise#allSettled
- */
-Q.allSettled = allSettled;
-function allSettled(promises) {
-    return Q(promises).allSettled();
-}
-
-/**
- * Turns an array of promises into a promise for an array of their states (as
- * returned by `inspect`) when they have all settled.
- * @param {Array[Any*]} values an array (or promise for an array) of values (or
- * promises for values)
- * @returns {Array[State]} an array of states for the respective values.
- */
-Promise.prototype.allSettled = function () {
-    return this.then(function (promises) {
-        return all(array_map(promises, function (promise) {
-            promise = Q(promise);
-            function regardless() {
-                return promise.inspect();
-            }
-            return promise.then(regardless, regardless);
-        }));
-    });
-};
-
-/**
- * Captures the failure of a promise, giving an oportunity to recover
- * with a callback.  If the given promise is fulfilled, the returned
- * promise is fulfilled.
- * @param {Any*} promise for something
- * @param {Function} callback to fulfill the returned promise if the
- * given promise is rejected
- * @returns a promise for the return value of the callback
- */
-Q.fail = // XXX legacy
-Q["catch"] = function (object, rejected) {
-    return Q(object).then(void 0, rejected);
-};
-
-Promise.prototype.fail = // XXX legacy
-Promise.prototype["catch"] = function (rejected) {
-    return this.then(void 0, rejected);
-};
-
-/**
- * Attaches a listener that can respond to progress notifications from a
- * promise's originating deferred. This listener receives the exact arguments
- * passed to ``deferred.notify``.
- * @param {Any*} promise for something
- * @param {Function} callback to receive any progress notifications
- * @returns the given promise, unchanged
- */
-Q.progress = progress;
-function progress(object, progressed) {
-    return Q(object).then(void 0, void 0, progressed);
-}
-
-Promise.prototype.progress = function (progressed) {
-    return this.then(void 0, void 0, progressed);
-};
-
-/**
- * Provides an opportunity to observe the settling of a promise,
- * regardless of whether the promise is fulfilled or rejected.  Forwards
- * the resolution to the returned promise when the callback is done.
- * The callback can return a promise to defer completion.
- * @param {Any*} promise
- * @param {Function} callback to observe the resolution of the given
- * promise, takes no arguments.
- * @returns a promise for the resolution of the given promise when
- * ``fin`` is done.
- */
-Q.fin = // XXX legacy
-Q["finally"] = function (object, callback) {
-    return Q(object)["finally"](callback);
-};
-
-Promise.prototype.fin = // XXX legacy
-Promise.prototype["finally"] = function (callback) {
-    callback = Q(callback);
-    return this.then(function (value) {
-        return callback.fcall().then(function () {
-            return value;
-        });
-    }, function (reason) {
-        // TODO attempt to recycle the rejection with "this".
-        return callback.fcall().then(function () {
-            throw reason;
-        });
-    });
-};
-
-/**
- * Terminates a chain of promises, forcing rejections to be
- * thrown as exceptions.
- * @param {Any*} promise at the end of a chain of promises
- * @returns nothing
- */
-Q.done = function (object, fulfilled, rejected, progress) {
-    return Q(object).done(fulfilled, rejected, progress);
-};
-
-Promise.prototype.done = function (fulfilled, rejected, progress) {
-    var onUnhandledError = function (error) {
-        // forward to a future turn so that ``when``
-        // does not catch it and turn it into a rejection.
-        nextTick(function () {
-            makeStackTraceLong(error, promise);
-            if (Q.onerror) {
-                Q.onerror(error);
-            } else {
-                throw error;
-            }
-        });
-    };
-
-    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.
-    var promise = fulfilled || rejected || progress ?
-        this.then(fulfilled, rejected, progress) :
-        this;
-
-    if (typeof process === "object" && process && process.domain) {
-        onUnhandledError = process.domain.bind(onUnhandledError);
-    }
-
-    promise.then(void 0, onUnhandledError);
-};
-
-/**
- * Causes a promise to be rejected if it does not get fulfilled before
- * some milliseconds time out.
- * @param {Any*} promise
- * @param {Number} milliseconds timeout
- * @param {Any*} custom error message or Error object (optional)
- * @returns a promise for the resolution of the given promise if it is
- * fulfilled before the timeout, otherwise rejected.
- */
-Q.timeout = function (object, ms, error) {
-    return Q(object).timeout(ms, error);
-};
-
-Promise.prototype.timeout = function (ms, error) {
-    var deferred = defer();
-    var timeoutId = setTimeout(function () {
-        if (!error || "string" === typeof error) {
-            error = new Error(error || "Timed out after " + ms + " ms");
-            error.code = "ETIMEDOUT";
-        }
-        deferred.reject(error);
-    }, ms);
-
-    this.then(function (value) {
-        clearTimeout(timeoutId);
-        deferred.resolve(value);
-    }, function (exception) {
-        clearTimeout(timeoutId);
-        deferred.reject(exception);
-    }, deferred.notify);
-
-    return deferred.promise;
-};
-
-/**
- * Returns a promise for the given value (or promised value), some
- * milliseconds after it resolved. Passes rejections immediately.
- * @param {Any*} promise
- * @param {Number} milliseconds
- * @returns a promise for the resolution of the given promise after milliseconds
- * time has elapsed since the resolution of the given promise.
- * If the given promise rejects, that is passed immediately.
- */
-Q.delay = function (object, timeout) {
-    if (timeout === void 0) {
-        timeout = object;
-        object = void 0;
-    }
-    return Q(object).delay(timeout);
-};
-
-Promise.prototype.delay = function (timeout) {
-    return this.then(function (value) {
-        var deferred = defer();
-        setTimeout(function () {
-            deferred.resolve(value);
-        }, timeout);
-        return deferred.promise;
-    });
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided as an array, and returns a promise.
- *
- *      Q.nfapply(FS.readFile, [__filename])
- *      .then(function (content) {
- *      })
- *
- */
-Q.nfapply = function (callback, args) {
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfapply = function (args) {
-    var deferred = defer();
-    var nodeArgs = array_slice(args);
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided individually, and returns a promise.
- * @example
- * Q.nfcall(FS.readFile, __filename)
- * .then(function (content) {
- * })
- *
- */
-Q.nfcall = function (callback /*...args*/) {
-    var args = array_slice(arguments, 1);
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfcall = function (/*...args*/) {
-    var nodeArgs = array_slice(arguments);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Wraps a NodeJS continuation passing function and returns an equivalent
- * version that returns a promise.
- * @example
- * Q.nfbind(FS.readFile, __filename)("utf-8")
- * .then(console.log)
- * .done()
- */
-Q.nfbind =
-Q.denodeify = function (callback /*...args*/) {
-    var baseArgs = array_slice(arguments, 1);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        Q(callback).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
-
-Promise.prototype.nfbind =
-Promise.prototype.denodeify = function (/*...args*/) {
-    var args = array_slice(arguments);
-    args.unshift(this);
-    return Q.denodeify.apply(void 0, args);
-};
-
-Q.nbind = function (callback, thisp /*...args*/) {
-    var baseArgs = array_slice(arguments, 2);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        function bound() {
-            return callback.apply(thisp, arguments);
-        }
-        Q(bound).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
-
-Promise.prototype.nbind = function (/*thisp, ...args*/) {
-    var args = array_slice(arguments, 0);
-    args.unshift(this);
-    return Q.nbind.apply(void 0, args);
-};
-
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback with a given array of arguments, plus a provided callback.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param {Array} args arguments to pass to the method; the callback
- * will be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nmapply = // XXX As proposed by "Redsandro"
-Q.npost = function (object, name, args) {
-    return Q(object).npost(name, args);
-};
-
-Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
-Promise.prototype.npost = function (name, args) {
-    var nodeArgs = array_slice(args || []);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback, forwarding the given variadic arguments, plus a provided
- * callback argument.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param ...args arguments to pass to the method; the callback will
- * be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nsend = // XXX Based on Mark Miller's proposed "send"
-Q.nmcall = // XXX Based on "Redsandro's" proposal
-Q.ninvoke = function (object, name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 2);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
-Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
-Promise.prototype.ninvoke = function (name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 1);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * If a function would like to support both Node continuation-passing-style and
- * promise-returning-style, it can end its internal promise chain with
- * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
- * elects to use a nodeback, the result will be sent there.  If they do not
- * pass a nodeback, they will receive the result promise.
- * @param object a result (or a promise for a result)
- * @param {Function} nodeback a Node.js-style callback
- * @returns either the promise or nothing
- */
-Q.nodeify = nodeify;
-function nodeify(object, nodeback) {
-    return Q(object).nodeify(nodeback);
-}
-
-Promise.prototype.nodeify = function (nodeback) {
-    if (nodeback) {
-        this.then(function (value) {
-            nextTick(function () {
-                nodeback(null, value);
-            });
-        }, function (error) {
-            nextTick(function () {
-                nodeback(error);
-            });
-        });
-    } else {
-        return this;
-    }
-};
-
-// All code before this point will be filtered from stack traces.
-var qEndingLine = captureLine();
-
-return Q;
-
-});
-
diff --git a/cmd/mist/assets/ext/qml_messaging.js b/cmd/mist/assets/ext/qml_messaging.js
deleted file mode 100644
index 031c5efd1..000000000
--- a/cmd/mist/assets/ext/qml_messaging.js
+++ /dev/null
@@ -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);
-		}
-	}
-}
diff --git a/cmd/mist/assets/ext/qt_messaging_adapter.js b/cmd/mist/assets/ext/qt_messaging_adapter.js
deleted file mode 100644
index 04f8e034a..000000000
--- a/cmd/mist/assets/ext/qt_messaging_adapter.js
+++ /dev/null
@@ -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];
-			}
-		}
-	}
-}
diff --git a/cmd/mist/assets/ext/setup.js b/cmd/mist/assets/ext/setup.js
deleted file mode 100644
index 8317937b3..000000000
--- a/cmd/mist/assets/ext/setup.js
+++ /dev/null
@@ -1,8 +0,0 @@
-(function() {
-    if (typeof(Promise) === "undefined")
-        window.Promise = Q.Promise;
-
-    var eth = web3.eth;
-
-    web3.setProvider(new web3.providers.QtProvider());
-})()
diff --git a/cmd/mist/assets/ext/string.js b/cmd/mist/assets/ext/string.js
deleted file mode 100644
index e8dbd14d4..000000000
--- a/cmd/mist/assets/ext/string.js
+++ /dev/null
@@ -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()
-}
diff --git a/cmd/mist/assets/ext/test.html b/cmd/mist/assets/ext/test.html
deleted file mode 100644
index 4bac7d36f..000000000
--- a/cmd/mist/assets/ext/test.html
+++ /dev/null
@@ -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>
diff --git a/cmd/mist/assets/qml/main.qml b/cmd/mist/assets/qml/main.qml
index b8e56cd8b..1a8885e58 100644
--- 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
diff --git a/cmd/mist/assets/qml/views/browser.qml b/cmd/mist/assets/qml/views/browser.qml
index 0b70e0120..d6a762278 100644
--- 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: {
diff --git a/cmd/mist/flags.go b/cmd/mist/flags.go
index f530394c2..9dc3ae10a 100644
--- 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")
diff --git a/core/filter.go b/core/filter.go
index efdd819ed..d154e7b7a 100644
--- 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
diff --git a/crypto/crypto.go b/crypto/crypto.go
index 4b2cc7bb4..effa703d0 100644
--- 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:]
+}
diff --git a/crypto/key.go b/crypto/key.go
index ca29b691f..b9ad34f47 100644
--- 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
 }
 
@@ -51,18 +54,15 @@ type cipherJSON struct {
 }
 
 type encryptedKeyJSON struct {
-	Id     []byte
-	Crypto cipherJSON
-}
-
-func (k *Key) Address() []byte {
-	pubBytes := FromECDSAPub(&k.PrivateKey.PublicKey)
-	return Sha3(pubBytes[1:])[12:]
+	Id      []byte
+	Address []byte
+	Crypto  cipherJSON
 }
 
 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
diff --git a/crypto/key_store_passphrase.go b/crypto/key_store_passphrase.go
index 80bf49d68..0862b7886 100644
--- 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 {
diff --git a/crypto/key_store_plain.go b/crypto/key_store_plain.go
index b6e2a309a..6b76962a0 100644
--- 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
-	StoreKey(*Key, string) error             // store key optionally using auth string
-	DeleteKey(*uuid.UUID, string) error      // delete key by 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([]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
+}
diff --git a/crypto/key_store_test.go b/crypto/key_store_test.go
index 54efc739a..0d229ab65 100644
--- 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)
 	}
diff --git a/gocoverage.sh b/gocoverage.sh
index 24c8e9280..f908a2d66 100755
--- 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)
diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go
index c780eb754..398daf43a 100644
--- 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()
diff --git a/rpc/args.go b/rpc/args.go
index 8b01cc191..79519e7d2 100644
--- 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"`
-	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)
+	From     string `json:"from"`
+	To       string `json:"to"`
+	Value    string `json:"value"`
+	Gas      string `json:"gas"`
+	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
+}
diff --git a/rpc/message.go b/rpc/message.go
index caf50a6c0..05f66ee95 100644
--- 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
 }
diff --git a/rpc/packages.go b/rpc/packages.go
index 5d17a0f90..e8dc570fd 100644
--- 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()
 }
 
-func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
-	return &EthereumApi{xeth: xeth}
+type EthereumApi struct {
+	xeth          *xeth.XEth
+	filterManager *filter.FilterManager
+
+	mut  sync.RWMutex
+	logs map[int]state.Logs
 }
 
-type EthereumApi struct {
-	xeth *xeth.XEth
+func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
+	api := &EthereumApi{
+		xeth:          xeth,
+		filterManager: filter.NewFilterManager(xeth.Backend().EventMux()),
+		logs:          make(map[int]state.Logs),
+	}
+	go api.filterManager.Start()
+
+	return api
+}
+
+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)
diff --git a/vm/vm.go b/vm/vm.go
index 37e4249f5..4364b1cb9 100644
--- 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)))
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 89b2459b0..4cfa104d0 100644
--- 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 (