merge

2015-02-13 15:05:56 +01:00 · 2015-02-13 15:05:56 +01:00 · a5ea21cd85
commit a5ea21cd85
parent db24fb792c 38faf2c51a
311 changed files with 24908 additions and 8721 deletions
--- a/.gitignore
+++ b/.gitignore
@ -15,3 +15,5 @@
 .#*
 *#
 *~
+.project
+.settings
--- a/.travis.yml
+++ b/.travis.yml
@ -1,17 +1,18 @@
 language: go
 go:
-  - tip
+  - 1.4.1
 before_install:
-  - sudo add-apt-repository ppa:ubuntu-sdk-team/ppa -y
+  - sudo add-apt-repository ppa:beineri/opt-qt54 -y
  - sudo apt-get update -qq
-  - sudo apt-get install -yqq libgmp3-dev qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev libreadline6-dev
+  - sudo apt-get install -yqq libgmp3-dev libreadline6-dev qt54quickcontrols qt54webengine
 install:
  - go get code.google.com/p/go.tools/cmd/goimports
  - go get github.com/golang/lint/golint
  # - go get golang.org/x/tools/cmd/vet 
  - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
  - go get github.com/mattn/goveralls
-  - ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get $ETH_DEPS; fi
+  - go get gopkg.in/check.v1
+  - DEPS=$(go list -f '{{.Imports}}' ./... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$DEPS" ]; then go get -d -v $DEPS; fi
 before_script:
  - gofmt -l -w .
  - goimports -l -w .
@ -20,6 +21,11 @@ before_script:
  # - go test -race ./...
 script:
  - ./gocoverage.sh
+after_success:
+  - if [ "$COVERALLS_TOKEN" ]; then goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN; fi
 env:
-  - secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="
+  global:
+    - PKG_CONFIG_PATH=/opt/qt54/lib/pkgconfig
+    - LD_LIBRARY_PATH=/opt/qt54/lib
+    - secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="

--- a/36
+++ b/36
@ -3,39 +3,35 @@ FROM ubuntu:14.04
 ## Environment setup
 ENV HOME /root
 ENV GOPATH /root/go
-ENV PATH /go/bin:/root/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
+ENV PATH /golang/bin:/root/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
+ENV PKG_CONFIG_PATH /opt/qt54/lib/pkgconfig

 RUN mkdir -p /root/go
 ENV DEBIAN_FRONTEND noninteractive

 ## Install base dependencies
 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
+RUN apt-get install -y git mercurial build-essential software-properties-common pkg-config libgmp3-dev libreadline6-dev libpcre3-dev libpcre++-dev mesa-common-dev libglu1-mesa-dev

-## Build and install Go
-RUN hg clone -u release https://code.google.com/p/go
-RUN cd go && hg update go1.4
-RUN cd go/src && ./all.bash && go version
-
-## Install GUI dependencies
-RUN add-apt-repository ppa:ubuntu-sdk-team/ppa -y
+## Install Qt5.4 dependencies from PPA
+RUN add-apt-repository ppa:beineri/opt-qt54-trusty -y
 RUN apt-get update -y
-RUN apt-get install -y qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev
+RUN apt-get install -y qt54quickcontrols qt54webengine 

-## Fetch and install serpent-go
-RUN go get -v -d github.com/ethereum/serpent-go
-WORKDIR $GOPATH/src/github.com/ethereum/serpent-go
-# RUN git checkout master
-RUN git submodule update --init
-RUN go install -v
+## Build and install latest Go
+RUN git clone https://go.googlesource.com/go golang
+RUN cd golang && git checkout go1.4.1
+RUN cd golang/src && ./make.bash && go version

-# Fetch and install go-ethereum
-RUN go get -v -d github.com/ethereum/go-ethereum/...
+# this is a workaround, to make sure that docker's cache is invalidated whenever the git repo changes
+ADD https://api.github.com/repos/ethereum/go-ethereum/git/refs/heads/develop file_does_not_exist
+
+## Fetch and install go-ethereum
+RUN go get -u -v -d github.com/ethereum/go-ethereum/...
 WORKDIR $GOPATH/src/github.com/ethereum/go-ethereum
-# RUN git checkout develop
 RUN ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get $ETH_DEPS; fi
 RUN go install -v ./cmd/ethereum

-# Run JSON RPC
+## Run & expose JSON RPC
 ENTRYPOINT ["ethereum", "-rpc=true", "-rpcport=8080"]
 EXPOSE 8080
--- a/README.md
+++ b/README.md
@ -1,30 +1,26 @@
-[![Bugs](https://badge.waffle.io/ethereum/go-ethereum.png?label=bug&title=Bugs)](https://waffle.io/ethereum/go-ethereum)
-[![Stories in Ready](https://badge.waffle.io/ethereum/go-ethereum.png?label=ready&title=Ready)](https://waffle.io/ethereum/go-ethereum)
-[![Stories in
-Progress](https://badge.waffle.io/ethereum/go-ethereum.svg?label=in%20progress&title=In Progress)](http://waffle.io/ethereum/go-ethereum)
-
-Ethereum
-========
-
-[![Build
-Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20master%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20master%20branch/builds/-1) master [![Build
-Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20develop%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20develop%20branch/builds/-1) develop
-[![Coverage Status](https://coveralls.io/repos/ethereum/go-ethereum/badge.png?branch=tests)](https://coveralls.io/r/ethereum/go-ethereum?branch=tests) tests
+## Ethereum Go

 Ethereum Go Client © 2014 Jeffrey Wilcke.

-Current state: Proof of Concept 0.8
+          | Linux   | OSX | Windows
+----------|---------|-----|--------
+develop   | [![Build+Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20develop%20branch)](http://build.ethdev.com/builders/Linux%20Go%20develop%20branch/builds/-1) | [![Build+Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20develop%20branch)](http://build.ethdev.com/builders/OSX%20Go%20develop%20branch/builds/-1) | N/A
+master    | [![Build+Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20master%20branch)](http://build.ethdev.com/builders/Linux%20Go%20master%20branch/builds/-1) | [![Build+Status](http://build.ethdev.com/buildstatusimage?builder=OSX%20Go%20master%20branch)](http://build.ethdev.com/builders/OSX%20Go%20master%20branch/builds/-1) | N/A
+
+[![Bugs](https://badge.waffle.io/ethereum/go-ethereum.png?label=bug&title=Bugs)](https://waffle.io/ethereum/go-ethereum)
+[![Stories in Ready](https://badge.waffle.io/ethereum/go-ethereum.png?label=ready&title=Ready)](https://waffle.io/ethereum/go-ethereum)
+[![Stories in Progress](https://badge.waffle.io/ethereum/go-ethereum.svg?label=in%20progress&title=In Progress)](http://waffle.io/ethereum/go-ethereum)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ethereum/go-ethereum?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

-Ethereum is currently in its testing phase. 

 Build
 =====

-To build Mist (GUI):
+Mist (GUI):

 `go get github.com/ethereum/go-ethereum/cmd/mist`

-To build the node (CLI):
+Ethereum (CLI):

 `go get github.com/ethereum/go-ethereum/cmd/ethereum`

@ -33,7 +29,7 @@ For further, detailed, build instruction please see the [Wiki](https://github.co
 Automated (dev) builds
 ======================

-* [[OS X](http://build.ethdev.com/builds/OSX%20Go%20develop%20branch/latest/app/)]
+* [[OS X](http://build.ethdev.com/builds/OSX%20Go%20develop%20branch/Mist-OSX-latest.dmg)]
 * [Windows] Coming soon&trade;
 * [Linux] Coming soon&trade;

@ -46,9 +42,12 @@ Go Ethereum comes with several binaries found in
 * `mist` Official Ethereum Browser
 * `ethereum` Ethereum CLI
 * `ethtest` test tool which runs with the [tests](https://github.com/ethereum/testes) suit: 
-  `ethtest "`cat myfile.json`"`.
+  `cat file | ethtest`.
 * `evm` is a generic Ethereum Virtual Machine: `evm -code 60ff60ff -gas
  10000 -price 0 -dump`. See `-h` for a detailed description.
+* `rlpdump` converts a rlp stream to `interface{}`.
+* `peerserver` simple P2P (noi-ethereum) peer server.
+* `disasm` disassembles EVM code: `echo "6001" | disasm`

 General command line options
 ============================
@ -104,7 +103,7 @@ Style](http://golang.org/doc/effective_go.html#formatting).
 Unless structs fields are supposed to be directly accesible, provide
 Getters and hide the fields through Go's exporting facility.

-When you comment put meaningfull comments. Describe in detail what you
+When you comment put meaningful comments. Describe in detail what you
 want to achieve.

 *wrong*
@ -125,3 +124,4 @@ expect you to write tests for me so I don't have to test your code
 manually. (If you want to contribute by just writing tests that's fine
 too!)

+
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -0,0 +1,155 @@
+package abi
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// Callable method given a `Name` and whether the method is a constant.
+// If the method is `Const` no transaction needs to be created for this
+// particular Method call. It can easily be simulated using a local VM.
+// For example a `Balance()` method only needs to retrieve something
+// from the storage and therefor requires no Tx to be send to the
+// network. A method such as `Transact` does require a Tx and thus will
+// be flagged `true`.
+// Input specifies the required input parameters for this gives method.
+type Method struct {
+	Name   string
+	Const  bool
+	Input  []Argument
+	Return Type // not yet implemented
+}
+
+// Returns the methods string signature according to the ABI spec.
+//
+// Example
+//
+//     function foo(uint32 a, int b)    =    "foo(uint32,int256)"
+//
+// Please note that "int" is substitute for its canonical representation "int256"
+func (m Method) String() (out string) {
+	out += m.Name
+	types := make([]string, len(m.Input))
+	i := 0
+	for _, input := range m.Input {
+		types[i] = input.Type.String()
+		i++
+	}
+	out += "(" + strings.Join(types, ",") + ")"
+
+	return
+}
+
+func (m Method) Id() []byte {
+	return crypto.Sha3([]byte(m.String()))[:4]
+}
+
+// Argument holds the name of the argument and the corresponding type.
+// Types are used when packing and testing arguments.
+type Argument struct {
+	Name string
+	Type Type
+}
+
+func (a *Argument) UnmarshalJSON(data []byte) error {
+	var extarg struct {
+		Name string
+		Type string
+	}
+	err := json.Unmarshal(data, &extarg)
+	if err != nil {
+		return fmt.Errorf("argument json err: %v", err)
+	}
+
+	a.Type, err = NewType(extarg.Type)
+	if err != nil {
+		return err
+	}
+	a.Name = extarg.Name
+
+	return nil
+}
+
+// The ABI holds information about a contract's context and available
+// invokable methods. It will allow you to type check function calls and
+// packs data accordingly.
+type ABI struct {
+	Methods map[string]Method
+}
+
+// tests, tests whether the given input would result in a successful
+// call. Checks argument list count and matches input to `input`.
+func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) {
+	method := abi.Methods[name]
+
+	var ret []byte
+	for i, a := range args {
+		input := method.Input[i]
+
+		packed, err := input.Type.pack(a)
+		if err != nil {
+			return nil, fmt.Errorf("`%s` %v", name, err)
+		}
+		ret = append(ret, packed...)
+
+	}
+
+	return ret, nil
+}
+
+// Pack the given method name to conform the ABI. Method call's data
+// will consist of method_id, args0, arg1, ... argN. Method id consists
+// of 4 bytes and arguments are all 32 bytes.
+// Method ids are created from the first 4 bytes of the hash of the
+// methods string signature. (signature = baz(uint32,string32))
+func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
+	method, exist := abi.Methods[name]
+	if !exist {
+		return nil, fmt.Errorf("method '%s' not found", name)
+	}
+
+	// start with argument count match
+	if len(args) != len(method.Input) {
+		return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Input))
+	}
+
+	arguments, err := abi.pack(name, args...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set function id
+	packed := abi.Methods[name].Id()
+	packed = append(packed, arguments...)
+
+	return packed, nil
+}
+
+func (abi *ABI) UnmarshalJSON(data []byte) error {
+	var methods []Method
+	if err := json.Unmarshal(data, &methods); err != nil {
+		return err
+	}
+
+	abi.Methods = make(map[string]Method)
+	for _, method := range methods {
+		abi.Methods[method.Name] = method
+	}
+
+	return nil
+}
+
+func JSON(reader io.Reader) (ABI, error) {
+	dec := json.NewDecoder(reader)
+
+	var abi ABI
+	if err := dec.Decode(&abi); err != nil {
+		return ABI{}, err
+	}
+
+	return abi, nil
+}
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@ -0,0 +1,330 @@
+package abi
+
+import (
+	"bytes"
+	"math/big"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const jsondata = `
+[
+	{ "name" : "balance", "const" : true },
+	{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] }
+]`
+
+const jsondata2 = `
+[
+	{ "name" : "balance", "const" : true },
+	{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] },
+	{ "name" : "test", "const" : false, "input" : [ { "name" : "number", "type" : "uint32" } ] },
+	{ "name" : "string", "const" : false, "input" : [ { "name" : "input", "type" : "string" } ] },
+	{ "name" : "bool", "const" : false, "input" : [ { "name" : "input", "type" : "bool" } ] },
+	{ "name" : "address", "const" : false, "input" : [ { "name" : "input", "type" : "address" } ] },
+	{ "name" : "string32", "const" : false, "input" : [ { "name" : "input", "type" : "string32" } ] },
+	{ "name" : "uint64[2]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[2]" } ] },
+	{ "name" : "uint64[]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[]" } ] },
+	{ "name" : "foo", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" } ] },
+	{ "name" : "bar", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] },
+	{ "name" : "slice", "const" : false, "input" : [ { "name" : "input", "type" : "uint32[2]" } ] },
+	{ "name" : "slice256", "const" : false, "input" : [ { "name" : "input", "type" : "uint256[2]" } ] }
+]`
+
+func TestType(t *testing.T) {
+	typ, err := NewType("uint32")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Ptr {
+		t.Error("expected uint32 to have kind Ptr")
+	}
+
+	typ, err = NewType("uint32[]")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Slice {
+		t.Error("expected uint32[] to have type slice")
+	}
+	if typ.Type != ubig_ts {
+		t.Error("expcted uith32[] to have type uint64")
+	}
+
+	typ, err = NewType("uint32[2]")
+	if err != nil {
+		t.Error(err)
+	}
+	if typ.Kind != reflect.Slice {
+		t.Error("expected uint32[2] to have kind slice")
+	}
+	if typ.Type != ubig_ts {
+		t.Error("expcted uith32[2] to have type uint64")
+	}
+	if typ.Size != 2 {
+		t.Error("expected uint32[2] to have a size of 2")
+	}
+}
+
+func TestReader(t *testing.T) {
+	Uint256, _ := NewType("uint256")
+	exp := ABI{
+		Methods: map[string]Method{
+			"balance": Method{
+				"balance", true, nil, Type{},
+			},
+			"send": Method{
+				"send", false, []Argument{
+					Argument{"amount", Uint256},
+				}, Type{},
+			},
+		},
+	}
+
+	abi, err := JSON(strings.NewReader(jsondata))
+	if err != nil {
+		t.Error(err)
+	}
+
+	// deep equal fails for some reason
+	t.Skip()
+	if !reflect.DeepEqual(abi, exp) {
+		t.Errorf("\nabi: %v\ndoes not match exp: %v", abi, exp)
+	}
+}
+
+func TestTestNumbers(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("balance"); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := abi.Pack("balance", 1); err == nil {
+		t.Error("expected error for balance(1)")
+	}
+
+	if _, err := abi.Pack("doesntexist", nil); err == nil {
+		t.Errorf("doesntexist shouldn't exist")
+	}
+
+	if _, err := abi.Pack("doesntexist", 1); err == nil {
+		t.Errorf("doesntexist(1) shouldn't exist")
+	}
+
+	if _, err := abi.Pack("send", big.NewInt(1000)); err != nil {
+		t.Error(err)
+	}
+
+	i := new(int)
+	*i = 1000
+	if _, err := abi.Pack("send", i); err == nil {
+		t.Errorf("expected send( ptr ) to throw, requires *big.Int instead of *int")
+	}
+
+	if _, err := abi.Pack("send", 1000); err != nil {
+		t.Error("expected send(1000) to cast to big")
+	}
+
+	if _, err := abi.Pack("test", uint32(1000)); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestString(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("string", "hello world"); err != nil {
+		t.Error(err)
+	}
+
+	str10 := string(make([]byte, 10))
+	if _, err := abi.Pack("string32", str10); err != nil {
+		t.Error(err)
+	}
+
+	str32 := string(make([]byte, 32))
+	if _, err := abi.Pack("string32", str32); err != nil {
+		t.Error(err)
+	}
+
+	str33 := string(make([]byte, 33))
+	if _, err := abi.Pack("string32", str33); err == nil {
+		t.Error("expected str33 to throw out of bound error")
+	}
+}
+
+func TestTestBool(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("bool", true); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestSlice(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	addr := make([]byte, 20)
+	if _, err := abi.Pack("address", addr); err != nil {
+		t.Error(err)
+	}
+
+	addr = make([]byte, 21)
+	if _, err := abi.Pack("address", addr); err == nil {
+		t.Error("expected address of 21 width to throw")
+	}
+
+	slice := make([]byte, 2)
+	if _, err := abi.Pack("uint64[2]", slice); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := abi.Pack("uint64[]", slice); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestAddress(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	addr := make([]byte, 20)
+	if _, err := abi.Pack("address", addr); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestMethodSignature(t *testing.T) {
+	String, _ := NewType("string")
+	String32, _ := NewType("string32")
+	m := Method{"foo", false, []Argument{Argument{"bar", String32}, Argument{"baz", String}}, Type{}}
+	exp := "foo(string32,string)"
+	if m.String() != exp {
+		t.Error("signature mismatch", exp, "!=", m.String())
+	}
+
+	idexp := crypto.Sha3([]byte(exp))[:4]
+	if !bytes.Equal(m.Id(), idexp) {
+		t.Errorf("expected ids to match %x != %x", m.Id(), idexp)
+	}
+
+	uintt, _ := NewType("uint")
+	m = Method{"foo", false, []Argument{Argument{"bar", uintt}}, Type{}}
+	exp = "foo(uint256)"
+	if m.String() != exp {
+		t.Error("signature mismatch", exp, "!=", m.String())
+	}
+}
+
+func TestPack(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("foo(uint32)"))[:4]
+	sig = append(sig, make([]byte, 32)...)
+	sig[35] = 10
+
+	packed, err := abi.Pack("foo", uint32(10))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestMultiPack(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("bar(uint32,uint16)"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 10
+	sig[67] = 11
+
+	packed, err := abi.Pack("bar", uint32(10), uint16(11))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestPackSlice(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("slice(uint32[2])"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 1
+	sig[67] = 2
+
+	packed, err := abi.Pack("slice", []uint32{1, 2})
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
+
+func TestPackSliceBig(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	sig := crypto.Sha3([]byte("slice256(uint256[2])"))[:4]
+	sig = append(sig, make([]byte, 64)...)
+	sig[35] = 1
+	sig[67] = 2
+
+	packed, err := abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)})
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if !bytes.Equal(packed, sig) {
+		t.Errorf("expected %x got %x", sig, packed)
+	}
+}
--- a/accounts/abi/doc.go
+++ b/accounts/abi/doc.go
@ -0,0 +1,10 @@
+// Package abi implements the Ethereum ABI (Application Binary
+// Interface).
+//
+// The Ethereum ABI is strongly typed, known at compile time
+// and static. This ABI will handle basic type casting; unsigned
+// to signed and visa versa. It does not handle slice casting such
+// as unsigned slice to signed slice. Bit size type casting is also
+// handled. ints with a bit size of 32 will be properly cast to int256,
+// etc.
+package abi
--- a/accounts/abi/numbers.go
+++ b/accounts/abi/numbers.go
@ -0,0 +1,106 @@
+package abi
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+var big_t = reflect.TypeOf(&big.Int{})
+var ubig_t = reflect.TypeOf(&big.Int{})
+var byte_t = reflect.TypeOf(byte(0))
+var byte_ts = reflect.TypeOf([]byte(nil))
+var uint_t = reflect.TypeOf(uint(0))
+var uint8_t = reflect.TypeOf(uint8(0))
+var uint16_t = reflect.TypeOf(uint16(0))
+var uint32_t = reflect.TypeOf(uint32(0))
+var uint64_t = reflect.TypeOf(uint64(0))
+var int_t = reflect.TypeOf(int(0))
+var int8_t = reflect.TypeOf(int8(0))
+var int16_t = reflect.TypeOf(int16(0))
+var int32_t = reflect.TypeOf(int32(0))
+var int64_t = reflect.TypeOf(int64(0))
+
+var uint_ts = reflect.TypeOf([]uint(nil))
+var uint8_ts = reflect.TypeOf([]uint8(nil))
+var uint16_ts = reflect.TypeOf([]uint16(nil))
+var uint32_ts = reflect.TypeOf([]uint32(nil))
+var uint64_ts = reflect.TypeOf([]uint64(nil))
+var ubig_ts = reflect.TypeOf([]*big.Int(nil))
+
+var int_ts = reflect.TypeOf([]int(nil))
+var int8_ts = reflect.TypeOf([]int8(nil))
+var int16_ts = reflect.TypeOf([]int16(nil))
+var int32_ts = reflect.TypeOf([]int32(nil))
+var int64_ts = reflect.TypeOf([]int64(nil))
+var big_ts = reflect.TypeOf([]*big.Int(nil))
+
+// U256 will ensure unsigned 256bit on big nums
+func U256(n *big.Int) []byte {
+	return ethutil.LeftPadBytes(ethutil.U256(n).Bytes(), 32)
+}
+
+func S256(n *big.Int) []byte {
+	sint := ethutil.S256(n)
+	ret := ethutil.LeftPadBytes(sint.Bytes(), 32)
+	if sint.Cmp(ethutil.Big0) < 0 {
+		for i, b := range ret {
+			if b == 0 {
+				ret[i] = 1
+				continue
+			}
+			break
+		}
+	}
+
+	return ret
+}
+
+// S256 will ensure signed 256bit on big nums
+func U2U256(n uint64) []byte {
+	return U256(big.NewInt(int64(n)))
+}
+
+func S2S256(n int64) []byte {
+	return S256(big.NewInt(n))
+}
+
+// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
+func packNum(value reflect.Value, to byte) []byte {
+	switch kind := value.Kind(); kind {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if to == UintTy {
+			return U2U256(value.Uint())
+		} else {
+			return S2S256(int64(value.Uint()))
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if to == UintTy {
+			return U2U256(uint64(value.Int()))
+		} else {
+			return S2S256(value.Int())
+		}
+	case reflect.Ptr:
+		// This only takes care of packing and casting. No type checking is done here. It should be done prior to using this function.
+		if to == UintTy {
+			return U256(value.Interface().(*big.Int))
+		} else {
+			return S256(value.Interface().(*big.Int))
+		}
+
+	}
+
+	return nil
+}
+
+// checks whether the given reflect value is signed. This also works for slices with a number type
+func isSigned(v reflect.Value) bool {
+	switch v.Type() {
+	case ubig_ts, big_ts, big_t, ubig_t:
+		return true
+	case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t:
+		return true
+	}
+	return false
+}
--- a/accounts/abi/numbers_test.go
+++ b/accounts/abi/numbers_test.go
@ -0,0 +1,72 @@
+package abi
+
+import (
+	"bytes"
+	"math/big"
+	"reflect"
+	"testing"
+)
+
+func TestNumberTypes(t *testing.T) {
+	ubytes := make([]byte, 32)
+	ubytes[31] = 1
+	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+
+	unsigned := U256(big.NewInt(1))
+	if !bytes.Equal(unsigned, ubytes) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+
+	signed := S256(big.NewInt(1))
+	if !bytes.Equal(signed, ubytes) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+
+	signed = S256(big.NewInt(-1))
+	if !bytes.Equal(signed, sbytesmin) {
+		t.Error("expected %x got %x", ubytes, unsigned)
+	}
+}
+
+func TestPackNumber(t *testing.T) {
+	ubytes := make([]byte, 32)
+	ubytes[31] = 1
+	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+	maxunsigned := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
+
+	packed := packNum(reflect.ValueOf(1), IntTy)
+	if !bytes.Equal(packed, ubytes) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(-1), IntTy)
+	if !bytes.Equal(packed, sbytesmin) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(1), UintTy)
+	if !bytes.Equal(packed, ubytes) {
+		t.Errorf("expected %x got %x", ubytes, packed)
+	}
+	packed = packNum(reflect.ValueOf(-1), UintTy)
+	if !bytes.Equal(packed, maxunsigned) {
+		t.Errorf("expected %x got %x", maxunsigned, packed)
+	}
+
+	packed = packNum(reflect.ValueOf("string"), UintTy)
+	if packed != nil {
+		t.Errorf("expected 'string' to pack to nil. got %x instead", packed)
+	}
+}
+
+func TestSigned(t *testing.T) {
+	if isSigned(reflect.ValueOf(uint(10))) {
+		t.Error()
+	}
+
+	if !isSigned(reflect.ValueOf(int(10))) {
+		t.Error()
+	}
+
+	if !isSigned(reflect.ValueOf(big.NewInt(10))) {
+		t.Error()
+	}
+}
--- a/accounts/abi/profile.cov
+++ b/accounts/abi/profile.cov
@ -0,0 +1,106 @@
+mode: set
+github.com/ethereum/go-ethereum/abi/abi.go:27.39,31.32 4 1
+github.com/ethereum/go-ethereum/abi/abi.go:35.2,37.8 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:31.32,34.3 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:40.29,42.2 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:51.53,57.16 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:61.2,62.16 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:65.2,67.12 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:57.16,59.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:62.16,64.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:79.71,83.25 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:94.2,94.17 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:83.25,87.17 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:90.3,90.31 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:87.17,89.4 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:102.71,104.12 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:109.2,109.36 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:113.2,114.16 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:119.2,122.20 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:104.12,106.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:109.36,111.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:114.16,116.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:125.50,127.55 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:131.2,132.33 2 1
+github.com/ethereum/go-ethereum/abi/abi.go:136.2,136.12 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:127.55,129.3 1 0
+github.com/ethereum/go-ethereum/abi/abi.go:132.33,134.3 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:139.42,143.41 3 1
+github.com/ethereum/go-ethereum/abi/abi.go:147.2,147.17 1 1
+github.com/ethereum/go-ethereum/abi/abi.go:143.41,145.3 1 0
+github.com/ethereum/go-ethereum/abi/numbers.go:39.30,41.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:43.30,46.32 3 1
+github.com/ethereum/go-ethereum/abi/numbers.go:56.2,56.12 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:46.32,47.25 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:47.25,48.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:52.4,52.9 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:48.14,50.13 2 1
+github.com/ethereum/go-ethereum/abi/numbers.go:59.30,61.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:63.29,65.2 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:67.51,68.36 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:91.2,91.12 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:69.2,70.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:75.2,76.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:81.2,83.19 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:70.19,72.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:72.4,74.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:76.19,78.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:78.4,80.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:83.19,85.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:85.4,87.4 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:94.37,95.18 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:101.2,101.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:96.2,97.14 1 1
+github.com/ethereum/go-ethereum/abi/numbers.go:98.2,99.14 1 1
+github.com/ethereum/go-ethereum/abi/type.go:32.46,35.16 2 1
+github.com/ethereum/go-ethereum/abi/type.go:38.2,43.9 3 1
+github.com/ethereum/go-ethereum/abi/type.go:55.2,56.16 2 1
+github.com/ethereum/go-ethereum/abi/type.go:60.2,64.55 4 1
+github.com/ethereum/go-ethereum/abi/type.go:69.2,69.13 1 1
+github.com/ethereum/go-ethereum/abi/type.go:111.2,113.8 2 1
+github.com/ethereum/go-ethereum/abi/type.go:35.16,37.3 1 0
+github.com/ethereum/go-ethereum/abi/type.go:44.2,47.17 2 1
+github.com/ethereum/go-ethereum/abi/type.go:48.2,50.12 2 1
+github.com/ethereum/go-ethereum/abi/type.go:51.2,52.60 1 0
+github.com/ethereum/go-ethereum/abi/type.go:56.16,58.3 1 0
+github.com/ethereum/go-ethereum/abi/type.go:64.55,67.3 2 1
+github.com/ethereum/go-ethereum/abi/type.go:69.13,72.16 3 1
+github.com/ethereum/go-ethereum/abi/type.go:73.3,74.21 1 0
+github.com/ethereum/go-ethereum/abi/type.go:75.3,76.22 1 1
+github.com/ethereum/go-ethereum/abi/type.go:77.3,78.66 1 0
+github.com/ethereum/go-ethereum/abi/type.go:80.3,81.16 1 1
+github.com/ethereum/go-ethereum/abi/type.go:82.3,86.17 4 0
+github.com/ethereum/go-ethereum/abi/type.go:87.3,91.18 4 1
+github.com/ethereum/go-ethereum/abi/type.go:92.3,93.27 1 1
+github.com/ethereum/go-ethereum/abi/type.go:94.3,95.30 1 0
+github.com/ethereum/go-ethereum/abi/type.go:96.3,100.21 4 1
+github.com/ethereum/go-ethereum/abi/type.go:101.3,104.17 3 1
+github.com/ethereum/go-ethereum/abi/type.go:107.3,108.60 1 0
+github.com/ethereum/go-ethereum/abi/type.go:104.17,106.5 1 1
+github.com/ethereum/go-ethereum/abi/type.go:116.37,118.2 1 1
+github.com/ethereum/go-ethereum/abi/type.go:126.51,128.36 2 1
+github.com/ethereum/go-ethereum/abi/type.go:179.2,179.20 1 0
+github.com/ethereum/go-ethereum/abi/type.go:129.2,130.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:133.3,133.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:134.2,135.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:138.3,138.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:139.2,142.49 1 1
+github.com/ethereum/go-ethereum/abi/type.go:145.3,145.34 1 1
+github.com/ethereum/go-ethereum/abi/type.go:146.2,147.42 1 1
+github.com/ethereum/go-ethereum/abi/type.go:150.3,150.60 1 1
+github.com/ethereum/go-ethereum/abi/type.go:151.2,152.42 1 1
+github.com/ethereum/go-ethereum/abi/type.go:157.3,157.23 1 1
+github.com/ethereum/go-ethereum/abi/type.go:162.3,162.78 1 1
+github.com/ethereum/go-ethereum/abi/type.go:166.3,167.36 2 1
+github.com/ethereum/go-ethereum/abi/type.go:170.3,170.21 1 1
+github.com/ethereum/go-ethereum/abi/type.go:171.2,172.19 1 1
+github.com/ethereum/go-ethereum/abi/type.go:130.23,132.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:135.23,137.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:142.49,144.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:147.42,149.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:152.42,154.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:157.23,159.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:162.78,164.4 1 0
+github.com/ethereum/go-ethereum/abi/type.go:167.36,169.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:172.19,174.4 1 1
+github.com/ethereum/go-ethereum/abi/type.go:174.4,176.4 1 0
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -0,0 +1,190 @@
+package abi
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+const (
+	IntTy byte = iota
+	UintTy
+	BoolTy
+	SliceTy
+	AddressTy
+	RealTy
+)
+
+// Type is the reflection of the supported argument type
+type Type struct {
+	Kind       reflect.Kind
+	Type       reflect.Type
+	Size       int
+	T          byte   // Our own type checking
+	stringKind string // holds the unparsed string for deriving signatures
+}
+
+// New type returns a fully parsed Type given by the input string or an error if it  can't be parsed.
+//
+// Strings can be in the format of:
+//
+// 	Input  = Type [ "[" [ Number ] "]" ] Name .
+// 	Type   = [ "u" ] "int" [ Number ] .
+//
+// Examples:
+//
+//      string     int       uint       real
+//      string32   int8      uint8      uint[]
+//      address    int256    uint256    real[2]
+func NewType(t string) (typ Type, err error) {
+	// 1. full string 2. type 3. (opt.) is slice 4. (opt.) size
+	freg, err := regexp.Compile("([a-zA-Z0-9]+)(\\[([0-9]*)?\\])?")
+	if err != nil {
+		return Type{}, err
+	}
+	res := freg.FindAllStringSubmatch(t, -1)[0]
+	var (
+		isslice bool
+		size    int
+	)
+	switch {
+	case res[3] != "":
+		// err is ignored. Already checked for number through the regexp
+		size, _ = strconv.Atoi(res[3])
+		isslice = true
+	case res[2] != "":
+		isslice = true
+		size = -1
+	case res[0] == "":
+		return Type{}, fmt.Errorf("type parse error for `%s`", t)
+	}
+
+	treg, err := regexp.Compile("([a-zA-Z]+)([0-9]*)?")
+	if err != nil {
+		return Type{}, err
+	}
+
+	parsedType := treg.FindAllStringSubmatch(res[1], -1)[0]
+	vsize, _ := strconv.Atoi(parsedType[2])
+	vtype := parsedType[1]
+	// substitute canonical representation
+	if vsize == 0 && (vtype == "int" || vtype == "uint") {
+		vsize = 256
+		t += "256"
+	}
+
+	if isslice {
+		typ.Kind = reflect.Slice
+		typ.Size = size
+		switch vtype {
+		case "int":
+			typ.Type = big_ts
+		case "uint":
+			typ.Type = ubig_ts
+		default:
+			return Type{}, fmt.Errorf("unsupported arg slice type: %s", t)
+		}
+	} else {
+		switch vtype {
+		case "int":
+			typ.Kind = reflect.Ptr
+			typ.Type = big_t
+			typ.Size = 256
+			typ.T = IntTy
+		case "uint":
+			typ.Kind = reflect.Ptr
+			typ.Type = ubig_t
+			typ.Size = 256
+			typ.T = UintTy
+		case "bool":
+			typ.Kind = reflect.Bool
+		case "real": // TODO
+			typ.Kind = reflect.Invalid
+		case "address":
+			typ.Kind = reflect.Slice
+			typ.Type = byte_ts
+			typ.Size = 20
+			typ.T = AddressTy
+		case "string":
+			typ.Kind = reflect.String
+			typ.Size = -1
+			if vsize > 0 {
+				typ.Size = 32
+			}
+		default:
+			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
+		}
+	}
+	typ.stringKind = t
+
+	return
+}
+
+func (t Type) String() (out string) {
+	return t.stringKind
+}
+
+// Test the given input parameter `v` and checks if it matches certain
+// criteria
+// * Big integers are checks for ptr types and if the given value is
+//   assignable
+// * Integer are checked for size
+// * Strings, addresses and bytes are checks for type and size
+func (t Type) pack(v interface{}) ([]byte, error) {
+	value := reflect.ValueOf(v)
+	switch kind := value.Kind(); kind {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if t.Type != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		if t.Type != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.Ptr:
+		// If the value is a ptr do a assign check (only used by
+		// big.Int for now)
+		if t.Type == ubig_t && value.Type() != ubig_t {
+			return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v)
+		}
+		return packNum(value, t.T), nil
+	case reflect.String:
+		if t.Size > -1 && value.Len() > t.Size {
+			return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size)
+		}
+		return []byte(ethutil.LeftPadString(t.String(), 32)), nil
+	case reflect.Slice:
+		if t.Size > -1 && value.Len() > t.Size {
+			return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size)
+		}
+
+		// Address is a special slice. The slice acts as one rather than a list of elements.
+		if t.T == AddressTy {
+			return ethutil.LeftPadBytes(v.([]byte), 32), nil
+		}
+
+		// Signed / Unsigned check
+		if (t.T != IntTy && isSigned(value)) || (t.T == UintTy && isSigned(value)) {
+			return nil, fmt.Errorf("slice of incompatible types.")
+		}
+
+		var packed []byte
+		for i := 0; i < value.Len(); i++ {
+			packed = append(packed, packNum(value.Index(i), t.T)...)
+		}
+		return packed, nil
+	case reflect.Bool:
+		if value.Bool() {
+			return ethutil.LeftPadBytes(ethutil.Big1.Bytes(), 32), nil
+		} else {
+			return ethutil.LeftPadBytes(ethutil.Big0.Bytes(), 32), nil
+		}
+	}
+
+	panic("unreached")
+}
--- a/accounts/account_manager.go
+++ b/accounts/account_manager.go
@ -0,0 +1,95 @@
+/*
+	This file is part of go-ethereum
+
+	go-ethereum is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	go-ethereum is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @authors
+ * 	Gustav Simonsson <gustav.simonsson@gmail.com>
+ * @date 2015
+ *
+ */
+/*
+
+This abstracts part of a user's interaction with an account she controls.
+It's not an abstraction of core Ethereum accounts data type / logic -
+for that see the core processing code of blocks / txs.
+
+Currently this is pretty much a passthrough to the KeyStore2 interface,
+and accounts persistence is derived from stored keys' addresses
+
+*/
+package accounts
+
+import (
+	crand "crypto/rand"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// TODO: better name for this struct?
+type Account struct {
+	Address []byte
+}
+
+type AccountManager struct {
+	keyStore crypto.KeyStore2
+}
+
+// TODO: get key by addr - modify KeyStore2 GetKey to work with addr
+
+// TODO: pass through passphrase for APIs which require access to private key?
+func NewAccountManager(keyStore crypto.KeyStore2) AccountManager {
+	am := &AccountManager{
+		keyStore: keyStore,
+	}
+	return *am
+}
+
+func (am *AccountManager) Sign(fromAccount *Account, keyAuth string, toSign []byte) (signature []byte, err error) {
+	key, err := am.keyStore.GetKey(fromAccount.Address, keyAuth)
+	if err != nil {
+		return nil, err
+	}
+	signature, err = crypto.Sign(toSign, key.PrivateKey)
+	return signature, err
+}
+
+func (am AccountManager) NewAccount(auth string) (*Account, error) {
+	key, err := am.keyStore.GenerateNewKey(crand.Reader, auth)
+	if err != nil {
+		return nil, err
+	}
+	ua := &Account{
+		Address: key.Address,
+	}
+	return ua, err
+}
+
+// set of accounts == set of keys in given key store
+// TODO: do we need persistence of accounts as well?
+func (am *AccountManager) Accounts() ([]Account, error) {
+	addresses, err := am.keyStore.GetKeyAddresses()
+	if err != nil {
+		return nil, err
+	}
+
+	accounts := make([]Account, len(addresses))
+
+	for i, addr := range addresses {
+		accounts[i] = Account{
+			Address: addr,
+		}
+	}
+	return accounts, err
+}
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@ -0,0 +1,18 @@
+package accounts
+
+import (
+	"github.com/ethereum/go-ethereum/crypto"
+	"testing"
+)
+
+func TestAccountManager(t *testing.T) {
+	ks := crypto.NewKeyStorePlain(crypto.DefaultDataDir())
+	am := NewAccountManager(ks)
+	pass := "" // not used but required by API
+	a1, err := am.NewAccount(pass)
+	toSign := crypto.GetEntropyCSPRNG(32)
+	_, err = am.Sign(a1, pass, toSign)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
--- a/cmd/disasm/main.go
+++ b/cmd/disasm/main.go
@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+func main() {
+	code, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	code = ethutil.Hex2Bytes(string(code[:len(code)-1]))
+	fmt.Printf("%x\n", code)
+
+	for pc := uint64(0); pc < uint64(len(code)); pc++ {
+		op := vm.OpCode(code[pc])
+		fmt.Printf("%-5d  %v", pc, op)
+
+		switch op {
+		case vm.PUSH1, vm.PUSH2, vm.PUSH3, vm.PUSH4, vm.PUSH5, vm.PUSH6, vm.PUSH7, vm.PUSH8, vm.PUSH9, vm.PUSH10, vm.PUSH11, vm.PUSH12, vm.PUSH13, vm.PUSH14, vm.PUSH15, vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32:
+			a := uint64(op) - uint64(vm.PUSH1) + 1
+			fmt.Printf("  => %x", code[pc+1:pc+1+a])
+
+			pc += a
+		}
+		fmt.Println()
+	}
+}
--- a/cmd/ethereum/flags.go
+++ b/cmd/ethereum/flags.go
@ -41,6 +41,7 @@ var (
 	StartRpc        bool
 	StartWebSockets bool
 	RpcPort         int
+	WsPort          int
 	NatType         string
 	PMPGateway      string
 	OutboundPort    string
@ -48,7 +49,7 @@ var (
 	AddPeer         string
 	MaxPeer         int
 	GenAddr         bool
-	UseSeed         bool
+	SeedNode        string
 	SecretFile      string
 	ExportDir       string
 	NonInteractive  bool
@ -96,11 +97,12 @@ func Init() {
 	flag.StringVar(&NatType, "nat", "", "NAT support (UPNP|PMP) (none)")
 	flag.StringVar(&PMPGateway, "pmp", "", "Gateway IP for PMP")
 	flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
-	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
+	flag.IntVar(&RpcPort, "rpcport", 8545, "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(&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")
+	flag.StringVar(&SeedNode, "seednode", "poc-8.ethdev.com:30303", "ip:port of seed node to connect to. Set to blank for skip")
 	flag.BoolVar(&SHH, "shh", true, "whisper protocol (on)")
 	flag.BoolVar(&Dial, "dial", true, "dial out connections (on)")
 	flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
--- a/cmd/ethereum/main.go
+++ b/cmd/ethereum/main.go
@ -36,7 +36,7 @@ import (

 const (
 	ClientIdentifier = "Ethereum(G)"
-	Version          = "0.8.1"
+	Version          = "0.8.2"
 )

 var clilogger = logger.NewLogger("CLI")
@ -132,10 +132,10 @@ func main() {
 	}

 	if StartWebSockets {
-		utils.StartWebSockets(ethereum)
+		utils.StartWebSockets(ethereum, WsPort)
 	}

-	utils.StartEthereum(ethereum, UseSeed)
+	utils.StartEthereum(ethereum, SeedNode)

 	if StartJsConsole {
 		InitJsConsole(ethereum)
--- a/cmd/evm/main.go
+++ b/cmd/evm/main.go
@ -128,6 +128,7 @@ func (self *VMEnv) Difficulty() *big.Int  { return ethutil.Big1 }
 func (self *VMEnv) BlockHash() []byte     { return make([]byte, 32) }
 func (self *VMEnv) Value() *big.Int       { return self.value }
 func (self *VMEnv) GasLimit() *big.Int    { return big.NewInt(1000000000) }
+func (self *VMEnv) VmType() vm.Type       { return vm.StdVmTy }
 func (self *VMEnv) Depth() int            { return 0 }
 func (self *VMEnv) SetDepth(i int)        { self.depth = i }
 func (self *VMEnv) GetHash(n uint64) []byte {
--- a/cmd/mist/assets/backButton.png
+++ b/cmd/mist/assets/backButton.png
--- a/cmd/mist/assets/backButton@2x.png
+++ b/cmd/mist/assets/backButton@2x.png
--- a/cmd/mist/assets/browser.png
+++ b/cmd/mist/assets/browser.png
--- a/cmd/mist/assets/examples/abi.html
+++ b/cmd/mist/assets/examples/abi.html
@ -0,0 +1,55 @@
+<!doctype>
+<html>
+<head>
+<title>Hello world</title>
+<script src="../ext/bignumber.min.js"></script>
+<script src="../ext/ethereum.js/dist/ethereum.js"></script>
+<script>
+	var web3 = require('web3');
+	web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+	var eth = web3.eth;
+	var desc =  [{
+		"name": "multiply(uint256)",
+		"inputs": [{
+			"name": "a",
+			"type": "uint256"
+		}],
+		"outputs": [{
+			"name": "d",
+			"type": "uint256"
+		}]
+	}];
+	var address = web3.eth.transact({
+		data: "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056",
+		gasPrice: "1000000000000000",
+		gas: "10000",
+	});
+	var contract = web3.eth.contract(address, desc);
+
+	function calculate() {
+		var param = parseInt(document.getElementById('value').value);
+
+		var res = contract.call().multiply(param);
+		document.getElementById('result').innerText = res.toString(10);
+	}
+</script>
+</head>
+<body>
+<h3>Contract content</h3>
+<textarea style="height:100px; width: 300px;" disabled="disabled">
+contract test {
+    function multiply(uint a) returns(uint d) {
+        return a * 7;
+    }
+}
+</textarea>
+<code><pre>
+603880600c6000396000f3006001600060e060020a600035048063c6888fa1140
+05b6021600435602b565b8060005260206000f35b600081600702905091905056</pre></code>
+
+<hr>
+<div>7 x <input type="number" id="value" onkeyup='calculate()'></input> = 
+<span id="result"></spa>
+
+</body>
+</html>
--- a/cmd/mist/assets/examples/balance.html
+++ b/cmd/mist/assets/examples/balance.html
@ -0,0 +1,40 @@
+<!doctype>
+<html>
+
+<head>
+<script src="../ext/bignumber.min.js"></script>
+<script src="../ext/ethereum.js/dist/ethereum.js"></script>
+<script type="text/javascript">
+   
+    var web3 = require('web3');
+    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+    function watchBalance() {
+        var coinbase = web3.eth.coinbase;
+        var originalBalance = 0;
+
+        var balance = web3.eth.balanceAt(coinbase);
+        var originalBalance = web3.toDecimal(balance);
+        document.getElementById('original').innerText = 'original balance: ' + originalBalance + '    watching...';
+
+        web3.eth.watch({altered: coinbase}).changed(function() {
+            balance = web3.eth.balanceAt(coinbase)
+            var currentBalance = web3.toDecimal(balance);
+            document.getElementById("current").innerText = 'current: ' + currentBalance;
+            document.getElementById("diff").innerText = 'diff:    ' + (currentBalance - originalBalance);
+        });
+    }
+
+</script>
+</head>
+<body>
+    <h1>coinbase balance</h1>
+    <button type="button" onClick="watchBalance();">watch balance</button>
+    <div></div>
+    <div id="original"></div>
+    <div id="current"></div>
+    <div id="diff"></div>
+</body>
+</html>
+
+
--- a/cmd/mist/assets/examples/coin.html
+++ b/cmd/mist/assets/examples/coin.html
@ -0,0 +1,142 @@
+<!doctype>
+<html>
+<title>JevCoin</title>
+<head>
+<script type="text/javascript" src="../ext/bignumber.min.js"></script>
+<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script>
+</head>
+<body>
+
+<h1>JevCoin <code id="contract_addr"></code></h1>
+<div>
+	<strong>Balance</strong>
+	<span id="balance"></strong>
+</div>
+
+<div>
+	<span class="amount">Amount:</span>
+	<input type="text" id="address" style="width:200px">
+	<input type="text" id="amount" style="width:200px">
+	<button onclick="transact()">Send</button>
+</div>
+
+<hr>
+
+<table width="100%" id="table">
+	<tr><td style="width:40%;">Address</td><td>Balance</td></tr>
+	<tbody id="table_body"></tbody>
+</table>
+
+</body>
+
+<script type="text/javascript">
+	var web3 = require('web3');
+	var eth = web3.eth;
+
+	web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8545'));
+	var desc = [{
+		"name": "balance(address)",
+		"type": "function",
+		"inputs": [{
+			"name": "who",
+			"type": "address"
+		}],
+		"constant": true,
+		"outputs": [{
+			"name": "value",
+			"type": "uint256"
+		}]
+	}, {
+		"name": "send(address,uint256)",
+		"type": "function",
+		"inputs": [{
+			"name": "to",
+			"type": "address"
+		}, {
+			"name": "value",
+			"type": "uint256"
+		}],
+		"outputs": []
+	}, {
+		"name":"received",
+		"type":"event",
+		"inputs": [
+			{"name":"from","type":"address","indexed":true},
+			{"name":"amount","type":"uint256","indexed":true},
+		],
+	}];
+
+	var address = localStorage.getItem("address");
+	// deploy if not exist
+	if (address == null) {
+		var code = "0x60056013565b61012b806100346000396000f35b6103e8600033600160a060020a0316600052602052604060002081905550560060e060020a6000350480637bb98a681461002b578063d0679d3414610039578063e3d670d71461004d57005b610033610126565b60006000f35b610047600435602435610062565b60006000f35b610058600435610104565b8060005260206000f35b80600033600160a060020a0316600052602052604060002054101561008657610100565b80600033600160a060020a0316600052602052604060002090815403908190555080600083600160a060020a0316600052602052604060002090815401908190555033600160a060020a0316600052806020527ff11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef60406000a15b5050565b6000600082600160a060020a03166000526020526040600020549050919050565b5b60008156";
+		address = web3.eth.transact({data: code});
+        	localStorage.setItem("address", address);
+	}
+	document.querySelector("#contract_addr").innerHTML = address.toUpperCase();
+
+	var contract = web3.eth.contract(address, desc);
+	contract.received({from: eth.coinbase}).changed(function() {
+		refresh();
+	});
+	eth.watch('chain').changed(function() {
+		refresh();
+	});
+
+	function refresh() {
+        	document.querySelector("#balance").innerHTML = contract.balance(eth.coinbase);
+
+		var table = document.querySelector("#table_body");
+		table.innerHTML = ""; // clear
+
+		var storage = eth.storageAt(address);
+		table.innerHTML = "";
+		for( var item in storage ) {
+			table.innerHTML += "<tr><td>"+item.toUpperCase()+"</td><td>"+web3.toDecimal(storage[item])+"</td></tr>";
+		}
+	}
+
+	function transact() {
+		var to = document.querySelector("#address").value;
+		if( to.length == 0 ) {
+			to = "0x4205b06c2cfa0e30359edcab94543266cb6fa1d3";
+		} else {
+			to = "0x"+to;
+		}
+
+		var value = parseInt( document.querySelector("#amount").value );
+
+		contract.send( to, value );
+	}
+
+	refresh();
+</script>
+
+</html>
+
+<!--
+contract JevCoin {
+    function JevCoin()
+    {
+        balances[msg.sender] = 1000000;
+    }
+ 
+    event changed(address indexed from, address indexed to);
+    function send(address to, uint value)
+    {
+        if( balances[msg.sender] < value ) return;
+ 
+        balances[msg.sender] -= value;
+        balances[to] += value;
+ 
+        changed(msg.sender, to);
+    }
+ 
+    function balance(address who) constant returns(uint t)
+    {
+        t = balances[who];
+    }
+ 
+    mapping(address => uint256) balances;
+ }
+-!>
--- a/cmd/mist/assets/examples/coin.js
+++ b/cmd/mist/assets/examples/coin.js
@ -0,0 +1,64 @@
+var contract = web3.eth.contractFromAbi([
+    {
+	"constant":false,
+	"inputs":[
+	    {"name":"_h","type":"hash256"}
+	],
+	"name":"confirm",
+	"outputs":[],
+	"type":"function"
+    },{
+	"constant":false,
+	"inputs":[
+	    {"name":_to,"type":"address"},
+	    {"name":"_value","type":"uint256"},
+	    {"name":"_data","type":"bytes"}
+	],
+	"name":"execute",
+	"outputs":[
+	    {"name":"_r","type":"hash256"}
+	],
+	"type":"function"
+    },{
+	"constant":false,
+	"inputs":[
+	    {"name":"_to","type":"address"}
+	],"name":"kill",
+	"outputs":[],
+	"type":"function"
+    },{
+	"constant":false,
+	"inputs":[
+	    {"name":"_from","type":"address"},
+	    {"name":"_to","type":"address"}
+	],
+	"name":"changeOwner",
+	"outputs":[],
+	"type":"function"
+    },{
+	"inputs":[
+	    {"indexed":false,"name":"value","type":"uint256"}
+	],
+	"name":"CashIn",
+	"type":"event"
+    },{
+	"inputs":[
+	    {"indexed":true,"name":"out","type":"string32"},
+	    {"indexed":false,"name":"owner","type":"address"},
+	    {"indexed":false,"name":"value","type":"uint256"},
+	    {"indexed":false,"name":"to","type":"address"}
+	],
+	"name":"SingleTransact",
+	"type":"event"
+    },{
+	"inputs":[
+	    {"indexed":true,"name":"out","type":"string32"},
+	    {"indexed":false,"name":"owner","type":"address"},
+	    {"indexed":false,"name":"operation","type":"hash256"},
+	    {"indexed":false,"name":"value","type":"uint256"},
+	    {"indexed":false,"name":"to","type":"address"}
+	],
+	"name":"MultiTransact",
+	"type":"event"
+    }
+]);
--- a/cmd/mist/assets/examples/info.html
+++ b/cmd/mist/assets/examples/info.html
@ -0,0 +1,77 @@
+
+<!doctype>
+<html>
+
+<head>
+<script type="text/javascript" src="../ext/bignumber.min.js"></script>
+<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script>
+</head>
+<body>
+    <h1>Info</h1>
+
+	<table width="100%">
+		<tr>
+			<td>Block number</td>
+			<td id="number"></td>
+		</tr>
+
+		<tr>
+			<td>Peer count</td>
+			<td id="peer_count"></td>
+		</tr>
+
+		<tr>
+			<td>Default block</td>
+			<td id="default_block"></td>
+		</tr>
+
+		<tr>
+			<td>Accounts</td>
+			<td id="accounts"></td>
+		</tr>
+
+		<tr>
+			<td>Balance</td>
+			<td id="balance"></td>
+
+		<tr>
+			<td>Gas price</td>
+			<td id="gas_price"></td>
+		</tr>
+
+		<tr>
+			<td>Mining</td>
+			<td id="mining"></td>
+		</tr>
+
+		<tr>
+			<td>Listening</td>
+			<td id="listening"></td>
+		</tr>
+
+		<tr>
+			<td>Coinbase</td>
+			<td id="coinbase"></td>
+		</tr>
+	</table>
+</body>
+
+<script type="text/javascript">
+    var web3 = require('web3');
+    var eth = web3.eth;
+
+    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+    document.querySelector("#number").innerHTML = eth.number;
+    document.querySelector("#coinbase").innerHTML = eth.coinbase
+    document.querySelector("#peer_count").innerHTML = eth.peerCount;
+    document.querySelector("#default_block").innerHTML = eth.defaultBlock;
+    document.querySelector("#accounts").innerHTML = eth.accounts;
+    document.querySelector("#balance").innerHTML = web3.toEth(eth.balanceAt(eth.accounts[0]));
+    document.querySelector("#gas_price").innerHTML = eth.gasPrice;
+    document.querySelector("#mining").innerHTML = eth.mining;
+    document.querySelector("#listening").innerHTML = eth.listening;
+</script>
+
+</html>
+
--- a/cmd/mist/assets/examples/whisper.html
+++ b/cmd/mist/assets/examples/whisper.html
@ -0,0 +1,70 @@
+<!doctype>
+<html>
+<title>Whisper test</title>
+<head>
+<script type="text/javascript" src="../ext/bignumber.min.js"></script>
+<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script>
+</head>
+<body>
+
+<h1>Whisper test</h1>
+
+<button onclick="test()">Send</button>
+<button onclick="test2()">Private send</button>
+
+<table width="100%" id="table">
+	<tr>
+		<td>Count</td>
+		<td id="count"></td>
+	</tr>
+
+	<tr>
+		<td>ID</td>
+		<td id="id"></td>
+	</tr>
+
+	<tr>
+		<td>Has identity</td>
+		<td id="known"></td>
+	</tr>
+</table>
+</body>
+
+<script type="text/javascript">
+	var web3 = require('web3');
+	web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+	var shh = web3.shh;
+
+	var id = shh.newIdentity();
+	document.querySelector("#id").innerHTML = id;
+	document.querySelector("#known").innerHTML =  shh.haveIdentity(id);
+
+	var watch = shh.watch({topics: ["test"]})
+	watch.arrived(function(message) {
+		document.querySelector("#table").innerHTML += "<tr><td colspan='2'>"+JSON.stringify(message)+"</td></tr>";
+	});
+
+	var selfWatch = shh.watch({to: id, topics: ["test"]})
+	selfWatch.arrived(function(message) {
+		document.querySelector("#table").innerHTML += "<tr><td>To me</td><td>"+JSON.stringify(message)+"</td></tr>";
+	});
+
+	function test() {
+		shh.post({topics: ["test"], payload: web3.fromAscii("test it")});
+		count();
+	}
+
+	function test2() {
+		shh.post({to: id, topics: ["test"], payload: web3.fromAscii("Private")});
+		count();
+	}
+
+	function count() {
+		document.querySelector("#count").innerHTML = watch.messages().length;
+	}
+</script>
+
+</html>
+
+
--- a/cmd/mist/assets/ext/.bowerrc
+++ b/cmd/mist/assets/ext/.bowerrc
@ -0,0 +1,5 @@
+{
+  "directory": "example/js/",
+  "cwd": "./",
+  "analytics": false
+}
--- a/cmd/mist/assets/ext/.editorconfig
+++ b/cmd/mist/assets/ext/.editorconfig
@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
--- a/cmd/mist/assets/ext/.gitignore
+++ b/cmd/mist/assets/ext/.gitignore
@ -0,0 +1,18 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+*.swp
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+ethereum/ethereum
+ethereal/ethereal
+example/js
+node_modules
+bower_components
+npm-debug.log
--- a/cmd/mist/assets/ext/.jshintrc
+++ b/cmd/mist/assets/ext/.jshintrc
@ -0,0 +1,50 @@
+{
+    "predef": [
+        "console",
+        "require",
+        "equal",
+        "test",
+        "testBoth",
+        "testWithDefault",
+        "raises",
+        "deepEqual",
+        "start",
+        "stop",
+        "ok",
+        "strictEqual",
+        "module",
+        "expect",
+        "reject",
+        "impl"
+    ],
+
+    "esnext": true,
+    "proto": true,
+    "node" : true,
+    "browser" : true,
+    "browserify" : true,
+
+    "boss" : true,
+    "curly": false,
+    "debug": true,
+    "devel": true,
+    "eqeqeq": true,
+    "evil": true,
+    "forin": false,
+    "immed": false,
+    "laxbreak": false,
+    "newcap": true,
+    "noarg": true,
+    "noempty": false,
+    "nonew": false,
+    "nomen": false,
+    "onevar": false,
+    "plusplus": false,
+    "regexp": false,
+    "undef": true,
+    "sub": true,
+    "strict": false,
+    "white": false,
+    "shadow": true,
+    "eqnull": true
+}
--- a/cmd/mist/assets/ext/.npmignore
+++ b/cmd/mist/assets/ext/.npmignore
@ -0,0 +1,9 @@
+example/js
+node_modules
+test
+.gitignore
+.editorconfig
+.travis.yml
+.npmignore
+component.json
+testling.html
--- a/cmd/mist/assets/ext/.travis.yml
+++ b/cmd/mist/assets/ext/.travis.yml
@ -0,0 +1,13 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+before_script:
+  - npm install
+  - npm install jshint
+script:
+   - "jshint *.js lib"
+after_script:
+  - npm run-script build
+  - npm test
+
--- a/cmd/mist/assets/ext/big.js
+++ b/cmd/mist/assets/ext/big.js
@ -1,397 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-var bigInt = (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 = bigInt(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 = bigInt(value, s);
-	        if (first) normalize(first, val);
-        	return val;
-	}
-    };
-
-    var goesInto = function (a, b) {
-        var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive);
-        if (a.equals(0)) throw new Error("Cannot divide by 0");
-        var n = 0;
-        do {
-            var inc = 1;
-            var c = bigInt(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 bigInt = function (value, s) {
-        var self = {
-            value: value,
-            sign: s
-        };
-        var o = {
-            value: value,
-            sign: s,
-            negate: function (m) {
-                var first = m || self;
-                return bigInt(first.value, !first.sign);
-            },
-            abs: function (m) {
-                var first = m || self;
-                return bigInt(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 = bigInt(first.value, sign.positive);
-                    second = bigInt(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 bigInt(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 bigInt(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 bigInt(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 (bigInt(first.value, first.sign).equals(0)) return {
-                    quotient: bigInt([0], sign.positive),
-                    remainder: bigInt([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: bigInt(result, s),
-                    remainder: bigInt(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 = bigInt(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 = bigInt([0], sign.positive);
-    var ONE = bigInt([1], sign.positive);
-    var MINUS_ONE = bigInt([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 = bigInt;
-}
-
--- a/cmd/mist/assets/ext/bignumber.min.js
+++ b/cmd/mist/assets/ext/bignumber.min.js
--- a/cmd/mist/assets/ext/ethereum.js/.travis.yml
+++ b/cmd/mist/assets/ext/ethereum.js/.travis.yml
@ -8,4 +8,6 @@ before_script:
 script:
   - "jshint *.js lib"
 after_script:
-  - npm run-script gulp
+  - npm run-script build
+  - npm test
+
--- a/cmd/mist/assets/ext/ethereum.js/README.md
+++ b/cmd/mist/assets/ext/ethereum.js/README.md
@ -1,6 +1,6 @@
 # Ethereum JavaScript API

-This is the Ethereum compatible JavaScript API using `Promise`s
+This is the Ethereum compatible [JavaScript API](https://github.com/ethereum/wiki/wiki/JavaScript-API)
 which implements the [Generic JSON RPC](https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC) spec. It's available on npm as a node module and also for bower and component as an embeddable js

 [![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![dependency status][dep-image]][dep-url] [![dev dependency status][dep-dev-image]][dep-dev-url]
@ -23,7 +23,7 @@ Component
 	component install ethereum/ethereum.js

 * Include `ethereum.min.js` in your html file.
-* Include [es6-promise](https://github.com/jakearchibald/es6-promise) or another ES6-Shim if your browser doesn't support ECMAScript 6.
+* Include [bignumber.js](https://github.com/MikeMcl/bignumber.js/)

 ## Usage
 Require the library:
@ -37,25 +37,41 @@ Set a provider (QtProvider, WebSocketProvider, HttpRpcProvider)
 There you go, now you can use it:

 ```
-web3.eth.coinbase.then(function(result){
-  console.log(result);
-  return web3.eth.balanceAt(result);
-}).then(function(balance){
-  console.log(web3.toDecimal(balance));
-}).catch(function(err){
-  console.log(err);
-});
+var coinbase = web3.eth.coinbase;
+var balance = web3.eth.balanceAt(coinbase);
 ```


 For another example see `example/index.html`.

-## Building
+## Contribute!

-* `gulp build`
+### Requirements
+
+* Node.js
+* npm
+* gulp (build)
+* mocha (tests)
+
+```bash
+sudo apt-get update
+sudo apt-get install nodejs
+sudo apt-get install npm
+sudo apt-get install nodejs-legacy
+```
+
+### Building (gulp)
+
+```bash
+npm run-script build
+```


-### Testing
+### Testing (mocha)
+
+```bash
+npm test
+```

 **Please note this repo is in it's early stage.**

@ -76,4 +92,5 @@ ethereum -ws -loglevel=4
 [dep-image]: https://david-dm.org/ethereum/ethereum.js.svg
 [dep-url]: https://david-dm.org/ethereum/ethereum.js
 [dep-dev-image]: https://david-dm.org/ethereum/ethereum.js/dev-status.svg
-[dep-dev-url]: https://david-dm.org/ethereum/ethereum.js#info=devDependencies
+[dep-dev-url]: https://david-dm.org/ethereum/ethereum.js#info=devDependencies
+
--- a/cmd/mist/assets/ext/ethereum.js/bower.json
+++ b/cmd/mist/assets/ext/ethereum.js/bower.json
@ -1,11 +1,11 @@
 {
  "name": "ethereum.js",
  "namespace": "ethereum",
-  "version": "0.0.3",
+  "version": "0.0.13",
  "description": "Ethereum Compatible JavaScript API",
  "main": ["./dist/ethereum.js", "./dist/ethereum.min.js"],
  "dependencies": {
-    "es6-promise": "#master"
+    "bignumber.js": ">=2.0.0"
  },
  "repository": {
    "type": "git",
@ -48,4 +48,4 @@
    "index.js",
    "**/*.txt"
  ]
-}
+}
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.js.map
--- a/cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
+++ b/cmd/mist/assets/ext/ethereum.js/dist/ethereum.min.js
--- a/cmd/mist/assets/ext/ethereum.js/example/balance.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/balance.html
@ -2,28 +2,30 @@
 <html>

 <head>
-<script type="text/javascript" src="js/es6-promise/promise.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">
   
    var web3 = require('web3');
-    web3.setProvider(new web3.providers.AutoProvider());
+    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));

    function watchBalance() {
        var coinbase = web3.eth.coinbase;
        var originalBalance = 0;

-        web3.eth.balanceAt(coinbase).then(function (balance) {
-            originalBalance = web3.toDecimal(balance);
-            document.getElementById('original').innerText = 'original balance: ' + originalBalance + '    watching...';
-        });
+        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() {
-            web3.eth.balanceAt(coinbase).then(function (balance) {
-                var currentBalance = web3.toDecimal(balance);
-                document.getElementById("current").innerText = 'current: ' + currentBalance;
-                document.getElementById("diff").innerText = 'diff:    ' + (currentBalance - originalBalance);
-            });
+<<<<<<< HEAD:cmd/mist/assets/ext/ethereum.js/example/balance.html
+        var filter = web3.eth.watch({address: coinbase}).changed(function() {
+=======
+        web3.eth.watch('pending').changed(function() {
+>>>>>>> 859a1999cb204d2c6fcb08d6569c738c5af5cd86:example/balance.html
+            balance = web3.eth.balanceAt(coinbase)
+            var currentBalance = web3.toDecimal(balance);
+            document.getElementById("current").innerText = 'current: ' + currentBalance;
+            document.getElementById("diff").innerText = 'diff:    ' + (currentBalance - originalBalance);
        });
    }

--- a/cmd/mist/assets/ext/ethereum.js/example/contract.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/contract.html
@ -2,12 +2,12 @@
 <html>

 <head>
-<script type="text/javascript" src="js/es6-promise/promise.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">

    var web3 = require('web3');
-    web3.setProvider(new web3.providers.AutoProvider());
+    web3.setProvider(new web3.providers.HttpSyncProvider());

    // solidity source code
    var source = "" + 
@ -19,7 +19,8 @@

    // contract description, this will be autogenerated somehow
    var desc =  [{
-        "name": "multiply",
+        "name": "multiply(uint256)",
+        "type": "function",
        "inputs": [
        {
            "name": "a",
@ -42,10 +43,9 @@
        document.getElementById('source').innerText = source;

        // create contract
-        web3.eth.transact({code: web3.eth.solidity(source)}).then(function (address) {
-            contract = web3.contract(address, desc);
-            document.getElementById('call').style.visibility = 'visible';
-        });
+        var address = web3.eth.transact({code: web3.eth.solidity(source)});
+        contract = web3.eth.contract(address, desc);
+        document.getElementById('call').style.visibility = 'visible';
    }

    function callExampleContract() {
@ -53,9 +53,8 @@
        var param = parseInt(document.getElementById('value').value);

        // call the contract
-        contract.multiply(param).call().then(function(res) {
-            document.getElementById('result').innerText = res[0];
-        });
+        var res = contract.call().multiply(param);
+        document.getElementById('result').innerText = res.toString(10);
    }

 </script>
--- a/cmd/mist/assets/ext/ethereum.js/example/contract_with_array.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/contract_with_array.html
@ -0,0 +1,76 @@
+<!doctype>
+<html>
+
+<head>
+<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">
+
+    var web3 = require('web3');
+    web3.setProvider(new web3.providers.HttpSyncProvider());
+
+    // solidity source code
+    var source = "" + 
+    "contract test {\n" +
+    "   function multiply(uint[] a) returns(uint d) {\n" +
+    "       return a[0] + a[1];\n" +
+    "   }\n" +
+    "}\n";
+
+    // contract description, this will be autogenerated somehow
+    var desc =  [{
+        "name": "multiply(uint256[])",
+        "type": "function",
+        "inputs": [
+        {
+            "name": "a",
+            "type": "uint256[]"
+        }
+        ],
+        "outputs": [
+        {
+            "name": "d",
+            "type": "uint256"
+        }
+        ]
+    }];
+
+    var contract;
+
+    function createExampleContract() {
+        // hide create button
+        document.getElementById('create').style.visibility = 'hidden'; 
+        document.getElementById('source').innerText = source;
+
+        // create contract
+        var address = web3.eth.transact({code: web3.eth.solidity(source)});
+        contract = web3.eth.contract(address, desc);
+        document.getElementById('call').style.visibility = 'visible';
+    }
+
+    function callExampleContract() {
+        // this should be generated by ethereum
+        var param = parseInt(document.getElementById('value').value);
+        var param2 = parseInt(document.getElementById('value2').value);
+
+        // call the contract
+        var res = contract.call().multiply([param, param2]);
+        document.getElementById('result').innerText = res.toString(10);
+    }
+
+</script>
+</head>
+<body>
+    <h1>contract</h1>
+    <div id="source"></div> 
+    <div id='create'>
+        <button type="button" onClick="createExampleContract();">create example contract</button>
+    </div>
+    <div id='call' style='visibility: hidden;'>
+        <input type="number" id="value" onkeyup='callExampleContract()'></input>
+        <input type="number" id="value2" onkeyup='callExampleContract()'></input>
+    </div>
+    <div id="result"></div>
+</body>
+</html>
+
--- a/cmd/mist/assets/ext/ethereum.js/example/event.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/event.html
@ -0,0 +1,120 @@
+<!doctype>
+<html>
+    <head>
+    <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">
+        var web3 = require('web3');
+        web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+        var desc = [{
+            "type":"event",
+            "inputs": [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}],
+            "name":"Event"
+        }, {
+            "type":"event",
+            "inputs": [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}],
+            "name":"Event2"
+        }, {
+            "type":"function",
+            "inputs": [{"name":"a","type":"uint256"}],
+            "name":"foo",
+            "outputs": []
+        }];
+
+        var address = '0x01';
+
+        var contract = web3.eth.contract(address, desc); 
+
+        function test1() {
+            // "{"topic":["0x83c9849c","0xc4d76332"],"address":"0x01"}"
+            web3.eth.watch(contract).changed(function (res) {
+                
+            });
+        };
+
+        function test2() {
+            // "{"topic":["0x83c9849c"],"address":"0x01"}"
+            web3.eth.watch(contract.Event).changed(function (res) {
+                
+            });
+        };
+
+        function test3() {
+            // "{"topic":["0x83c9849c"],"address":"0x01"}"
+            contract.Event().changed(function (res) {
+                
+            });
+        };
+
+        function test4() {
+            // "{"topic":["0x83c9849c","0000000000000000000000000000000000000000000000000000000000000045"],"address":"0x01"}"
+            contract.Event({a: 69}).changed(function (res) {
+                
+            });
+        };
+
+        function test5() {
+            // "{"topic":["0x83c9849c",["0000000000000000000000000000000000000000000000000000000000000045","000000000000000000000000000000000000000000000000000000000000002a"]],"address":"0x01"}"
+            contract.Event({a: [69, 42]}).changed(function (res) {
+                
+            });
+        };
+
+        function test6() {
+            // "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"max":100,"address":"0x01"}"
+            contract.Event({a: 30}, {max: 100}).changed(function (res) {
+                
+            });
+        };
+
+        function test7() {
+            // "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"address":"0x01"}"
+            web3.eth.watch(contract.Event, {a: 30}).changed(function (res) {
+
+            });
+        };
+
+        function test8() {
+            // "{"topic":["0x83c9849c","000000000000000000000000000000000000000000000000000000000000001e"],"max":100,"address":"0x01"}"
+            web3.eth.watch(contract.Event, {a: 30}, {max: 100}).changed(function (res) {
+
+            });
+        };
+        
+        // not valid
+        // function testX() {
+        //    web3.eth.watch([contract.Event, contract.Event2]).changed(function (res) {
+        //    });
+        // };
+
+    </script>
+    </head>
+
+    <body>
+        <div>
+            <button type="button" onClick="test1();">test1</button>
+        </div>
+        <div>
+            <button type="button" onClick="test2();">test2</button>
+        </div>
+        <div>
+            <button type="button" onClick="test3();">test3</button>
+        </div>
+        <div>
+            <button type="button" onClick="test4();">test4</button>
+        </div>
+        <div>
+            <button type="button" onClick="test5();">test5</button>
+        </div>
+        <div>
+            <button type="button" onClick="test6();">test6</button>
+        </div>
+        <div>
+            <button type="button" onClick="test7();">test7</button>
+        </div>
+        <div>
+            <button type="button" onClick="test8();">test8</button>
+        </div>
+    </body>
+</html>
--- a/cmd/mist/assets/ext/ethereum.js/example/event_inc.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/event_inc.html
@ -0,0 +1,66 @@
+<!doctype>
+<html>
+    <head>
+    <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">
+        var web3 = require('web3');
+        web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+        var source = "" + 
+        "contract Contract { " +
+        "   event Incremented(bool indexed odd, uint x); " +
+        "   function Contract() { " +
+        "        x = 69; " +
+        "    } " +
+        "    function inc() { " +
+        "        ++x; " +
+        "        Incremented(x % 2 == 1, x); " +
+        "    } " +
+        "    uint x; " +
+        "}";
+
+        var desc = [{
+            "type":"event",
+            "name":"Incremented",
+            "inputs": [{"name":"odd","type":"bool","indexed":true},{"name":"x","type":"uint","indexed":false}],
+        }, {
+            "type":"function",
+            "name":"inc",
+            "inputs": [],
+            "outputs": []
+        }];
+
+        var address;
+        var contract;
+
+        var update = function (x) {
+            document.getElementById('result').innerText = JSON.stringify(x);
+        };
+    
+        var createContract = function () {
+            address = web3.eth.transact({code: web3.eth.solidity(source)});
+            contract = web3.eth.contract(address, desc); 
+            contract.Incremented({odd: true}).changed(update);
+            
+        };
+
+        var callContract = function () {
+            contract.call().inc();
+        };
+
+
+    </script>
+    </head>
+
+    <body>
+        <div>
+            <button type="button" onClick="createContract();">create contract</button>
+        </div>
+        <div>
+            <button type="button" onClick="callContract();">test1</button>
+        </div>
+        <div id="result">
+        </div>
+    </body>
+</html>
--- a/cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
+++ b/cmd/mist/assets/ext/ethereum.js/example/natspec_contract.html
@ -0,0 +1,77 @@
+<!doctype>
+<html>
+
+<head>
+<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">
+
+    var web3 = require('web3');
+    web3.setProvider(new web3.providers.QtSyncProvider());
+
+    // solidity source code
+    var source = "" + 
+    "contract test {\n" +
+    "   /// @notice Will multiply `a` by 7. \n" +
+    "   function multiply(uint a) returns(uint d) {\n" +
+    "       return a * 7;\n" +
+    "   }\n" +
+    "}\n";
+
+    // contract description, this will be autogenerated somehow
+    var desc =  [{
+        "name": "multiply(uint256)",
+        "type": "function",
+        "inputs": [
+        {
+            "name": "a",
+            "type": "uint256"
+        }
+        ],
+        "outputs": [
+        {
+            "name": "d",
+            "type": "uint256"
+        }
+        ]
+    }];
+
+    var contract;
+
+    function createExampleContract() {
+        // hide create button
+        document.getElementById('create').style.visibility = 'hidden'; 
+        document.getElementById('source').innerText = source;
+
+        // create contract
+        var address = web3.eth.transact({code: web3.eth.solidity(source)});
+        contract = web3.eth.contract(address, desc);
+        document.getElementById('call').style.visibility = 'visible';
+    }
+
+    function callExampleContract() {
+        // this should be generated by ethereum
+        var param = parseInt(document.getElementById('value').value);
+
+        // transaction does not return any result, cause it's not synchronous and we don't know,
+        // when it will be processed
+        contract.transact().multiply(param);
+        document.getElementById('result').innerText = 'transaction made';
+    }
+
+</script>
+</head>
+<body>
+    <h1>contract</h1>
+    <div id="source"></div> 
+    <div id='create'>
+        <button type="button" onClick="createExampleContract();">create example contract</button>
+    </div>
+    <div id='call' style='visibility: hidden;'>
+        <input type="number" id="value"></input>
+		<button type="button" onClick="callExampleContract()">Call Contract</button>
+    </div>
+    <div id="result"></div>
+</body>
+</html>
+
--- a/cmd/mist/assets/ext/ethereum.js/example/node-app.js
+++ b/cmd/mist/assets/ext/ethereum.js/example/node-app.js
@ -1,16 +1,12 @@
 #!/usr/bin/env node

-require('es6-promise').polyfill();
-
 var web3 = require("../index.js");

-web3.setProvider(new web3.providers.HttpRpcProvider('http://localhost:8080'));
+web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080'));
+
+var coinbase = web3.eth.coinbase;
+console.log(coinbase);
+
+var balance = web3.eth.balanceAt(coinbase);
+console.log(balance);

-web3.eth.coinbase.then(function(result){
-  console.log(result);
-  return web3.eth.balanceAt(result);
-}).then(function(balance){
-  console.log(web3.toDecimal(balance));
-}).catch(function(err){
-  console.log(err);
-});
--- a/cmd/mist/assets/ext/ethereum.js/gulpfile.js
+++ b/cmd/mist/assets/ext/ethereum.js/gulpfile.js
@ -90,7 +90,7 @@ gulp.task('uglify', ['build'], function(){
    return uglifyFile('ethereum');
 });

-gulp.task('uglify', ['buildDev'], function(){
+gulp.task('uglifyDev', ['buildDev'], function(){
    return uglifyFile('ethereum');
 });

@ -99,6 +99,6 @@ gulp.task('watch', function() {
 });

 gulp.task('release', ['bower', 'lint', 'build', 'uglify']);
-gulp.task('dev', ['bower', 'lint', 'buildDev', 'uglify']);
+gulp.task('dev', ['bower', 'lint', 'buildDev', 'uglifyDev']);
 gulp.task('default', ['dev']);

--- a/cmd/mist/assets/ext/ethereum.js/index.js
+++ b/cmd/mist/assets/ext/ethereum.js/index.js
@ -1,8 +1,11 @@
 var web3 = require('./lib/web3');
-web3.providers.WebSocketProvider = require('./lib/websocket');
-web3.providers.HttpRpcProvider = require('./lib/httprpc');
-web3.providers.QtProvider = require('./lib/qt');
-web3.providers.AutoProvider = require('./lib/autoprovider');
-web3.contract = require('./lib/contract');
+var ProviderManager = require('./lib/providermanager');
+web3.provider = new ProviderManager();
+web3.filter = require('./lib/filter');
+web3.providers.HttpSyncProvider = require('./lib/httpsync');
+web3.providers.QtSyncProvider = require('./lib/qtsync');
+web3.eth.contract = require('./lib/contract');
+web3.abi = require('./lib/abi');
+

 module.exports = web3;
--- a/cmd/mist/assets/ext/ethereum.js/lib/abi.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/abi.js
@ -21,247 +21,190 @@
 * @date 2014
 */

-// TODO: is these line is supposed to be here? 
-if (process.env.NODE_ENV !== 'build') {
-    var web3 = require('./web3'); // jshint ignore:line
-}
+var web3 = require('./web3'); 
+var utils = require('./utils');
+var types = require('./types');
+var c = require('./const');
+var f = require('./formatters');

-// TODO: make these be actually accurate instead of falling back onto JS's doubles.
-var hexToDec = function (hex) {
-    return parseInt(hex, 16).toString();
+var displayTypeError = function (type) {
+    console.error('parser does not support type: ' + type);
 };

-var decToHex = function (dec) {
-    return parseInt(dec).toString(16);
+/// This method should be called if we want to check if givent type is an array type
+/// @returns true if it is, otherwise false
+var arrayType = function (type) {
+    return type.slice(-2) === '[]';
 };

-var findIndex = function (array, callback) {
-    var end = false;
-    var i = 0;
-    for (; i < array.length && !end; i++) {
-        end = callback(array[i]);
-    }
-    return end ? i - 1 : -1;
+var dynamicTypeBytes = function (type, value) {
+    // TODO: decide what to do with array of strings
+    if (arrayType(type) || type === 'string')    // only string itself that is dynamic; stringX is static length.
+        return f.formatInputInt(value.length); 
+    return "";
 };

-var findMethodIndex = function (json, methodName) {
-    return findIndex(json, function (method) {
-        return method.name === methodName;
-    });
-};
+var inputTypes = types.inputTypes(); 

-var padLeft = function (string, chars) {
-    return new Array(chars - string.length + 1).join("0") + string;
-};
-
-var calcBitPadding = function (type, expected) {
-    var value = type.slice(expected.length);
-    if (value === "") {
-        return 32;
-    }
-    return parseInt(value) / 8;
-};
-
-var calcBytePadding = function (type, expected) {
-    var value = type.slice(expected.length);
-    if (value === "") {
-        return 32;
-    }
-    return parseInt(value);
-};
-
-var calcRealPadding = function (type, expected) {
-    var value = type.slice(expected.length);
-    if (value === "") {
-        return 32;
-    }
-    var sizes = value.split('x');
-    for (var padding = 0, i = 0; i < sizes; i++) {
-        padding += (sizes[i] / 8);
-    }
-    return padding;
-};
-
-var setupInputTypes = function () {
-    
-    var prefixedType = function (prefix, calcPadding) {
-        return function (type, value) {
-            var expected = prefix;
-            if (type.indexOf(expected) !== 0) {
-                return false;
-            }
-
-            var padding = calcPadding(type, expected);
-            if (typeof value === "number")
-                value = value.toString(16);
-            else if (typeof value === "string")
-                value = web3.toHex(value); 
-            else if (value.indexOf('0x') === 0)
-                value = value.substr(2);
-            else
-                value = (+value).toString(16);
-            return padLeft(value, padding * 2);
-        };
-    };
-
-    var namedType = function (name, padding, formatter) {
-        return function (type, value) {
-            if (type !== name) {
-                return false;
-            }
-
-            return padLeft(formatter ? formatter(value) : value, padding * 2);
-        };
-    };
-
-    var formatBool = function (value) {
-        return value ? '0x1' : '0x0';
-    };
-
-    return [
-        prefixedType('uint', calcBitPadding),
-        prefixedType('int', calcBitPadding),
-        prefixedType('hash', calcBitPadding),
-        prefixedType('string', calcBytePadding),
-        prefixedType('real', calcRealPadding),
-        prefixedType('ureal', calcRealPadding),
-        namedType('address', 20),
-        namedType('bool', 1, formatBool),
-    ];
-};
-
-var inputTypes = setupInputTypes();
-
-var toAbiInput = function (json, methodName, params) {
+/// Formats input params to bytes
+/// @param abi contract method inputs
+/// @param array of params that will be formatted to bytes
+/// @returns bytes representation of input params
+var formatInput = function (inputs, params) {
    var bytes = "";
-    var index = findMethodIndex(json, methodName);
+    var padding = c.ETH_PADDING * 2;

-    if (index === -1) {
-        return;
-    }
+    /// first we iterate in search for dynamic 
+    inputs.forEach(function (input, index) {
+        bytes += dynamicTypeBytes(input.type, params[index]);
+    });

-    bytes = "0x" + padLeft(index.toString(16), 2);
-    var method = json[index];
-
-    for (var i = 0; i < method.inputs.length; i++) {
-        var found = false;
-        for (var j = 0; j < inputTypes.length && !found; j++) {
-            found = inputTypes[j](method.inputs[i].type, params[i]);
+    inputs.forEach(function (input, i) {
+        var typeMatch = false;
+        for (var j = 0; j < inputTypes.length && !typeMatch; j++) {
+            typeMatch = inputTypes[j].type(inputs[i].type, params[i]);
        }
-        if (!found) {
-            console.error('unsupported json type: ' + method.inputs[i].type);
+        if (!typeMatch) {
+            displayTypeError(inputs[i].type);
        }
-        bytes += found;
-    }
+
+        var formatter = inputTypes[j - 1].format;
+        var toAppend = "";
+
+        if (arrayType(inputs[i].type))
+            toAppend = params[i].reduce(function (acc, curr) {
+                return acc + formatter(curr);
+            }, "");
+        else
+            toAppend = formatter(params[i]);
+
+        bytes += toAppend; 
+    });
    return bytes;
 };

-var setupOutputTypes = function () {
-
-    var prefixedType = function (prefix, calcPadding) {
-        return function (type) {
-            var expected = prefix;
-            if (type.indexOf(expected) !== 0) {
-                return -1;
-            }
-
-            var padding = calcPadding(type, expected);
-            return padding * 2;
-        };
-    };
-
-    var namedType = function (name, padding) {
-        return function (type) {
-            return name === type ? padding * 2 : -1;
-        };
-    };
-
-    var formatInt = function (value) {
-        return value.length <= 8 ? +parseInt(value, 16) : hexToDec(value);
-    };
-
-    var formatHash = function (value) {
-        return "0x" + value;
-    };
-
-    var formatBool = function (value) {
-        return value === '1' ? true : false;
-    };
-
-    var formatString = function (value) {
-        return web3.toAscii(value);
-    };
-
-    return [
-    { padding: prefixedType('uint', calcBitPadding), format: formatInt },
-    { padding: prefixedType('int', calcBitPadding), format: formatInt },
-    { padding: prefixedType('hash', calcBitPadding), format: formatHash },
-    { padding: prefixedType('string', calcBytePadding), format: formatString },
-    { padding: prefixedType('real', calcRealPadding), format: formatInt },
-    { padding: prefixedType('ureal', calcRealPadding), format: formatInt },
-    { padding: namedType('address', 20) },
-    { padding: namedType('bool', 1), format: formatBool }
-    ];
+var dynamicBytesLength = function (type) {
+    if (arrayType(type) || type === 'string')   // only string itself that is dynamic; stringX is static length.
+        return c.ETH_PADDING * 2;
+    return 0;
 };

-var outputTypes = setupOutputTypes();
-
-var fromAbiOutput = function (json, methodName, output) {
-    var index = findMethodIndex(json, methodName);
-
-    if (index === -1) {
-        return;
-    }
+var outputTypes = types.outputTypes(); 

+/// Formats output bytes back to param list
+/// @param contract abi method outputs
+/// @param bytes representtion of output 
+/// @returns array of output params 
+var formatOutput = function (outs, output) {
+    
    output = output.slice(2);
-
    var result = [];
-    var method = json[index];
-    for (var i = 0; i < method.outputs.length; i++) {
-        var padding = -1;
-        for (var j = 0; j < outputTypes.length && padding === -1; j++) {
-            padding = outputTypes[j].padding(method.outputs[i].type);
+    var padding = c.ETH_PADDING * 2;
+
+    var dynamicPartLength = outs.reduce(function (acc, curr) {
+        return acc + dynamicBytesLength(curr.type);
+    }, 0);
+    
+    var dynamicPart = output.slice(0, dynamicPartLength);
+    output = output.slice(dynamicPartLength);
+
+    outs.forEach(function (out, i) {
+        var typeMatch = false;
+        for (var j = 0; j < outputTypes.length && !typeMatch; j++) {
+            typeMatch = outputTypes[j].type(outs[i].type);
        }

-        if (padding === -1) {
-            // not found output parsing
-            continue;
+        if (!typeMatch) {
+            displayTypeError(outs[i].type);
        }
-        var res = output.slice(0, padding);
+
        var formatter = outputTypes[j - 1].format;
-        result.push(formatter ? formatter(res) : ("0x" + res));
-        output = output.slice(padding);
-    }
+        if (arrayType(outs[i].type)) {
+            var size = f.formatOutputUInt(dynamicPart.slice(0, padding));
+            dynamicPart = dynamicPart.slice(padding);
+            var array = [];
+            for (var k = 0; k < size; k++) {
+                array.push(formatter(output.slice(0, padding))); 
+                output = output.slice(padding);
+            }
+            result.push(array);
+        }
+        else if (types.prefixedType('string')(outs[i].type)) {
+            dynamicPart = dynamicPart.slice(padding); 
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        } else {
+            result.push(formatter(output.slice(0, padding)));
+            output = output.slice(padding);
+        }
+    });

    return result;
 };

+/// @param json abi for contract
+/// @returns input parser object for given json abi
+/// TODO: refactor creating the parser, do not double logic from contract
 var inputParser = function (json) {
    var parser = {};
    json.forEach(function (method) {
-        parser[method.name] = function () {
+        var displayName = utils.extractDisplayName(method.name); 
+        var typeName = utils.extractTypeName(method.name);
+
+        var impl = function () {
            var params = Array.prototype.slice.call(arguments);
-            return toAbiInput(json, method.name, params);
+            return formatInput(method.inputs, params);
        };
+       
+        if (parser[displayName] === undefined) {
+            parser[displayName] = impl;
+        }
+
+        parser[displayName][typeName] = impl;
    });

    return parser;
 };

+/// @param json abi for contract
+/// @returns output parser for given json abi
 var outputParser = function (json) {
    var parser = {};
    json.forEach(function (method) {
-        parser[method.name] = function (output) {
-            return fromAbiOutput(json, method.name, output);
+
+        var displayName = utils.extractDisplayName(method.name); 
+        var typeName = utils.extractTypeName(method.name);
+
+        var impl = function (output) {
+            return formatOutput(method.outputs, output);
        };
+
+        if (parser[displayName] === undefined) {
+            parser[displayName] = impl;
+        }
+
+        parser[displayName][typeName] = impl;
    });

    return parser;
 };

-if (typeof(module) !== "undefined") {
-	module.exports = {
-		inputParser: inputParser,
-		outputParser: outputParser
-	};
-}
+/// @param function/event name for which we want to get signature
+/// @returns signature of function/event with given name
+var signatureFromAscii = function (name) {
+    return web3.sha3(web3.fromAscii(name)).slice(0, 2 + c.ETH_SIGNATURE_LENGTH * 2);
+};
+
+var eventSignatureFromAscii = function (name) {
+    return web3.sha3(web3.fromAscii(name));
+};
+
+module.exports = {
+    inputParser: inputParser,
+    outputParser: outputParser,
+    formatInput: formatInput,
+    formatOutput: formatOutput,
+    signatureFromAscii: signatureFromAscii,
+    eventSignatureFromAscii: eventSignatureFromAscii
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/autoprovider.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/autoprovider.js
@ -1,103 +0,0 @@
-/*
-    This file is part of ethereum.js.
-
-    ethereum.js 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.
-
-    ethereum.js 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 Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file autoprovider.js
- * @authors:
- *   Marek Kotewicz <marek@ethdev.com>
- *   Marian Oancea <marian@ethdev.com>
- * @date 2014
- */
-
-/*
- * @brief if qt object is available, uses QtProvider,
- * if not tries to connect over websockets
- * if it fails, it uses HttpRpcProvider
- */
-
-// TODO: is these line is supposed to be here? 
-if (process.env.NODE_ENV !== 'build') {
-    var WebSocket = require('ws'); // jshint ignore:line
-    var web3 = require('./web3'); // jshint ignore:line
-}
-
-var AutoProvider = function (userOptions) {
-    if (web3.haveProvider()) {
-        return;
-    }
-
-    // before we determine what provider we are, we have to cache request
-    this.sendQueue = [];
-    this.onmessageQueue = [];
-
-    if (navigator.qt) {
-        this.provider = new web3.providers.QtProvider();
-        return;
-    }
-
-    userOptions = userOptions || {};
-    var options = {
-        httprpc: userOptions.httprpc || 'http://localhost:8080',
-        websockets: userOptions.websockets || 'ws://localhost:40404/eth'
-    };
-
-    var self = this;
-    var closeWithSuccess = function (success) {
-        ws.close();
-        if (success) {
-            self.provider = new web3.providers.WebSocketProvider(options.websockets);
-        } else {
-            self.provider = new web3.providers.HttpRpcProvider(options.httprpc);
-            self.poll = self.provider.poll.bind(self.provider);
-        }
-        self.sendQueue.forEach(function (payload) {
-            self.provider(payload);
-        });
-        self.onmessageQueue.forEach(function (handler) {
-            self.provider.onmessage = handler;
-        });
-    };
-
-    var ws = new WebSocket(options.websockets);
-
-    ws.onopen = function() {
-        closeWithSuccess(true);
-    };
-
-    ws.onerror = function() {
-        closeWithSuccess(false);
-    };
-};
-
-AutoProvider.prototype.send = function (payload) {
-    if (this.provider) {
-        this.provider.send(payload);
-        return;
-    }
-    this.sendQueue.push(payload);
-};
-
-Object.defineProperty(AutoProvider.prototype, 'onmessage', {
-    set: function (handler) {
-        if (this.provider) {
-            this.provider.onmessage = handler;
-            return;
-        }
-        this.onmessageQueue.push(handler);
-    }
-});
-
-if (typeof(module) !== "undefined")
-	module.exports = AutoProvider;
--- a/cmd/mist/assets/ext/ethereum.js/lib/const.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/const.js
@ -0,0 +1,56 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file const.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+/// required to define ETH_BIGNUMBER_ROUNDING_MODE
+if (process.env.NODE_ENV !== 'build') {
+    var BigNumber = require('bignumber.js'); // jshint ignore:line
+}
+
+var ETH_UNITS = [ 
+    'wei', 
+    'Kwei', 
+    'Mwei', 
+    'Gwei', 
+    'szabo', 
+    'finney', 
+    'ether', 
+    'grand', 
+    'Mether', 
+    'Gether', 
+    'Tether', 
+    'Pether', 
+    'Eether', 
+    'Zether', 
+    'Yether', 
+    'Nether', 
+    'Dether', 
+    'Vether', 
+    'Uether' 
+];
+
+module.exports = {
+    ETH_PADDING: 32,
+    ETH_SIGNATURE_LENGTH: 4,
+    ETH_UNITS: ETH_UNITS,
+    ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN }
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/contract.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/contract.js
@ -20,47 +20,198 @@
 * @date 2014
 */

-// TODO: is these line is supposed to be here? 
-if (process.env.NODE_ENV !== 'build') {
-    var web3 = require('./web3'); // jshint ignore:line
-}
-
+var web3 = require('./web3'); 
 var abi = require('./abi');
+var utils = require('./utils');
+var eventImpl = require('./event');

-var contract = function (address, desc) {
-    var inputParser = abi.inputParser(desc);
-    var outputParser = abi.outputParser(desc);
+var exportNatspecGlobals = function (vars) {
+    // it's used byt natspec.js
+    // TODO: figure out better way to solve this
+    web3._currentContractAbi = vars.abi;
+    web3._currentContractAddress = vars.address;
+    web3._currentContractMethodName = vars.method;
+    web3._currentContractMethodParams = vars.params;
+};

-    var contract = {};
+var addFunctionRelatedPropertiesToContract = function (contract) {
+    
+    contract.call = function (options) {
+        contract._isTransact = false;
+        contract._options = options;
+        return contract;
+    };

-    desc.forEach(function (method) {
-        contract[method.name] = function () {
-            var params = Array.prototype.slice.call(arguments);
-            var parsed = inputParser[method.name].apply(null, params);
+    contract.transact = function (options) {
+        contract._isTransact = true;
+        contract._options = options;
+        return contract;
+    };

-            var onSuccess = function (result) {
-                return outputParser[method.name](result);
-            };
-
-            return {
-                call: function (extra) {
-                    extra = extra || {};
-                    extra.to = address;
-                    extra.data = parsed;
-                    return web3.eth.call(extra).then(onSuccess);
-                },
-                transact: function (extra) {
-                    extra = extra || {};
-                    extra.to = address;
-                    extra.data = parsed;
-                    return web3.eth.transact(extra).then(onSuccess);
-                }
-            };
+    contract._options = {};
+    ['gas', 'gasPrice', 'value', 'from'].forEach(function(p) {
+        contract[p] = function (v) {
+            contract._options[p] = v;
+            return contract;
        };
    });

-    return contract;
 };

-if (typeof(module) !== "undefined")
-	module.exports = contract;
+var addFunctionsToContract = function (contract, desc, address) {
+    var inputParser = abi.inputParser(desc);
+    var outputParser = abi.outputParser(desc);
+
+    // create contract functions
+    utils.filterFunctions(desc).forEach(function (method) {
+
+        var displayName = utils.extractDisplayName(method.name);
+        var typeName = utils.extractTypeName(method.name);
+
+        var impl = function () {
+            var params = Array.prototype.slice.call(arguments);
+            var signature = abi.signatureFromAscii(method.name);
+            var parsed = inputParser[displayName][typeName].apply(null, params);
+
+            var options = contract._options || {};
+            options.to = address;
+            options.data = signature + parsed;
+            
+            var isTransact = contract._isTransact === true || (contract._isTransact !== false && !method.constant);
+            var collapse = options.collapse !== false;
+            
+            // reset
+            contract._options = {};
+            contract._isTransact = null;
+
+            if (isTransact) {
+                
+                exportNatspecGlobals({
+                    abi: desc,
+                    address: address,
+                    method: method.name,
+                    params: params
+                });
+
+                // transactions do not have any output, cause we do not know, when they will be processed
+                web3.eth.transact(options);
+                return;
+            }
+            
+            var output = web3.eth.call(options);
+            var ret = outputParser[displayName][typeName](output);
+            if (collapse)
+            {
+                if (ret.length === 1)
+                    ret = ret[0];
+                else if (ret.length === 0)
+                    ret = null;
+            }
+            return ret;
+        };
+
+        if (contract[displayName] === undefined) {
+            contract[displayName] = impl;
+        }
+
+        contract[displayName][typeName] = impl;
+    });
+};
+
+var addEventRelatedPropertiesToContract = function (contract, desc, address) {
+    contract.address = address;
+    contract._onWatchEventResult = function (data) {
+        var matchingEvent = event.getMatchingEvent(utils.filterEvents(desc));
+        var parser = eventImpl.outputParser(matchingEvent);
+        return parser(data);
+    };
+    
+    Object.defineProperty(contract, 'topic', {
+        get: function() {
+            return utils.filterEvents(desc).map(function (e) {
+                return abi.eventSignatureFromAscii(e.name);
+            });
+        }
+    });
+
+};
+
+var addEventsToContract = function (contract, desc, address) {
+    // create contract events
+    utils.filterEvents(desc).forEach(function (e) {
+
+        var impl = function () {
+            var params = Array.prototype.slice.call(arguments);
+            var signature = abi.eventSignatureFromAscii(e.name);
+            var event = eventImpl.inputParser(address, signature, e);
+            var o = event.apply(null, params);
+            o._onWatchEventResult = function (data) {
+                var parser = eventImpl.outputParser(e);
+                return parser(data);
+            };
+            return web3.eth.watch(o);  
+        };
+        
+        // this property should be used by eth.filter to check if object is an event
+        impl._isEvent = true;
+
+        var displayName = utils.extractDisplayName(e.name);
+        var typeName = utils.extractTypeName(e.name);
+
+        if (contract[displayName] === undefined) {
+            contract[displayName] = impl;
+        }
+
+        contract[displayName][typeName] = impl;
+
+    });
+};
+
+
+/**
+ * This method should be called when we want to call / transact some solidity method from javascript
+ * it returns an object which has same methods available as solidity contract description
+ * usage example: 
+ *
+ * var abi = [{
+ *      name: 'myMethod',
+ *      inputs: [{ name: 'a', type: 'string' }],
+ *      outputs: [{name: 'd', type: 'string' }]
+ * }];  // contract abi
+ *
+ * var myContract = web3.eth.contract('0x0123123121', abi); // creation of contract object
+ *
+ * myContract.myMethod('this is test string param for call'); // myMethod call (implicit, default)
+ * myContract.call().myMethod('this is test string param for call'); // myMethod call (explicit)
+ * myContract.transact().myMethod('this is test string param for transact'); // myMethod transact
+ *
+ * @param address - address of the contract, which should be called
+ * @param desc - abi json description of the contract, which is being created
+ * @returns contract object
+ */
+
+var contract = function (address, desc) {
+
+    // workaround for invalid assumption that method.name is the full anonymous prototype of the method.
+    // it's not. it's just the name. the rest of the code assumes it's actually the anonymous
+    // prototype, so we make it so as a workaround.
+    // TODO: we may not want to modify input params, maybe use copy instead?
+    desc.forEach(function (method) {
+        if (method.name.indexOf('(') === -1) {
+            var displayName = method.name;
+            var typeName = method.inputs.map(function(i){return i.type; }).join();
+            method.name = displayName + '(' + typeName + ')';
+        }
+    });
+
+    var result = {};
+    addFunctionRelatedPropertiesToContract(result);
+    addFunctionsToContract(result, desc, address);
+    addEventRelatedPropertiesToContract(result, desc, address);
+    addEventsToContract(result, desc, address);
+
+    return result;
+};
+
+module.exports = contract;
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/event.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/event.js
@ -0,0 +1,135 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file event.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2014
+ */
+
+var abi = require('./abi');
+var utils = require('./utils');
+
+/// filter inputs array && returns only indexed (or not) inputs
+/// @param inputs array
+/// @param bool if result should be an array of indexed params on not
+/// @returns array of (not?) indexed params
+var filterInputs = function (inputs, indexed) {
+    return inputs.filter(function (current) {
+        return current.indexed === indexed;
+    });
+};
+
+var inputWithName = function (inputs, name) {
+    var index = utils.findIndex(inputs, function (input) {
+        return input.name === name;
+    });
+    
+    if (index === -1) {
+        console.error('indexed param with name ' + name + ' not found');
+        return undefined;
+    }
+    return inputs[index];
+};
+
+var indexedParamsToTopics = function (event, indexed) {
+    // sort keys?
+    return Object.keys(indexed).map(function (key) {
+        var inputs = [inputWithName(filterInputs(event.inputs, true), key)];
+
+        var value = indexed[key];
+        if (value instanceof Array) {
+            return value.map(function (v) {
+                return abi.formatInput(inputs, [v]);
+            }); 
+        }
+        return abi.formatInput(inputs, [value]);
+    });
+};
+
+var inputParser = function (address, signature, event) {
+    
+    // valid options are 'earliest', 'latest', 'offset' and 'max', as defined for 'eth.watch'
+    return function (indexed, options) {
+        var o = options || {};
+        o.address = address;
+        o.topic = [];
+        o.topic.push(signature);
+        if (indexed) {
+            o.topic = o.topic.concat(indexedParamsToTopics(event, indexed));
+        }
+        return o;
+    };
+};
+
+var getArgumentsObject = function (inputs, indexed, notIndexed) {
+    var indexedCopy = indexed.slice();
+    var notIndexedCopy = notIndexed.slice();
+    return inputs.reduce(function (acc, current) {
+        var value;
+        if (current.indexed)
+            value = indexed.splice(0, 1)[0];
+        else
+            value = notIndexed.splice(0, 1)[0];
+
+        acc[current.name] = value;
+        return acc;
+    }, {}); 
+};
+ 
+var outputParser = function (event) {
+    
+    return function (output) {
+        var result = {
+            event: utils.extractDisplayName(event.name),
+            number: output.number,
+            args: {}
+        };
+
+        if (!output.topic) {
+            return result;
+        }
+       
+        var indexedOutputs = filterInputs(event.inputs, true);
+        var indexedData = "0x" + output.topic.slice(1, output.topic.length).map(function (topic) { return topic.slice(2); }).join("");
+        var indexedRes = abi.formatOutput(indexedOutputs, indexedData);
+
+        var notIndexedOutputs = filterInputs(event.inputs, false);
+        var notIndexedRes = abi.formatOutput(notIndexedOutputs, output.data);
+
+        result.args = getArgumentsObject(event.inputs, indexedRes, notIndexedRes);
+
+        return result;
+    };
+};
+
+var getMatchingEvent = function (events, payload) {
+    for (var i = 0; i < events.length; i++) {
+        var signature = abi.eventSignatureFromAscii(events[i].name); 
+        if (signature === payload.topic[0]) {
+            return events[i];
+        }
+    }
+    return undefined;
+};
+
+
+module.exports = {
+    inputParser: inputParser,
+    outputParser: outputParser,
+    getMatchingEvent: getMatchingEvent
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/filter.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/filter.js
@ -0,0 +1,101 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file filter.js
+ * @authors:
+ *   Jeffrey Wilcke <jeff@ethdev.com>
+ *   Marek Kotewicz <marek@ethdev.com>
+ *   Marian Oancea <marian@ethdev.com>
+ *   Gav Wood <g@ethdev.com>
+ * @date 2014
+ */
+
+var web3 = require('./web3'); // jshint ignore:line
+
+/// should be used when we want to watch something
+/// it's using inner polling mechanism and is notified about changes
+/// TODO: change 'options' name cause it may be not the best matching one, since we have events
+var Filter = function(options, impl) {
+
+    if (typeof options !== "string") {
+
+        // topics property is deprecated, warn about it!
+        if (options.topics) {
+            console.warn('"topics" is deprecated, use "topic" instead');
+        }
+        
+        this._onWatchResult = options._onWatchEventResult;
+
+        // evaluate lazy properties
+        options = {
+            to: options.to,
+            topic: options.topic,
+            earliest: options.earliest,
+            latest: options.latest,
+            max: options.max,
+            skip: options.skip,
+            address: options.address
+        };
+
+    }
+    
+    this.impl = impl;
+    this.callbacks = [];
+
+    this.id = impl.newFilter(options);
+    web3.provider.startPolling({method: impl.changed, params: [this.id]}, this.id, this.trigger.bind(this));
+};
+
+/// alias for changed*
+Filter.prototype.arrived = function(callback) {
+    this.changed(callback);
+};
+Filter.prototype.happened = function(callback) {
+    this.changed(callback);
+};
+
+/// gets called when there is new eth/shh message
+Filter.prototype.changed = function(callback) {
+    this.callbacks.push(callback);
+};
+
+/// trigger calling new message from people
+Filter.prototype.trigger = function(messages) {
+    for (var i = 0; i < this.callbacks.length; i++) {
+        for (var j = 0; j < messages.length; j++) {
+            var message = this._onWatchResult ? this._onWatchResult(messages[j]) : messages[j];
+            this.callbacks[i].call(this, message);
+        }
+    }
+};
+
+/// should be called to uninstall current filter
+Filter.prototype.uninstall = function() {
+    this.impl.uninstallFilter(this.id);
+    web3.provider.stopPolling(this.id);
+};
+
+/// should be called to manually trigger getting latest messages from the client
+Filter.prototype.messages = function() {
+    return this.impl.getMessages(this.id);
+};
+
+/// alias for messages
+Filter.prototype.logs = function () {
+    return this.messages();
+};
+
+module.exports = Filter;
--- a/cmd/mist/assets/ext/ethereum.js/lib/formatters.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/formatters.js
@ -0,0 +1,154 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file formatters.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+if (process.env.NODE_ENV !== 'build') {
+    var BigNumber = require('bignumber.js'); // jshint ignore:line
+}
+
+var utils = require('./utils');
+var c = require('./const');
+
+/// @param string string to be padded
+/// @param number of characters that result string should have
+/// @param sign, by default 0
+/// @returns right aligned string
+var padLeft = function (string, chars, sign) {
+    return new Array(chars - string.length + 1).join(sign ? sign : "0") + string;
+};
+
+/// Formats input value to byte representation of int
+/// If value is negative, return it's two's complement
+/// If the value is floating point, round it down
+/// @returns right-aligned byte representation of int
+var formatInputInt = function (value) {
+    var padding = c.ETH_PADDING * 2;
+    if (value instanceof BigNumber || typeof value === 'number') {
+        if (typeof value === 'number')
+            value = new BigNumber(value);
+        BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);
+        value = value.round();
+
+        if (value.lessThan(0)) 
+            value = new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(value).plus(1);
+        value = value.toString(16);
+    }
+    else if (value.indexOf('0x') === 0)
+        value = value.substr(2);
+    else if (typeof value === 'string')
+        value = formatInputInt(new BigNumber(value));
+    else
+        value = (+value).toString(16);
+    return padLeft(value, padding);
+};
+
+/// Formats input value to byte representation of string
+/// @returns left-algined byte representation of string
+var formatInputString = function (value) {
+    return utils.fromAscii(value, c.ETH_PADDING).substr(2);
+};
+
+/// Formats input value to byte representation of bool
+/// @returns right-aligned byte representation bool
+var formatInputBool = function (value) {
+    return '000000000000000000000000000000000000000000000000000000000000000' + (value ?  '1' : '0');
+};
+
+/// Formats input value to byte representation of real
+/// Values are multiplied by 2^m and encoded as integers
+/// @returns byte representation of real
+var formatInputReal = function (value) {
+    return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128))); 
+};
+
+
+/// Check if input value is negative
+/// @param value is hex format
+/// @returns true if it is negative, otherwise false
+var signedIsNegative = function (value) {
+    return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';
+};
+
+/// Formats input right-aligned input bytes to int
+/// @returns right-aligned input bytes formatted to int
+var formatOutputInt = function (value) {
+    value = value || "0";
+    // check if it's negative number
+    // it it is, return two's complement
+    if (signedIsNegative(value)) {
+        return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);
+    }
+    return new BigNumber(value, 16);
+};
+
+/// Formats big right-aligned input bytes to uint
+/// @returns right-aligned input bytes formatted to uint
+var formatOutputUInt = function (value) {
+    value = value || "0";
+    return new BigNumber(value, 16);
+};
+
+/// @returns input bytes formatted to real
+var formatOutputReal = function (value) {
+    return formatOutputInt(value).dividedBy(new BigNumber(2).pow(128)); 
+};
+
+/// @returns input bytes formatted to ureal
+var formatOutputUReal = function (value) {
+    return formatOutputUInt(value).dividedBy(new BigNumber(2).pow(128)); 
+};
+
+/// @returns right-aligned input bytes formatted to hex
+var formatOutputHash = function (value) {
+    return "0x" + value;
+};
+
+/// @returns right-aligned input bytes formatted to bool
+var formatOutputBool = function (value) {
+    return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
+};
+
+/// @returns left-aligned input bytes formatted to ascii string
+var formatOutputString = function (value) {
+    return utils.toAscii(value);
+};
+
+/// @returns right-aligned input bytes formatted to address
+var formatOutputAddress = function (value) {
+    return "0x" + value.slice(value.length - 40, value.length);
+};
+
+
+module.exports = {
+    formatInputInt: formatInputInt,
+    formatInputString: formatInputString,
+    formatInputBool: formatInputBool,
+    formatInputReal: formatInputReal,
+    formatOutputInt: formatOutputInt,
+    formatOutputUInt: formatOutputUInt,
+    formatOutputReal: formatOutputReal,
+    formatOutputUReal: formatOutputUReal,
+    formatOutputHash: formatOutputHash,
+    formatOutputBool: formatOutputBool,
+    formatOutputString: formatOutputString,
+    formatOutputAddress: formatOutputAddress
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/httprpc.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/httprpc.js
@ -1,95 +0,0 @@
-/*
-    This file is part of ethereum.js.
-
-    ethereum.js 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.
-
-    ethereum.js 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 Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file httprpc.js
- * @authors:
- *   Marek Kotewicz <marek@ethdev.com>
- *   Marian Oancea <marian@ethdev.com>
- * @date 2014
- */
-
-// TODO: is these line is supposed to be here? 
-if (process.env.NODE_ENV !== 'build') {
-    var XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore:line
-}
-
-var HttpRpcProvider = function (host) {
-    this.handlers = [];
-    this.host = host;
-};
-
-function formatJsonRpcObject(object) {
-    return {
-        jsonrpc: '2.0',
-        method: object.call,
-        params: object.args,
-        id: object._id
-    };
-}
-
-function formatJsonRpcMessage(message) {
-    var object = JSON.parse(message);
-
-    return {
-        _id: object.id,
-        data: object.result,
-        error: object.error
-    };
-}
-
-HttpRpcProvider.prototype.sendRequest = function (payload, cb) {
-    var data = formatJsonRpcObject(payload);
-
-    var request = new XMLHttpRequest();
-    request.open("POST", this.host, true);
-    request.send(JSON.stringify(data));
-    request.onreadystatechange = function () {
-        if (request.readyState === 4 && cb) {
-            cb(request);
-        }
-    };
-};
-
-HttpRpcProvider.prototype.send = function (payload) {
-    var self = this;
-    this.sendRequest(payload, function (request) {
-        self.handlers.forEach(function (handler) {
-            handler.call(self, formatJsonRpcMessage(request.responseText));
-        });
-    });
-};
-
-HttpRpcProvider.prototype.poll = function (payload, id) {
-    var self = this;
-    this.sendRequest(payload, function (request) {
-        var parsed = JSON.parse(request.responseText);
-        if (parsed.error || (parsed.result instanceof Array ? parsed.result.length === 0 : !parsed.result)) {
-            return;
-        }
-        self.handlers.forEach(function (handler) {
-            handler.call(self, {_event: payload.call, _id: id, data: parsed.result});
-        });
-    });
-};
-
-Object.defineProperty(HttpRpcProvider.prototype, "onmessage", {
-    set: function (handler) {
-        this.handlers.push(handler);
-    }
-});
-
-if (typeof(module) !== "undefined")
-	module.exports = HttpRpcProvider;
--- a/cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/httpsync.js
@ -0,0 +1,46 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file httpsync.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ *   Marian Oancea <marian@ethdev.com>
+ * @date 2014
+ */
+
+if (process.env.NODE_ENV !== 'build') {
+        var XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore:line
+}
+
+var HttpSyncProvider = function (host) {
+    this.handlers = [];
+    this.host = host || 'http://localhost:8080';
+};
+
+HttpSyncProvider.prototype.send = function (payload) {
+    //var data = formatJsonRpcObject(payload);
+    
+    var request = new XMLHttpRequest();
+    request.open('POST', this.host, false);
+    request.send(JSON.stringify(payload));
+    
+    // check request.status
+    var result = request.responseText;
+    return JSON.parse(result);
+};
+
+module.exports = HttpSyncProvider;
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/jsonrpc.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/jsonrpc.js
@ -0,0 +1,65 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file jsonrpc.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+var messageId = 1;
+
+/// Should be called to valid json create payload object
+/// @param method of jsonrpc call, required
+/// @param params, an array of method params, optional
+/// @returns valid jsonrpc payload object
+var toPayload = function (method, params) {
+    if (!method)
+        console.error('jsonrpc method should be specified!');
+
+    return {
+        jsonrpc: '2.0',
+        method: method,
+        params: params || [],
+        id: messageId++
+    }; 
+};
+
+/// Should be called to check if jsonrpc response is valid
+/// @returns true if response is valid, otherwise false 
+var isValidResponse = function (response) {
+    return !!response &&
+        !response.error &&
+        response.jsonrpc === '2.0' &&
+        typeof response.id === 'number' &&
+        response.result !== undefined; // only undefined is not valid json object
+};
+
+/// Should be called to create batch payload object
+/// @param messages, an array of objects with method (required) and params (optional) fields
+var toBatchPayload = function (messages) {
+    return messages.map(function (message) {
+        return toPayload(message.method, message.params);
+    }); 
+};
+
+module.exports = {
+    toPayload: toPayload,
+    isValidResponse: isValidResponse,
+    toBatchPayload: toBatchPayload
+};
+
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/local.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/local.js
@ -0,0 +1,18 @@
+var addressName = {"0x12378912345789": "Gav", "0x57835893478594739854": "Jeff"};
+var nameAddress = {};
+
+for (var prop in addressName) {
+  if (addressName.hasOwnProperty(prop)) {
+    nameAddress[addressName[prop]]  = prop;
+  }
+}
+
+var local = {
+  addressBook:{
+    byName: addressName,
+    byAddress: nameAddress
+  }
+};
+
+if (typeof(module) !== "undefined")
+    module.exports = local;
--- a/cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/providermanager.js
@ -0,0 +1,102 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file providermanager.js
+ * @authors:
+ *   Jeffrey Wilcke <jeff@ethdev.com>
+ *   Marek Kotewicz <marek@ethdev.com>
+ *   Marian Oancea <marian@ethdev.com>
+ *   Gav Wood <g@ethdev.com>
+ * @date 2014
+ */
+
+var web3 = require('./web3'); 
+var jsonrpc = require('./jsonrpc');
+
+
+/**
+ * Provider manager object prototype
+ * It's responsible for passing messages to providers
+ * If no provider is set it's responsible for queuing requests
+ * It's also responsible for polling the ethereum node for incoming messages
+ * Default poll timeout is 12 seconds
+ * If we are running ethereum.js inside ethereum browser, there are backend based tools responsible for polling,
+ * and provider manager polling mechanism is not used
+ */
+var ProviderManager = function() {
+    this.polls = [];
+    this.provider = undefined;
+
+    var self = this;
+    var poll = function () {
+        self.polls.forEach(function (data) {
+            var result = self.send(data.data);
+
+            if (!(result instanceof Array) || result.length === 0) {
+                return;
+            }
+
+            data.callback(result);
+        });
+
+        setTimeout(poll, 1000);
+    };
+    poll();
+};
+
+/// sends outgoing requests
+/// @params data - an object with at least 'method' property
+ProviderManager.prototype.send = function(data) {
+    var payload = jsonrpc.toPayload(data.method, data.params);
+
+    if (this.provider === undefined) {
+        console.error('provider is not set');
+        return null; 
+    }
+
+    var result = this.provider.send(payload);
+
+    if (!jsonrpc.isValidResponse(result)) {
+        console.log(result);
+        return null;
+    }
+
+    return result.result;
+};
+
+/// setups provider, which will be used for sending messages
+ProviderManager.prototype.set = function(provider) {
+    this.provider = provider;
+};
+
+/// this method is only used, when we do not have native qt bindings and have to do polling on our own
+/// should be callled, on start watching for eth/shh changes
+ProviderManager.prototype.startPolling = function (data, pollId, callback) {
+    this.polls.push({data: data, id: pollId, callback: callback});
+};
+
+/// should be called to stop polling for certain watch changes
+ProviderManager.prototype.stopPolling = function (pollId) {
+    for (var i = this.polls.length; i--;) {
+        var poll = this.polls[i];
+        if (poll.id === pollId) {
+            this.polls.splice(i, 1);
+        }
+    }
+};
+
+module.exports = ProviderManager;
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/qtsync.js
@ -14,33 +14,20 @@
    You should have received a copy of the GNU Lesser General Public License
    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
 */
-/** @file qt.js
+/** @file qtsync.js
 * @authors:
- *   Jeffrey Wilcke <jeff@ethdev.com>
 *   Marek Kotewicz <marek@ethdev.com>
+ *   Marian Oancea <marian@ethdev.com>
 * @date 2014
 */

-var QtProvider = function() {
-    this.handlers = [];
-
-    var self = this;
-    navigator.qt.onmessage = function (message) {
-        self.handlers.forEach(function (handler) {
-            handler.call(self, JSON.parse(message.data));
-        });
-    };
+var QtSyncProvider = function () {
 };

-QtProvider.prototype.send = function(payload) {
-    navigator.qt.postMessage(JSON.stringify(payload));
+QtSyncProvider.prototype.send = function (payload) {
+    var result = navigator.qt.callMethod(JSON.stringify(payload));
+    return JSON.parse(result);
 };

-Object.defineProperty(QtProvider.prototype, "onmessage", {
-    set: function(handler) {
-        this.handlers.push(handler);
-    }
-});
+module.exports = QtSyncProvider;

-if (typeof(module) !== "undefined")
-	module.exports = QtProvider;
--- a/cmd/mist/assets/ext/ethereum.js/lib/types.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/types.js
@ -0,0 +1,79 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file types.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+var f = require('./formatters');
+
+/// @param expected type prefix (string)
+/// @returns function which checks if type has matching prefix. if yes, returns true, otherwise false
+var prefixedType = function (prefix) {
+    return function (type) {
+        return type.indexOf(prefix) === 0;
+    };
+};
+
+/// @param expected type name (string)
+/// @returns function which checks if type is matching expected one. if yes, returns true, otherwise false
+var namedType = function (name) {
+    return function (type) {
+        return name === type;
+    };
+};
+
+/// Setups input formatters for solidity types
+/// @returns an array of input formatters 
+var inputTypes = function () {
+    
+    return [
+        { type: prefixedType('uint'), format: f.formatInputInt },
+        { type: prefixedType('int'), format: f.formatInputInt },
+        { type: prefixedType('hash'), format: f.formatInputInt },
+        { type: prefixedType('string'), format: f.formatInputString }, 
+        { type: prefixedType('real'), format: f.formatInputReal },
+        { type: prefixedType('ureal'), format: f.formatInputReal },
+        { type: namedType('address'), format: f.formatInputInt },
+        { type: namedType('bool'), format: f.formatInputBool }
+    ];
+};
+
+/// Setups output formaters for solidity types
+/// @returns an array of output formatters
+var outputTypes = function () {
+
+    return [
+        { type: prefixedType('uint'), format: f.formatOutputUInt },
+        { type: prefixedType('int'), format: f.formatOutputInt },
+        { type: prefixedType('hash'), format: f.formatOutputHash },
+        { type: prefixedType('string'), format: f.formatOutputString },
+        { type: prefixedType('real'), format: f.formatOutputReal },
+        { type: prefixedType('ureal'), format: f.formatOutputUReal },
+        { type: namedType('address'), format: f.formatOutputAddress },
+        { type: namedType('bool'), format: f.formatOutputBool }
+    ];
+};
+
+module.exports = {
+    prefixedType: prefixedType,
+    namedType: namedType,
+    inputTypes: inputTypes,
+    outputTypes: outputTypes
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/utils.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/utils.js
@ -0,0 +1,142 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js 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.
+
+    ethereum.js 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file utils.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+var c = require('./const');
+
+/// Finds first index of array element matching pattern
+/// @param array
+/// @param callback pattern
+/// @returns index of element
+var findIndex = function (array, callback) {
+    var end = false;
+    var i = 0;
+    for (; i < array.length && !end; i++) {
+        end = callback(array[i]);
+    }
+    return end ? i - 1 : -1;
+};
+
+/// @returns ascii string representation of hex value prefixed with 0x
+var toAscii = function(hex) {
+// Find termination
+    var str = "";
+    var i = 0, l = hex.length;
+    if (hex.substring(0, 2) === '0x') {
+        i = 2;
+    }
+    for (; i < l; i+=2) {
+        var code = parseInt(hex.substr(i, 2), 16);
+        if (code === 0) {
+            break;
+        }
+
+        str += String.fromCharCode(code);
+    }
+
+    return str;
+};
+    
+var 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;
+};
+
+/// @returns hex representation (prefixed by 0x) of ascii string
+var fromAscii = function(str, pad) {
+    pad = pad === undefined ? 0 : pad;
+    var hex = toHex(str);
+    while (hex.length < pad*2)
+        hex += "00";
+    return "0x" + hex;
+};
+
+/// @returns display name for function/event eg. multiply(uint256) -> multiply
+var extractDisplayName = function (name) {
+    var length = name.indexOf('('); 
+    return length !== -1 ? name.substr(0, length) : name;
+};
+
+/// @returns overloaded part of function/event name
+var extractTypeName = function (name) {
+    /// TODO: make it invulnerable
+    var length = name.indexOf('(');
+    return length !== -1 ? name.substr(length + 1, name.length - 1 - (length + 1)).replace(' ', '') : "";
+};
+
+/// Filters all function from input abi
+/// @returns abi array with filtered objects of type 'function'
+var filterFunctions = function (json) {
+    return json.filter(function (current) {
+        return current.type === 'function'; 
+    }); 
+};
+
+/// Filters all events form input abi
+/// @returns abi array with filtered objects of type 'event'
+var filterEvents = function (json) {
+    return json.filter(function (current) {
+        return current.type === 'event';
+    });
+};
+
+/// used to transform value/string to eth string
+/// TODO: use BigNumber.js to parse int
+/// TODO: add tests for it!
+var toEth = function (str) {
+    var val = typeof str === "string" ? str.indexOf('0x') === 0 ? parseInt(str.substr(2), 16) : parseInt(str) : str;
+    var unit = 0;
+    var units = c.ETH_UNITS;
+    while (val > 3000 && unit < units.length - 1)
+    {
+        val /= 1000;
+        unit++;
+    }
+    var s = val.toString().length < val.toFixed(2).length ? val.toString() : val.toFixed(2);
+    var replaceFunction = function($0, $1, $2) {
+        return $1 + ',' + $2;
+    };
+
+    while (true) {
+        var o = s;
+        s = s.replace(/(\d)(\d\d\d[\.\,])/, replaceFunction);
+        if (o === s)
+            break;
+    }
+    return s + ' ' + units[unit];
+};
+
+module.exports = {
+    findIndex: findIndex,
+    toAscii: toAscii,
+    fromAscii: fromAscii,
+    extractDisplayName: extractDisplayName,
+    extractTypeName: extractTypeName,
+    filterFunctions: filterFunctions,
+    filterEvents: filterEvents,
+    toEth: toEth
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/lib/web3.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/web3.js
@ -14,7 +14,7 @@
    You should have received a copy of the GNU Lesser General Public License
    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
 */
-/** @file main.js
+/** @file web3.js
 * @authors:
 *   Jeffrey Wilcke <jeff@ethdev.com>
 *   Marek Kotewicz <marek@ethdev.com>
@ -23,51 +23,20 @@
 * @date 2014
 */

-function flattenPromise (obj) {
-    if (obj instanceof Promise) {
-        return Promise.resolve(obj);
-    }
-
-    if (obj instanceof Array) {
-        return new Promise(function (resolve) {
-            var promises = obj.map(function (o) {
-                return flattenPromise(o);
-            });
-
-            return Promise.all(promises).then(function (res) {
-                for (var i = 0; i < obj.length; i++) {
-                    obj[i] = res[i];
-                }
-                resolve(obj);
-            });
-        });
-    }
-
-    if (obj instanceof Object) {
-        return new Promise(function (resolve) {
-            var keys = Object.keys(obj);
-            var promises = keys.map(function (key) {
-                return flattenPromise(obj[key]);
-            });
-
-            return Promise.all(promises).then(function (res) {
-                for (var i = 0; i < keys.length; i++) {
-                    obj[keys[i]] = res[i];
-                }
-                resolve(obj);
-            });
-        });
-    }
-
-    return Promise.resolve(obj);
+if (process.env.NODE_ENV !== 'build') {
+    var BigNumber = require('bignumber.js');
 }

+var utils = require('./utils');
+
+/// @returns an array of objects describing web3 api methods
 var web3Methods = function () {
    return [
    { name: 'sha3', call: 'web3_sha3' }
    ];
 };

+/// @returns an array of objects describing web3.eth api methods
 var ethMethods = function () {
    var blockCall = function (args) {
        return typeof args[0] === "string" ? "eth_blockByHash" : "eth_blockByNumber";
@ -93,6 +62,7 @@ var ethMethods = function () {
    { name: 'transaction', call: transactionCall },
    { name: 'uncle', call: uncleCall },
    { name: 'compilers', call: 'eth_compilers' },
+    { name: 'flush', call: 'eth_flush' },
    { name: 'lll', call: 'eth_lll' },
    { name: 'solidity', call: 'eth_solidity' },
    { name: 'serpent', call: 'eth_serpent' },
@ -101,13 +71,13 @@ var ethMethods = function () {
    return methods;
 };

+/// @returns an array of objects describing web3.eth api properties
 var ethProperties = function () {
    return [
    { name: 'coinbase', getter: 'eth_coinbase', setter: 'eth_setCoinbase' },
    { name: 'listening', getter: 'eth_listening', setter: 'eth_setListening' },
    { name: 'mining', getter: 'eth_mining', setter: 'eth_setMining' },
    { name: 'gasPrice', getter: 'eth_gasPrice' },
-    { name: 'account', getter: 'eth_account' },
    { name: 'accounts', getter: 'eth_accounts' },
    { name: 'peerCount', getter: 'eth_peerCount' },
    { name: 'defaultBlock', getter: 'eth_defaultBlock', setter: 'eth_setDefaultBlock' },
@ -115,6 +85,7 @@ var ethProperties = function () {
    ];
 };

+/// @returns an array of objects describing web3.db api methods
 var dbMethods = function () {
    return [
    { name: 'put', call: 'db_put' },
@ -124,6 +95,7 @@ var dbMethods = function () {
    ];
 };

+/// @returns an array of objects describing web3.shh api methods
 var shhMethods = function () {
    return [
    { name: 'post', call: 'shh_post' },
@ -134,6 +106,7 @@ var shhMethods = function () {
    ];
 };

+/// @returns an array of objects describing web3.eth.watch api methods
 var ethWatchMethods = function () {
    var newFilter = function (args) {
        return typeof args[0] === 'string' ? 'eth_newFilterString' : 'eth_newFilter';
@ -146,6 +119,7 @@ var ethWatchMethods = function () {
    ];
 };

+/// @returns an array of objects describing web3.shh.watch api methods
 var shhWatchMethods = function () {
    return [
    { name: 'newFilter', call: 'shh_newFilter' },
@ -154,57 +128,37 @@ var shhWatchMethods = function () {
    ];
 };

+/// creates methods in a given object based on method description on input
+/// setups api calls for these methods
 var setupMethods = function (obj, methods) {
    methods.forEach(function (method) {
        obj[method.name] = function () {
-            return flattenPromise(Array.prototype.slice.call(arguments)).then(function (args) {
-                var call = typeof method.call === "function" ? method.call(args) : method.call;
-                return {call: call, args: args};
-            }).then(function (request) {
-                return new Promise(function (resolve, reject) {
-                    web3.provider.send(request, function (err, result) {
-                        if (!err) {
-                            resolve(result);
-                            return;
-                        }
-                        reject(err);
-                    });
-                });
-            }).catch(function(err) {
-                console.error(err);
+            var args = Array.prototype.slice.call(arguments);
+            var call = typeof method.call === 'function' ? method.call(args) : method.call;
+            return web3.provider.send({
+                method: call,
+                params: args
            });
        };
    });
 };

+/// creates properties in a given object based on properties description on input
+/// setups api calls for these properties
 var setupProperties = function (obj, properties) {
    properties.forEach(function (property) {
        var proto = {};
        proto.get = function () {
-            return new Promise(function(resolve, reject) {
-                web3.provider.send({call: property.getter}, function(err, result) {
-                    if (!err) {
-                        resolve(result);
-                        return;
-                    }
-                    reject(err);
-                });
+            return web3.provider.send({
+                method: property.getter
            });
        };
+
        if (property.setter) {
            proto.set = function (val) {
-                return flattenPromise([val]).then(function (args) {
-                    return new Promise(function (resolve) {
-                        web3.provider.send({call: property.setter, args: args}, function (err, result) {
-                            if (!err) {
-                                resolve(result);
-                                return;
-                            }
-                            reject(err);
-                        });
-                    });
-                }).catch(function (err) {
-                    console.error(err);
+                return web3.provider.send({
+                    method: property.setter,
+                    params: [val]
                });
            };
        }
@ -212,133 +166,70 @@ var setupProperties = function (obj, properties) {
    });
 };

-// TODO: import from a dependency, don't duplicate.
-var hexToDec = function (hex) {
-    return parseInt(hex, 16).toString();
-};
-
-var decToHex = function (dec) {
-    return parseInt(dec).toString(16);
-};
-
-
+/// setups web3 object, and it's in-browser executed methods
 var web3 = {
    _callbacks: {},
    _events: {},
    providers: {},

-    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;
-        }
+    /// @returns ascii string representation of hex value prefixed with 0x
+    toAscii: utils.toAscii,

-        return hex;
-    },
-
-    toAscii: function(hex) {
-        // Find termination
-        var str = "";
-        var i = 0, l = hex.length;
-        if (hex.substring(0, 2) === '0x')
-            i = 2;
-        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) {
-        pad = pad === undefined ? 32 : pad;
-        var hex = this.toHex(str);
-        while(hex.length < pad*2)
-            hex += "00";
-        return "0x" + hex;
-    },
+    /// @returns hex representation (prefixed by 0x) of ascii string
+    fromAscii: utils.fromAscii,

+    /// @returns decimal representaton of hex value prefixed by 0x
    toDecimal: function (val) {
-        return hexToDec(val.substring(2));
+        // remove 0x and place 0, if it's required
+        val = val.length > 2 ? val.substring(2) : "0";
+        return (new BigNumber(val, 16).toString(10));
    },

+    /// @returns hex representation (prefixed by 0x) of decimal value
    fromDecimal: function (val) {
-        return "0x" + decToHex(val);
+        return "0x" + (new BigNumber(val).toString(16));
    },

-    toEth: function(str) {
-        var val = typeof str === "string" ? str.indexOf('0x') === 0 ? parseInt(str.substr(2), 16) : parseInt(str) : str;
-        var unit = 0;
-        var units = [ 'wei', 'Kwei', 'Mwei', 'Gwei', 'szabo', 'finney', 'ether', 'grand', 'Mether', 'Gether', 'Tether', 'Pether', 'Eether', 'Zether', 'Yether', 'Nether', 'Dether', 'Vether', 'Uether' ];
-        while (val > 3000 && unit < units.length - 1)
-        {
-            val /= 1000;
-            unit++;
-        }
-        var s = val.toString().length < val.toFixed(2).length ? val.toString() : val.toFixed(2);
-        var replaceFunction = function($0, $1, $2) {
-            return $1 + ',' + $2;
-        };
-
-        while (true) {
-            var o = s;
-            s = s.replace(/(\d)(\d\d\d[\.\,])/, replaceFunction);
-            if (o === s)
-                break;
-        }
-        return s + ' ' + units[unit];
-    },
+    /// used to transform value/string to eth string
+    toEth: utils.toEth,

+    /// eth object prototype
    eth: {
-        prototype: Object(), // jshint ignore:line
-        watch: function (params) {
-            return new Filter(params, ethWatch);
+        contractFromAbi: function (abi) {
+            return function(addr) {
+                // Default to address of Config. TODO: rremove prior to genesis.
+                addr = addr || '0xc6d9d2cd449a754c494264e1809c50e34d64562b';
+                var ret = web3.eth.contract(addr, abi);
+                ret.address = addr;
+                return ret;
+            };
+        },
+
+        /// @param filter may be a string, object or event
+        /// @param indexed is optional, this is an object with optional event indexed params
+        /// @param options is optional, this is an object with optional event options ('max'...)
+        watch: function (filter, indexed, options) {
+            if (filter._isEvent) {
+                return filter(indexed, options);
+            }
+            return new web3.filter(filter, ethWatch);
        }
    },

-    db: {
-        prototype: Object() // jshint ignore:line
-    },
+    /// db object prototype
+    db: {},

+    /// shh object prototype
    shh: {
-        prototype: Object(), // jshint ignore:line
-        watch: function (params) {
-            return new Filter(params, shhWatch);
+        
+        /// @param filter may be a string, object or event
+        watch: function (filter, indexed) {
+            return new web3.filter(filter, shhWatch);
        }
    },
-
-    on: function(event, id, cb) {
-        if(web3._events[event] === undefined) {
-            web3._events[event] = {};
-        }
-
-        web3._events[event][id] = cb;
-        return this;
-    },
-
-    off: function(event, id) {
-        if(web3._events[event] !== undefined) {
-            delete web3._events[event][id];
-        }
-
-        return this;
-    },
-
-    trigger: function(event, id, data) {
-        var callbacks = web3._events[event];
-        if (!callbacks || !callbacks[id]) {
-            return;
-        }
-        var cb = callbacks[id];
-        cb(data);
-    }
 };

+/// setups all api methods
 setupMethods(web3, web3Methods());
 setupMethods(web3.eth, ethMethods());
 setupProperties(web3.eth, ethProperties());
@ -348,162 +239,18 @@ setupMethods(web3.shh, shhMethods());
 var ethWatch = {
    changed: 'eth_changed'
 };
+
 setupMethods(ethWatch, ethWatchMethods());
+
 var shhWatch = {
    changed: 'shh_changed'
 };
+
 setupMethods(shhWatch, shhWatchMethods());

-var ProviderManager = function() {
-    this.queued = [];
-    this.polls = [];
-    this.ready = false;
-    this.provider = undefined;
-    this.id = 1;
-
-    var self = this;
-    var poll = function () {
-        if (self.provider && self.provider.poll) {
-            self.polls.forEach(function (data) {
-                data.data._id = self.id;
-                self.id++;
-                self.provider.poll(data.data, data.id);
-            });
-        }
-        setTimeout(poll, 12000);
-    };
-    poll();
-};
-
-ProviderManager.prototype.send = function(data, cb) {
-    data._id = this.id;
-    if (cb) {
-        web3._callbacks[data._id] = cb;
-    }
-
-    data.args = data.args || [];
-    this.id++;
-
-    if(this.provider !== undefined) {
-        this.provider.send(data);
-    } else {
-        console.warn("provider is not set");
-        this.queued.push(data);
-    }
-};
-
-ProviderManager.prototype.set = function(provider) {
-    if(this.provider !== undefined && this.provider.unload !== undefined) {
-        this.provider.unload();
-    }
-
-    this.provider = provider;
-    this.ready = true;
-};
-
-ProviderManager.prototype.sendQueued = function() {
-    for(var i = 0; this.queued.length; i++) {
-        // Resend
-        this.send(this.queued[i]);
-    }
-};
-
-ProviderManager.prototype.installed = function() {
-    return this.provider !== undefined;
-};
-
-ProviderManager.prototype.startPolling = function (data, pollId) {
-    if (!this.provider || !this.provider.poll) {
-        return;
-    }
-    this.polls.push({data: data, id: pollId});
-};
-
-ProviderManager.prototype.stopPolling = function (pollId) {
-    for (var i = this.polls.length; i--;) {
-        var poll = this.polls[i];
-        if (poll.id === pollId) {
-            this.polls.splice(i, 1);
-        }
-    }
-};
-
-web3.provider = new ProviderManager();
-
 web3.setProvider = function(provider) {
-    provider.onmessage = messageHandler;
    web3.provider.set(provider);
-    web3.provider.sendQueued();
 };

-web3.haveProvider = function() {
-    return !!web3.provider.provider;
-};
+module.exports = web3;

-var Filter = function(options, impl) {
-    this.impl = impl;
-    this.callbacks = [];
-
-    var self = this;
-    this.promise = impl.newFilter(options);
-    this.promise.then(function (id) {
-        self.id = id;
-        web3.on(impl.changed, id, self.trigger.bind(self));
-        web3.provider.startPolling({call: impl.changed, args: [id]}, id);
-    });
-};
-
-Filter.prototype.arrived = function(callback) {
-    this.changed(callback);
-};
-
-Filter.prototype.changed = function(callback) {
-    var self = this;
-    this.promise.then(function(id) {
-        self.callbacks.push(callback);
-    });
-};
-
-Filter.prototype.trigger = function(messages) {
-    for(var i = 0; i < this.callbacks.length; i++) {
-        this.callbacks[i].call(this, messages);
-    }
-};
-
-Filter.prototype.uninstall = function() {
-    var self = this;
-    this.promise.then(function (id) {
-        self.impl.uninstallFilter(id);
-        web3.provider.stopPolling(id);
-        web3.off(impl.changed, id);
-    });
-};
-
-Filter.prototype.messages = function() {
-    var self = this;
-    return this.promise.then(function (id) {
-        return self.impl.getMessages(id);
-    });
-};
-
-Filter.prototype.logs = function () {
-    return this.messages();
-};
-
-function messageHandler(data) {
-    if(data._event !== undefined) {
-        web3.trigger(data._event, data._id, data.data);
-        return;
-    }
-
-    if(data._id) {
-        var cb = web3._callbacks[data._id];
-        if (cb) {
-            cb.call(this, data.error, data.data);
-            delete web3._callbacks[data._id];
-        }
-    }
-}
-
-if (typeof(module) !== "undefined")
-    module.exports = web3;
--- a/cmd/mist/assets/ext/ethereum.js/lib/websocket.js
+++ b/cmd/mist/assets/ext/ethereum.js/lib/websocket.js
@ -1,78 +0,0 @@
-/*
-    This file is part of ethereum.js.
-
-    ethereum.js 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.
-
-    ethereum.js 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 Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file websocket.js
- * @authors:
- *   Jeffrey Wilcke <jeff@ethdev.com>
- *   Marek Kotewicz <marek@ethdev.com>
- *   Marian Oancea <marian@ethdev.com>
- * @date 2014
- */
-
-// TODO: is these line is supposed to be here? 
-if (process.env.NODE_ENV !== 'build') {
-    var WebSocket = require('ws'); // jshint ignore:line
-}
-
-var WebSocketProvider = function(host) {
-    // onmessage handlers
-    this.handlers = [];
-    // queue will be filled with messages if send is invoked before the ws is ready
-    this.queued = [];
-    this.ready = false;
-
-    this.ws = new WebSocket(host);
-
-    var self = this;
-    this.ws.onmessage = function(event) {
-        for(var i = 0; i < self.handlers.length; i++) {
-            self.handlers[i].call(self, JSON.parse(event.data), event);
-        }
-    };
-
-    this.ws.onopen = function() {
-        self.ready = true;
-
-        for(var i = 0; i < self.queued.length; i++) {
-            // Resend
-            self.send(self.queued[i]);
-        }
-    };
-};
-
-WebSocketProvider.prototype.send = function(payload) {
-    if(this.ready) {
-        var data = JSON.stringify(payload);
-
-        this.ws.send(data);
-    } else {
-        this.queued.push(payload);
-    }
-};
-
-WebSocketProvider.prototype.onMessage = function(handler) {
-    this.handlers.push(handler);
-};
-
-WebSocketProvider.prototype.unload = function() {
-    this.ws.close();
-};
-Object.defineProperty(WebSocketProvider.prototype, "onmessage", {
-    set: function(provider) { this.onMessage(provider); }
-});
-
-if (typeof(module) !== "undefined")
-    module.exports = WebSocketProvider;
--- a/cmd/mist/assets/ext/ethereum.js/package.json
+++ b/cmd/mist/assets/ext/ethereum.js/package.json
@ -1,16 +1,16 @@
 {
  "name": "ethereum.js",
  "namespace": "ethereum",
-  "version": "0.0.6",
+  "version": "0.0.13",
  "description": "Ethereum Compatible JavaScript API",
  "main": "./index.js",
  "directories": {
    "lib": "./lib"
  },
  "dependencies": {
-    "es6-promise": "*",
    "ws": "*",
-    "xmlhttprequest": "*"
+    "xmlhttprequest": "*",
+    "bignumber.js": ">=2.0.0"
  },
  "devDependencies": {
    "bower": ">=1.3.0",
@ -25,12 +25,14 @@
    "jshint": ">=2.5.0",
    "uglifyify": "^2.6.0",
    "unreachable-branch-transform": "^0.1.0",
-    "vinyl-source-stream": "^1.0.0"
+    "vinyl-source-stream": "^1.0.0",
+    "mocha": ">=2.1.0"
  },
  "scripts": {
    "build": "gulp",
    "watch": "gulp watch",
-    "lint": "gulp lint"
+    "lint": "gulp lint",
+    "test": "mocha"
  },
  "repository": {
    "type": "git",
--- a/cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/abi.parsers.js
@ -0,0 +1,860 @@
+var assert = require('assert');
+var BigNumber = require('bignumber.js');
+var abi = require('../lib/abi.js');
+var clone = function (object) { return JSON.parse(JSON.stringify(object)); };
+
+var description =  [{
+    "name": "test",
+    "inputs": [{
+        "name": "a",
+        "type": "uint256"
+    }
+    ],
+    "outputs": [
+    {
+        "name": "d",
+        "type": "uint256"
+    }
+    ]
+}];
+
+describe('abi', function() {
+    describe('inputParser', function() {
+        it('should parse input uint', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+
+        });
+
+        it('should parse input uint128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint128" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+
+        });
+        
+        it('should parse input uint256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+            
+        });
+
+        it('should parse input int', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+        });
+
+        it('should parse input int128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int128" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+
+        });
+
+        it('should parse input int256', function() {
+        
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(
+                parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)),
+                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+                );
+            assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003");
+            assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003");
+            
+        });
+
+        it('should parse input bool', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: 'bool' }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(true), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(false), "0000000000000000000000000000000000000000000000000000000000000000");
+
+        });
+
+        it('should parse input hash', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        }); 
+
+        it('should parse input hash256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        });
+
+
+        it('should parse input hash160', function() {
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash160" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+            
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+        });
+
+        it('should parse input address', function () {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "address" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d)
+            
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        });
+
+        it('should parse input string', function () {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(
+                parser.test('hello'), 
+                "000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000"
+                );
+            assert.equal(
+                parser.test('world'),
+                "0000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000"
+                );
+        });
+
+        it('should use proper method name', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].name = 'helloworld(int)';
+            d[0].inputs = [
+                { type: "int" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.helloworld(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.helloworld['int'](1), "0000000000000000000000000000000000000000000000000000000000000001");
+
+        });
+        
+        it('should parse multiple methods', function () {
+            
+            // given
+            var d =  [{
+                name: "test",
+                inputs: [{ type: "int" }],
+                outputs: [{ type: "int" }]
+            },{
+                name: "test2",
+                inputs: [{ type: "string" }],
+                outputs: [{ type: "string" }]
+            }];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            //then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(
+                parser.test2('hello'), 
+                "000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000"
+                );
+
+        });
+
+        it('should parse input array of ints', function () {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int[]" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(
+                parser.test([5, 6]),
+                "0000000000000000000000000000000000000000000000000000000000000002" + 
+                "0000000000000000000000000000000000000000000000000000000000000005" + 
+                "0000000000000000000000000000000000000000000000000000000000000006"
+                );
+        });
+
+        it('should parse input real', function () {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: 'real' }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test([1]),      "0000000000000000000000000000000100000000000000000000000000000000"); 
+            assert.equal(parser.test([2.125]),  "0000000000000000000000000000000220000000000000000000000000000000"); 
+            assert.equal(parser.test([8.5]),    "0000000000000000000000000000000880000000000000000000000000000000"); 
+            assert.equal(parser.test([-1]),     "ffffffffffffffffffffffffffffffff00000000000000000000000000000000"); 
+                
+        });
+        
+        it('should parse input ureal', function () {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: 'ureal' }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test([1]),      "0000000000000000000000000000000100000000000000000000000000000000"); 
+            assert.equal(parser.test([2.125]),  "0000000000000000000000000000000220000000000000000000000000000000"); 
+            assert.equal(parser.test([8.5]),    "0000000000000000000000000000000880000000000000000000000000000000"); 
+                
+        });
+
+    });
+
+    describe('outputParser', function() {
+        it('should parse output string', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+            
+            // then
+            assert.equal(
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                'hello'
+                );
+            assert.equal(
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0], 
+                'world'
+                );
+
+        });
+
+        it('should parse output uint', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+        
+        it('should parse output uint256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+
+        it('should parse output uint128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+
+        it('should parse output int', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+        
+        it('should parse output int256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+
+        it('should parse output int128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+
+        it('should parse output hash', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+        
+        it('should parse output hash256', function() {
+        
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+
+        it('should parse output hash160', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash160' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+            // TODO shouldnt' the expected hash be shorter?
+        });
+
+        it('should parse output address', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'address' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+
+        it('should parse output bool', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'bool' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true);
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false);
+            
+
+        });
+
+        it('should parse output real', function() {
+            
+            // given
+            var d = clone(description); 
+
+            d[0].outputs = [
+                { type: 'real' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
+            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
+            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1); 
+            
+        });
+
+        it('should parse output ureal', function() {
+
+            // given
+            var d = clone(description); 
+
+            d[0].outputs = [
+                { type: 'ureal' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
+            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
+            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
+
+        });
+        
+
+        it('should parse multiple output strings', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" },
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0],
+                'hello'
+                );
+            assert.equal(
+                parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[1],
+                'world'
+                );
+
+        });
+        
+        it('should use proper method name', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].name = 'helloworld(int)';
+            d[0].outputs = [
+                { type: "int" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+
+        });
+
+
+        it('should parse multiple methods', function () {
+            
+            // given
+            var d =  [{
+                name: "test",
+                inputs: [{ type: "int" }],
+                outputs: [{ type: "int" }]
+            },{
+                name: "test2",
+                inputs: [{ type: "string" }],
+                outputs: [{ type: "string" }]
+            }];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            //then
+            assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test2("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                "hello"
+                );
+
+        });
+
+        it('should parse output array', function () {
+            
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'int[]' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000002" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" + 
+                    "0000000000000000000000000000000000000000000000000000000000000006")[0][0],
+                5
+                );
+            assert.equal(parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000002" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" + 
+                    "0000000000000000000000000000000000000000000000000000000000000006")[0][1],
+                6
+                );
+
+        });
+
+        it('should parse 0x value', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'int' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x")[0], 0);
+
+        });
+        
+        it('should parse 0x value', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'uint' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x")[0], 0);
+
+        });
+
+    });
+});
+
--- a/cmd/mist/assets/ext/ethereum.js/test/db.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/db.methods.js
@ -0,0 +1,14 @@
+
+var assert = require('assert');
+var web3 = require('../index.js');
+var u = require('./test.utils.js');
+
+describe('web3', function() {
+    describe('db', function() {
+        u.methodExists(web3.db, 'put');
+        u.methodExists(web3.db, 'get');
+        u.methodExists(web3.db, 'putString');
+        u.methodExists(web3.db, 'getString');
+    });
+});
+
--- a/cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/eth.methods.js
@ -0,0 +1,34 @@
+var assert = require('assert');
+var web3 = require('../index.js');
+var u = require('./test.utils.js');
+
+describe('web3', function() {
+    describe('eth', function() {
+        u.methodExists(web3.eth, 'balanceAt');
+        u.methodExists(web3.eth, 'stateAt');
+        u.methodExists(web3.eth, 'storageAt');
+        u.methodExists(web3.eth, 'countAt');
+        u.methodExists(web3.eth, 'codeAt');
+        u.methodExists(web3.eth, 'transact');
+        u.methodExists(web3.eth, 'call');
+        u.methodExists(web3.eth, 'block');
+        u.methodExists(web3.eth, 'transaction');
+        u.methodExists(web3.eth, 'uncle');
+        u.methodExists(web3.eth, 'compilers');
+        u.methodExists(web3.eth, 'lll');
+        u.methodExists(web3.eth, 'solidity');
+        u.methodExists(web3.eth, 'serpent');
+        u.methodExists(web3.eth, 'logs');
+
+        u.propertyExists(web3.eth, 'coinbase');
+        u.propertyExists(web3.eth, 'listening');
+        u.propertyExists(web3.eth, 'mining');
+        u.propertyExists(web3.eth, 'gasPrice');
+        u.propertyExists(web3.eth, 'accounts');
+        u.propertyExists(web3.eth, 'peerCount');
+        u.propertyExists(web3.eth, 'defaultBlock');
+        u.propertyExists(web3.eth, 'number');
+    });
+});
+
+
--- a/cmd/mist/assets/ext/ethereum.js/test/mocha.opts
+++ b/cmd/mist/assets/ext/ethereum.js/test/mocha.opts
@ -0,0 +1,2 @@
+--reporter spec 
+
--- a/cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/shh.methods.js
@ -0,0 +1,14 @@
+var assert = require('assert');
+var web3 = require('../index.js');
+var u = require('./test.utils.js');
+
+describe('web3', function() {
+    describe('shh', function() {
+        u.methodExists(web3.shh, 'post');
+        u.methodExists(web3.shh, 'newIdentity');
+        u.methodExists(web3.shh, 'haveIdentity');
+        u.methodExists(web3.shh, 'newGroup');
+        u.methodExists(web3.shh, 'addToGroup');
+    });
+});
+
--- a/cmd/mist/assets/ext/ethereum.js/test/utils.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/utils.js
@ -0,0 +1,19 @@
+var assert = require('assert');
+
+var methodExists = function (object, method) {
+    it('should have method ' + method + ' implemented', function() {
+        assert.equal('function', typeof object[method], 'method ' + method + ' is not implemented');
+    });
+};
+
+var propertyExists = function (object, property) {
+    it('should have property ' + property + ' implemented', function() {
+        assert.notEqual('undefined', typeof object[property], 'property ' + property + ' is not implemented');
+    });
+};
+
+module.exports = {
+    methodExists: methodExists,
+    propertyExists: propertyExists
+};
+
--- a/cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
+++ b/cmd/mist/assets/ext/ethereum.js/test/web3.methods.js
@ -0,0 +1,10 @@
+var assert = require('assert');
+var web3 = require('../index.js');
+var u = require('./test.utils.js');
+
+describe('web3', function() {
+    u.methodExists(web3, 'sha3');
+    u.methodExists(web3, 'toAscii');
+    u.methodExists(web3, 'fromAscii');
+});
+
--- a/cmd/mist/assets/ext/home.html
+++ b/cmd/mist/assets/ext/home.html
@ -1,22 +0,0 @@
-<!doctype>
-<html>
-<head>
-<title>Ethereum</title>
-
-<style type="text/css">
-h1 {
-    text-align: center;
-    font-family: Courier;
-    font-size: 50pt;
-}
-</style>
-</head>
-
-<body>
-<h1>... Ethereum ...</h1>
-<ul>
-	<li><a href="http://std.eth">std::Service</a></li>
-</ul>
-</body>
-</html>
-
--- a/cmd/mist/assets/ext/html_messaging.js
+++ b/cmd/mist/assets/ext/html_messaging.js
@ -1,481 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-// The magic return variable. The magic return variable will be set during the execution of the QML call.
-(function(window) {
-	var Promise = window.Promise;
-	if(typeof(Promise) === "undefined") {
-		var Promise = Q.Promise;
-	}
-
-	function isPromise(o) {
-		return typeof o === "object" && o.then
-	}
-
-	window.eth = {
-		_callbacks: {},
-		_events: {},
-		prototype: Object(),
-
-		toHex: function(str) {
-			var hex = "";
-			for(var i = 0; i < str.length; i++) {
-				var n = str.charCodeAt(i).toString(16);
-				hex += n.length < 2 ? '0' + n : n;
-			}
-
-			return hex;
-		},
-
-		toAscii: function(hex) {
-			// Find termination
-			var str = "";
-			var i = 0, l = hex.length;
-			for(; i < l; i+=2) {
-				var code = hex.charCodeAt(i)
-				if(code == 0) {
-					break;
-				}
-
-				str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
-			}
-
-			return str;
-		},
-
-		fromAscii: function(str, pad) {
-			if(pad === undefined) {
-				pad = 32
-			}
-
-			var hex = this.toHex(str);
-
-			while(hex.length < pad*2)
-				hex += "00";
-
-			return hex
-		},
-
-		block: function(numberOrHash) {
-			return new Promise(function(resolve, reject) {
-				var func;
-				if(typeof numberOrHash == "string") {
-					func =  "getBlockByHash";
-				} else {
-					func =  "getBlockByNumber";
-				}
-
-				postData({call: func, args: [numberOrHash]}, function(block) {
-					if(block)
-						resolve(block);
-					else
-						reject("not found");
-
-				});
-			});
-		},
-
-		transact: function(params) {
-			if(params === undefined) {
-				params = {};
-			}
-
-			if(params.endowment !== undefined)
-				params.value = params.endowment;
-			if(params.code !== undefined)
-				params.data = params.code;
-
-
-			var promises = []
-			if(isPromise(params.to)) {
-				promises.push(params.to.then(function(_to) { params.to = _to; }));
-			}
-			if(isPromise(params.from)) {
-				promises.push(params.from.then(function(_from) { params.from = _from; }));
-			}
-
-            if(typeof params.data !== "object" || isPromise(params.data)) {
-                params.data = [params.data]
-            }
-
-            var data = params.data;
-            for(var i = 0; i < params.data.length; i++) {
-                if(isPromise(params.data[i])) {
-                    var promise = params.data[i];
-                    var _i = i;
-                    promises.push(promise.then(function(_arg) { params.data[_i] = _arg; }));
-                }
-            }
-                
-			// Make sure everything is string
-			var fields = ["value", "gas", "gasPrice"];
-			for(var i = 0; i < fields.length; i++) {
-				if(params[fields[i]] === undefined) {
-					params[fields[i]] = "";
-				}
-				params[fields[i]] = params[fields[i]].toString();
-			}
-
-			// Load promises then call the last "transact".
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-                    params.data = params.data.join("");
-					postData({call: "transact", args: params}, function(data) {
-						if(data[1])
-							reject(data[0]);
-						else
-							resolve(data[0]);
-					});
-				});
-			})
-		},
-
-		compile: function(code) {
-			return new Promise(function(resolve, reject) {
-				postData({call: "compile", args: [code]}, function(data) {
-					if(data[1])
-						reject(data[0]);
-					else
-						resolve(data[0]);
-				});
-			});
-		},
-
-		balanceAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getBalanceAt", args: [address]}, function(balance) {
-						resolve(balance);
-					});
-				});
-			});
-		},
-
-		countAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getCountAt", args: [address]}, function(count) {
-						resolve(count);
-					});
-				});
-			});
-		},
-
-		codeAt: function(address) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getCodeAt", args: [address]}, function(code) {
-						resolve(code);
-					});
-				});
-			});
-		},
-
-		storageAt: function(address, storageAddress) {
-			var promises = [];
-
-			if(isPromise(address)) {
-				promises.push(address.then(function(_address) { address = _address; }));
-			}
-
-			if(isPromise(storageAddress)) {
-				promises.push(storageAddress.then(function(_sa) { storageAddress = _sa; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getStorageAt", args: [address, storageAddress]}, function(entry) {
-						resolve(entry);
-					});
-				});
-			});
-		},
-
-		stateAt: function(address, storageAddress) {
-			return this.storageAt(address, storageAddress);
-		},
-
-		call: function(params) {
-			if(params === undefined) {
-				params = {};
-			}
-
-			if(params.endowment !== undefined)
-				params.value = params.endowment;
-			if(params.code !== undefined)
-				params.data = params.code;
-
-
-			var promises = []
-			if(isPromise(params.to)) {
-				promises.push(params.to.then(function(_to) { params.to = _to; }));
-			}
-			if(isPromise(params.from)) {
-				promises.push(params.from.then(function(_from) { params.from = _from; }));
-			}
-
-			if(isPromise(params.data)) {
-				promises.push(params.data.then(function(_code) { params.data = _code; }));
-			} else {
-				if(typeof params.data === "object") {
-					data = "";
-					for(var i = 0; i < params.data.length; i++) {
-						data += params.data[i]
-					}
-				} else {
-					data = params.data;
-				}
-			}
-
-			// Make sure everything is string
-			var fields = ["value", "gas", "gasPrice"];
-			for(var i = 0; i < fields.length; i++) {
-				if(params[fields[i]] === undefined) {
-					params[fields[i]] = "";
-				}
-				params[fields[i]] = params[fields[i]].toString();
-			}
-
-			// Load promises then call the last "transact".
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "call", args: params}, function(data) {
-						if(data[1])
-							reject(data[0]);
-						else
-							resolve(data[0]);
-					});
-				});
-			})
-		},
-
-		watch: function(params) {
-			return new Filter(params);
-		},
-
-		secretToAddress: function(key) {
-			var promises = [];
-			if(isPromise(key)) {
-				promises.push(key.then(function(_key) { key = _key; }));
-			}
-
-			return Q.all(promises).then(function() {
-				return new Promise(function(resolve, reject) {
-					postData({call: "getSecretToAddress", args: [key]}, function(address) {
-						resolve(address);
-					});
-				});
-			});
-		},
-
-		on: function(event, cb) {
-			if(eth._events[event] === undefined) {
-				eth._events[event] = [];
-			}
-
-			eth._events[event].push(cb);
-
-			return this
-		},
-
-		off: function(event, cb) {
-			if(eth._events[event] !== undefined) {
-				var callbacks = eth._events[event];
-				for(var i = 0; i < callbacks.length; i++) {
-					if(callbacks[i] === cb) {
-						delete callbacks[i];
-					}
-				}
-			}
-
-			return this
-		},
-
-		trigger: function(event, data) {
-			var callbacks = eth._events[event];
-			if(callbacks !== undefined) {
-				for(var i = 0; i < callbacks.length; i++) {
-					// Figure out whether the returned data was an array
-					// array means multiple return arguments (multiple params)
-					if(data instanceof Array) {
-						callbacks[i].apply(this, data);
-					} else {
-						callbacks[i].call(this, data);
-					}
-				}
-			}
-		},
-	};
-
-	// Eth object properties
-	Object.defineProperty(eth, "key", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getKey"}, function(k) {
-					resolve(k);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "gasPrice", {
-		get: function() {
-			return "10000000000000"
-		}
-	});
-
-	Object.defineProperty(eth, "coinbase", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getCoinBase"}, function(coinbase) {
-					resolve(coinbase);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "listening", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getIsListening"}, function(listening) {
-					resolve(listening);
-				});
-			});
-		},
-	});
-
-
-	Object.defineProperty(eth, "mining", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getIsMining"}, function(mining) {
-					resolve(mining);
-				});
-			});
-		},
-	});
-
-	Object.defineProperty(eth, "peerCount", {
-		get: function() {
-			return new Promise(function(resolve, reject) {
-				postData({call: "getPeerCount"}, function(peerCount) {
-					resolve(peerCount);
-				});
-			});
-		},
-	});
-
-	var filters = [];
-	var Filter = function(options) {
-		filters.push(this);
-
-		this.callbacks = [];
-		this.options = options;
-
-		var call;
-		if(options === "chain") {
-			call = "newFilterString"
-		} else if(typeof options === "object") {
-			call = "newFilter"
-		}
-
-		var self = this; // Cheaper than binding
-		this.promise = new Promise(function(resolve, reject) {
-			postData({call: call, args: [options]}, function(id) {
-				self.id = id;
-
-				resolve(id);
-			});
-		});
-	};
-
-	Filter.prototype.changed = function(callback) {
-		var self = this;
-		this.promise.then(function(id) {
-			self.callbacks.push(callback);
-		});
-	};
-
-	Filter.prototype.trigger = function(messages, id) {
-		if(id == this.id) {
-			for(var i = 0; i < this.callbacks.length; i++) {
-				this.callbacks[i].call(this, messages);
-			}
-		}
-	};
-
-	Filter.prototype.uninstall = function() {
-		this.promise.then(function(id) {
-			postData({call: "uninstallFilter", args:[id]});
-		});
-	};
-
-	Filter.prototype.messages = function() {
-		var self=this;
-		return Q.all([this.promise]).then(function() {
-			var id = self.id
-			return new Promise(function(resolve, reject) {
-				postData({call: "getMessages", args: [id]}, function(messages) {
-					resolve(messages);
-				});
-			});
-		});
-	};
-
-	// Register to the messages callback. "messages" will be emitted when new messages
-	// from the client have been created.
-	eth.on("messages", function(messages, id) {
-		for(var i = 0; i < filters.length; i++) {
-			filters[i].trigger(messages, id);
-		}
-	});
-
-
-	var g_seed = 1;
-	function postData(data, cb) {
-		data._seed = g_seed;
-		if(cb) {
-			eth._callbacks[data._seed] = cb;
-		}
-
-		if(data.args === undefined) {
-			data.args = [];
-		}
-
-		g_seed++;
-
-		window._messagingAdapter.call(this, JSON.stringify(data))
-	}
-})(this);
--- a/cmd/mist/assets/ext/q.js
+++ b/cmd/mist/assets/ext/q.js
--- a/cmd/mist/assets/ext/qml_messaging.js
+++ b/cmd/mist/assets/ext/qml_messaging.js
@ -1,30 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-function HandleMessage(data) {
-	var message;
-	try { message = JSON.parse(data) } catch(e) {};
-
-	if(message) {
-		switch(message.type) {
-			case "coinbase":
-				return eth.coinBase();
-			case "block":
-				return eth.blockByNumber(0);
-		}
-	}
-}
--- a/cmd/mist/assets/ext/qt_messaging_adapter.js
+++ b/cmd/mist/assets/ext/qt_messaging_adapter.js
@ -1,38 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-window._messagingAdapter = function(data) {
-	navigator.qt.postMessage(data);
-};
-
-navigator.qt.onmessage = function(ev) {
-	var data = JSON.parse(ev.data)
-
-	if(data._event !== undefined) {
-		eth.trigger(data._event, data.data);
-	} else {
-		if(data._seed) {
-			var cb = eth._callbacks[data._seed];
-			if(cb) {
-				cb.call(this, data.data)
-
-				// Remove the "trigger" callback
-				delete eth._callbacks[ev._seed];
-			}
-		}
-	}
-}
--- a/cmd/mist/assets/ext/setup.js
+++ b/cmd/mist/assets/ext/setup.js
@ -1,8 +0,0 @@
-(function() {
-    if (typeof(Promise) === "undefined")
-        window.Promise = Q.Promise;
-
-    var eth = web3.eth;
-
-    web3.setProvider(new web3.providers.QtProvider());
-})()
--- a/cmd/mist/assets/ext/string.js
+++ b/cmd/mist/assets/ext/string.js
@ -1,75 +0,0 @@
-// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this library; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
-// MA 02110-1301  USA
-
-String.prototype.pad = function(l, r) {
-	if (r === undefined) {
-		r = l
-		if (!(this.substr(0, 2) == "0x" || /^\d+$/.test(this)))
-			l = 0
-	}
-	var ret = this.bin();
-	while (ret.length < l)
-		ret = "\0" + ret
-	while (ret.length < r)
-		ret = ret + "\0"
-	return ret;
-}
-
-String.prototype.unpad = function() {
-	var i = this.length;
-	while (i && this[i - 1] == "\0")
-		--i
-	return this.substr(0, i)
-}
-
-String.prototype.bin = function() {
-	if (this.substr(0, 2) == "0x") {
-		bytes = []
-		var i = 2;
-
-		// Check if it's odd - pad with a zero if so.
-		if (this.length % 2)
-			bytes.push(parseInt(this.substr(i++, 1), 16))
-
-		for (; i < this.length - 1; i += 2)
-			bytes.push(parseInt(this.substr(i, 2), 16));
-
-		return String.fromCharCode.apply(String, bytes);
-	} else if (/^\d+$/.test(this))
-		return bigInt(this.substr(0)).toHex().bin()
-
-	// Otherwise we'll return the "String" object instead of an actual string
-	return this.substr(0, this.length)
-}
-
-String.prototype.unbin = function() {
-	var i, l, o = '';
-	for(i = 0, l = this.length; i < l; i++) {
-		var n = this.charCodeAt(i).toString(16);
-		o += n.length < 2 ? '0' + n : n;
-	}
-
-	return "0x" + o;
-}
-
-String.prototype.dec = function() {
-	return bigInt(this.substr(0)).toString()
-}
-
-String.prototype.hex = function() {
-	return bigInt(this.substr(0)).toHex()
-}
--- a/cmd/mist/assets/ext/test.html
+++ b/cmd/mist/assets/ext/test.html
@ -1,44 +0,0 @@
-<!doctype>
-<html>
-<head>
-<title>Tests</title>
-</head>
-
-<body>
-<button onclick="test();">Test me</button>
-
-<script type="text/javascript">
-function test() {
-	var filter = eth.watch({
-		latest: -1,
-		from: "e6716f9544a56c530d868e4bfbacb172315bdead",
-		altered: ["aabb", {id: "eeff", "at": "aabb"}],
-	});
-
-	filter.changed(function(messages) {
-		console.log("messages", messages)
-	})
-
-	filter.getMessages(function(messages) {
-			console.log("getMessages", messages)
-			});
-
-	eth.getEachStorageAt("9ef0f0d81e040012600b0c1abdef7c48f720f88a", function(entries) {
-			for(var i = 0; i < entries.length; i++) {
-				console.log(entries[i].key, " : ", entries[i].value)
-			}
-	})
-
-	eth.getBlock("f70097659f329a09642a27f11338d9269de64f1d4485786e36bfc410832148cd", function(block) {
-			console.log(block)
-	})
-
-	eth.mutan("var a = 10", function(code) {
-			console.log("code", code)
-	});
-}
-</script>
-
-</body>
-
-</html>
--- a/cmd/mist/assets/html/home.html
+++ b/cmd/mist/assets/html/home.html
@ -0,0 +1,83 @@
+<!doctype>
+<html>
+<head>
+<title>Ethereum</title>
+<script type="text/javascript" src="../ext/bignumber.min.js"></script>
+<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script>
+<style type="text/css">
+    body {
+        font-family: Helvetica;
+    }
+    div.logo {
+        width: 192px;
+        margin: 40px auto;
+    }
+</style>
+</head>
+<body>
+    <div class="logo"><img src="logo.png"></img></div>
+    <h1>Info</h1>
+
+	<table width="100%">
+		<tr>
+			<td>Block number</td>
+			<td id="number"></td>
+		</tr>
+
+		<tr>
+			<td>Peer count</td>
+			<td id="peer_count"></td>
+		</tr>
+
+		<tr>
+			<td>Accounts</td>
+			<td id="accounts"></td>
+		</tr>
+
+		<tr>
+			<td>Gas price</td>
+			<td id="gas_price"></td>
+		</tr>
+
+		<tr>
+			<td>Mining</td>
+			<td id="mining"></td>
+		</tr>
+
+		<tr>
+			<td>Listening</td>
+			<td id="listening"></td>
+		</tr>
+
+		<tr>
+			<td>Coinbase</td>
+			<td id="coinbase"></td>
+		</tr>
+	</table>
+</body>
+
+<script type="text/javascript">
+    var web3 = require('web3');
+    var eth = web3.eth;
+
+    web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8545'));
+
+    document.querySelector("#number").innerHTML = eth.number;
+    document.querySelector("#coinbase").innerHTML = eth.coinbase
+    document.querySelector("#peer_count").innerHTML = eth.peerCount;
+    document.querySelector("#accounts").innerHTML = eth.accounts;
+    document.querySelector("#gas_price").innerHTML = eth.gasPrice;
+    document.querySelector("#mining").innerHTML = eth.mining;
+    document.querySelector("#listening").innerHTML = eth.listening;
+
+    eth.watch('pending').changed(function() {
+        console.log("pending changed");
+    });
+    eth.watch('chain').changed(function() {
+        document.querySelector("#number").innerHTML = eth.number;
+    });
+
+</script>
+
+</html>
+
--- a/cmd/mist/assets/html/logo.png
+++ b/cmd/mist/assets/html/logo.png
--- a/cmd/mist/assets/qml/browser.qml
+++ b/cmd/mist/assets/qml/browser.qml
@ -1,491 +0,0 @@
-import QtQuick 2.1
-import QtWebKit 3.0
-import QtWebKit.experimental 1.0
-import QtQuick.Controls 1.0;
-import QtQuick.Controls.Styles 1.0
-import QtQuick.Layouts 1.0;
-import QtQuick.Window 2.1;
-import Ethereum 1.0
-
-Rectangle {
-	id: window
-    objectName: "browserView"
-    anchors.fill: parent
-    color: "#00000000"
-
-	property var title: "Browser"
-	property var iconSource: "../browser.png"
-	property var menuItem
-
-	property alias url: webview.url
-	property alias webView: webview
-
-	property var cleanPath: false
-	property var open: function(url) {
-		if(!window.cleanPath) {
-			var uri = url;
-			if(!/.*\:\/\/.*/.test(uri)) {
-				uri = "http://" + uri;
-			}
-
-			var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/
-
-			if(reg.test(uri)) {
-				uri.replace(reg, function(match, pre, domain, path) {
-					uri = pre;
-
-					var lookup = eth.lookupDomain(domain.substring(0, domain.length - 4));
-					var ip = [];
-					for(var i = 0, l = lookup.length; i < l; i++) {
-						ip.push(lookup.charCodeAt(i))
-					}
-
-					if(ip.length != 0) {
-						uri += lookup;
-					} else {
-						uri += domain;
-					}
-
-					uri += path;
-				});
-			}
-
-			window.cleanPath = true;
-
-			webview.url = uri;
-
-			//uriNav.text = uri.text.replace(/(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.\w{2,3})(.*)/, "$1$2<span style='color:#CCC'>$3</span>");
-			uriNav.text = uri;
-		} else {
-			// Prevent inf loop.
-			window.cleanPath = false;
-		}
-	}
-
-	Component.onCompleted: {
-		webview.url = "http://etherian.io"
-	}
-
-	signal messages(var messages, int id);
-	onMessages: {
-		// Bit of a cheat to get proper JSON
-		var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
-		webview.postEvent("eth_changed", id, m);
-	}
-
-	function onShhMessage(message, id) {
-		webview.postEvent("shh_changed", id, message)
-	}
-
-	Item {
-		objectName: "root"
-		id: root
-		anchors.fill: parent
-		state: "inspectorShown"
-
-		RowLayout {
-			id: navBar
-			height: 40
-			anchors {
-				left: parent.left
-				right: parent.right
-				leftMargin: 7
-			}
-
-			Button {
-				id: back
-				onClicked: {
-					webview.goBack()
-				}
-				style: ButtonStyle {
-					background: Image {
-						source: "../back.png"
-						width: 30
-						height: 30
-					}
-				}
-			}
-
-			TextField {
-				anchors {
-					left: back.right
-					right: toggleInspector.left
-					leftMargin: 10
-					rightMargin: 10
-				}
-				text: webview.url;
-				id: uriNav
-				y: parent.height / 2 - this.height / 2
-
-				Keys.onReturnPressed: {
-					webview.url = this.text;
-				}
-			}
-
-			Button {
-				id: toggleInspector
-				anchors {
-					right: parent.right
-				}
-				iconSource: "../bug.png"
-				onClicked: {
-					if(inspector.visible == true){
-						inspector.visible = false
-					}else{
-						inspector.visible = true
-						inspector.url = webview.experimental.remoteInspectorUrl
-					}
-				}
-			}
-		}
-
-        // Border
-        Rectangle {
-            id: divider
-            anchors {
-                left: parent.left
-                right: parent.right
-                top: navBar.bottom
-            }
-            z: -1
-            height: 1
-            color: "#CCCCCC"
-        }
-
-		WebView {
-			objectName: "webView"
-			id: webview
-			anchors {
-				left: parent.left
-				right: parent.right
-				bottom: parent.bottom
-				top: divider.bottom
-			}
-
-			function injectJs(js) {
-				webview.experimental.navigatorQtObjectEnabled = true;
-				webview.experimental.evaluateJavaScript(js)
-				webview.experimental.javascriptEnabled = true;
-			}
-
-			function sendMessage(data) {
-				webview.experimental.postMessage(JSON.stringify(data))
-			}
-
-
-			experimental.preferences.javascriptEnabled: true
-			experimental.preferences.webGLEnabled: true
-			experimental.itemSelector:  MouseArea {
-				// To avoid conflicting with ListView.model when inside Initiator context.
-				property QtObject selectorModel: model
-				anchors.fill: parent
-				onClicked: selectorModel.reject()
-
-				Menu {
-					visible: true
-					id: itemSelector
-
-					Instantiator {
-						model: selectorModel.items
-						delegate: MenuItem {
-							text: model.text
-							onTriggered: {
-								selectorModel.accept(index)
-							}
-						}
-						onObjectAdded: itemSelector.insertItem(index, object)
-						onObjectRemoved: itemSelector.removeItem(object)
-					}
-				}
-
-				Component.onCompleted: {
-					itemSelector.popup()
-				}
-			}
-			experimental.preferences.webAudioEnabled: true
-			experimental.preferences.navigatorQtObjectEnabled: true
-			experimental.preferences.developerExtrasEnabled: true
-			experimental.userScripts: ["../ext/q.js", "../ext/ethereum.js/lib/web3.js", "../ext/ethereum.js/lib/qt.js", "../ext/setup.js"]
-			experimental.onMessageReceived: {
-				console.log("[onMessageReceived]: ", message.data)
-				// TODO move to messaging.js
-				var data = JSON.parse(message.data)
-
-				try {
-					switch(data.call) {
-						case "eth_compile":
-						postData(data._id, eth.compile(data.args[0]))
-						break
-
-						case "eth_coinbase":
-						postData(data._id, eth.coinBase())
-
-						case "eth_account":
-						postData(data._id, eth.key().address);
-
-						case "eth_istening":
-						postData(data._id, eth.isListening())
-
-						break
-
-						case "eth_mining":
-						postData(data._id, eth.isMining())
-
-						break
-
-						case "eth_peerCount":
-						postData(data._id, eth.peerCount())
-
-						break
-
-						case "eth_countAt":
-						require(1)
-						postData(data._id, eth.txCountAt(data.args[0]))
-
-						break
-
-						case "eth_codeAt":
-						require(1)
-						var code = eth.codeAt(data.args[0])
-						postData(data._id, code);
-
-						break
-
-						case "eth_blockByNumber":
-						require(1)
-						var block = eth.blockByNumber(data.args[0])
-						postData(data._id, block)
-						break
-
-						case "eth_blockByHash":
-						require(1)
-						var block = eth.blockByHash(data.args[0])
-						postData(data._id, block)
-						break
-
-						require(2)
-						var block = eth.blockByHash(data.args[0])
-						postData(data._id, block.transactions[data.args[1]])
-						break
-
-						case "eth_transactionByHash":
-						case "eth_transactionByNumber":
-						require(2)
-
-						var block;
-						if (data.call === "transactionByHash")
-						block = eth.blockByHash(data.args[0])
-						else
-						block = eth.blockByNumber(data.args[0])
-
-						var tx = block.transactions.get(data.args[1])
-
-						postData(data._id, tx)
-						break
-
-						case "eth_uncleByHash":
-						case "eth_uncleByNumber":
-						require(2)
-
-						var block;
-						if (data.call === "uncleByHash")
-						block = eth.blockByHash(data.args[0])
-						else
-						block = eth.blockByNumber(data.args[0])
-
-						var uncle = block.uncles.get(data.args[1])
-
-						postData(data._id, uncle)
-
-						break
-
-						case "transact":
-						require(5)
-
-						var tx = eth.transact(data.args)
-						postData(data._id, tx)
-
-						break
-
-						case "eth_stateAt":
-						require(2);
-
-						var storage = eth.storageAt(data.args[0], data.args[1]);
-						postData(data._id, storage)
-
-						break
-
-						case "eth_call":
-						require(1);
-						var ret = eth.call(data.args)
-						postData(data._id, ret)
-						break
-
-						case "eth_balanceAt":
-						require(1);
-
-						postData(data._id, eth.balanceAt(data.args[0]));
-						break
-
-						case "eth_watch":
-						require(2)
-						eth.watch(data.args[0], data.args[1])
-
-						case "eth_disconnect":
-						require(1)
-						postData(data._id, null)
-						break;
-
-						case "eth_newFilterString":
-						require(1)
-						var id = eth.newFilterString(data.args[0])
-						postData(data._id, id);
-						break;
-
-						case "eth_newFilter":
-						require(1)
-						var id = eth.newFilter(data.args[0])
-
-						postData(data._id, id);
-						break;
-
-						case "eth_filterLogs":
-						require(1);
-
-						var messages = eth.messages(data.args[0]);
-						var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
-						postData(data._id, m);
-
-						break;
-
-						case "eth_deleteFilter":
-						require(1);
-						eth.uninstallFilter(data.args[0])
-						break;
-
-
-						case "shh_newFilter":
-						require(1);
-						var id = shh.watch(data.args[0], window);
-						postData(data._id, id);
-						break;
-
-						case "shh_newIdentity":
-						var id = shh.newIdentity()
-						postData(data._id, id)
-
-						break
-
-						case "shh_post":
-						require(1);
-
-						var params = data.args[0];
-						var fields = ["payload", "to", "from"];
-						for(var i = 0; i < fields.length; i++) {
-							params[fields[i]] = params[fields[i]] || "";
-						}
-						if(typeof params.payload !== "object") { params.payload = [params.payload]; } //params.payload = params.payload.join(""); }
-						params.topics = params.topics || [];
-						params.priority = params.priority || 1000;
-						params.ttl = params.ttl || 100;
-
-						shh.post(params.payload, params.to, params.from, params.topics, params.priority, params.ttl);
-
-						break;
-
-						case "shh_getMessages":
-						require(1);
-
-						var m = shh.messages(data.args[0]);
-						var messages = JSON.parse(JSON.parse(JSON.stringify(m)));
-						postData(data._id, messages);
-
-						break;
-
-						case "ssh_newGroup":
-						postData(data._id, "");
-						break;
-					}
-				} catch(e) {
-					console.log(data.call + ": " + e)
-
-					postData(data._id, null);
-				}
-			}
-
-
-			function post(seed, data) {
-				postData(data._id, data)
-			}
-
-			function require(args, num) {
-				if(args.length < num) {
-					throw("required argument count of "+num+" got "+args.length);
-				}
-			}
-			function postData(seed, data) {
-				webview.experimental.postMessage(JSON.stringify({data: data, _id: seed}))
-			}
-			function postEvent(event, id, data) {
-				webview.experimental.postMessage(JSON.stringify({data: data, _id: id, _event: event}))
-			}
-
-			function onWatchedCb(data, id) {
-				var messages = JSON.parse(data)
-				postEvent("watched:"+id, messages)
-			}
-
-			function onNewBlockCb(block) {
-				postEvent("block:new", block)
-			}
-			function onObjectChangeCb(stateObject) {
-				postEvent("object:"+stateObject.address(), stateObject)
-			}
-			function onStorageChangeCb(storageObject) {
-				var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
-				postEvent(ev, [storageObject.address, storageObject.value])
-			}
-		}
-
-
-		Rectangle {
-			id: sizeGrip
-			color: "gray"
-			visible: false
-			height: 10
-			anchors {
-				left: root.left
-				right: root.right
-			}
-			y: Math.round(root.height * 2 / 3)
-
-			MouseArea {
-				anchors.fill: parent
-				drag.target: sizeGrip
-				drag.minimumY: 0
-				drag.maximumY: root.height
-				drag.axis: Drag.YAxis
-			}
-		}
-
-		WebView {
-			id: inspector
-			visible: false
-			anchors {
-				left: root.left
-				right: root.right
-				top: sizeGrip.bottom
-				bottom: root.bottom
-			}
-		}
-
-		states: [
-			State {
-				name: "inspectorShown"
-				PropertyChanges {
-					target: inspector
-				}
-			}
-		]
-	}
-}
--- a/cmd/mist/assets/qml/depricated_browser.qml
+++ b/cmd/mist/assets/qml/depricated_browser.qml
@ -0,0 +1,486 @@
+import QtQuick 2.1
+import QtWebKit 3.0
+import QtWebKit.experimental 1.0
+import QtQuick.Controls 1.0;
+import QtQuick.Controls.Styles 1.0
+import QtQuick.Layouts 1.0;
+import QtQuick.Window 2.1;
+import Ethereum 1.0
+
+Rectangle {
+	id: window
+	anchors.fill: parent
+	color: "#00000000"
+
+	property var title: "DApps"
+	property var iconSource: "../browser.png"
+	property var menuItem
+    property var hideUrl: true
+
+	property alias url: webview.url
+    property alias windowTitle: webview.title
+	property alias webView: webview
+
+	property var cleanPath: false
+	property var open: function(url) {
+		if(!window.cleanPath) {
+			var uri = url;
+			if(!/.*\:\/\/.*/.test(uri)) {
+				uri = "http://" + uri;
+			}
+
+			var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/
+
+			if(reg.test(uri)) {
+				uri.replace(reg, function(match, pre, domain, path) {
+					uri = pre;
+
+					var lookup = eth.lookupDomain(domain.substring(0, domain.length - 4));
+					var ip = [];
+					for(var i = 0, l = lookup.length; i < l; i++) {
+						ip.push(lookup.charCodeAt(i))
+					}
+
+					if(ip.length != 0) {
+						uri += lookup;
+					} else {
+						uri += domain;
+					}
+
+					uri += path;
+				});
+			}
+
+			window.cleanPath = true;
+
+			webview.url = uri;
+
+			//uriNav.text = uri.text.replace(/(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.\w{2,3})(.*)/, "$1$2<span style='color:#CCC'>$3</span>");
+			uriNav.text = uri;
+		} else {
+			// Prevent inf loop.
+			window.cleanPath = false;
+		}
+	}
+
+	Component.onCompleted: {
+		webview.url = "http://etherian.io"
+	}
+
+    function messages(messages, id) {
+		// Bit of a cheat to get proper JSON
+		var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
+		webview.postEvent("eth_changed", id, m);
+	}
+
+	function onShhMessage(message, id) {
+		webview.postEvent("shh_changed", id, message)
+	}
+
+	Item {
+		objectName: "root"
+		id: root
+		anchors.fill: parent
+		state: "inspectorShown"
+
+		RowLayout {
+			id: navBar
+			height: 40
+			anchors {
+				left: parent.left
+				right: parent.right
+				leftMargin: 7
+			}
+
+			Button {
+				id: back
+				onClicked: {
+					webview.goBack()
+				}
+				style: ButtonStyle {
+					background: Image {
+						source: "../back.png"
+						width: 30
+						height: 30
+					}
+				}
+			}
+
+			TextField {
+				anchors {
+					left: back.right
+					right: toggleInspector.left
+					leftMargin: 10
+					rightMargin: 10
+				}
+				text: webview.url;
+				id: uriNav
+				y: parent.height / 2 - this.height / 2
+
+				Keys.onReturnPressed: {
+					webview.url = this.text;
+				}
+			}
+
+			Button {
+				id: toggleInspector
+				anchors {
+					right: parent.right
+				}
+				iconSource: "../bug.png"
+				onClicked: {
+					if(inspector.visible == true){
+						inspector.visible = false
+					}else{
+						inspector.visible = true
+						inspector.url = webview.experimental.remoteInspectorUrl
+					}
+				}
+			}
+		}
+
+		// Border
+		Rectangle {
+			id: divider
+			anchors {
+				left: parent.left
+				right: parent.right
+				top: navBar.bottom
+			}
+			z: -1
+			height: 1
+			color: "#CCCCCC"
+		}
+
+		ScrollView {
+			anchors {
+				left: parent.left
+				right: parent.right
+				bottom: parent.bottom
+				top: divider.bottom
+			}
+			WebView {
+				objectName: "webView"
+				id: webview
+				anchors.fill: parent
+
+				function sendMessage(data) {
+					webview.experimental.postMessage(JSON.stringify(data))
+				}
+
+				experimental.preferences.javascriptEnabled: true
+				experimental.preferences.webAudioEnabled: true
+				experimental.preferences.pluginsEnabled: true
+				experimental.preferences.navigatorQtObjectEnabled: true
+				experimental.preferences.developerExtrasEnabled: true
+				experimental.preferences.webGLEnabled: true
+				experimental.preferences.notificationsEnabled: true
+				experimental.preferences.localStorageEnabled: true
+				experimental.userAgent:"Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36  (KHTML, like Gecko) Mist/0.1 Safari/537.36"
+
+				experimental.itemSelector:  MouseArea {
+					// To avoid conflicting with ListView.model when inside Initiator context.
+					property QtObject selectorModel: model
+					anchors.fill: parent
+					onClicked: selectorModel.reject()
+
+					Menu {
+						visible: true
+						id: itemSelector
+
+						Instantiator {
+							model: selectorModel.items
+							delegate: MenuItem {
+								text: model.text
+								onTriggered: {
+									selectorModel.accept(index)
+								}
+							}
+							onObjectAdded: itemSelector.insertItem(index, object)
+							onObjectRemoved: itemSelector.removeItem(object)
+						}
+					}
+
+					Component.onCompleted: {
+						itemSelector.popup()
+					}
+				}
+				experimental.userScripts: ["../ext/q.js", "../ext/ethereum.js/lib/web3.js", "../ext/ethereum.js/lib/qt.js", "../ext/setup.js"]
+				experimental.onMessageReceived: {
+					//console.log("[onMessageReceived]: ", message.data)
+					var data = JSON.parse(message.data)
+
+					try {
+						switch(data.call) {
+							case "eth_compile":
+							postData(data._id, eth.compile(data.args[0]))
+							break
+
+							case "eth_coinbase":
+							postData(data._id, eth.coinBase())
+
+							case "eth_account":
+							postData(data._id, eth.key().address);
+
+							case "eth_istening":
+							postData(data._id, eth.isListening())
+
+							break
+
+							case "eth_mining":
+							postData(data._id, eth.isMining())
+
+							break
+
+							case "eth_peerCount":
+							postData(data._id, eth.peerCount())
+
+							break
+
+							case "eth_countAt":
+							require(1)
+							postData(data._id, eth.txCountAt(data.args[0]))
+
+							break
+
+							case "eth_codeAt":
+							require(1)
+							var code = eth.codeAt(data.args[0])
+							postData(data._id, code);
+
+							break
+
+							case "eth_blockByNumber":
+							require(1)
+							var block = eth.blockByNumber(data.args[0])
+							postData(data._id, block)
+							break
+
+							case "eth_blockByHash":
+							require(1)
+							var block = eth.blockByHash(data.args[0])
+							postData(data._id, block)
+							break
+
+							require(2)
+							var block = eth.blockByHash(data.args[0])
+							postData(data._id, block.transactions[data.args[1]])
+							break
+
+							case "eth_transactionByHash":
+							case "eth_transactionByNumber":
+							require(2)
+
+							var block;
+							if (data.call === "transactionByHash")
+							block = eth.blockByHash(data.args[0])
+							else
+							block = eth.blockByNumber(data.args[0])
+
+							var tx = block.transactions.get(data.args[1])
+
+							postData(data._id, tx)
+							break
+
+							case "eth_uncleByHash":
+							case "eth_uncleByNumber":
+							require(2)
+
+							var block;
+							if (data.call === "uncleByHash")
+							block = eth.blockByHash(data.args[0])
+							else
+							block = eth.blockByNumber(data.args[0])
+
+							var uncle = block.uncles.get(data.args[1])
+
+							postData(data._id, uncle)
+
+							break
+
+							case "transact":
+							require(5)
+
+							var tx = eth.transact(data.args)
+							postData(data._id, tx)
+
+							break
+
+							case "eth_stateAt":
+							require(2);
+
+							var storage = eth.storageAt(data.args[0], data.args[1]);
+							postData(data._id, storage)
+
+							break
+
+							case "eth_call":
+							require(1);
+							var ret = eth.call(data.args)
+							postData(data._id, ret)
+							break
+
+							case "eth_balanceAt":
+							require(1);
+
+							postData(data._id, eth.balanceAt(data.args[0]));
+							break
+
+							case "eth_watch":
+							require(2)
+							eth.watch(data.args[0], data.args[1])
+
+							case "eth_disconnect":
+							require(1)
+							postData(data._id, null)
+							break;
+
+							case "eth_newFilterString":
+							require(1)
+							var id = eth.newFilterString(data.args[0], window)
+							postData(data._id, id);
+							break;
+
+							case "eth_newFilter":
+							require(1)
+							var id = eth.newFilter(data.args[0], window)
+
+							postData(data._id, id);
+							break;
+
+							case "eth_filterLogs":
+							require(1);
+
+							var messages = eth.messages(data.args[0]);
+							var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
+							postData(data._id, m);
+
+							break;
+
+							case "eth_deleteFilter":
+							require(1);
+							eth.uninstallFilter(data.args[0])
+							break;
+
+
+							case "shh_newFilter":
+							require(1);
+							var id = shh.watch(data.args[0], window);
+							postData(data._id, id);
+							break;
+
+							case "shh_newIdentity":
+							var id = shh.newIdentity()
+							postData(data._id, id)
+
+							break
+
+							case "shh_post":
+							require(1);
+
+							var params = data.args[0];
+							var fields = ["payload", "to", "from"];
+							for(var i = 0; i < fields.length; i++) {
+								params[fields[i]] = params[fields[i]] || "";
+							}
+							if(typeof params.payload !== "object") { params.payload = [params.payload]; } //params.payload = params.payload.join(""); }
+							params.topics = params.topics || [];
+							params.priority = params.priority || 1000;
+							params.ttl = params.ttl || 100;
+
+							shh.post(params.payload, params.to, params.from, params.topics, params.priority, params.ttl);
+
+							break;
+
+							case "shh_getMessages":
+							require(1);
+
+							var m = shh.messages(data.args[0]);
+							var messages = JSON.parse(JSON.parse(JSON.stringify(m)));
+							postData(data._id, messages);
+
+							break;
+
+							case "ssh_newGroup":
+							postData(data._id, "");
+							break;
+						}
+					} catch(e) {
+						console.log(data.call + ": " + e)
+
+						postData(data._id, null);
+					}
+				}
+
+				function post(seed, data) {
+					postData(data._id, data)
+				}
+				function require(args, num) {
+					if(args.length < num) {
+						throw("required argument count of "+num+" got "+args.length);
+					}
+				}
+				function postData(seed, data) {
+					webview.experimental.postMessage(JSON.stringify({data: data, _id: seed}))
+				}
+				function postEvent(event, id, data) {
+					webview.experimental.postMessage(JSON.stringify({data: data, _id: id, _event: event}))
+				}
+				function onWatchedCb(data, id) {
+					var messages = JSON.parse(data)
+					postEvent("watched:"+id, messages)
+				}
+				function onNewBlockCb(block) {
+					postEvent("block:new", block)
+				}
+				function onObjectChangeCb(stateObject) {
+					postEvent("object:"+stateObject.address(), stateObject)
+				}
+				function onStorageChangeCb(storageObject) {
+					var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
+					postEvent(ev, [storageObject.address, storageObject.value])
+				}
+			}
+		}
+
+		Rectangle {
+			id: sizeGrip
+			color: "gray"
+			visible: false
+			height: 10
+			anchors {
+				left: root.left
+				right: root.right
+			}
+			y: Math.round(root.height * 2 / 3)
+
+			MouseArea {
+				anchors.fill: parent
+				drag.target: sizeGrip
+				drag.minimumY: 0
+				drag.maximumY: root.height
+				drag.axis: Drag.YAxis
+			}
+		}
+
+		WebView {
+			id: inspector
+			visible: false
+			anchors {
+				left: root.left
+				right: root.right
+				top: sizeGrip.bottom
+				bottom: root.bottom
+			}
+		}
+
+		states: [
+			State {
+				name: "inspectorShown"
+				PropertyChanges {
+					target: inspector
+				}
+			}
+		]
+	}
+}
--- a/cmd/mist/assets/qml/fonts/Simple-Line-Icons.ttf
+++ b/cmd/mist/assets/qml/fonts/Simple-Line-Icons.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-Black.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Black.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-BlackIt.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-BlackIt.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-Bold.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Bold.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-BoldIt.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-BoldIt.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLight.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLight.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLightIt.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLightIt.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-It.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-It.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-Light.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Light.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-LightIt.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-LightIt.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-Regular.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Regular.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-Semibold.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Semibold.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSansPro-SemiboldIt.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSansPro-SemiboldIt.ttf
--- a/cmd/mist/assets/qml/fonts/SourceSerifPro-Bold.ttf
+++ b/cmd/mist/assets/qml/fonts/SourceSerifPro-Bold.ttf
--- a/Show More
+++ b/Show More