Fixed EVM environment. Closes #215

* big(bytes) == 0 when len(bytes) > 0

.gitignore

@@ -9,4 +9,4 @@
 *un~
 .DS_Store
 */**/.DS_Store
-
+.ethtest

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ethereal/assets/samplecoin"]
+	path = ethereal/assets/samplecoin
+	url = git@github.com:obscuren/SampleCoin.git

.travis.yml

@@ -1,4 +1,25 @@
-before_install: sudo apt-get install libgmp3-dev
 language: go
 go:
-  - 1.2
+  - 1.3
+before_install:
+  - sudo add-apt-repository ppa:ubuntu-sdk-team/ppa -y
+  - sudo apt-get update -qq
+  - sudo apt-get install -yqq libgmp3-dev qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev libreadline6-dev
+install:
+  - go get code.google.com/p/go.tools/cmd/goimports
+  - go get github.com/golang/lint/golint
+  # - go get code.google.com/p/go.tools/cmd/vet
+  - go get code.google.com/p/go.tools/cmd/cover
+  - go get github.com/mattn/goveralls
+  - ./install_deps.sh
+before_script:
+  - gofmt -l -w .
+  - goimports -l -w .
+  - golint .
+  # - go vet ./...
+  # - go test -race ./...
+script:
+  - ./gocoverage.sh && goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN
+env:
+  - secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64="
+

Dockerfile

@@ -0,0 +1,41 @@
+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
+
+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
+
+## 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
+RUN apt-get update -y
+RUN apt-get install -y qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev
+
+## 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
+
+# Fetch and install go-ethereum
+RUN go get -v -d github.com/ethereum/go-ethereum/...
+WORKDIR $GOPATH/src/github.com/ethereum/go-ethereum
+RUN git checkout poc8
+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
+ENTRYPOINT ["ethereum", "-rpc=true", "-rpcport=8080"]
+EXPOSE 8080

LICENSE

@@ -1,21 +1,16 @@
-The MIT License (MIT)
+Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
 
-Copyright (c) 2013 Geff Obscura
+This library 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 2.1 of the License, or (at your option) any later version.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+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
+Lesser General Public License for more details.
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+You should have received a copy of the GNU Lesser 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

README.md

@@ -1,72 +1,93 @@
+[![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](https://travis-ci.org/ethereum/go-ethereum.png?branch=master)](https://travis-ci.org/ethereum/go-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
 
-Ethereum Go developer client (c) Jeffrey Wilcke
+Ethereum Go Client © 2014 Jeffrey Wilcke.
 
-Ethereum is currently in its testing phase. The current state is "Proof
-of Concept 2". For build instructions see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Edge).
+Current state: Proof of Concept 0.7
 
-Ethereum Go is split up in several sub packages Please refer to each
-individual package for more information.
-  1. [eth](https://github.com/ethereum/eth-go)
-  2. [ethchain](https://github.com/ethereum/ethchain-go)
-  3. [ethwire](https://github.com/ethereum/ethwire-go)
-  4. [ethdb](https://github.com/ethereum/ethdb-go)
-  5. [ethutil](https://github.com/ethereum/ethutil-go)
-
-The [eth](https://github.com/ethereum/eth-go) is the top-level package
-of the Ethereum protocol. It functions as the Ethereum bootstrapping and
-peer communication layer. The [ethchain](https://github.com/ethereum/ethchain-go)
-contains the Ethereum blockchain, block manager, transaction and
-transaction handlers. The [ethwire](https://github.com/ethereum/ethwire-go) contains
-the Ethereum [wire protocol](http://wiki.ethereum.org/index.php/Wire_Protocol) which can be used
-to hook in to the Ethereum network. [ethutil](https://github.com/ethereum/ethutil-go) contains
-utility functions which are not Ethereum specific. The utility package
-contains the [patricia trie](http://wiki.ethereum.org/index.php/Patricia_Tree),
-[RLP Encoding](http://wiki.ethereum.org/index.php/RLP) and hex encoding
-helpers. The [ethdb](https://github.com/ethereum/ethdb-go) package
-contains the LevelDB interface and memory DB interface.
-
-This executable is the front-end (currently nothing but a dev console) for
-the Ethereum Go implementation.
+Ethereum is currently in its testing phase. 
 
 Build
-=======
+=====
 
-For build instruction please see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Edge)
+To build Mist (GUI):
 
+`go get github.com/ethereum/go-ethereum/cmd/mist`
 
-Command line options
-====================
+To build the node (CLI):
+
+`go get github.com/ethereum/go-ethereum/cmd/ethereum`
+
+For further, detailed, build instruction please see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go))
+
+Automated (dev) builds
+======================
+
+* [[OS X](http://build.ethdev.com/builds/OSX%20Go%20develop%20branch/latest/app/)]
+* [Windows] Coming soon™
+* [Linux] Coming soon™
+
+Binaries
+========
+
+Go Ethereum comes with several binaries found in
+[cmd](https://github.com/ethereum/go-ethereum/tree/master/cmd):
+
+* `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`"`.
+* `evm` is a generic Ethereum Virtual Machine: `evm -code 60ff60ff -gas
+  10000 -price 0 -dump`. See `-h` for a detailed description.
+
+General command line options
+============================
 
 ```
--c       Launch the developer console
+== Shared between ethereum and Mist ==
+
+= Settings
+-id      Set the custom identifier of the client (shows up on other clients)
+-port    Port on which the server will accept incomming connections
+-upnp    Enable UPnP
+-maxpeer Desired amount of peers
+-rpc     Start JSON RPC
+-dir     Data directory used to store configs and databases
+
+= Utility 
+-h         This
+-import    Import a private key
+-genaddr   Generates a new address and private key (destructive action)
+-dump      Dump a specific state of a block to stdout given the -number or -hash
+-difftool  Supress all output and prints VM output to stdout
+-diff      vm=only vm output, all=all output including state storage
+
+Ethereum only
+ethereum [options] [filename]
+-js        Start the JavaScript REPL
+filename   Load the given file and interpret as JavaScript
 -m       Start mining blocks
--genaddr Generates a new address and private key (destructive action)
--p       Port on which the server will accept incomming connections (= 30303)
--upnp    Enable UPnP (= false)
--x       Desired amount of peers (= 5)
--h       This help
-```
 
-Developer console commands
-==========================
+== Mist only ==
 
+-asset_path    absolute path to GUI assets directory
 ```
-addp <host>:<port>     Connect to the given host
-tx <addr> <amount>     Send <amount> Wei to the specified <addr>
-```
-
-See the "help" command for *developer* options.
 
 Contribution
 ============
 
-If you'd like to contribute to Ethereum Go please fork, fix, commit and
+If you'd like to contribute to Ethereum please fork, fix, commit and
 send a pull request. Commits who do not comply with the coding standards
-are ignored. If you send pull requests make absolute sure that you
+are ignored (use gofmt!). If you send pull requests make absolute sure that you
 commit on the `develop` branch and that you do not merge to master.
 Commits that are directly based on master are simply ignored.
 

block_pool.go

@@ -0,0 +1,351 @@
+package eth
+
+import (
+	"bytes"
+	"container/list"
+	"fmt"
+	"math"
+	"math/big"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/wire"
+)
+
+var poollogger = logger.NewLogger("BPOOL")
+
+type block struct {
+	from      *Peer
+	peer      *Peer
+	block     *types.Block
+	reqAt     time.Time
+	requested int
+}
+
+type BlockPool struct {
+	mut sync.Mutex
+
+	eth *Ethereum
+
+	hashes [][]byte
+	pool   map[string]*block
+
+	td   *big.Int
+	quit chan bool
+
+	fetchingHashes    bool
+	downloadStartedAt time.Time
+
+	ChainLength, BlocksProcessed int
+
+	peer *Peer
+}
+
+func NewBlockPool(eth *Ethereum) *BlockPool {
+	return &BlockPool{
+		eth:  eth,
+		pool: make(map[string]*block),
+		td:   ethutil.Big0,
+		quit: make(chan bool),
+	}
+}
+
+func (self *BlockPool) Len() int {
+	return len(self.hashes)
+}
+
+func (self *BlockPool) Reset() {
+	self.pool = make(map[string]*block)
+	self.hashes = nil
+}
+
+func (self *BlockPool) HasLatestHash() bool {
+	self.mut.Lock()
+	defer self.mut.Unlock()
+
+	return self.pool[string(self.eth.ChainManager().CurrentBlock().Hash())] != nil
+}
+
+func (self *BlockPool) HasCommonHash(hash []byte) bool {
+	return self.eth.ChainManager().GetBlock(hash) != nil
+}
+
+func (self *BlockPool) Blocks() (blocks types.Blocks) {
+	for _, item := range self.pool {
+		if item.block != nil {
+			blocks = append(blocks, item.block)
+		}
+	}
+
+	return
+}
+
+func (self *BlockPool) FetchHashes(peer *Peer) bool {
+	highestTd := self.eth.HighestTDPeer()
+
+	if (self.peer == nil && peer.td.Cmp(highestTd) >= 0) || (self.peer != nil && peer.td.Cmp(self.peer.td) > 0) || self.peer == peer {
+		if self.peer != peer {
+			poollogger.Infof("Found better suitable peer (%v vs %v)\n", self.td, peer.td)
+
+			if self.peer != nil {
+				self.peer.doneFetchingHashes = true
+			}
+		}
+
+		self.peer = peer
+		self.td = peer.td
+
+		if !self.HasLatestHash() {
+			self.fetchHashes()
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func (self *BlockPool) fetchHashes() {
+	peer := self.peer
+
+	peer.doneFetchingHashes = false
+
+	const amount = 256
+	peerlogger.Debugf("Fetching hashes (%d) %x...\n", amount, peer.lastReceivedHash[0:4])
+	peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{peer.lastReceivedHash, uint32(amount)}))
+}
+
+func (self *BlockPool) AddHash(hash []byte, peer *Peer) {
+	self.mut.Lock()
+	defer self.mut.Unlock()
+
+	if self.pool[string(hash)] == nil {
+		self.pool[string(hash)] = &block{peer, nil, nil, time.Now(), 0}
+
+		self.hashes = append([][]byte{hash}, self.hashes...)
+	}
+}
+
+func (self *BlockPool) Add(b *types.Block, peer *Peer) {
+	self.addBlock(b, peer, false)
+}
+
+func (self *BlockPool) AddNew(b *types.Block, peer *Peer) {
+	self.addBlock(b, peer, true)
+}
+
+func (self *BlockPool) addBlock(b *types.Block, peer *Peer, newBlock bool) {
+	self.mut.Lock()
+	defer self.mut.Unlock()
+
+	hash := string(b.Hash())
+
+	if self.pool[hash] == nil && !self.eth.ChainManager().HasBlock(b.Hash()) {
+		poollogger.Infof("Got unrequested block (%x...)\n", hash[0:4])
+
+		self.hashes = append(self.hashes, b.Hash())
+		self.pool[hash] = &block{peer, peer, b, time.Now(), 0}
+
+		// The following is only performed on an unrequested new block
+		if newBlock {
+			fmt.Println("1.", !self.eth.ChainManager().HasBlock(b.PrevHash), ethutil.Bytes2Hex(b.Hash()[0:4]), ethutil.Bytes2Hex(b.PrevHash[0:4]))
+			fmt.Println("2.", self.pool[string(b.PrevHash)] == nil)
+			fmt.Println("3.", !self.fetchingHashes)
+			if !self.eth.ChainManager().HasBlock(b.PrevHash) /*&& self.pool[string(b.PrevHash)] == nil*/ && !self.fetchingHashes {
+				poollogger.Infof("Unknown chain, requesting (%x...)\n", b.PrevHash[0:4])
+				peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{b.Hash(), uint32(256)}))
+			}
+		}
+	} else if self.pool[hash] != nil {
+		self.pool[hash].block = b
+	}
+
+	self.BlocksProcessed++
+}
+
+func (self *BlockPool) Remove(hash []byte) {
+	self.mut.Lock()
+	defer self.mut.Unlock()
+
+	self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash)
+	delete(self.pool, string(hash))
+}
+
+func (self *BlockPool) DistributeHashes() {
+	self.mut.Lock()
+	defer self.mut.Unlock()
+
+	var (
+		peerLen = self.eth.peers.Len()
+		amount  = 256 * peerLen
+		dist    = make(map[*Peer][][]byte)
+	)
+
+	num := int(math.Min(float64(amount), float64(len(self.pool))))
+	for i, j := 0, 0; i < len(self.hashes) && j < num; i++ {
+		hash := self.hashes[i]
+		item := self.pool[string(hash)]
+
+		if item != nil && item.block == nil {
+			var peer *Peer
+			lastFetchFailed := time.Since(item.reqAt) > 5*time.Second
+
+			// Handle failed requests
+			if lastFetchFailed && item.requested > 5 && item.peer != nil {
+				if item.requested < 100 {
+					// Select peer the hash was retrieved off
+					peer = item.from
+				} else {
+					// Remove it
+					self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash)
+					delete(self.pool, string(hash))
+				}
+			} else if lastFetchFailed || item.peer == nil {
+				// Find a suitable, available peer
+				eachPeer(self.eth.peers, func(p *Peer, v *list.Element) {
+					if peer == nil && len(dist[p]) < amount/peerLen && p.statusKnown {
+						peer = p
+					}
+				})
+			}
+
+			if peer != nil {
+				item.reqAt = time.Now()
+				item.peer = peer
+				item.requested++
+
+				dist[peer] = append(dist[peer], hash)
+			}
+		}
+	}
+
+	for peer, hashes := range dist {
+		peer.FetchBlocks(hashes)
+	}
+
+	if len(dist) > 0 {
+		self.downloadStartedAt = time.Now()
+	}
+}
+
+func (self *BlockPool) Start() {
+	go self.downloadThread()
+	go self.chainThread()
+}
+
+func (self *BlockPool) Stop() {
+	close(self.quit)
+}
+
+func (self *BlockPool) downloadThread() {
+	serviceTimer := time.NewTicker(100 * time.Millisecond)
+out:
+	for {
+		select {
+		case <-self.quit:
+			break out
+		case <-serviceTimer.C:
+			// Check if we're catching up. If not distribute the hashes to
+			// the peers and download the blockchain
+			self.fetchingHashes = false
+			eachPeer(self.eth.peers, func(p *Peer, v *list.Element) {
+				if p.statusKnown && p.FetchingHashes() {
+					self.fetchingHashes = true
+				}
+			})
+
+			if len(self.hashes) > 0 {
+				self.DistributeHashes()
+			}
+
+			if self.ChainLength < len(self.hashes) {
+				self.ChainLength = len(self.hashes)
+			}
+
+			if self.peer != nil &&
+				!self.peer.doneFetchingHashes &&
+				time.Since(self.peer.lastHashAt) > 10*time.Second &&
+				time.Since(self.peer.lastHashRequestedAt) > 5*time.Second {
+				self.fetchHashes()
+			}
+
+			/*
+				if !self.fetchingHashes {
+					blocks := self.Blocks()
+					chain.BlockBy(chain.Number).Sort(blocks)
+
+					if len(blocks) > 0 {
+						if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes {
+						}
+					}
+				}
+			*/
+		}
+	}
+}
+
+func (self *BlockPool) chainThread() {
+	procTimer := time.NewTicker(500 * time.Millisecond)
+out:
+	for {
+		select {
+		case <-self.quit:
+			break out
+		case <-procTimer.C:
+			blocks := self.Blocks()
+			types.BlockBy(types.Number).Sort(blocks)
+
+			// Find common block
+			for i, block := range blocks {
+				if self.eth.ChainManager().HasBlock(block.PrevHash) {
+					blocks = blocks[i:]
+					break
+				}
+			}
+
+			if len(blocks) > 0 {
+				if self.eth.ChainManager().HasBlock(blocks[0].PrevHash) {
+					for i, block := range blocks[1:] {
+						// NOTE: The Ith element in this loop refers to the previous block in
+						// outer "blocks"
+						if bytes.Compare(block.PrevHash, blocks[i].Hash()) != 0 {
+							blocks = blocks[:i]
+
+							break
+						}
+					}
+				} else {
+					blocks = nil
+				}
+			}
+
+			if len(blocks) > 0 {
+				chainman := self.eth.ChainManager()
+
+				err := chainman.InsertChain(blocks)
+				if err != nil {
+					poollogger.Debugln(err)
+
+					self.Reset()
+
+					if self.peer != nil && self.peer.conn != nil {
+						poollogger.Debugf("Punishing peer for supplying bad chain (%v)\n", self.peer.conn.RemoteAddr())
+					}
+
+					// This peer gave us bad hashes and made us fetch a bad chain, therefor he shall be punished.
+					self.eth.BlacklistPeer(self.peer)
+					self.peer.StopWithReason(DiscBadPeer)
+					self.td = ethutil.Big0
+					self.peer = nil
+				}
+
+				for _, block := range blocks {
+					self.Remove(block.Hash())
+				}
+			}
+		}
+	}
+}

cmd/LICENSE

@@ -0,0 +1,16 @@
+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

cmd/ethereum/cmd.go

@@ -0,0 +1,52 @@
+// 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
+
+package main
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/cmd/ethereum/repl"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/javascript"
+)
+
+func InitJsConsole(ethereum *eth.Ethereum) {
+	repl := ethrepl.NewJSRepl(ethereum)
+	go repl.Start()
+	utils.RegisterInterrupt(func(os.Signal) {
+		repl.Stop()
+	})
+}
+
+func ExecJsFile(ethereum *eth.Ethereum, InputFile string) {
+	file, err := os.Open(InputFile)
+	if err != nil {
+		clilogger.Fatalln(err)
+	}
+	content, err := ioutil.ReadAll(file)
+	if err != nil {
+		clilogger.Fatalln(err)
+	}
+	re := javascript.NewJSRE(ethereum)
+	utils.RegisterInterrupt(func(os.Signal) {
+		re.Stop()
+	})
+	re.Run(string(content))
+}

cmd/ethereum/flags.go

@@ -0,0 +1,120 @@
+// 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
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/user"
+	"path"
+
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+var (
+	Identifier      string
+	KeyRing         string
+	DiffTool        bool
+	DiffType        string
+	KeyStore        string
+	StartRpc        bool
+	StartWebSockets bool
+	RpcPort         int
+	UseUPnP         bool
+	OutboundPort    string
+	ShowGenesis     bool
+	AddPeer         string
+	MaxPeer         int
+	GenAddr         bool
+	UseSeed         bool
+	SecretFile      string
+	ExportDir       string
+	NonInteractive  bool
+	Datadir         string
+	LogFile         string
+	ConfigFile      string
+	DebugFile       string
+	LogLevel        int
+	Dump            bool
+	DumpHash        string
+	DumpNumber      int
+	VmType          int
+)
+
+// flags specific to cli client
+var (
+	StartMining    bool
+	StartJsConsole bool
+	InputFile      string
+)
+
+func defaultDataDir() string {
+	usr, _ := user.Current()
+	return path.Join(usr.HomeDir, ".ethereum")
+}
+
+var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
+
+func Init() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	flag.IntVar(&VmType, "vm", 0, "Virtual Machine type: 0-1: standard, debug")
+	flag.StringVar(&Identifier, "id", "", "Custom client identifier")
+	flag.StringVar(&KeyRing, "keyring", "", "identifier for keyring to use")
+	flag.StringVar(&KeyStore, "keystore", "db", "system to store keyrings: db|file (db)")
+	flag.StringVar(&OutboundPort, "port", "30303", "listening port")
+	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
+	flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
+	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-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.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
+	flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
+	flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
+	flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
+	flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
+	flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
+	flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
+	flag.IntVar(&LogLevel, "loglevel", int(logger.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
+	flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0")
+	flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false")
+	flag.BoolVar(&ShowGenesis, "genesis", false, "Dump the genesis block")
+
+	flag.BoolVar(&Dump, "dump", false, "output the ethereum state in JSON format. Sub args [number, hash]")
+	flag.StringVar(&DumpHash, "hash", "", "specify arg in hex")
+	flag.IntVar(&DumpNumber, "number", -1, "specify arg in number")
+
+	flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
+	flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")
+
+	flag.Parse()
+
+	if VmType >= int(vm.MaxVmTy) {
+		log.Fatal("Invalid VM type ", VmType)
+	}
+
+	InputFile = flag.Arg(0)
+}

cmd/ethereum/main.go

@@ -0,0 +1,135 @@
+// 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
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+)
+
+const (
+	ClientIdentifier = "Ethereum(G)"
+	Version          = "0.7.10"
+)
+
+var clilogger = logger.NewLogger("CLI")
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	utils.HandleInterrupt()
+
+	// precedence: code-internal flag default < config file < environment variables < command line
+	Init() // parsing command line
+
+	// If the difftool option is selected ignore all other log output
+	if DiffTool || Dump {
+		LogLevel = 0
+	}
+
+	utils.InitConfig(VmType, ConfigFile, Datadir, "ETH")
+	ethutil.Config.Diff = DiffTool
+	ethutil.Config.DiffType = DiffType
+
+	utils.InitDataDir(Datadir)
+
+	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	db := utils.NewDatabase()
+	err := utils.DBSanityCheck(db)
+	if err != nil {
+		fmt.Println(err)
+
+		os.Exit(1)
+	}
+
+	keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
+
+	// create, import, export keys
+	utils.KeyTasks(keyManager, KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
+
+	clientIdentity := utils.NewClientIdentity(ClientIdentifier, Version, Identifier)
+
+	ethereum := utils.NewEthereum(db, clientIdentity, keyManager, UseUPnP, OutboundPort, MaxPeer)
+
+	if Dump {
+		var block *types.Block
+
+		if len(DumpHash) == 0 && DumpNumber == -1 {
+			block = ethereum.ChainManager().CurrentBlock()
+		} else if len(DumpHash) > 0 {
+			block = ethereum.ChainManager().GetBlock(ethutil.Hex2Bytes(DumpHash))
+		} else {
+			block = ethereum.ChainManager().GetBlockByNumber(uint64(DumpNumber))
+		}
+
+		if block == nil {
+			fmt.Fprintln(os.Stderr, "block not found")
+
+			// We want to output valid JSON
+			fmt.Println("{}")
+
+			os.Exit(1)
+		}
+
+		// block.GetRoot() does not exist
+		//fmt.Printf("RLP: %x\nstate: %x\nhash: %x\n", ethutil.Rlp(block), block.GetRoot(), block.Hash())
+
+		// Leave the Println. This needs clean output for piping
+		fmt.Printf("%s\n", block.State().Dump())
+
+		fmt.Println(block)
+
+		os.Exit(0)
+	}
+
+	if ShowGenesis {
+		utils.ShowGenesis(ethereum)
+	}
+
+	if StartMining {
+		utils.StartMining(ethereum)
+	}
+
+	// better reworked as cases
+	if StartJsConsole {
+		InitJsConsole(ethereum)
+	} else if len(InputFile) > 0 {
+		ExecJsFile(ethereum, InputFile)
+	}
+
+	if StartRpc {
+		utils.StartRpc(ethereum, RpcPort)
+	}
+
+	if StartWebSockets {
+		utils.StartWebSockets(ethereum)
+	}
+
+	utils.StartEthereum(ethereum, UseSeed)
+
+	// this blocks the thread
+	ethereum.WaitForShutdown()
+	logger.Flush()
+}

cmd/ethereum/repl/console_colors_windows.go

@@ -0,0 +1,97 @@
+// 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
+
+/* Inspired by https://github.com/xuyu/logging/blob/master/colorful_win.go */
+
+package ethrepl
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+type color uint16
+
+const (
+	green  = color(0x0002)
+	red    = color(0x0004)
+	yellow = color(0x000E)
+)
+
+const (
+	mask = uint16(yellow | green | red)
+)
+
+var (
+	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
+	procGetStdHandle               = kernel32.NewProc("GetStdHandle")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	hStdout                        uintptr
+	initScreenInfo                 *consoleScreenBufferInfo
+)
+
+func setConsoleTextAttribute(hConsoleOutput uintptr, wAttributes uint16) bool {
+	ret, _, _ := procSetConsoleTextAttribute.Call(hConsoleOutput, uintptr(wAttributes))
+	return ret != 0
+}
+
+type coord struct {
+	X, Y int16
+}
+
+type smallRect struct {
+	Left, Top, Right, Bottom int16
+}
+
+type consoleScreenBufferInfo struct {
+	DwSize              coord
+	DwCursorPosition    coord
+	WAttributes         uint16
+	SrWindow            smallRect
+	DwMaximumWindowSize coord
+}
+
+func getConsoleScreenBufferInfo(hConsoleOutput uintptr) *consoleScreenBufferInfo {
+	var csbi consoleScreenBufferInfo
+	ret, _, _ := procGetConsoleScreenBufferInfo.Call(hConsoleOutput, uintptr(unsafe.Pointer(&csbi)))
+	if ret == 0 {
+		return nil
+	}
+	return &csbi
+}
+
+const (
+	stdOutputHandle = uint32(-11 & 0xFFFFFFFF)
+)
+
+func init() {
+	hStdout, _, _ = procGetStdHandle.Call(uintptr(stdOutputHandle))
+	initScreenInfo = getConsoleScreenBufferInfo(hStdout)
+}
+
+func resetColorful() {
+	if initScreenInfo == nil {
+		return
+	}
+	setConsoleTextAttribute(hStdout, initScreenInfo.WAttributes)
+}
+
+func changeColor(c color) {
+	attr := uint16(0) & ^mask | uint16(c)
+	setConsoleTextAttribute(hStdout, attr)
+}

cmd/ethereum/repl/repl.go

@@ -0,0 +1,102 @@
+// 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
+
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/logger"
+)
+
+var repllogger = logger.NewLogger("REPL")
+
+type Repl interface {
+	Start()
+	Stop()
+}
+
+type JSRepl struct {
+	re *javascript.JSRE
+
+	prompt string
+
+	history *os.File
+
+	running bool
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+	hist, err := os.OpenFile(path.Join(ethutil.Config.ExecPath, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
+	if err != nil {
+		panic(err)
+	}
+
+	return &JSRepl{re: javascript.NewJSRE(ethereum), prompt: "> ", history: hist}
+}
+
+func (self *JSRepl) Start() {
+	if !self.running {
+		self.running = true
+		repllogger.Infoln("init JS Console")
+		reader := bufio.NewReader(self.history)
+		for {
+			line, err := reader.ReadString('\n')
+			if err != nil && err == io.EOF {
+				break
+			} else if err != nil {
+				fmt.Println("error reading history", err)
+				break
+			}
+
+			addHistory(line[:len(line)-1])
+		}
+		self.read()
+	}
+}
+
+func (self *JSRepl) Stop() {
+	if self.running {
+		self.running = false
+		self.re.Stop()
+		repllogger.Infoln("exit JS Console")
+		self.history.Close()
+	}
+}
+
+func (self *JSRepl) parseInput(code string) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("[native] error", r)
+		}
+	}()
+
+	value, err := self.re.Run(code)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	self.PrintValue(value)
+}

cmd/ethereum/repl/repl_darwin.go

@@ -0,0 +1,144 @@
+// 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
+
+package ethrepl
+
+// #cgo darwin CFLAGS: -I/usr/local/opt/readline/include
+// #cgo darwin LDFLAGS: -L/usr/local/opt/readline/lib
+// #cgo LDFLAGS: -lreadline
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <readline/readline.h>
+// #include <readline/history.h>
+import "C"
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+func initReadLine() {
+	C.rl_catch_sigwinch = 0
+	C.rl_catch_signals = 0
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGWINCH)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for sig := range c {
+			switch sig {
+			case syscall.SIGWINCH:
+				C.rl_resize_terminal()
+
+			case os.Interrupt:
+				C.rl_cleanup_after_signal()
+			default:
+
+			}
+		}
+	}()
+}
+
+func readLine(prompt *string) *string {
+	var p *C.char
+
+	//readline allows an empty prompt(NULL)
+	if prompt != nil {
+		p = C.CString(*prompt)
+	}
+
+	ret := C.readline(p)
+
+	if p != nil {
+		C.free(unsafe.Pointer(p))
+	}
+
+	if ret == nil {
+		return nil
+	} //EOF
+
+	s := C.GoString(ret)
+	C.free(unsafe.Pointer(ret))
+	return &s
+}
+
+func addHistory(s string) {
+	p := C.CString(s)
+	C.add_history(p)
+	C.free(unsafe.Pointer(p))
+}
+
+var indentCount = 0
+var str = ""
+
+func (self *JSRepl) setIndent() {
+	open := strings.Count(str, "{")
+	open += strings.Count(str, "(")
+	closed := strings.Count(str, "}")
+	closed += strings.Count(str, ")")
+	indentCount = open - closed
+	if indentCount <= 0 {
+		self.prompt = "> "
+	} else {
+		self.prompt = strings.Join(make([]string, indentCount*2), "..")
+		self.prompt += " "
+	}
+}
+
+func (self *JSRepl) read() {
+	initReadLine()
+L:
+	for {
+		switch result := readLine(&self.prompt); true {
+		case result == nil:
+			break L
+
+		case *result != "":
+			str += *result + "\n"
+
+			self.setIndent()
+
+			if indentCount <= 0 {
+				if *result == "exit" {
+					self.Stop()
+					break L
+				}
+
+				hist := str[:len(str)-1]
+				addHistory(hist) //allow user to recall this line
+				self.history.WriteString(str)
+
+				self.parseInput(str)
+
+				str = ""
+			}
+		}
+	}
+}
+
+func (self *JSRepl) PrintValue(v interface{}) {
+	method, _ := self.re.Vm.Get("prettyPrint")
+	v, err := self.re.Vm.ToValue(v)
+	if err == nil {
+		val, err := method.Call(method, v)
+		if err == nil {
+			fmt.Printf("%v", val)
+		}
+	}
+}

cmd/ethereum/repl/repl_linux.go

@@ -0,0 +1 @@
+repl_darwin.go

cmd/ethereum/repl/repl_windows.go

@@ -0,0 +1,92 @@
+// 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
+
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func (self *JSRepl) read() {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Printf(self.prompt)
+		str, _, err := reader.ReadLine()
+		if err != nil {
+			fmt.Println("Error reading input", err)
+		} else {
+			if string(str) == "exit" {
+				self.Stop()
+				break
+			} else {
+				self.parseInput(string(str))
+			}
+		}
+	}
+}
+
+func addHistory(s string) {
+}
+
+func printColored(outputVal string) {
+	for outputVal != "" {
+		codePart := ""
+		if strings.HasPrefix(outputVal, "\033[32m") {
+			codePart = "\033[32m"
+			changeColor(2)
+		}
+		if strings.HasPrefix(outputVal, "\033[1m\033[30m") {
+			codePart = "\033[1m\033[30m"
+			changeColor(8)
+		}
+		if strings.HasPrefix(outputVal, "\033[31m") {
+			codePart = "\033[31m"
+			changeColor(red)
+		}
+		if strings.HasPrefix(outputVal, "\033[35m") {
+			codePart = "\033[35m"
+			changeColor(5)
+		}
+		if strings.HasPrefix(outputVal, "\033[0m") {
+			codePart = "\033[0m"
+			resetColorful()
+		}
+		textPart := outputVal[len(codePart):len(outputVal)]
+		index := strings.Index(textPart, "\033")
+		if index == -1 {
+			outputVal = ""
+		} else {
+			outputVal = textPart[index:len(textPart)]
+			textPart = textPart[0:index]
+		}
+		fmt.Printf("%v", textPart)
+	}
+}
+
+func (self *JSRepl) PrintValue(v interface{}) {
+	method, _ := self.re.Vm.Get("prettyPrint")
+	v, err := self.re.Vm.ToValue(v)
+	if err == nil {
+		val, err := method.Call(method, v)
+		if err == nil {
+			printColored(fmt.Sprintf("%v", val))
+		}
+	}
+}

cmd/ethtest/main.go

@@ -0,0 +1,128 @@
+/*
+	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 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 General Public License
+	along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @authors:
+ * 	Jeffrey Wilcke <i@jev.io>
+ * @date 2014
+ *
+ */
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/tests/helper"
+)
+
+type Account struct {
+	Balance string
+	Code    string
+	Nonce   string
+	Storage map[string]string
+}
+
+func StateObjectFromAccount(addr string, account Account) *state.StateObject {
+	obj := state.NewStateObject(ethutil.Hex2Bytes(addr))
+	obj.SetBalance(ethutil.Big(account.Balance))
+
+	if ethutil.IsHex(account.Code) {
+		account.Code = account.Code[2:]
+	}
+	obj.Code = ethutil.Hex2Bytes(account.Code)
+	obj.Nonce = ethutil.Big(account.Nonce).Uint64()
+
+	return obj
+}
+
+type VmTest struct {
+	Callcreates interface{}
+	Env         map[string]string
+	Exec        map[string]string
+	Gas         string
+	Out         string
+	Post        map[string]Account
+	Pre         map[string]Account
+}
+
+func RunVmTest(js string) (failed int) {
+	tests := make(map[string]VmTest)
+
+	data, _ := ioutil.ReadAll(strings.NewReader(js))
+	err := json.Unmarshal(data, &tests)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	for name, test := range tests {
+		state := state.New(helper.NewTrie())
+		for addr, account := range test.Pre {
+			obj := StateObjectFromAccount(addr, account)
+			state.SetStateObject(obj)
+		}
+
+		ret, _, gas, err := helper.RunVm(state, test.Env, test.Exec)
+		// When an error is returned it doesn't always mean the tests fails.
+		// Have to come up with some conditional failing mechanism.
+		if err != nil {
+			log.Println(err)
+		}
+
+		rexp := helper.FromHex(test.Out)
+		if bytes.Compare(rexp, ret) != 0 {
+			log.Printf("%s's return failed. Expected %x, got %x\n", name, rexp, ret)
+			failed = 1
+		}
+
+		gexp := ethutil.Big(test.Gas)
+		if gexp.Cmp(gas) != 0 {
+			log.Printf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas)
+			failed = 1
+		}
+
+		for addr, account := range test.Post {
+			obj := state.GetStateObject(helper.FromHex(addr))
+			for addr, value := range account.Storage {
+				v := obj.GetState(helper.FromHex(addr)).Bytes()
+				vexp := helper.FromHex(value)
+
+				if bytes.Compare(v, vexp) != 0 {
+					log.Printf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v))
+					failed = 1
+				}
+			}
+		}
+	}
+
+	return
+}
+
+func main() {
+	helper.Logger.SetLogLevel(5)
+	if len(os.Args) == 1 {
+		log.Fatalln("no json supplied")
+	}
+
+	os.Exit(RunVmTest(os.Args[1]))
+}

cmd/evm/code.txt

@@ -0,0 +1 @@
+60006102ff5360003560001a60008114156103395760013560405260216040516020025990590160009052606052604051602002816060513760405160200281019050506002604051121561005957604051602002606051f35b604051602002599059016000905260a052600060c052604051602002599059016000905260e0526000610100526001610120525b604051610120511215610109576060515161012051602002606051015112156100d8576101205160200260605101516101005160200260e051015260016101005101610100526100f9565b61012051602002606051015160c05160200260a0510152600160c0510160c0525b600161012051016101205261008d565b60216020599059016000905260c051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260a0518260005b8381101561016657808301518186015260208101905061014b565b50505050825160200281019050604059905901600090526102405281610240515283602061024051015261024051905090509050905060c05160200280599059016000905281816020850151855160003060195a03f1508090509050905060a05260216020599059016000905261010051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260e0518260005b8381101561022557808301518186015260208101905061020a565b50505050825160200281019050604059905901600090526102c052816102c051528360206102c05101526102c05190509050905090506101005160200280599059016000905281816020850151855160003060195a03f1508090509050905060e05260405160200259905901600090526102e0526000610120525b610100516101205112156102d7576101205160200260e0510151610120516020026102e051015260016101205101610120526102a0565b60605151610100516020026102e05101526000610120525b60c05161012051121561032d576101205160200260a05101516101205160016101005101016020026102e051015260016101205101610120526102ef565b6040516020026102e051f35b50

cmd/evm/main.go

@@ -0,0 +1,162 @@
+/*
+	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 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 General Public License
+	along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @authors
+ * 	Jeffrey Wilcke <i@jev.io>
+ * @date 2014
+ *
+ */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"math/big"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/trie"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+var (
+	code     = flag.String("code", "", "evm code")
+	loglevel = flag.Int("log", 4, "log level")
+	gas      = flag.String("gas", "1000000000", "gas amount")
+	price    = flag.String("price", "0", "gas price")
+	value    = flag.String("value", "0", "tx value")
+	dump     = flag.Bool("dump", false, "dump state after run")
+	data     = flag.String("data", "", "data")
+)
+
+func perr(v ...interface{}) {
+	fmt.Println(v...)
+	//os.Exit(1)
+}
+
+func main() {
+	flag.Parse()
+
+	logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.LogLevel(*loglevel)))
+
+	ethutil.ReadConfig("/tmp/evmtest", "/tmp/evm", "")
+
+	db, _ := ethdb.NewMemDatabase()
+	statedb := state.New(trie.New(db, ""))
+	sender := statedb.NewStateObject([]byte("sender"))
+	receiver := statedb.NewStateObject([]byte("receiver"))
+	//receiver.SetCode([]byte(*code))
+	receiver.SetCode(ethutil.Hex2Bytes(*code))
+
+	vmenv := NewEnv(statedb, []byte("evmuser"), ethutil.Big(*value))
+
+	tstart := time.Now()
+
+	ret, e := vmenv.Call(sender, receiver.Address(), ethutil.Hex2Bytes(*data), ethutil.Big(*gas), ethutil.Big(*price), ethutil.Big(*value))
+
+	logger.Flush()
+	if e != nil {
+		perr(e)
+	}
+
+	if *dump {
+		fmt.Println(string(statedb.Dump()))
+	}
+
+	var mem runtime.MemStats
+	runtime.ReadMemStats(&mem)
+	fmt.Printf("vm took %v\n", time.Since(tstart))
+	fmt.Printf(`alloc:      %d
+tot alloc:  %d
+no. malloc: %d
+heap alloc: %d
+heap objs:  %d
+num gc:     %d
+`, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC)
+
+	fmt.Printf("%x\n", ret)
+}
+
+type VMEnv struct {
+	state *state.StateDB
+	block *types.Block
+
+	transactor []byte
+	value      *big.Int
+
+	depth int
+	Gas   *big.Int
+	time  int64
+}
+
+func NewEnv(state *state.StateDB, transactor []byte, value *big.Int) *VMEnv {
+	return &VMEnv{
+		state:      state,
+		transactor: transactor,
+		value:      value,
+		time:       time.Now().Unix(),
+	}
+}
+
+func (self *VMEnv) State() *state.StateDB { return self.state }
+func (self *VMEnv) Origin() []byte        { return self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int { return ethutil.Big0 }
+func (self *VMEnv) PrevHash() []byte      { return make([]byte, 32) }
+func (self *VMEnv) Coinbase() []byte      { return self.transactor }
+func (self *VMEnv) Time() int64           { return self.time }
+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) Depth() int            { return 0 }
+func (self *VMEnv) SetDepth(i int)        { self.depth = i }
+func (self *VMEnv) AddLog(log state.Log) {
+	self.state.AddLog(log)
+}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+	return vm.Transfer(from, to, amount)
+}
+
+func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution {
+	return core.NewExecution(self, addr, data, gas, price, value)
+}
+
+func (self *VMEnv) Call(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	exe := self.vm(addr, data, gas, price, value)
+	ret, err := exe.Call(addr, caller)
+	self.Gas = exe.Gas
+
+	return ret, err
+}
+func (self *VMEnv) CallCode(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	exe := self.vm(caller.Address(), data, gas, price, value)
+	return exe.Call(addr, caller)
+}
+
+func (self *VMEnv) Create(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef) {
+	exe := self.vm(addr, data, gas, price, value)
+	return exe.Create(caller)
+}

cmd/mist/assets/debugger/debugger.qml

@@ -0,0 +1,435 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+ApplicationWindow {
+    id: win
+    visible: false
+    title: "IceCREAM"
+    minimumWidth: 1280
+    minimumHeight: 700
+    width: 1290
+    height: 750
+
+    property alias codeText: codeEditor.text
+    property alias dataText: rawDataField.text
+
+    onClosing: {
+        dbg.Stop()
+    }
+
+    menuBar: MenuBar {
+        Menu {
+            title: "Edit"
+            MenuItem {
+                text: "Focus code"
+                shortcut: "Ctrl+1"
+                onTriggered: {
+                    codeEditor.focus = true
+                }
+            }
+            MenuItem {
+                text: "Focus data"
+                shortcut: "Ctrl+2"
+                onTriggered: {
+                    rawDataField.focus = true
+                }
+            }
+
+            MenuItem {
+                text: "Command"
+                shortcut: "Ctrl+l"
+                onTriggered: {
+                    dbgCommand.focus = true
+                }
+            }
+        }
+
+        Menu {
+            title: "Debugger"
+            MenuItem {
+                text: "Run"
+                shortcut: "Ctrl+r"
+                onTriggered: debugCurrent()
+            }
+
+            MenuItem {
+                text: "Stop"
+                onTriggered: dbp.stop()
+            }
+
+            MenuSeparator {}
+
+            MenuItem {
+                text: "Next"
+                shortcut: "Ctrl+n"
+                onTriggered: dbg.next()
+            }
+
+            MenuItem {
+                text: "Continue"
+                shortcut: "Ctrl+g"
+                onTriggered: dbg.continue()
+            }
+        }
+    }
+
+
+    SplitView {
+        anchors.fill: parent
+        property var asmModel: ListModel {
+            id: asmModel
+        }
+
+        TableView {
+            id: asmTableView
+            width: 200
+            headerVisible: false
+            TableViewColumn{ role: "value" ; title: "" ; width: asmTableView.width - 2 }
+            model: asmModel
+            /*
+             alternatingRowColors: false
+             itemDelegate: Item {
+                 Rectangle {
+                     anchors.fill: parent
+                     color: "#DDD"
+                     Text {
+                         anchors {
+                             left: parent.left
+                             right: parent.right
+                             leftMargin: 10
+                             verticalCenter: parent.verticalCenter
+                         }
+                         color: "#333"
+                         elide: styleData.elideMode
+                         text: styleData.value
+                         font.pixelSize: 11
+                         MouseArea {
+                             acceptedButtons: Qt.LeftButton
+                             anchors.fill: parent
+                             onClicked: {
+                                 mouse.accepted = true
+                             }
+                         }
+                     }
+                 }
+             }
+             */
+        }
+
+        Rectangle {
+            color: "#00000000"
+            anchors.left: asmTableView.right
+            anchors.right: parent.right
+            SplitView {
+                orientation: Qt.Vertical
+                anchors.fill: parent
+
+                Rectangle {
+                    color: "#00000000"
+                    height: 330
+                    anchors.left: parent.left
+                    anchors.right: parent.right
+
+                    TextArea {
+                        id: codeEditor
+                        anchors.top: parent.top
+                        anchors.bottom: parent.bottom
+                        anchors.left: parent.left
+                        anchors.right: settings.left
+                        focus: true
+
+                        /*
+                         Timer {
+                             id: compileTimer
+                             interval: 500 ; running: true ;  repeat: true
+                             onTriggered: {
+                                 dbg.autoComp(codeEditor.text)
+                             }
+                         }
+                         */
+                    }
+
+                    Column {
+                        id: settings
+                        spacing: 5
+                        width: 300
+                        height: parent.height
+                        anchors.right: parent.right
+                        anchors.top: parent.top
+                        anchors.bottom: parent.bottom
+
+                        Label {
+                            text: "Arbitrary data"
+                        }
+                        TextArea {
+                            id: rawDataField
+                            anchors.left: parent.left
+                            anchors.right: parent.right
+                            height: 150
+                        }
+
+                        Label {
+                            text: "Amount"
+                        }
+                        TextField {
+                            id: txValue
+                            width: 200
+                            placeholderText: "Amount"
+                            validator: RegExpValidator { regExp: /\d*/ }
+                        }
+                        Label {
+                            text: "Amount of gas"
+                        }
+                        TextField {
+                            id: txGas
+                            width: 200
+                            validator: RegExpValidator { regExp: /\d*/ }
+                            text: "10000"
+                            placeholderText: "Gas"
+                        }
+                        Label {
+                            text: "Gas price"
+                        }
+                        TextField {
+                            id: txGasPrice
+                            width: 200
+                            placeholderText: "Gas price"
+                            text: "1000000000000"
+                            validator: RegExpValidator { regExp: /\d*/ }
+                        }
+                    }
+                }
+
+                SplitView {
+                    orientation: Qt.Vertical
+                    id: inspectorPane
+                    height: 500
+
+                    SplitView {
+                        orientation: Qt.Horizontal
+                        height: 150
+
+                        TableView {
+                            id: stackTableView
+                            property var stackModel: ListModel {
+                                id: stackModel
+                            }
+                            height: parent.height
+                            width: 300
+                            TableViewColumn{ role: "value" ; title: "Local VM stack" ; width: stackTableView.width - 2 }
+                            model: stackModel
+                        }
+
+                        TableView {
+                            id: memoryTableView
+                            property var memModel: ListModel {
+                                id: memModel
+                            }
+                            height: parent.height
+                            width: parent.width - stackTableView.width
+                            TableViewColumn{ id:mnumColmn ; role: "num" ; title: "#" ; width: 50 }
+                            TableViewColumn{ role: "value" ; title: "Memory" ; width: 650 }
+                            model: memModel
+                        }
+                    }
+
+                    Rectangle {
+                        height: 100
+                        width: parent.width
+                        TableView {
+                            id: storageTableView
+                            property var memModel: ListModel {
+                                id: storageModel
+                            }
+                            height: parent.height
+                            width: parent.width
+                            TableViewColumn{ id: key ; role: "key" ; title: "#" ; width: storageTableView.width / 2 - 1}
+                            TableViewColumn{ role: "value" ; title: "Storage" ; width:  storageTableView.width / 2 - 1}
+                            model: storageModel
+                        }
+                    }
+
+                    Rectangle {
+                        height: 200
+                        width: parent.width * 0.66
+                        TableView {
+                            id: logTableView
+                            property var logModel: ListModel {
+                                id: logModel
+                            }
+                            height: parent.height
+                            width: parent.width
+                            TableViewColumn{ id: message ; role: "message" ; title: "log" ; width: logTableView.width - 2 }
+                            model: logModel
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    function exec() {
+        dbg.execCommand(dbgCommand.text);
+        dbgCommand.text = "";
+    }
+    statusBar: StatusBar {
+        height: 30
+
+
+        TextField {
+            id: dbgCommand
+            y: 1
+            x: asmTableView.width
+            width: 500
+            placeholderText: "Debugger (type 'help')"
+            Keys.onReturnPressed: {
+                exec()
+            }
+        }
+
+        RowLayout {
+            anchors.left: dbgCommand.right
+            anchors.leftMargin: 10
+            spacing: 5
+            y: parent.height / 2 - this.height / 2
+
+            Text {
+                objectName: "stackFrame"
+                font.pixelSize: 10
+                text: "<b>stack ptr</b>: 0"
+            }
+
+            Text {
+                objectName: "stackSize"
+                font.pixelSize: 10
+                text: "<b>stack size</b>: 0"
+            }
+
+            Text {
+                objectName: "memSize"
+                font.pixelSize: 10
+                text: "<b>mem size</b>: 0"
+            }
+        }
+    }
+
+    toolBar: ToolBar {
+        height: 30
+        RowLayout {
+            spacing: 10
+
+            Button {
+                property var enabled: true
+                id: debugStart
+                onClicked: {
+                    debugCurrent()
+                }
+                text: "Debug"
+            }
+
+            Button {
+                property var enabled: true
+                id: debugNextButton
+                onClicked: {
+                    dbg.next()
+                }
+                text: "Next"
+            }
+
+            Button {
+                id: debugContinueButton
+                onClicked: {
+                    dbg.continue()
+                }
+                text: "Continue"
+            }
+        }
+
+
+        ComboBox {
+            id: snippets
+            anchors.right: parent.right
+            model: ListModel {
+                ListElement { text: "Snippets" ; value: "" }
+                ListElement { text: "Call Contract" ; value: "var[2] in = { \"arg1\", 0xdeadbeef };\nvar ret;\n\nvar success = call(0x0c542ddea93dae0c2fcb2cf175f03ad80d6be9a0, 0, 7000, in, ret)\n\nreturn ret" }
+            }
+            onCurrentIndexChanged: {
+                if(currentIndex != 0) {
+                    var code = snippets.model.get(currentIndex).value;
+                    codeEditor.insert(codeEditor.cursorPosition, code)
+                }
+            }
+        }
+
+    }
+
+    function debugCurrent() {
+        dbg.debug(txValue.text, txGas.text, txGasPrice.text, codeEditor.text, rawDataField.text)
+    }
+
+    function setAsm(asm) {
+        asmModel.append({asm: asm})
+    }
+
+    function clearAsm() {
+        asmModel.clear()
+    }
+
+    function setInstruction(num) {
+        asmTableView.selection.clear()
+        asmTableView.selection.select(num)
+        asmTableView.positionViewAtRow(num, ListView.Center)
+    }
+
+    function setMem(mem) {
+        memModel.append({num: mem.num, value: mem.value})
+    }
+    function clearMem(){
+        memModel.clear()
+    }
+
+    function setStack(stack) {
+        stackModel.append({value: stack})
+    }
+    function addDebugMessage(message){
+        debuggerLog.append({value: message})
+    }
+
+    function clearStack() {
+        stackModel.clear()
+    }
+
+    function clearStorage() {
+        storageModel.clear()
+    }
+
+    function setStorage(storage) {
+        storageModel.append({key: storage.key, value: storage.value})
+    }
+
+    function setLog(msg) {
+        // Remove first item once we've reached max log items
+        if(logModel.count > 250) {
+            logModel.remove(0)
+        }
+
+        if(msg.len != 0) {
+            if(logTableView.flickableItem.atYEnd) {
+                logModel.append({message: msg})
+                logTableView.positionViewAtRow(logTableView.rowCount - 1, ListView.Contain)
+            } else {
+                logModel.append({message: msg})
+            }
+        }
+    }
+
+    function clearLog() {
+        logModel.clear()
+    }
+}

cmd/mist/assets/ext/big.js

@@ -0,0 +1,397 @@
+// 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;
+}
+

cmd/mist/assets/ext/eth.js/.gitignore

@@ -0,0 +1,14 @@
+# 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
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+ethereum/ethereum
+ethereal/ethereal
+

cmd/mist/assets/ext/eth.js/README.md

@@ -0,0 +1,18 @@
+# Ethereum JavaScript API
+
+This is the Ethereum compatible JavaScript API using `Promise`s
+which implements the [Generic JSON RPC](https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC) spec.
+
+For an example see `index.html`.
+
+**Please note this repo is in it's early stage.**
+
+If you'd like to run a WebSocket ethereum node check out
+[go-ethereum](https://github.com/ethereum/go-ethereum).
+
+To install ethereum and spawn a node:
+
+```
+go get github.com/ethereum/go-ethereum/ethereum
+ethereum -ws -loglevel=4
+```

cmd/mist/assets/ext/eth.js/httprpc.js

@@ -0,0 +1,70 @@
+(function () {
+    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
+        };
+    };
+
+    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.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(web3) !== "undefined" && web3.providers !== undefined) {
+        web3.providers.HttpRpcProvider = HttpRpcProvider;
+    }
+})();
+

cmd/mist/assets/ext/eth.js/index.html

@@ -0,0 +1,33 @@
+<!doctype>
+<html>
+
+<head>
+<script type="text/javascript" src="main.js"></script>
+<script type="text/javascript" src="websocket.js"></script>
+<script type="text/javascript" src="qt.js"></script>
+<script type="text/javascript" src="httprpc.js"></script>
+<script type="text/javascript">
+function registerName() {
+    var name = document.querySelector("#name").value;
+    name = web3.fromAscii(name);
+
+    var eth = web3.eth;
+    eth.transact({to: "NameReg", gas: "10000", gasPrice: eth.gasPrice, data: [web3.fromAscii("register"), name]}).then(function(tx) {
+        document.querySelector("#result").innerHTML = "Registered name. Please wait for the next block to come through.";
+    }, function(err) {
+        console.log(err); 
+    });
+}
+</script>
+</head>
+
+<body>
+
+<h1>std::name_reg</h1>
+<input type="text" id="name"></input>
+<input type="submit" onClick="registerName();"></input>
+<div id="result"></div>
+
+</body>
+
+</html>

cmd/mist/assets/ext/eth.js/main.js

@@ -0,0 +1,432 @@
+(function(window) {
+    function isPromise(o) {
+        return o instanceof Promise
+    }
+
+    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);
+    };
+
+    var ethMethods = function () {
+        var blockCall = function (args) {
+            return typeof args[0] === "string" ? "blockByHash" : "blockByNumber";
+        };
+
+        var transactionCall = function (args) {
+            return typeof args[0] === "string" ? 'transactionByHash' : 'transactionByNumber';   
+        };
+
+        var uncleCall = function (args) {
+            return typeof args[0] === "string" ? 'uncleByHash' : 'uncleByNumber';       
+        };
+
+        var methods = [
+        { name: 'balanceAt', call: 'balanceAt' },
+        { name: 'stateAt', call: 'stateAt' },
+        { name: 'countAt', call: 'countAt'},
+        { name: 'codeAt', call: 'codeAt' },
+        { name: 'transact', call: 'transact' },
+        { name: 'call', call: 'call' },
+        { name: 'block', call: blockCall },
+        { name: 'transaction', call: transactionCall },
+        { name: 'uncle', call: uncleCall },
+        { name: 'compile', call: 'compile' }
+        ];
+        return methods;
+    };
+
+    var ethProperties = function () {
+        return [
+        { name: 'coinbase', getter: 'coinbase', setter: 'setCoinbase' },
+        { name: 'listening', getter: 'listening', setter: 'setListening' },
+        { name: 'mining', getter: 'mining', setter: 'setMining' },
+        { name: 'gasPrice', getter: 'gasPrice' },
+        { name: 'account', getter: 'account' },
+        { name: 'accounts', getter: 'accounts' },
+        { name: 'peerCount', getter: 'peerCount' },
+        { name: 'defaultBlock', getter: 'defaultBlock', setter: 'setDefaultBlock' },
+        { name: 'number', getter: 'number'}
+        ];
+    };
+
+    var dbMethods = function () {
+        return [
+        { name: 'put', call: 'put' },
+        { name: 'get', call: 'get' },
+        { name: 'putString', call: 'putString' },
+        { name: 'getString', call: 'getString' }
+        ];
+    };
+
+    var shhMethods = function () {
+        return [
+        { name: 'post', call: 'post' },
+        { name: 'newIdentity', call: 'newIdentity' },
+        { name: 'haveIdentity', call: 'haveIdentity' },
+        { name: 'newGroup', call: 'newGroup' },
+        { name: 'addToGroup', call: 'addToGroup' }
+        ];
+    };
+
+    var ethWatchMethods = function () {
+        var newFilter = function (args) {
+            return typeof args[0] === 'string' ? 'newFilterString' : 'newFilter';
+        };
+
+        return [
+        { name: 'newFilter', call: newFilter },
+        { name: 'uninstallFilter', call: 'uninstallFilter' },
+        { name: 'getMessages', call: 'getMessages' }
+        ];
+    };
+
+    var shhWatchMethods = function () {
+        return [
+        { name: 'newFilter', call: 'shhNewFilter' },
+        { name: 'uninstallFilter', call: 'shhUninstallFilter' },
+        { name: 'getMessage', call: 'shhGetMessages' }
+        ];
+    };
+
+    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 (result) {
+                            //if (result || typeof result === "boolean") {
+                                resolve(result);
+                                return;
+                            //} 
+                            //reject(result);
+                        });
+                    });
+                }).catch(function( err) {
+                    console.error(err);
+                });
+            };
+        });
+    };
+
+    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(result) {
+                        resolve(result);
+                    });
+                });
+            };
+            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 (result) {
+                                resolve(result);
+                            });
+                        });
+                    }).catch(function (err) {
+                        console.error(err);
+                    });
+                }
+            }
+            Object.defineProperty(obj, property.name, proto);
+        });
+    };
+    
+    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;
+            }
+
+            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;
+        },
+
+        toDecimal: function (val) {
+            return parseInt(val, 16);         
+        },
+
+        fromAscii: function(str, pad) {
+            pad = pad === undefined ? 32 : pad;
+            var hex = this.toHex(str);
+            while(hex.length < pad*2)
+                hex += "00";
+            return hex
+        },
+
+        eth: {
+            prototype: Object(),
+            watch: function (params) {
+                return new Filter(params, ethWatch);
+            },
+        },
+
+        db: {
+            prototype: Object()
+        },
+
+        shh: {
+            prototype: Object(),
+            watch: function (params) {
+                return new Filter(params, 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);
+        },
+    };
+
+    var eth = web3.eth;
+    setupMethods(eth, ethMethods());
+    setupProperties(eth, ethProperties());
+    setupMethods(web3.db, dbMethods());
+    setupMethods(web3.shh, shhMethods());
+
+    var ethWatch = {
+        changed: 'changed'
+    };
+    setupMethods(ethWatch, ethWatchMethods());
+    var shhWatch = {
+        changed: 'shhChanged'
+    };
+    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();
+    };
+
+    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);
+        });
+    };
+
+    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.data)
+                delete web3._callbacks[data._id];
+            }
+        }
+    }
+
+    /*
+    // Install default provider
+    if(!web3.provider.installed()) {
+        var sock = new web3.WebSocket("ws://localhost:40404/eth");
+
+        web3.setProvider(sock);
+    }
+    */
+
+    window.web3 = web3;
+
+})(this);

cmd/mist/assets/ext/eth.js/qt.js

@@ -0,0 +1,27 @@
+(function() {
+    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));
+            });
+        }
+    };
+
+    QtProvider.prototype.send = function(payload) {
+        navigator.qt.postMessage(JSON.stringify(payload));
+    };
+
+    Object.defineProperty(QtProvider.prototype, "onmessage", {
+        set: function(handler) {
+            this.handlers.push(handler);
+        },
+    }); 
+
+    if(typeof(web3) !== "undefined" && web3.providers !== undefined) {
+        web3.providers.QtProvider = QtProvider;
+    }
+})();
+

cmd/mist/assets/ext/eth.js/websocket.js

@@ -0,0 +1,51 @@
+(function() {
+    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(web3) !== "undefined" && web3.providers !== undefined) {
+        web3.providers.WebSocketProvider = WebSocketProvider;
+    }
+})();

cmd/mist/assets/ext/ethereum.js

@@ -0,0 +1,312 @@
+// 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
+
+// Main Ethereum library
+window.eth = {
+	prototype: Object(),
+	_callbacks: {},
+	_onCallbacks: {},
+
+    test: function() {
+        var t = undefined;
+	postData({call: "test"})
+        navigator.qt.onmessage = function(d) {console.log("onmessage called"); t = d; }
+        for(;;) {
+            if(t !== undefined) {
+                return t
+            }
+        }
+    },
+
+	mutan: function(code, cb) {
+		postData({call: "mutan", args: [code]}, cb)
+	},
+
+	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
+	},
+
+
+	// Retrieve block
+	//
+	// Either supply a number or a string. Type is determent for the lookup method
+	// string - Retrieves the block by looking up the hash
+	// number - Retrieves the block by looking up the block number
+	getBlock: function(numberOrHash, cb) {
+		var func;
+		if(typeof numberOrHash == "string") {
+			func =  "getBlockByHash";
+		} else {
+			func =  "getBlockByNumber";
+		}
+		postData({call: func, args: [numberOrHash]}, cb);
+	},
+
+	// Create transaction
+	//
+	// Transact between two state objects
+	transact: function(params, cb) {
+		if(params === undefined) {
+			params = {};
+		}
+
+		if(params.endowment !== undefined)
+			params.value = params.endowment;
+		if(params.code !== undefined)
+			params.data = params.code;
+
+		// Make sure everything is string
+		var fields = ["to", "from", "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();
+		}
+
+		var data;
+		if(typeof params.data === "object") {
+			data = "";
+			for(var i = 0; i < params.data.length; i++) {
+				data += params.data[i]
+			}
+		} else {
+			data = params.data;
+		}
+
+		postData({call: "transact", args: [params.from, params.to, params.value, params.gas, params.gasPrice, "0x"+data]}, cb);
+	},
+
+	getMessages: function(filter, cb) {
+		postData({call: "messages", args: [filter]}, cb);
+	},
+
+	getStorageAt: function(address, storageAddress, cb) {
+		postData({call: "getStorage", args: [address, storageAddress]}, cb);
+	},
+
+	getEachStorageAt: function(address, cb){
+		postData({call: "getEachStorage", args: [address]}, cb);
+	},
+
+	getKey: function(cb) {
+		postData({call: "getKey"}, cb);
+	},
+
+	getTxCountAt: function(address, cb) {
+		postData({call: "getTxCountAt", args: [address]}, cb);
+	},
+	getIsMining: function(cb){
+		postData({call: "getIsMining"}, cb)
+	},
+	getIsListening: function(cb){
+		postData({call: "getIsListening"}, cb)
+	},
+	getCoinBase: function(cb){
+		postData({call: "getCoinBase"}, cb);
+	},
+	getPeerCount: function(cb){
+		postData({call: "getPeerCount"}, cb);
+	},
+	getBalanceAt: function(address, cb) {
+		postData({call: "getBalance", args: [address]}, cb);
+	},
+	getTransactionsFor: function(address, cb) {
+		postData({call: "getTransactionsFor", args: [address]}, cb);
+	},
+
+	getSecretToAddress: function(sec, cb) {
+		postData({call: "getSecretToAddress", args: [sec]}, cb);
+	},
+
+	/*
+	watch: function(address, storageAddrOrCb, cb) {
+		var ev;
+		if(cb === undefined) {
+			cb = storageAddrOrCb;
+			storageAddrOrCb = "";
+			ev = "object:"+address;
+		} else {
+			ev = "storage:"+address+":"+storageAddrOrCb;
+		}
+
+		eth.on(ev, cb)
+
+		postData({call: "watch", args: [address, storageAddrOrCb]});
+	},
+
+	disconnect: function(address, storageAddrOrCb, cb) {
+		var ev;
+		if(cb === undefined) {
+			cb = storageAddrOrCb;
+			storageAddrOrCb = "";
+			ev = "object:"+address;
+		} else {
+			ev = "storage:"+address+":"+storageAddrOrCb;
+		}
+
+		eth.off(ev, cb)
+
+		postData({call: "disconnect", args: [address, storageAddrOrCb]});
+	},
+	*/
+
+       watch: function(options) {
+	       var filter = new Filter(options);
+	       filter.number = newWatchNum().toString()
+
+	       postData({call: "watch", args: [options, filter.number]})
+
+	       return filter;
+       },
+
+	set: function(props) {
+		postData({call: "set", args: props});
+	},
+
+	on: function(event, cb) {
+		if(eth._onCallbacks[event] === undefined) {
+			eth._onCallbacks[event] = [];
+		}
+
+		eth._onCallbacks[event].push(cb);
+
+		return this
+	},
+
+	off: function(event, cb) {
+		if(eth._onCallbacks[event] !== undefined) {
+			var callbacks = eth._onCallbacks[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._onCallbacks[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);
+				}
+			}
+		}
+	},
+}
+
+
+var Filter = function(options) {
+	this.options = options;
+};
+Filter.prototype.changed = function(callback) {
+	// Register the watched:<number>. Qml will call the appropriate event if anything
+	// interesting happens in the land of Go.
+	eth.on("watched:"+this.number, callback)
+}
+Filter.prototype.getMessages = function(cb) {
+	return eth.getMessages(this.options, cb)
+}
+
+var watchNum = 0;
+function newWatchNum() {
+	return watchNum++;
+}
+
+function postData(data, cb) {
+	data._seed = Math.floor(Math.random() * 1000000)
+	if(cb) {
+		eth._callbacks[data._seed] = cb;
+	}
+
+	if(data.args === undefined) {
+		data.args = [];
+	}
+
+	navigator.qt.postMessage(JSON.stringify(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];
+			}
+		}
+	}
+}
+
+eth.on("chain:changed", function() {
+})
+
+eth.on("messages", { /* filters */}, function(messages){
+})
+
+eth.on("pending:changed", function() {
+})
+

cmd/mist/assets/ext/filter.js

@@ -0,0 +1,66 @@
+// 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 ethx = {
+    prototype: Object,
+
+    watch: function(options) {
+        return new Filter(options);
+    },
+
+    note: function() {
+        var args = Array.prototype.slice.call(arguments, 0);
+        var o = []
+        for(var i = 0; i < args.length; i++) {
+            o.push(args[i].toString())
+        }
+
+        eth.notef(o);
+    },
+};
+
+var Filter = function(options) {
+	this.callbacks = [];
+	this.options = options;
+
+	if(options === "chain") {
+		this.id = eth.newFilterString(options);
+	} else if(typeof options === "object") {
+		this.id = eth.newFilter(options);
+	}
+};
+
+Filter.prototype.changed = function(callback) {
+    this.callbacks.push(callback);
+
+	var self = this;
+	messages.connect(function(messages, id) {
+		if(id ==  self.id) {
+			for(var i = 0; i < self.callbacks.length; i++) {
+				self.callbacks[i].call(self, messages);
+			}
+		}
+	});
+};
+
+Filter.prototype.uninstall = function() {
+	eth.uninstallFilter(this.id)
+}
+
+Filter.prototype.messages = function() {
+	return eth.messages(this.id)
+}

cmd/mist/assets/ext/home.html

@@ -0,0 +1,22 @@
+<!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>
+

cmd/mist/assets/ext/html_messaging.js

@@ -0,0 +1,481 @@
+// 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);

cmd/mist/assets/ext/http.js

@@ -0,0 +1,30 @@
+// 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
+
+// this function is included locally, but you can also include separately via a header definition
+function request(url, callback) {
+	var xhr = new XMLHttpRequest();
+	xhr.onreadystatechange = (function(req) {
+		return function() {
+			if(req.readyState === 4) {
+				callback(req);
+			}
+		}
+	})(xhr);
+	xhr.open('GET', url, true);
+	xhr.send('');
+}

cmd/mist/assets/ext/qml_messaging.js

@@ -0,0 +1,30 @@
+// 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);
+		}
+	}
+}

cmd/mist/assets/ext/qt_messaging_adapter.js

@@ -0,0 +1,38 @@
+// 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];
+			}
+		}
+	}
+}

cmd/mist/assets/ext/setup.js

@@ -0,0 +1,8 @@
+(function() {
+    if (typeof(Promise) === "undefined")
+        window.Promise = Q.Promise;
+
+    var eth = web3.eth;
+
+    web3.setProvider(new web3.providers.QtProvider());
+})()

cmd/mist/assets/ext/string.js

@@ -0,0 +1,75 @@
+// 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()
+}

cmd/mist/assets/ext/test.html

@@ -0,0 +1,44 @@
+<!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>

cmd/mist/assets/muted/codemirror.css

@@ -0,0 +1,272 @@
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+}
+.CodeMirror-scroll {
+  /* Set scrolling behaviour here */
+  overflow: auto;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+  white-space: nowrap;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+/* CURSOR */
+
+.CodeMirror div.CodeMirror-cursor {
+  border-left: 1px solid black;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: #7e7;
+}
+/* Can style cursor different in overwrite (non-insert) mode */
+div.CodeMirror-overwrite div.CodeMirror-cursor {}
+
+.cm-tab { display: inline-block; }
+
+.CodeMirror-ruler {
+  border-left: 1px solid #ccc;
+  position: absolute;
+}
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable,
+.cm-s-default .cm-punctuation,
+.cm-s-default .cm-property,
+.cm-s-default .cm-operator {}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+
+.cm-s-default .cm-error {color: #f00;}
+.cm-invalidchar {color: #f00;}
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+.CodeMirror-activeline-background {background: #e8f2ff;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  line-height: 1;
+  position: relative;
+  overflow: hidden;
+  background: white;
+  color: black;
+}
+
+.CodeMirror-scroll {
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -30px; margin-right: -30px;
+  padding-bottom: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+.CodeMirror-sizer {
+  position: relative;
+  border-right: 30px solid transparent;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actuall scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+}
+.CodeMirror-gutter-filler {
+  left: 0; bottom: 0;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  padding-bottom: 30px;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  white-space: normal;
+  height: 100%;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  padding-bottom: 30px;
+  margin-bottom: -32px;
+  display: inline-block;
+  /* Hack to make IE7 behave */
+  *zoom:1;
+  *display:inline;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-widget {}
+
+.CodeMirror-wrap .CodeMirror-scroll {
+  overflow-x: hidden;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%;
+  height: 0;
+  overflow: hidden;
+  visibility: hidden;
+}
+.CodeMirror-measure pre { position: static; }
+
+.CodeMirror div.CodeMirror-cursor {
+  position: absolute;
+  border-right: none;
+  width: 0;
+}
+
+div.CodeMirror-cursors {
+  visibility: hidden;
+  position: relative;
+  z-index: 1;
+}
+.CodeMirror-focused div.CodeMirror-cursors {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+.CodeMirror-crosshair { cursor: crosshair; }
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, .4);
+}
+
+/* IE7 hack to prevent it from returning funny offsetTops on the spans */
+.CodeMirror span { *vertical-align: text-bottom; }
+
+/* Used to force a border model for a node */
+.cm-force-border { padding-right: .1px; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursors {
+    visibility: hidden;
+  }
+}

cmd/mist/assets/muted/debugger.html

@@ -0,0 +1,53 @@
+<!doctype>
+<html>
+<head>
+<style type="text/css">
+    html, body {
+        margin: 0; padding: 0;
+        min-height: 100%;
+    }
+
+    #debugger {
+	    height: 100%;
+	    font-family: "Monaco"
+    }
+    #debugger .line {
+	    overflow: none;
+    }
+    #debugger .col1, #debugger .col2 {
+	    float: left;
+	    padding: 3px;
+    }
+    #debugger .col1 {
+	    width: 10px;
+	    padding-left: 10px
+	    -webkit-touch-callout: none;
+	    -webkit-user-select: none;
+	    -khtml-user-select: none;
+	    -moz-user-select: none;
+	    -ms-user-select: none;
+	    user-select: none;
+    }
+    #debugger .col2 {
+	    width: 90%;
+    }
+    .prompt {
+	    color: "#5089D4";
+    }
+</style>
+
+</head>
+
+<body>
+<div id="debugger">
+	<div class="line">
+		<div class="col1 prompt">
+			&gt;
+		</div>
+		<div class="col2" contenteditable>
+		</div>
+	</div>
+</div>
+
+</body>
+</html>

cmd/mist/assets/muted/eclipse.css

@@ -0,0 +1,23 @@
+.cm-s-eclipse span.cm-meta {color: #FF1717;}
+.cm-s-eclipse span.cm-keyword { line-height: 1em; font-weight: bold; color: #7F0055; }
+.cm-s-eclipse span.cm-atom {color: #219;}
+.cm-s-eclipse span.cm-number {color: #164;}
+.cm-s-eclipse span.cm-def {color: #00f;}
+.cm-s-eclipse span.cm-variable {color: black;}
+.cm-s-eclipse span.cm-variable-2 {color: #0000C0;}
+.cm-s-eclipse span.cm-variable-3 {color: #0000C0;}
+.cm-s-eclipse span.cm-property {color: black;}
+.cm-s-eclipse span.cm-operator {color: black;}
+.cm-s-eclipse span.cm-comment {color: #3F7F5F;}
+.cm-s-eclipse span.cm-string {color: #2A00FF;}
+.cm-s-eclipse span.cm-string-2 {color: #f50;}
+.cm-s-eclipse span.cm-qualifier {color: #555;}
+.cm-s-eclipse span.cm-builtin {color: #30a;}
+.cm-s-eclipse span.cm-bracket {color: #cc7;}
+.cm-s-eclipse span.cm-tag {color: #170;}
+.cm-s-eclipse span.cm-attribute {color: #00c;}
+.cm-s-eclipse span.cm-link {color: #219;}
+.cm-s-eclipse span.cm-error {color: #f00;}
+
+.cm-s-eclipse .CodeMirror-activeline-background {background: #e8f2ff !important;}
+.cm-s-eclipse .CodeMirror-matchingbracket {outline:1px solid grey; color:black !important;}

cmd/mist/assets/muted/index.html

@@ -0,0 +1,80 @@
+<!doctype>
+<html>
+<head>
+<title>Mutan Editor</title>
+<link rel="stylesheet" href="codemirror.css">
+<link rel="stylesheet" href="eclipse.css">
+<script src="lib/codemirror.js"></script>
+<script src="lib/matchbrackets.js"></script>
+<script src="lib/go.js"></script>
+<script src="muted.js"></script>
+
+<style type="text/css">
+    html, body {
+        margin: 0; padding: 0;
+        min-height: 100%;
+    }
+
+    #debugger {
+	    height: 30%;
+	    font-family: "Monaco";
+        border-top: 5px solid grey;
+    }
+    #debugger .line {
+	    overflow: none;
+    }
+    #debugger .col1, #debugger .col2 {
+	    float: left;
+	    padding: 3px;
+    }
+    #debugger .col1 {
+	    width: 10px;
+	    padding-left: 10px
+	    -webkit-touch-callout: none;
+	    -webkit-user-select: none;
+	    -khtml-user-select: none;
+	    -moz-user-select: none;
+	    -ms-user-select: none;
+	    user-select: none;
+    }
+    #debugger .col2 {
+	    width: 90%;
+    }
+    .prompt {
+	    color: "#5089D4";
+    }
+
+    .CodeMirror {
+        height: 70%;
+	font-size: 14pt;
+    }
+</style>
+</head>
+
+<body>
+<textarea id="editor"></textarea>
+
+<div id="debugger">
+	<div class="line">
+		<div class="col1 prompt">
+			&gt;
+		</div>
+		<div class="col2" contenteditable>
+		</div>
+	</div>
+</div>
+
+<script>
+    var textArea = document.querySelector("#editor")
+    var editor = CodeMirror.fromTextArea(textArea, {
+        theme: "eclipse",
+        mode: "text/html",
+        lineNumbers: true,
+        mode: "text/x-go",
+        indentUnit: 8,
+        tabSize: 8,
+        indentWithTabs: true,
+    });
+</script>
+</body>
+</html>

cmd/mist/assets/muted/lib/go.js

@@ -0,0 +1,182 @@
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("go", function(config) {
+  var indentUnit = config.indentUnit;
+
+  var keywords = {
+    "break":true, "case":true, "chan":true, "const":true, "continue":true,
+    "default":true, "defer":true, "else":true, "fallthrough":true, "for":true,
+    "func":true, "go":true, "goto":true, "if":true, "import":true,
+    "interface":true, "map":true, "package":true, "range":true, "return":true,
+    "select":true, "struct":true, "switch":true, "type":true, "var":true,
+    "bool":true, "byte":true, "complex64":true, "complex128":true,
+    "float32":true, "float64":true, "int8":true, "int16":true, "int32":true,
+    "int64":true, "string":true, "uint8":true, "uint16":true, "uint32":true,
+    "uint64":true, "int":true, "uint":true, "uintptr":true, "big": true,
+    "main": true, "init": true, "this":true
+  };
+
+  var atoms = {
+    "true":true, "false":true, "iota":true, "nil":true, "append":true,
+    "cap":true, "close":true, "complex":true, "copy":true, "imag":true,
+    "len":true, "make":true, "new":true, "panic":true, "print":true,
+    "println":true, "real":true, "recover":true, 
+  };
+
+  var isOperatorChar = /[+\-*&^%:=<>!|\/]/;
+
+  var curPunc;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == '"' || ch == "'" || ch == "`") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\d\.]/.test(ch)) {
+      if (ch == ".") {
+        stream.match(/^[0-9]+([eE][\-+]?[0-9]+)?/);
+      } else if (ch == "0") {
+        stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);
+      } else {
+        stream.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/);
+      }
+      return "number";
+    }
+    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+      curPunc = ch;
+      return null;
+    }
+    if (ch == "/") {
+      if (stream.eat("*")) {
+        state.tokenize = tokenComment;
+        return tokenComment(stream, state);
+      }
+      if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var cur = stream.current();
+    if (keywords.propertyIsEnumerable(cur)) {
+      if (cur == "case" || cur == "default") curPunc = "case";
+      return "keyword";
+    }
+    if (atoms.propertyIsEnumerable(cur)) return "atom";
+    return "variable";
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {end = true; break;}
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !(escaped || quote == "`"))
+        state.tokenize = tokenBase;
+      return "string";
+    };
+  }
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = tokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return "comment";
+  }
+
+  function Context(indented, column, type, align, prev) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.align = align;
+    this.prev = prev;
+  }
+  function pushContext(state, col, type) {
+    return state.context = new Context(state.indented, col, type, null, state.context);
+  }
+  function popContext(state) {
+    var t = state.context.type;
+    if (t == ")" || t == "]" || t == "}")
+      state.indented = state.context.indented;
+    return state.context = state.context.prev;
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: null,
+        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
+        indented: 0,
+        startOfLine: true
+      };
+    },
+
+    token: function(stream, state) {
+      var ctx = state.context;
+      if (stream.sol()) {
+        if (ctx.align == null) ctx.align = false;
+        state.indented = stream.indentation();
+        state.startOfLine = true;
+        if (ctx.type == "case") ctx.type = "}";
+      }
+      if (stream.eatSpace()) return null;
+      curPunc = null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment") return style;
+      if (ctx.align == null) ctx.align = true;
+
+      if (curPunc == "{") pushContext(state, stream.column(), "}");
+      else if (curPunc == "[") pushContext(state, stream.column(), "]");
+      else if (curPunc == "(") pushContext(state, stream.column(), ")");
+      else if (curPunc == "case") ctx.type = "case";
+      else if (curPunc == "}" && ctx.type == "}") ctx = popContext(state);
+      else if (curPunc == ctx.type) popContext(state);
+      state.startOfLine = false;
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
+      var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
+      if (ctx.type == "case" && /^(?:case|default)\b/.test(textAfter)) {
+        state.context.type = "}";
+        return ctx.indented;
+      }
+      var closing = firstChar == ctx.type;
+      if (ctx.align) return ctx.column + (closing ? 0 : 1);
+      else return ctx.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: "{}):",
+    fold: "brace",
+    blockCommentStart: "/*",
+    blockCommentEnd: "*/",
+    lineComment: "//"
+  };
+});
+
+CodeMirror.defineMIME("text/x-go", "go");
+
+});

cmd/mist/assets/muted/lib/matchbrackets.js

@@ -0,0 +1,117 @@
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
+    (document.documentMode == null || document.documentMode < 8);
+
+  var Pos = CodeMirror.Pos;
+
+  var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
+
+  function findMatchingBracket(cm, where, strict, config) {
+    var line = cm.getLineHandle(where.line), pos = where.ch - 1;
+    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
+    if (!match) return null;
+    var dir = match.charAt(1) == ">" ? 1 : -1;
+    if (strict && (dir > 0) != (pos == where.ch)) return null;
+    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
+
+    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
+    if (found == null) return null;
+    return {from: Pos(where.line, pos), to: found && found.pos,
+            match: found && found.ch == match.charAt(0), forward: dir > 0};
+  }
+
+  // bracketRegex is used to specify which type of bracket to scan
+  // should be a regexp, e.g. /[[\]]/
+  //
+  // Note: If "where" is on an open bracket, then this bracket is ignored.
+  //
+  // Returns false when no bracket was found, null when it reached
+  // maxScanLines and gave up
+  function scanForBracket(cm, where, dir, style, config) {
+    var maxScanLen = (config && config.maxScanLineLength) || 10000;
+    var maxScanLines = (config && config.maxScanLines) || 1000;
+
+    var stack = [];
+    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
+    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
+                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
+    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
+      var line = cm.getLine(lineNo);
+      if (!line) continue;
+      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
+      if (line.length > maxScanLen) continue;
+      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
+      for (; pos != end; pos += dir) {
+        var ch = line.charAt(pos);
+        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
+          var match = matching[ch];
+          if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
+          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
+          else stack.pop();
+        }
+      }
+    }
+    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
+  }
+
+  function matchBrackets(cm, autoclear, config) {
+    // Disable brace matching in long lines, since it'll cause hugely slow updates
+    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
+    var marks = [], ranges = cm.listSelections();
+    for (var i = 0; i < ranges.length; i++) {
+      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
+      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
+        var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
+        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
+        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
+          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
+      }
+    }
+
+    if (marks.length) {
+      // Kludge to work around the IE bug from issue #1193, where text
+      // input stops going to the textare whever this fires.
+      if (ie_lt8 && cm.state.focused) cm.display.input.focus();
+
+      var clear = function() {
+        cm.operation(function() {
+          for (var i = 0; i < marks.length; i++) marks[i].clear();
+        });
+      };
+      if (autoclear) setTimeout(clear, 800);
+      else return clear;
+    }
+  }
+
+  var currentlyHighlighted = null;
+  function doMatchBrackets(cm) {
+    cm.operation(function() {
+      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
+      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
+    });
+  }
+
+  CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init)
+      cm.off("cursorActivity", doMatchBrackets);
+    if (val) {
+      cm.state.matchBrackets = typeof val == "object" ? val : {};
+      cm.on("cursorActivity", doMatchBrackets);
+    }
+  });
+
+  CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
+  CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
+    return findMatchingBracket(this, pos, strict, config);
+  });
+  CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
+    return scanForBracket(this, pos, dir, style, config);
+  });
+});

cmd/mist/assets/muted/muted.js

@@ -0,0 +1,78 @@
+// 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
+
+// Helper function for generating pseudo callbacks and sending data to the QML part of the application
+function postData(data, cb) {
+	data._seed = Math.floor(Math.random() * 1000000)
+	if(cb) {
+		Muted._callbacks[data._seed] = cb;
+	}
+
+	if(data.args === undefined) {
+		data.args = [];
+	}
+
+	navigator.qt.postMessage(JSON.stringify(data));
+}
+
+window.Muted = {
+	prototype: Object(),
+}
+
+window.Muted._callbacks = {}
+window.Muted._onCallbacks = {}
+
+function debug(/**/) {
+	console.log("hello world")
+
+	var args = arguments;
+	var msg = ""
+	for(var i = 0; i < args.length; i++){
+		if(typeof args[i] == "object") {
+			msg += " " + JSON.stringify(args[i])
+		} else {
+			msg += args[i]
+		}
+	}
+
+	document.querySelector("#debugger").innerHTML += "<div class='line'><div class='col1'></div><div class='col2'>"+msg+"</div></div>";
+}
+console.log = function() {
+	var args = []
+	for(var i = 0; i < arguments.length; i++) {
+		args.push(arguments[i]);
+	}
+	postData({call:"log", args:args})
+}
+
+navigator.qt.onmessage = function(ev) {
+	var data = JSON.parse(ev.data)
+
+	if(data._event !== undefined) {
+		Muted.trigger(data._event, data.data);
+	} else {
+		if(data._seed) {
+			var cb = Muted._callbacks[data._seed];
+			if(cb) {
+				// Call the callback
+				cb(data.data);
+				// Remove the "trigger" callback
+				delete Muted._callbacks[ev._seed];
+			}
+		}
+	}
+}

cmd/mist/assets/qml/QmlApp.qml

@@ -0,0 +1,22 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import Ethereum 1.0
+
+ApplicationWindow {
+	minimumWidth: 500
+	maximumWidth: 500
+	maximumHeight: 400
+	minimumHeight: 400
+
+	function onNewBlockCb(block) {
+		console.log("Please overwrite onNewBlock(block):", block)
+	}
+	function onObjectChangeCb(stateObject) {
+		console.log("Please overwrite onObjectChangeCb(object)", stateObject)
+	}
+	function onStorageChangeCb(storageObject) {
+		var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
+		console.log("Please overwrite onStorageChangeCb(object)", ev)
+	}
+}

cmd/mist/assets/qml/first_run.qml

@@ -0,0 +1,155 @@
+import QtQuick 2.0
+import Ethereum 1.0
+
+// Which ones do we actually need?
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import QtQuick.Dialogs 1.1
+
+ApplicationWindow {
+    id: wizardRoot
+    width: 500
+    height: 400
+    title: "Ethereal first run setup"
+
+    Column {
+        spacing: 5
+        anchors.leftMargin: 10
+        anchors.left: parent.left
+
+        Text {
+            visible: true
+            text: "<h2>Ethereal setup</h2>"
+        }
+
+        Column {
+            id: restoreColumn
+            spacing: 5
+            Text {
+                visible: true
+                font.pointSize: 14
+                text: "Restore your Ethereum account"
+                id: restoreLabel
+            }
+
+            TextField {
+                id: txPrivKey
+                width: 480
+                placeholderText: "Private key or mnemonic words"
+                focus: true
+                onTextChanged: {
+                    if(this.text.length == 64){
+                        detailLabel.text = "Private (hex) key detected."
+                        actionButton.enabled = true
+                    }
+                    else if(this.text.split(" ").length == 24){
+                        detailLabel.text = "Mnemonic key detected."
+                        actionButton.enabled = true
+                    }else{
+                        detailLabel.text = ""
+                        actionButton.enabled = false
+                    }
+                }
+            }
+            Row {
+                spacing: 10
+                Button {
+                    id: actionButton
+                    text: "Restore"
+                    enabled: false
+                    onClicked: {
+                        var success = lib.importAndSetPrivKey(txPrivKey.text)
+                        if(success){
+                            importedDetails.visible = true
+                            restoreColumn.visible = false
+                            newKey.visible = false
+                            wizardRoot.height = 120
+                        }
+                    }
+                }
+                Text {
+                    id: detailLabel
+                    font.pointSize: 12
+                    anchors.topMargin: 10
+                }
+            }
+        }
+        Column {
+            id: importedDetails
+            visible: false
+            Text {
+                text: "<b>Your account has been imported. Please close the application and restart it again to let the changes take effect.</b>"
+                wrapMode: Text.WordWrap
+                width: 460
+            }
+        }
+        Column {
+            spacing: 5
+            id: newDetailsColumn
+            visible: false
+            Text {
+                font.pointSize: 14
+                text: "Your account details"
+            }
+            Label {
+                text: "Address"
+            }
+            TextField {
+                id: addressInput
+                readOnly:true
+                width: 480
+            }
+            Label {
+                text: "Private key"
+            }
+            TextField {
+                id: privkeyInput
+                readOnly:true
+                width: 480
+            }
+            Label {
+                text: "Mnemonic words"
+            }
+            TextField {
+                id: mnemonicInput
+                readOnly:true
+                width: 480
+            }
+            Label {
+                text: "<b>A new account has been created. Please take the time to write down the <i>24 words</i>. You can use those to restore your account at a later date.</b>"
+                wrapMode: Text.WordWrap
+                width: 480
+            }
+            Label {
+                text: "Please restart the application once you have completed the steps above."
+                wrapMode: Text.WordWrap
+                width: 480
+            }
+        }
+
+    }
+    Button {
+        anchors.right: parent.right
+        anchors.bottom: parent.bottom
+        anchors.rightMargin: 10
+        anchors.bottomMargin: 10
+        id: newKey
+        text: "I don't have an account yet"
+        onClicked: {
+            var res = lib.createAndSetPrivKey()
+            mnemonicInput.text = res[0]
+            addressInput.text = res[1]
+            privkeyInput.text = res[2]
+
+            // Hide restore
+            restoreColumn.visible = false
+
+            // Show new details
+            newDetailsColumn.visible = true
+            newKey.visible = false
+        }
+    }
+}

cmd/mist/assets/qml/main.qml

@@ -0,0 +1,892 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+import "../ext/filter.js" as Eth
+import "../ext/http.js" as Http
+
+ApplicationWindow {
+	id: root
+
+	property var ethx : Eth.ethx
+	property var browser
+
+	width: 1200
+	height: 820
+	minimumHeight: 300
+
+	title: "Mist"
+
+	// This signal is used by the filter API. The filter API connects using this signal handler from
+	// the different QML files and plugins.
+	signal messages(var messages, int id);
+	function invokeFilterCallback(data, receiverSeed) {
+		//var messages = JSON.parse(data)
+		// Signal handler
+		messages(data, receiverSeed);
+		root.browser.view.messages(data, receiverSeed);
+	}
+
+	TextField {
+		id: copyElementHax
+		visible: false
+	}
+
+	function copyToClipboard(text) {
+		copyElementHax.text = text
+		copyElementHax.selectAll()
+		copyElementHax.copy()
+	}
+
+	// Takes care of loading all default plugins
+	Component.onCompleted: {
+		var wallet = addPlugin("./views/wallet.qml", {noAdd: true, close: false, section: "ethereum", active: true});
+		var browser = addPlugin("./webapp.qml", {noAdd: true, close: false, section: "ethereum", active: true});
+		root.browser = browser;
+		addPlugin("./views/miner.qml", {noAdd: true, close: false, section: "ethereum", active: true});
+
+		addPlugin("./views/transaction.qml", {noAdd: true, close: false, section: "legacy"});
+		addPlugin("./views/chain.qml", {noAdd: true, close: false, section: "legacy"});
+		addPlugin("./views/pending_tx.qml", {noAdd: true, close: false, section: "legacy"});
+		addPlugin("./views/info.qml", {noAdd: true, close: false, section: "legacy"});
+
+		addPlugin("./views/jeffcoin/jeffcoin.qml", {noAdd: true, close: false, section: "apps"})
+
+		mainSplit.setView(wallet.view, wallet.menuItem);
+
+		// Call the ready handler
+		gui.done();
+	}
+
+	function addViews(view, path, options) {
+		var views = mainSplit.addComponent(view, options)
+		views.menuItem.path = path
+
+		mainSplit.views.push(views);
+
+		if(!options.noAdd) {
+			gui.addPlugin(path)
+		}
+
+		return views
+	}
+
+	function addPlugin(path, options) {
+		try {
+			if(typeof(path) === "string" && /^https?/.test(path)) {
+				console.log('load http')
+				Http.request(path, function(o) {
+					if(o.status === 200) {
+						var view = Qt.createQmlObject(o.responseText, mainView, path)
+						addViews(view, path, options)
+					}
+				})
+
+				return
+			}
+
+			var component = Qt.createComponent(path);
+			if(component.status != Component.Ready) {
+				if(component.status == Component.Error) {
+					ethx.note("error: ", component.errorString());
+				}
+
+				return
+			}
+
+			var view = mainView.createView(component, options)
+			var views = addViews(view, path, options)
+
+			return views
+		} catch(e) {
+			ethx.note(e)
+		}
+	}
+
+	menuBar: MenuBar {
+		Menu {
+			title: "File"
+			MenuItem {
+				text: "Import App"
+				shortcut: "Ctrl+o"
+				onTriggered: {
+					generalFileDialog.show(true, importApp)
+				}
+			}
+
+			/*
+			 MenuItem {
+				 text: "Browser"
+				 onTriggered: eth.openBrowser()
+			 }
+			 */
+
+			MenuItem {
+				text: "Add plugin"
+				onTriggered: {
+					generalFileDialog.show(true, function(path) {
+						addPlugin(path, {close: true, section: "apps"})
+					})
+				}
+			}
+
+			MenuSeparator {}
+
+			MenuItem {
+				text: "Import key"
+				shortcut: "Ctrl+i"
+				onTriggered: {
+					generalFileDialog.show(true, function(path) {
+						gui.importKey(path)
+					})
+				}
+			}
+
+			MenuItem {
+				text: "Export keys"
+				shortcut: "Ctrl+e"
+				onTriggered: {
+					generalFileDialog.show(false, function(path) {
+					})
+				}
+			}
+
+		}
+
+		Menu {
+			title: "Developer"
+			MenuItem {
+				iconSource: "../icecream.png"
+				text: "Debugger"
+				shortcut: "Ctrl+d"
+				onTriggered: eth.startDebugger()
+			}
+
+			MenuItem {
+				text: "Import Tx"
+				onTriggered: {
+					txImportDialog.visible = true
+				}
+			}
+
+			MenuItem {
+				text: "Run JS file"
+				onTriggered: {
+					generalFileDialog.show(true, function(path) {
+						eth.evalJavascriptFile(path)
+					})
+				}
+			}
+
+			MenuItem {
+				text: "Dump state"
+				onTriggered: {
+					generalFileDialog.show(false, function(path) {
+						// Empty hash for latest
+						gui.dumpState("", path)
+					})
+				}
+			}
+
+			MenuSeparator {}
+
+			/*
+			 MenuItem {
+				 id: miningSpeed
+				 text: "Mining: Turbo"
+				 onTriggered: {
+					 gui.toggleTurboMining()
+					 if(text == "Mining: Turbo") {
+						 text = "Mining: Normal";
+					 } else {
+						 text = "Mining: Turbo";
+					 }
+				 }
+			 }
+			 */
+		}
+
+		Menu {
+			title: "Network"
+			MenuItem {
+				text: "Add Peer"
+				shortcut: "Ctrl+p"
+				onTriggered: {
+					addPeerWin.visible = true
+				}
+			}
+			MenuItem {
+				text: "Show Peers"
+				shortcut: "Ctrl+e"
+				onTriggered: {
+					peerWindow.visible = true
+				}
+			}
+		}
+
+		Menu {
+			title: "Help"
+			MenuItem {
+				text: "About"
+				onTriggered: {
+					aboutWin.visible = true
+				}
+			}
+		}
+
+		Menu {
+			title: "GLOBAL SHORTCUTS"
+			visible: false
+			MenuItem {
+				visible: false
+				shortcut: "Ctrl+l"
+				onTriggered: {
+					url.focus = true
+				}
+			}
+		}
+	}
+
+	statusBar: StatusBar {
+		//height: 32
+		id: statusBar
+		Label {
+			//y: 6
+			id: walletValueLabel
+
+			font.pixelSize: 10
+			styleColor: "#797979"
+		}
+
+		Label {
+			//y: 6
+			objectName: "miningLabel"
+			visible: true
+			font.pixelSize: 10
+			anchors.right: lastBlockLabel.left
+			anchors.rightMargin: 5
+		}
+
+		Label {
+			//y: 6
+			id: lastBlockLabel
+			objectName: "lastBlockLabel"
+			visible: true
+			text: ""
+			font.pixelSize: 10
+			anchors.right: peerGroup.left
+			anchors.rightMargin: 5
+		}
+
+		ProgressBar {
+			id: downloadIndicator
+			value: 0
+			objectName: "downloadIndicator"
+			y: -4
+			x: statusBar.width / 2 - this.width / 2
+			width: 160
+		}
+
+		Label {
+			objectName: "downloadLabel"
+			//y: 7
+			anchors.left: downloadIndicator.right
+			anchors.leftMargin: 5
+			font.pixelSize: 10
+			text: "0 / 0"
+		}
+
+
+		RowLayout {
+			id: peerGroup
+			//y: 7
+			anchors.right: parent.right
+			MouseArea {
+				onDoubleClicked:  peerWindow.visible = true
+				anchors.fill: parent
+			}
+
+			Label {
+				id: peerLabel
+				font.pixelSize: 10
+				text: "0 / 0"
+			}
+		}
+	}
+
+
+	property var blockModel: ListModel {
+		id: blockModel
+	}
+
+	SplitView {
+		property var views: [];
+
+		id: mainSplit
+		anchors.fill: parent
+		resizing: false
+
+		function setView(view, menu) {
+			for(var i = 0; i < views.length; i++) {
+				views[i].view.visible = false
+				views[i].menuItem.setSelection(false)
+			}
+			view.visible = true
+
+			//menu.border.color = "#CCCCCC"
+			//menu.color = "#FFFFFFFF"
+			menu.setSelection(true)
+		}
+
+		function addComponent(view, options) {
+			view.visible = false
+			view.anchors.fill = mainView
+
+			var menuItem = menu.createMenuItem(view, options);
+			if( view.hasOwnProperty("menuItem") ) {
+				view.menuItem = menuItem;
+			}
+
+			if( view.hasOwnProperty("onReady") ) {
+				view.onReady.call(view)
+			}
+
+			if( options.active ) {
+				setView(view, menuItem)
+			}
+
+
+			return {view: view, menuItem: menuItem}
+		}
+
+		/*********************
+		 * Main menu.
+		 ********************/
+		 Rectangle {
+			 id: menu
+			 Layout.minimumWidth: 210
+			 Layout.maximumWidth: 210
+			 anchors.top: parent.top
+			 color: "#ececec"
+
+			 Component {
+				 id: menuItemTemplate
+				 Rectangle {
+					 id: menuItem
+					 property var view;
+					 property var path;
+					 property var closable;
+
+					 property alias title: label.text
+					 property alias icon: icon.source
+					 property alias secondaryTitle: secondary.text
+					 function setSelection(on) {
+						 sel.visible = on
+					 }
+
+					 width: 206
+					 height: 28
+					 color: "#00000000"
+
+					 anchors {
+						 left: parent.left
+						 leftMargin: 4
+					 }
+
+					 Rectangle {
+						 id: sel
+						 visible: false
+						 anchors.fill: parent
+						 color: "#00000000"
+						 Rectangle {
+							 id: r
+							 anchors.fill: parent
+							 border.color: "#CCCCCC"
+							 border.width: 1
+							 radius: 5
+							 color: "#FFFFFFFF"
+						 }
+						 Rectangle {
+							 anchors {
+								 top: r.top
+								 bottom: r.bottom
+								 right: r.right
+							 }
+							 width: 10
+							 color: "#FFFFFFFF"
+
+							 Rectangle {
+								 anchors {
+									 left: parent.left
+									 right: parent.right
+									 top: parent.top
+								 }
+								 height: 1
+								 color: "#CCCCCC"
+							 }
+
+							 Rectangle {
+								 anchors {
+									 left: parent.left
+									 right: parent.right
+									 bottom: parent.bottom
+								 }
+								 height: 1
+								 color: "#CCCCCC"
+							 }
+						 }
+					 }
+
+					 MouseArea {
+						 anchors.fill: parent
+						 onClicked: {
+							 mainSplit.setView(view, menuItem)
+						 }
+					 }
+
+					 Image {
+						 id: icon
+						 height: 20
+						 width: 20
+						 anchors {
+							 left: parent.left
+							 verticalCenter: parent.verticalCenter
+							 leftMargin: 3
+						 }
+						 MouseArea {
+							 anchors.fill: parent
+							 onClicked: {
+								 menuItem.closeApp()
+							 }
+						 }
+					 }
+
+					 Text {
+						 id: label
+						 anchors {
+							 left: icon.right
+							 verticalCenter: parent.verticalCenter
+							 leftMargin: 3
+						 }
+
+						 color: "#0D0A01"
+						 font.pixelSize: 12
+					 }
+
+					 Text {
+						 id: secondary
+						 anchors {
+							 right: parent.right
+							 rightMargin: 8
+							 verticalCenter: parent.verticalCenter
+						 }
+						 color: "#AEADBE"
+						 font.pixelSize: 12
+					 }
+
+
+					 function closeApp() {
+						 if(!this.closable) { return; }
+
+						 if(this.view.hasOwnProperty("onDestroy")) {
+							 this.view.onDestroy.call(this.view)
+						 }
+
+						 this.view.destroy()
+						 this.destroy()
+						 gui.removePlugin(this.path)
+					 }
+				 }
+			 }
+
+			 function createMenuItem(view, options) {
+				 if(options === undefined) {
+					 options = {};
+				 }
+
+				 var section;
+				 switch(options.section) {
+					 case "ethereum":
+					 section = menuDefault;
+					 break;
+					 case "legacy":
+					 section = menuLegacy;
+					 break;
+					 default:
+					 section = menuApps;
+					 break;
+				 }
+
+				 var comp = menuItemTemplate.createObject(section)
+
+				 comp.view = view
+				 comp.title = view.title
+
+				 if(view.hasOwnProperty("iconSource")) {
+					 comp.icon = view.iconSource;
+				 }
+				 comp.closable = options.close;
+
+				 return comp
+			 }
+
+			 ColumnLayout {
+				 id: menuColumn
+				 y: 10
+				 width: parent.width
+				 anchors.left: parent.left
+				 anchors.right: parent.right
+				 spacing: 3
+
+				 Text {
+					 text: "ETHEREUM"
+					 font.bold: true
+					 anchors {
+						 left: parent.left
+						 leftMargin: 5
+					 }
+					 color: "#888888"
+				 }
+
+				 ColumnLayout {
+					 id: menuDefault
+					 spacing: 3
+					 anchors {
+						 left: parent.left
+						 right: parent.right
+					 }
+				 }
+
+
+				 Text {
+					 text: "APPS"
+					 font.bold: true
+					 anchors {
+						 left: parent.left
+						 leftMargin: 5
+					 }
+					 color: "#888888"
+				 }
+
+				 ColumnLayout {
+					 id: menuApps
+					 spacing: 3
+					 anchors {
+						 left: parent.left
+						 right: parent.right
+					 }
+				 }
+
+				 Text {
+					 text: "DEBUG"
+					 font.bold: true
+					 anchors {
+						 left: parent.left
+						 leftMargin: 5
+					 }
+					 color: "#888888"
+				 }
+
+				 ColumnLayout {
+					 id: menuLegacy
+					 spacing: 3
+					 anchors {
+						 left: parent.left
+						 right: parent.right
+					 }
+				 }
+			 }
+		 }
+
+		 /*********************
+		  * Main view
+		  ********************/
+		  Rectangle {
+			  anchors.right: parent.right
+			  anchors.left: menu.right
+			  anchors.bottom: parent.bottom
+			  anchors.top: parent.top
+			  color: "#00000000"
+
+			  Rectangle {
+				  id: urlPane
+				  height: 40
+				  color: "#00000000"
+				  anchors {
+					  left: parent.left
+					  right: parent.right
+					  leftMargin: 5
+					  rightMargin: 5
+					  top: parent.top
+					  topMargin: 5
+				  }
+				  TextField {
+					  id: url
+					  objectName: "url"
+					  placeholderText: "DApp URL"
+					  anchors {
+						  left: parent.left
+						  right: parent.right
+						  top: parent.top
+						  topMargin: 5
+						  rightMargin: 5
+						  leftMargin: 5
+					  }
+
+					  Keys.onReturnPressed: {
+						  if(/^https?/.test(this.text)) {
+							  root.browser.view.open(this.text);
+							  mainSplit.setView(root.browser.view, root.browser.menuItem);
+						  } else {
+							  addPlugin(this.text, {close: true, section: "apps"})
+						  }
+					  }
+				  }
+
+			  }
+
+			  // Border
+			  Rectangle {
+				  id: divider
+				  anchors {
+					  left: parent.left
+					  right: parent.right
+					  top: urlPane.bottom
+				  }
+				  z: -1
+				  height: 1
+				  color: "#CCCCCC"
+			  }
+
+			  Rectangle {
+				  id: mainView
+				  color: "#00000000"
+				  anchors.right: parent.right
+				  anchors.left: parent.left
+				  anchors.bottom: parent.bottom
+				  anchors.top: divider.bottom
+
+				  function createView(component) {
+					  var view = component.createObject(mainView)
+
+					  return view;
+				  }
+			  }
+		  }
+	  }
+
+
+	  /******************
+	   * Dialogs
+	   *****************/
+	   FileDialog {
+		   id: generalFileDialog
+		   property var callback;
+		   onAccepted: {
+			   var path = this.fileUrl.toString();
+			   callback.call(this, path);
+		   }
+
+		   function show(selectExisting, callback) {
+			   generalFileDialog.callback = callback;
+			   generalFileDialog.selectExisting = selectExisting;
+
+			   this.open();
+		   }
+	   }
+
+
+	   /******************
+	    * Wallet functions
+	    *****************/
+	    function importApp(path) {
+		    var ext = path.split('.').pop()
+		    if(ext == "html" || ext == "htm") {
+			    eth.openHtml(path)
+		    }else if(ext == "qml"){
+			    addPlugin(path, {close: true, section: "apps"})
+		    }
+	    }
+
+
+	    function setWalletValue(value) {
+		    walletValueLabel.text = value
+	    }
+
+	    function loadPlugin(name) {
+		    console.log("Loading plugin" + name)
+		    var view = mainView.addPlugin(name)
+	    }
+
+	    function setPeers(text) {
+		    peerLabel.text = text
+	    }
+
+	    function addPeer(peer) {
+		    // We could just append the whole peer object but it cries if you try to alter them
+		    peerModel.append({ip: peer.ip, port: peer.port, lastResponse:timeAgo(peer.lastSend), latency: peer.latency, version: peer.version, caps: peer.caps})
+	    }
+
+	    function resetPeers(){
+		    peerModel.clear()
+	    }
+
+	    function timeAgo(unixTs){
+		    var lapsed = (Date.now() - new Date(unixTs*1000)) / 1000
+		    return  (lapsed + " seconds ago")
+	    }
+
+	    function convertToPretty(unixTs){
+		    var a = new Date(unixTs*1000);
+		    var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+		    var year = a.getFullYear();
+		    var month = months[a.getMonth()];
+		    var date = a.getDate();
+		    var hour = a.getHours();
+		    var min = a.getMinutes();
+		    var sec = a.getSeconds();
+		    var time = date+' '+month+' '+year+' '+hour+':'+min+':'+sec ;
+		    return time;
+	    }
+
+	    /**********************
+	     * Windows
+	     *********************/
+	     Window {
+		     id: peerWindow
+		     //flags: Qt.CustomizeWindowHint | Qt.Tool | Qt.WindowCloseButtonHint
+		     height: 200
+		     width: 700
+		     Rectangle {
+			     anchors.fill: parent
+			     property var peerModel: ListModel {
+				     id: peerModel
+			     }
+			     TableView {
+				     anchors.fill: parent
+				     id: peerTable
+				     model: peerModel
+				     TableViewColumn{width: 100; role: "ip" ; title: "IP" }
+				     TableViewColumn{width: 60;  role: "port" ; title: "Port" }
+				     TableViewColumn{width: 140; role: "lastResponse"; title: "Last event" }
+				     TableViewColumn{width: 100; role: "latency"; title: "Latency" }
+				     TableViewColumn{width: 260; role: "version" ; title: "Version" }
+				     TableViewColumn{width: 80;  role: "caps" ; title: "Capabilities" }
+			     }
+		     }
+	     }
+
+	     Window {
+		     id: aboutWin
+		     visible: false
+		     title: "About"
+		     minimumWidth: 350
+		     maximumWidth: 350
+		     maximumHeight: 280
+		     minimumHeight: 280
+
+		     Image {
+			     id: aboutIcon
+			     height: 150
+			     width: 150
+			     fillMode: Image.PreserveAspectFit
+			     smooth: true
+			     source: "../facet.png"
+			     x: 10
+			     y: 30
+		     }
+
+		     Text {
+			     anchors.left: aboutIcon.right
+			     anchors.leftMargin: 10
+			     anchors.top: parent.top
+			     anchors.topMargin: 30
+			     font.pointSize: 12
+			     text: "<h2>Mist (0.7.10)</h2><br><h3>Development</h3>Jeffrey Wilcke<br>Viktor Trón<br>Felix Lange<br>Taylor Gerring<br>Daniel Nagy<br><h3>UX</h3>Alex van de Sande<br>"
+		     }
+	     }
+
+	     Window {
+		     id: txImportDialog
+		     minimumWidth: 270
+		     maximumWidth: 270
+		     maximumHeight: 50
+		     minimumHeight: 50
+		     TextField {
+			     id: txImportField
+			     width: 170
+			     anchors.verticalCenter: parent.verticalCenter
+			     anchors.left: parent.left
+			     anchors.leftMargin: 10
+			     onAccepted: {
+			     }
+		     }
+		     Button {
+			     anchors.left: txImportField.right
+			     anchors.verticalCenter: parent.verticalCenter
+			     anchors.leftMargin: 5
+			     text: "Import"
+			     onClicked: {
+				     eth.importTx(txImportField.text)
+				     txImportField.visible = false
+			     }
+		     }
+		     Component.onCompleted: {
+			     addrField.focus = true
+		     }
+	     }
+
+	     Window {
+		     id: addPeerWin
+		     visible: false
+		     minimumWidth: 300
+		     maximumWidth: 300
+		     maximumHeight: 50
+		     minimumHeight: 50
+		     title: "Connect to peer"
+
+		     ComboBox {
+			     id: addrField
+			     anchors.verticalCenter: parent.verticalCenter
+			     anchors.left: parent.left
+			     anchors.right: addPeerButton.left
+			     anchors.leftMargin: 10
+			     anchors.rightMargin: 10
+			     onAccepted: {
+				     eth.connectToPeer(addrField.currentText)
+				     addPeerWin.visible = false
+			     }
+
+			     editable: true
+			     model: ListModel { id: pastPeers }
+
+			     Component.onCompleted: {
+				     var ips = eth.pastPeers()
+				     for(var i = 0; i < ips.length; i++) {
+					     pastPeers.append({text: ips.get(i)})
+				     }
+
+				     pastPeers.insert(0, {text: "poc-7.ethdev.com:30303"})
+			     }
+		     }
+
+		     Button {
+			     id: addPeerButton
+			     anchors.right: parent.right
+			     anchors.verticalCenter: parent.verticalCenter
+			     anchors.rightMargin: 10
+			     text: "Add"
+			     onClicked: {
+				     eth.connectToPeer(addrField.currentText)
+				     addPeerWin.visible = false
+			     }
+		     }
+		     Component.onCompleted: {
+			     addrField.focus = true
+		     }
+	     }
+     }

cmd/mist/assets/qml/muted.qml

@@ -0,0 +1,74 @@
+import QtQuick 2.0
+import QtWebKit 3.0
+import QtWebKit.experimental 1.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Window 2.1;
+import Ethereum 1.0
+
+ApplicationWindow {
+    id: window
+    title: "muted"
+    width: 900
+    height: 600
+    minimumHeight: 300
+
+    property alias url: webView.url
+    property alias webView: webView
+
+
+    Item {
+        id: root
+        anchors.fill: parent
+        WebView {
+            objectName: "webView"
+            id: webView
+            anchors {
+                top: root.top
+                right: root.right
+                left: root.left
+                bottom: root.bottom
+                //bottom: sizeGrip.top
+            }
+
+            experimental.preferences.javascriptEnabled: true
+            experimental.preferences.navigatorQtObjectEnabled: true
+            experimental.onMessageReceived: {
+                var data = JSON.parse(message.data)
+
+                switch(data.call) {
+                case "log":
+                    console.log.apply(this, data.args)
+                    break;
+                }
+            }
+            function postData(seed, data) {
+                webview.experimental.postMessage(JSON.stringify({data: data, _seed: seed}))
+            }
+            function postEvent(event, data) {
+                webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
+            }
+        }
+
+        /*
+        Rectangle {
+            id: sizeGrip
+            color: "gray"
+            height: 5
+            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 - sizeGrip.height
+                drag.axis: Drag.YAxis
+            }
+        }
+        */
+    }
+}

cmd/mist/assets/qml/test_app.qml

@@ -0,0 +1,70 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import Ethereum 1.0
+
+QmlApp {
+	minimumWidth: 350
+	maximumWidth: 350
+	maximumHeight: 80
+	minimumHeight: 80
+
+	title: "Generic Coin"
+
+	property string contractAddr: "f299f6c74515620e4c4cd8fe3d205b5c4f2e25c8"
+	property string addr: "2ef47100e0787b915105fd5e3f4ff6752079d5cb"
+
+	Component.onCompleted: {
+		eth.watch(contractAddr, addr)
+		eth.watch(addr, contractAddr)
+		setAmount()
+	}
+
+	function onStorageChangeCb(storageObject) {
+		setAmount()
+	}
+
+	function setAmount(){
+		var state = eth.getStateObject(contractAddr)
+		var storage = state.getStorage(addr)
+		amountLabel.text = storage
+	}
+	Column {
+		spacing: 5
+		Row {
+			spacing: 20
+			Label {
+				id: genLabel
+				text: "Generic coin balance:"
+			}
+			Label {
+				id: amountLabel
+			}
+		}
+		Row {
+			spacing: 20
+			TextField {
+				id: address
+				placeholderText: "Address"
+			}
+			TextField {
+				id: amount
+				placeholderText: "Amount"
+			}
+		}
+		Button {
+			text: "Send coins"
+			onClicked: {
+				var privKey = eth.getKey().privateKey
+				if(privKey){
+					var result = eth.transact(privKey, contractAddr, 0,"100000","250", "0x" + address.text + "\n" + amount.text)
+					resultTx.text = result.hash
+				}
+			}
+		}
+		Label {
+			id: resultTx
+		}
+	}
+
+}

cmd/mist/assets/qml/transactions.qml

@@ -0,0 +1,9 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+
+Rectangle {
+	id: transactionView
+	visible: false
+	Text { text: "TX VIEW" }
+}

cmd/mist/assets/qml/views/chain.qml

@@ -0,0 +1,261 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	id: root
+	property var title: "Block Chain"
+	property var menuItem
+
+	objectName: "chainView"
+	visible: false
+	anchors.fill: parent
+
+	TableView {
+		id: blockTable
+		width: parent.width
+		anchors.top: parent.top
+		anchors.bottom: parent.bottom
+		TableViewColumn{ role: "number" ; title: "#" ; width: 100 }
+		TableViewColumn{ role: "hash" ; title: "Hash" ; width: 560 }
+		TableViewColumn{ role: "txAmount" ; title: "Tx amount" ; width: 100 }
+
+		model: blockModel
+
+		itemDelegate: Item {
+			Text {
+				anchors {
+					left: parent.left
+					right: parent.right
+					leftMargin: 10
+					verticalCenter: parent.verticalCenter
+				}
+				color: styleData.textColor
+				elide: styleData.elideMode
+				text: styleData.value
+				font.pixelSize: 11
+				MouseArea {
+					acceptedButtons: Qt.LeftButton | Qt.RightButton
+					propagateComposedEvents: true
+					anchors.fill: parent
+					onClicked: {
+						blockTable.selection.clear()
+						blockTable.selection.select(styleData.row)
+
+						if(mouse.button == Qt.RightButton) {
+							contextMenu.row = styleData.row;
+							contextMenu.popup()
+						}
+					}
+
+					onDoubleClicked: {
+						popup.visible = true
+						popup.setDetails(blockModel.get(styleData.row))
+					}
+				}
+			}
+
+		}
+
+		Menu {
+			id: contextMenu
+			property var row
+			MenuItem {
+				text: "Details"
+				onTriggered: {
+					popup.visible = true
+					popup.setDetails(blockModel.get(contextMenu.row))
+				}
+			}
+
+			MenuSeparator{}
+
+			MenuItem {
+				text: "Copy"
+				onTriggered: {
+					copyToClipboard(blockModel.get(contextMenu.row).hash)
+				}
+			}
+
+			MenuItem {
+				text: "Dump State"
+				onTriggered: {
+					generalFileDialog.show(false, function(path) {
+						var hash = blockModel.get(contextMenu.row).hash;
+
+						gui.dumpState(hash, path);
+					});
+				}
+			}
+		}
+	}
+
+
+
+	function addBlock(block, initial) {
+		if(initial == undefined){
+			initial = false
+		}
+
+	       var amount = block.transactions.length;
+	       var txs = [];
+	       for(var i = 0; i < block.transactions.length; i++) {
+		       var tx = JSON.parse(block.transactions.getAsJson(i));
+		       txs.push(tx);
+	       }
+
+		if(initial){
+			blockModel.append({raw: block.raw, bloom: block.bloom, size: block.size, number: block.number, name: block.name, gasLimit: block.gasLimit, gasUsed: block.gasUsed, coinbase: block.coinbase, hash: block.hash, txs: txs, txAmount: amount, time: block.time, prettyTime: convertToPretty(block.time)})
+		} else {
+			blockModel.insert(0, {bloom: block.bloom, size: block.size, number: block.number, name: block.name, gasLimit: block.gasLimit, gasUsed: block.gasUsed, coinbase: block.coinbase, hash: block.hash, txs: txs, txAmount: amount, time: block.time, prettyTime: convertToPretty(block.time)})
+		}
+	}
+
+	Window {
+		id: popup
+		visible: false
+		//flags: Qt.CustomizeWindowHint | Qt.Tool | Qt.WindowCloseButtonHint
+		property var block
+		width: root.width
+		height: 300
+		Component{
+			id: blockDetailsDelegate
+			Rectangle {
+				color: "#252525"
+				width: popup.width
+				height: 150
+				Column {
+					anchors.leftMargin: 10
+					anchors.topMargin: 5
+					anchors.top: parent.top
+					anchors.left: parent.left
+					Text { text: '<h3>Block details</h3>'; color: "#F2F2F2"}
+					Text { text: '<b>Block number:</b> ' + number + " (Size: " + size + ")"; color: "#F2F2F2"}
+					Text { text: '<b>Hash:</b> ' + hash; color: "#F2F2F2"}
+					Text { text: '<b>Bloom:</b> ' + bloom; color: "#F2F2F2"}
+					Text { text: '<b>Coinbase:</b> &lt;' + name + '&gt; ' + coinbase; color: "#F2F2F2"}
+					Text { text: '<b>Block found at:</b> ' + prettyTime; color: "#F2F2F2"}
+					Text { text: '<b>Gas used:</b> ' + gasUsed + " / " + gasLimit; color: "#F2F2F2"}
+				}
+			}
+		}
+		ListView {
+			model: singleBlock
+			delegate: blockDetailsDelegate
+			anchors.top: parent.top
+			height: 100
+			anchors.leftMargin: 20
+			id: listViewThing
+			Layout.maximumHeight: 40
+		}
+		TableView {
+			id: txView
+			anchors.top: listViewThing.bottom
+			anchors.topMargin: 50
+			width: parent.width
+
+			TableViewColumn{width: 90; role: "value" ; title: "Value" }
+			TableViewColumn{width: 200; role: "hash" ; title: "Hash" }
+			TableViewColumn{width: 200; role: "sender" ; title: "Sender" }
+			TableViewColumn{width: 200;role: "address" ; title: "Receiver" }
+			TableViewColumn{width: 60; role: "gas" ; title: "Gas" }
+			TableViewColumn{width: 60; role: "gasPrice" ; title: "Gas Price" }
+			TableViewColumn{width: 60; role: "isContract" ; title: "Contract" }
+
+			model: transactionModel
+			onClicked: {
+				var tx = transactionModel.get(row)
+				if(tx.data) {
+					popup.showContractData(tx)
+				}else{
+					popup.height = 440
+				}
+			}
+		}
+
+		function showContractData(tx) {
+			txDetailsDebugButton.tx = tx
+			if(tx.createsContract) {
+				contractData.text = tx.data
+				contractLabel.text = "<h4> Transaction created contract " + tx.address + "</h4>"
+			}else{
+				contractLabel.text = "<h4> Transaction ran contract " + tx.address + "</h4>"
+				contractData.text = tx.rawData
+			}
+			popup.height = 540
+		}
+
+		Rectangle {
+			id: txDetails
+			width: popup.width
+			height: 300
+			anchors.left: listViewThing.left
+			anchors.top: txView.bottom
+			Label {
+				text: "<h4>Contract data</h4>"
+				anchors.top: parent.top
+				anchors.left: parent.left
+				id: contractLabel
+				anchors.leftMargin: 10
+			}
+			Button {
+				property var tx
+				id: txDetailsDebugButton
+				anchors.right: parent.right
+				anchors.rightMargin: 10
+				anchors.top: parent.top
+				anchors.topMargin: 10
+				text: "Debug contract"
+				onClicked: {
+					if(tx && tx.createsContract){
+						eth.startDbWithCode(tx.rawData)
+					}else {
+						eth.startDbWithContractAndData(tx.address, tx.rawData)
+					}
+				}
+			}
+			TextArea {
+				id: contractData
+				text: "Contract"
+				anchors.top: contractLabel.bottom
+				anchors.left: parent.left
+				anchors.right: parent.right
+				wrapMode: Text.Wrap
+				height: 80
+			}
+			TextArea {
+				id: dumpData
+				anchors.top: contractData.bottom
+				anchors.left: parent.left
+				anchors.right: parent.right
+				anchors.bottom: parent.bottom
+				height: 300
+			}
+		}
+		property var transactionModel: ListModel {
+			id: transactionModel
+		}
+		property var singleBlock: ListModel {
+			id: singleBlock
+		}
+		function setDetails(bl){
+			singleBlock.set(0, bl)
+			popup.height = 300
+			transactionModel.clear()
+			if(bl.txs !== undefined){
+				for(var i = 0; i < bl.txs.count; i++) {
+					transactionModel.insert(0, bl.txs.get(i))
+				}
+				if(bl.txs.count > 0 && bl.txs.get(0).data){
+					popup.showContractData(bl.txs.get(0))
+				}
+			}
+			txView.forceActiveFocus()
+			dumpData.text = bl.raw;
+		}
+	}
+}

cmd/mist/assets/qml/views/history.qml

@@ -0,0 +1,51 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	property var title: "Transactions"
+	property var menuItem
+
+
+	id: historyView
+	visible: false
+	anchors.fill: parent
+	objectName: "transactionView"
+
+	property var txModel: ListModel {
+		id: txModel
+	}
+	TableView {
+		id: txTableView
+		anchors.fill: parent
+		TableViewColumn{ role: "inout" ; title: "" ; width: 40 }
+		TableViewColumn{ role: "value" ; title: "Value" ; width: 100 }
+		TableViewColumn{ role: "address" ; title: "Address" ; width: 430 }
+		TableViewColumn{ role: "contract" ; title: "Contract" ; width: 100 }
+
+		model: txModel
+	}
+
+	function addTx(tx, inout) {
+		var isContract
+		if (tx.contract == true){
+			isContract = "Yes"
+		}else{
+			isContract = "No"
+		}
+
+
+		var address;
+		if(inout == "recv") {
+			address = tx.sender;
+		} else {
+			address = tx.address;
+		}
+
+		txModel.insert(0, {inout: inout, hash: tx.hash, address: address, value: tx.value, contract: isContract})
+	}
+}

cmd/mist/assets/qml/views/info.qml

@@ -0,0 +1,196 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	property var title: "Debug Info"
+	property var menuItem
+
+	objectName: "infoView"
+	visible: false
+	anchors.fill: parent
+
+	color: "#00000000"
+
+	Column {
+		id: info
+		spacing: 3
+		anchors.fill: parent
+		anchors.topMargin: 5
+		anchors.leftMargin: 5
+
+		Label {
+			id: addressLabel
+			text: "Address"
+		}
+		TextField {
+			text: eth.key().address
+			width: 500
+		}
+
+		Label {
+			text: "Client ID"
+		}
+		TextField {
+			text: gui.getCustomIdentifier()
+			width: 500
+			placeholderText: "Anonymous"
+			onTextChanged: {
+				gui.setCustomIdentifier(text)
+			}
+		}
+
+		TextArea {
+			objectName: "statsPane"
+			width: parent.width
+			height: 200
+			selectByMouse: true
+			readOnly: true
+			font.family: "Courier"
+		}
+	}
+
+	RowLayout {
+		id: logLayout
+		width: parent.width
+		height: 200
+		anchors.bottom: parent.bottom
+
+		TableView {
+			id: addressView
+			width: parent.width
+			height: 200
+			anchors {
+				left: parent.left
+				right: logLevelSlider.left
+				bottom: parent.bottom
+				top: parent.top
+			}
+			TableViewColumn{ role: "name"; title: "name" }
+			TableViewColumn{ role: "address"; title: "address"; width: 300}
+
+			property var addressModel: ListModel {
+				id: addressModel
+			}
+
+			model: addressModel
+			itemDelegate: Item {
+				Text {
+					anchors {
+						left: parent.left
+						right: parent.right
+						leftMargin: 10
+						verticalCenter: parent.verticalCenter
+					}
+					color: styleData.textColor
+					elide: styleData.elideMode
+					text: styleData.value
+					font.pixelSize: 11
+					MouseArea {
+						acceptedButtons: Qt.LeftButton | Qt.RightButton
+						propagateComposedEvents: true
+						anchors.fill: parent
+						onClicked: {
+							addressView.selection.clear()
+							addressView.selection.select(styleData.row)
+
+							if(mouse.button == Qt.RightButton) {
+								contextMenu.row = styleData.row;
+								contextMenu.popup()
+							}
+						}
+					}
+				}
+			}
+
+			Menu {
+				id: contextMenu
+				property var row;
+
+				MenuItem {
+					text: "Copy"
+					onTriggered: {
+						copyToClipboard(addressModel.get(this.row).address)
+					}
+				}
+			}
+		}
+
+		/*
+		TableView {
+			id: logView
+			headerVisible: false
+			anchors {
+				right: logLevelSlider.left
+				left: parent.left
+				bottom: parent.bottom
+				top: parent.top
+			}
+
+			TableViewColumn{ role: "description" ; title: "log" }
+
+			model: logModel
+		}
+		*/
+
+		Slider {
+			id: logLevelSlider
+			value: gui.getLogLevelInt()
+			anchors {
+				right: parent.right
+				top: parent.top
+				bottom: parent.bottom
+
+				rightMargin: 5
+				leftMargin: 5
+				topMargin: 5
+				bottomMargin: 5
+			}
+
+			orientation: Qt.Vertical
+			maximumValue: 5
+			stepSize: 1
+
+			onValueChanged: {
+				gui.setLogLevel(value)
+			}
+		}
+	}
+
+	property var logModel: ListModel {
+		id: logModel
+	}
+
+	function addDebugMessage(message){
+		debuggerLog.append({value: message})
+	}
+
+	function addAddress(address) {
+		addressModel.append({name: address.name, address: address.address})
+	}
+
+	function clearAddress() {
+		addressModel.clear()
+	}
+
+	function addLog(str) {
+		// Remove first item once we've reached max log items
+		if(logModel.count > 250) {
+			logModel.remove(0)
+		}
+
+		if(str.len != 0) {
+			if(logView.flickableItem.atYEnd) {
+				logModel.append({description: str})
+				logView.positionViewAtRow(logView.rowCount - 1, ListView.Contain)
+			} else {
+				logModel.append({description: str})
+			}
+		}
+
+	}
+}

cmd/mist/assets/qml/views/jeffcoin/jeffcoin.qml

@@ -0,0 +1,190 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+
+Rectangle {
+	id: root
+	property var title: "JeffCoin"
+	property var iconSource: "./views/jeffcoin/jeff.png"
+	property var menuItem
+	property var filter
+	property var address: "fc0a9436890478bb9b1c6ed7455c2535366f4a99"
+
+	function insertTx(message, blockNumber) {
+		if(!message) return;
+
+		var from = message.from
+		var to = message.input.substr(24, 40)
+		var value = eth.fromNumber(message.input.substr(64, 64))
+
+		var me = eth.key().address;
+		if((to == me|| from == me) && message.input.length == 128) {
+			var to = eth.lookupName(to)
+			var from = eth.lookupName(from)
+			txModel.insert(0, {confirmations: blockNumber - message.number, from: from, to: to, value: value})
+		}
+	}
+
+	function setBalance() {
+		var jeffCoinAmount = eth.fromNumber(eth.storageAt(address, eth.key().address)) + " JΞF"
+		menuItem.secondaryTitle = jeffCoinAmount
+
+		balance.text = "<b>Balance</b>: " + jeffCoinAmount;
+	}
+
+	function onReady() {
+		setBalance()
+
+		filter = new ethx.watch({latest: -1, to: address})
+		filter.changed(function(messages) {
+			setBalance()
+
+			var blockNumber = eth.block(-1).number;
+			for(var i = 0; i < messages.length; i++) {
+				insertTx(messages.get(i), blockNumber);
+			}
+		});
+
+		var blockNumber = eth.block(-1).number;
+		var msgs = filter.messages()
+		for(var i = msgs.length-1; i >= 0; i--) {
+			var message = JSON.parse(msgs.getAsJson(i))
+
+			insertTx(message, blockNumber)
+		}
+
+		var chainChanged = ethx.watch("chain")
+		chainChanged.changed(function() {
+			for(var i = 0; i < txModel.count; i++) {
+				var entry = txModel.get(i);
+				entry.confirmations++;
+			}
+		});
+	}
+
+	function onDestroy() {
+		filter.uninstall()
+	}
+
+	ColumnLayout {
+		spacing: 10
+		y: 40
+		anchors.fill: parent
+
+		Text {
+			id: balance
+			text: "<b>Balance</b>: " + eth.fromNumber(eth.storageAt(address, eth.key().address)) + " JΞF"
+			font.pixelSize: 24
+			anchors {
+				horizontalCenter: parent.horizontalCenter
+				top: parent.top
+				topMargin: 20
+			}
+		}
+
+		Rectangle {
+			id: newTxPane
+			color: "#ececec"
+			border.color: "#cccccc"
+			border.width: 1
+			anchors {
+				top: balance.bottom
+				topMargin: 10
+				left: parent.left
+				leftMargin: 5
+				right: parent.right
+				rightMargin: 5
+			}
+			height: 100
+
+			RowLayout {
+				id: amountFields
+				spacing: 10
+				anchors {
+					top: parent.top
+					topMargin: 20
+					left: parent.left
+					leftMargin: 20
+				}
+
+				Text {
+					text: "JΞF  "
+				}
+
+				// There's something off with the row layout where textfields won't listen to the width setting
+				Rectangle {
+					width: 50
+					height: 20
+					TextField {
+						id: txValue
+						width: parent.width
+						placeholderText: "0.00"
+					}
+				}
+			}
+
+			RowLayout {
+				id: toFields
+				spacing: 10
+				anchors {
+					top: amountFields.bottom
+					topMargin: 5
+					left: parent.left
+					leftMargin: 20
+				}
+
+				Text {
+					text: "To"
+				}
+
+				Rectangle {
+					width: 200
+					height: 20
+					TextField {
+						id: txTo
+						width: parent.width
+						placeholderText: "Address or name"
+					}
+				}
+
+				Button {
+					text: "Send"
+					onClicked: {
+						var lookup = eth.lookupAddress(address)
+						if(lookup.length == 0)
+							lookup = address
+
+						eth.transact({from: eth.key().privateKey, to:lookup, gas: "9000", gasPrice: "10000000000000", data: ["0x"+txTo.text, txValue.text]})
+					}
+				}
+			}
+		}
+
+		Rectangle {
+			anchors {
+				left: parent.left
+				right: parent.right
+				top: newTxPane.bottom
+				topMargin: 10
+				bottom: parent.bottom
+			}
+			TableView {
+				id: txTableView
+				anchors.fill : parent
+				TableViewColumn{ role: "value" ; title: "Amount" ; width: 100 }
+				TableViewColumn{ role: "from" ; title: "From" ; width: 280 }
+				TableViewColumn{ role: "to" ; title: "To" ; width: 280 }
+				TableViewColumn{ role: "confirmations" ; title: "Confirmations" ; width: 100 }
+
+				model: ListModel {
+					id: txModel
+					Component.onCompleted: {
+					}
+				}
+			}
+		}
+	}
+}

cmd/mist/assets/qml/views/miner.qml

@@ -0,0 +1,254 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	id: root
+	property var title: "Miner"
+	property var iconSource: "../miner.png"
+	property var menuItem
+
+	color: "#00000000"
+
+	ColumnLayout {
+		spacing: 10
+		anchors.fill: parent
+
+		Rectangle {
+			id: mainPane
+			color: "#00000000"
+			anchors {
+				top: parent.top
+				bottom: localTxPane.top
+				left: parent.left
+				right: parent.right
+			}
+
+			Rectangle {
+				id: menu
+				height: 25
+				anchors {
+					left: parent.left
+				}
+
+				RowLayout {
+					id: tools
+					anchors {
+						left: parent.left
+						right: parent.right
+					}
+
+					Button {
+						text: "Start"
+						onClicked: {
+							eth.setGasPrice(minGasPrice.text || "10000000000000");
+							if (eth.toggleMining()) {
+								this.text = "Stop";
+							} else {
+								this.text = "Start";
+							}
+						}
+					}
+
+					Rectangle {
+						anchors.top: parent.top
+						anchors.topMargin: 2
+						width: 200
+						TextField {
+							id: minGasPrice
+							placeholderText: "Min Gas: 10000000000000"
+							width: 200
+							validator: RegExpValidator { regExp: /\d*/ }
+						}
+					}
+				}
+			}
+
+			Column {
+				anchors {
+					left: parent.left
+					right: parent.right
+					top: menu.bottom
+					topMargin: 5
+				}
+
+				Text {
+					text: "<b>Merged mining options</b>"
+				}
+
+				TableView {
+					id: mergedMiningTable
+					height: 300
+					anchors {
+						left: parent.left
+						right: parent.right
+					}
+					Component {
+						id: checkBoxDelegate
+
+						Item {
+							id: test
+							CheckBox {
+								anchors.fill: parent
+								checked: styleData.value
+
+								onClicked: {
+									var model = mergedMiningModel.get(styleData.row)
+
+									if (this.checked) {
+										model.id = txModel.createLocalTx(model.address, "0", "5000", "0", "")
+									} else {
+										txModel.removeWithId(model.id);
+										model.id = 0;
+									}
+								}
+							}
+						}
+					}
+					TableViewColumn{ role: "checked" ; title: "" ; width: 40 ; delegate: checkBoxDelegate }
+					TableViewColumn{ role: "name" ; title: "Name" ; width: 480 }
+					model: ListModel {
+						objectName: "mergedMiningModel"
+						id: mergedMiningModel 
+						function addMergedMiningOption(model) {
+							this.append(model);
+						}
+					}
+					Component.onCompleted: {
+						/*
+						// XXX Temp. replace with above eventually
+						var tmpItems = ["JEVCoin", "Some coin", "Other coin", "Etc coin"];
+						var address = "e6716f9544a56c530d868e4bfbacb172315bdead";
+						for (var i = 0; i < tmpItems.length; i++) {
+							mergedMiningModel.append({checked: false, name: tmpItems[i], address: address, id: 0, itemId: i});
+						}
+						*/
+					}
+				}
+			}
+		}
+
+		Rectangle {
+			id: localTxPane
+			color: "#ececec"
+			border.color: "#cccccc"
+			border.width: 1
+			anchors {
+				left: parent.left
+				right: parent.right
+				bottom: parent.bottom
+			}
+			height: 300
+
+			ColumnLayout {
+				spacing: 10
+				anchors.fill: parent
+				RowLayout {
+					id: newLocalTx
+					anchors {
+						left: parent.left
+						leftMargin: 5
+						top: parent.top
+						topMargin: 5
+						bottomMargin: 5
+					}
+
+					Text {
+						text: "Local tx"
+					}
+
+					Rectangle {
+						width: 250
+						color: "#00000000"
+						anchors.top: parent.top
+						anchors.topMargin: 2
+
+						TextField {
+							id: to
+							placeholderText: "To"
+							width: 250
+							validator: RegExpValidator { regExp: /[abcdefABCDEF1234567890]*/ }
+						}
+					}
+					TextField {
+						property var defaultGas: "5000"
+						id: gas
+						placeholderText: "Gas"
+						text: defaultGas
+						validator: RegExpValidator { regExp: /\d*/ }
+					}
+					TextField {
+						id: gasPrice
+						placeholderText: "Price"
+						validator: RegExpValidator { regExp: /\d*/ }
+					}
+					TextField {
+						id: value 
+						placeholderText: "Amount"
+						text: "0"
+						validator: RegExpValidator { regExp: /\d*/ }
+					}
+					TextField {
+						id: data
+						placeholderText: "Data"
+						validator: RegExpValidator { regExp: /[abcdefABCDEF1234567890]*/ }
+					}
+					Button {
+						text: "Create"
+						onClicked: {
+							if (to.text.length == 40 && gasPrice.text.length != 0 && value.text.length != 0 && gas.text.length != 0) {
+								txModel.createLocalTx(to.text, gasPrice.text, gas.text, value.text, data.text);
+
+								to.text = ""; gasPrice.text = "";
+								gas.text = gas.defaultGas;
+								value.text = "0"
+							}
+						}
+					}
+				}
+
+				TableView {
+					id: txTableView
+					anchors {
+						top: newLocalTx.bottom
+						topMargin: 5
+						left: parent.left
+						right: parent.right
+						bottom: parent.bottom
+					}
+					TableViewColumn{ role: "to" ; title: "To" ; width: 480 }
+					TableViewColumn{ role: "gas" ; title: "Gas" ; width: 100 }
+					TableViewColumn{ role: "gasPrice" ; title: "Gas Price" ; width: 100 }
+					TableViewColumn{ role: "value" ; title: "Amount" ; width: 100 }
+					TableViewColumn{ role: "data" ; title: "Data" ; width: 100 }
+
+					model: ListModel {
+						id: txModel
+						Component.onCompleted: {
+						}
+						function removeWithId(id) {
+							for (var i = 0; i < this.count; i++) {
+								if (txModel.get(i).id == id) {
+									this.remove(i);
+									eth.removeLocalTransaction(id)
+									break;
+								}
+							}
+						}
+
+						function createLocalTx(to, gasPrice, gas, value, data) {
+							var id = eth.addLocalTransaction(to, data, gas, gasPrice, value)
+							txModel.insert(0, {to: to, gas: gas, gasPrice: gasPrice, value: value, data: data, id: id});
+
+							return id
+						}
+					}
+				}
+			}
+		}
+	}
+}

cmd/mist/assets/qml/views/pending_tx.qml

@@ -0,0 +1,44 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	property var title: "Pending Transactions"
+	property var menuItem
+
+	objectName: "pendingTxView"
+	anchors.fill: parent
+	visible: false
+	id: pendingTxView
+
+	property var pendingTxModel: ListModel {
+		id: pendingTxModel
+	}
+
+	TableView {
+		id: pendingTxTableView
+		anchors.fill: parent
+		TableViewColumn{ role: "value" ; title: "Value" ; width: 100 }
+		TableViewColumn{ role: "from" ; title: "sender" ; width: 230 }
+		TableViewColumn{ role: "to" ; title: "Reciever" ; width: 230 }
+		TableViewColumn{ role: "contract" ; title: "Contract" ; width: 100 }
+
+		model: pendingTxModel
+	}
+
+	function addTx(tx, inout) {
+		var isContract
+		if (tx.contract == true){
+			isContract = "Yes"
+		}else{
+			isContract = "No"
+		}
+
+
+		pendingTxModel.insert(0, {hash: tx.hash, to: tx.address, from: tx.sender, value: tx.value, contract: isContract})
+	}
+}

cmd/mist/assets/qml/views/transaction.qml

@@ -0,0 +1,216 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	property var title: "New Transaction"
+	property var menuItem
+
+	objectName: "newTxView"
+	visible: false
+	anchors.fill: parent
+	color: "#00000000"
+
+	Column {
+		id: mainContractColumn
+		anchors.fill: parent
+
+
+		states: [
+			State{
+				name: "ERROR"
+
+				PropertyChanges { target: txResult; visible:true}
+				PropertyChanges { target: codeView; visible:true}
+			},
+			State {
+				name: "DONE"
+
+				PropertyChanges { target: txValue; visible:false}
+				PropertyChanges { target: txGas; visible:false}
+				PropertyChanges { target: txGasPrice; visible:false}
+				PropertyChanges { target: codeView; visible:false}
+				PropertyChanges { target: txButton; visible:false}
+				PropertyChanges { target: txDataLabel; visible:false}
+				PropertyChanges { target: atLabel; visible:false}
+				PropertyChanges { target: txFuelRecipient; visible:false}
+				PropertyChanges { target: valueDenom; visible:false}
+				PropertyChanges { target: gasDenom; visible:false}
+
+				PropertyChanges { target: txResult; visible:true}
+				PropertyChanges { target: txOutput; visible:true}
+				PropertyChanges { target: newTxButton; visible:true}
+			},
+			State {
+				name: "SETUP"
+
+				PropertyChanges { target: txValue; visible:true; text: ""}
+				PropertyChanges { target: txGas; visible:true;}
+				PropertyChanges { target: txGasPrice; visible:true;}
+				PropertyChanges { target: codeView; visible:true; text: ""}
+				PropertyChanges { target: txButton; visible:true}
+				PropertyChanges { target: txDataLabel; visible:true}
+				PropertyChanges { target: valueDenom; visible:true}
+				PropertyChanges { target: gasDenom; visible:true}
+
+				PropertyChanges { target: txResult; visible:false}
+				PropertyChanges { target: txOutput; visible:false}
+				PropertyChanges { target: newTxButton; visible:false}
+			}
+		]
+		width: 400
+		spacing: 5
+		anchors.left: parent.left
+		anchors.top: parent.top
+		anchors.leftMargin: 5
+		anchors.topMargin: 5
+
+		ListModel {
+			id: denomModel
+			ListElement { text: "Wei" ;     zeros: "" }
+			ListElement { text: "Ada" ;     zeros: "000" }
+			ListElement { text: "Babbage" ; zeros: "000000" }
+			ListElement { text: "Shannon" ; zeros: "000000000" }
+			ListElement { text: "Szabo" ;   zeros: "000000000000" }
+			ListElement { text: "Finney" ;  zeros: "000000000000000" }
+			ListElement { text: "Ether" ;   zeros: "000000000000000000" }
+			ListElement { text: "Einstein" ;zeros: "000000000000000000000" }
+			ListElement { text: "Douglas" ; zeros: "000000000000000000000000000000000000000000" }
+		}
+
+
+		TextField {
+			id: txFuelRecipient
+			placeholderText: "Address / Name or empty for contract"
+			//validator: RegExpValidator { regExp: /[a-f0-9]{40}/ }
+			width: 400
+		}
+
+		RowLayout {
+			TextField {
+				id: txValue
+				width: 222
+				placeholderText: "Amount"
+				validator: RegExpValidator { regExp: /\d*/ }
+				onTextChanged: {
+					contractFormReady()
+				}
+			}
+
+			ComboBox {
+				id: valueDenom
+				currentIndex: 6
+				model: denomModel
+			}
+		}
+
+		RowLayout {
+			TextField {
+				id: txGas
+				width: 50
+				validator: RegExpValidator { regExp: /\d*/ }
+				placeholderText: "Gas"
+				text: "5000"
+			}
+			Label {
+				id: atLabel
+				text: "@"
+			}
+
+			TextField {
+				id: txGasPrice
+				width: 200
+				placeholderText: "Gas price"
+				text: "10"
+				validator: RegExpValidator { regExp: /\d*/ }
+			}
+
+			ComboBox {
+				id: gasDenom
+				currentIndex: 4
+				model: denomModel
+			}
+		}
+
+		Label {
+			id: txDataLabel
+			text: "Data"
+		}
+
+		TextArea {
+			id: codeView
+			height: 300
+			anchors.topMargin: 5
+			width: 400
+			onTextChanged: {
+				contractFormReady()
+			}
+		}
+
+
+		Button {
+			id: txButton
+			/* enabled: false */
+			states: [
+				State {
+					name: "READY"
+					PropertyChanges { target: txButton; /*enabled: true*/}
+				},
+				State {
+					name: "NOTREADY"
+					PropertyChanges { target: txButton; /*enabled:false*/}
+				}
+			]
+			text: "Send"
+			onClicked: {
+				var value = txValue.text + denomModel.get(valueDenom.currentIndex).zeros;
+				var gasPrice = txGasPrice.text + denomModel.get(gasDenom.currentIndex).zeros;
+				var res = gui.transact(txFuelRecipient.text, value, txGas.text, gasPrice, codeView.text)
+				if(res[1]) {
+					txResult.text = "Your contract <b>could not</b> be sent over the network:\n<b>"
+					txResult.text += res[1].error()
+					txResult.text += "</b>"
+					mainContractColumn.state = "ERROR"
+				} else {
+					txResult.text = "Your transaction has been submitted:\n"
+					txOutput.text = res[0].address
+					mainContractColumn.state = "DONE"
+
+					console.log(res)
+				}
+			}
+		}
+		Text {
+			id: txResult
+			visible: false
+		}
+		TextField {
+			id: txOutput
+			visible: false
+			width: 530
+		}
+		Button {
+			id: newTxButton
+			visible: false
+			text: "Create a new transaction"
+			onClicked: {
+				this.visible = false
+				txResult.text = ""
+				txOutput.text = ""
+				mainContractColumn.state = "SETUP"
+			}
+		}
+	}
+
+	function contractFormReady(){
+		if(codeView.text.length > 0 && txValue.text.length > 0 && txGas.text.length > 0 && txGasPrice.length > 0) {
+			txButton.state = "READY"
+		}else{
+			txButton.state = "NOTREADY"
+		}
+	}
+}

cmd/mist/assets/qml/views/wallet.qml

@@ -0,0 +1,188 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	id: root
+	property var title: "Wallet"
+	property var iconSource: "../facet.png"
+	property var menuItem
+
+	objectName: "walletView"
+	anchors.fill: parent
+
+	function onReady() {
+		setBalance()
+	}
+
+	function setBalance() {
+		balance.text = "<b>Balance</b>: " + eth.numberToHuman(eth.balanceAt(eth.key().address))
+		if(menuItem)
+			menuItem.secondaryTitle = eth.numberToHuman(eth.balanceAt(eth.key().address))
+	}
+
+	ListModel {
+		id: denomModel
+		ListElement { text: "Wei" ;     zeros: "" }
+		ListElement { text: "Ada" ;     zeros: "000" }
+		ListElement { text: "Babbage" ; zeros: "000000" }
+		ListElement { text: "Shannon" ; zeros: "000000000" }
+		ListElement { text: "Szabo" ;   zeros: "000000000000" }
+		ListElement { text: "Finney" ;  zeros: "000000000000000" }
+		ListElement { text: "Ether" ;   zeros: "000000000000000000" }
+		ListElement { text: "Einstein" ;zeros: "000000000000000000000" }
+		ListElement { text: "Douglas" ; zeros: "000000000000000000000000000000000000000000" }
+	}
+
+	ColumnLayout {
+		spacing: 10
+		y: 40
+		anchors.fill: parent
+
+		Text {
+			id: balance
+			font.pixelSize: 24
+			anchors {
+				horizontalCenter: parent.horizontalCenter
+				top: parent.top
+				topMargin: 20
+			}
+		}
+
+		Rectangle {
+			id: newTxPane
+			color: "#ececec"
+			border.color: "#cccccc"
+			border.width: 1
+			anchors {
+				top: balance.bottom
+				topMargin: 10
+				left: parent.left
+				leftMargin: 5
+				right: parent.right
+				rightMargin: 5
+			}
+			height: 100
+
+			RowLayout {
+				id: amountFields
+				spacing: 10
+				anchors {
+					top: parent.top
+					topMargin: 20
+					left: parent.left
+					leftMargin: 20
+				}
+
+				Text {
+					text: "Ξ  "
+				}
+
+				// There's something off with the row layout where textfields won't listen to the width setting
+				Rectangle {
+					width: 50
+					height: 20
+					TextField {
+						id: txValue
+						width: parent.width
+						placeholderText: "0.00"
+					}
+				}
+
+				ComboBox {
+					id: valueDenom
+					currentIndex: 6
+					model: denomModel
+				}
+
+			}
+
+			RowLayout {
+				id: toFields
+				spacing: 10
+				anchors {
+					top: amountFields.bottom
+					topMargin: 5
+					left: parent.left
+					leftMargin: 20
+				}
+
+				Text {
+					text: "To"
+				}
+
+				Rectangle {
+					width: 200
+					height: 20
+					TextField {
+						id: txTo
+						width: parent.width
+						placeholderText: "Address or name"
+					}
+				}
+
+				Button {
+					text: "Send"
+					onClicked: {
+						var value = txValue.text + denomModel.get(valueDenom.currentIndex).zeros;
+						var gasPrice = "10000000000000"
+						var res = eth.transact({from: eth.key().privateKey, to: txTo.text, value: value, gas: "500", gasPrice: gasPrice})
+					}
+				}
+			}
+		}
+
+		Rectangle {
+			anchors {
+				left: parent.left
+				right: parent.right
+				top: newTxPane.bottom
+				topMargin: 10
+				bottom: parent.bottom
+			}
+			TableView {
+				id: txTableView
+				anchors.fill : parent
+				TableViewColumn{ role: "num" ; title: "#" ; width: 30 }
+				TableViewColumn{ role: "from" ; title: "From" ; width: 340 }
+				TableViewColumn{ role: "to" ; title: "To" ; width: 340 }
+				TableViewColumn{ role: "value" ; title: "Amount" ; width: 100 }
+
+				model: ListModel {
+					id: txModel
+					Component.onCompleted: {
+						var me = eth.key().address;
+						var filterTo = ethx.watch({latest: -1, to: me});
+						var filterFrom = ethx.watch({latest: -1, from: me});
+						filterTo.changed(addTxs)
+						filterFrom.changed(addTxs)
+
+						addTxs(filterTo.messages())
+						addTxs(filterFrom.messages())
+					}
+
+					function addTxs(messages) {
+						setBalance()
+
+						for(var i = 0; i < messages.length; i++) {
+							var message = messages.get(i);
+							var to = eth.lookupName(message.to);
+							var from;
+							if(message.from.length == 0) {
+								from = "- MINED -";
+							} else {
+								from = eth.lookupName(message.from);
+							}
+							txModel.insert(0, {num: txModel.count, from: from, to: to, value: eth.numberToHuman(message.value)})
+						}
+					}
+				}
+			}
+		}
+
+	}
+}

cmd/mist/assets/qml/webapp.qml

@@ -0,0 +1,413 @@
+import QtQuick 2.0
+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
+    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("messages", [m, id]);
+    }
+
+    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: 5
+                    rightMargin: 5
+                }
+                text: "http://etherian.io"
+                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
+                    }
+                }
+            }
+        }
+
+
+        WebView {
+            objectName: "webView"
+            id: webview
+            anchors {
+                left: parent.left
+                right: parent.right
+                bottom: parent.bottom
+                top: navBar.bottom
+            }
+
+            //property var cleanPath: false
+            onNavigationRequested: {
+                window.open(request.url.toString());					
+            }
+
+            function sendMessage(data) {
+                webview.experimental.postMessage(JSON.stringify(data))
+            }
+
+
+            experimental.preferences.javascriptEnabled: true
+            experimental.preferences.navigatorQtObjectEnabled: true
+            experimental.preferences.developerExtrasEnabled: true
+            //experimental.userScripts: ["../ext/qt_messaging_adapter.js", "../ext/q.js", "../ext/big.js", "../ext/string.js", "../ext/html_messaging.js"]
+            experimental.userScripts: ["../ext/q.js", "../ext/eth.js/main.js", "../ext/eth.js/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 "compile":
+                        postData(data._id, eth.compile(data.args[0]))
+                        break
+
+                        case "coinbase":
+                        postData(data._id, eth.coinBase())
+
+                        case "account":
+                        postData(data._id, eth.key().address);
+
+                        case "isListening":
+                        postData(data._id, eth.isListening())
+
+                        break
+
+                        case "isMining":
+                        postData(data._id, eth.isMining())
+
+                        break
+
+                        case "peerCount":
+                        postData(data._id, eth.peerCount())
+
+                        break
+
+                        case "countAt":
+                        require(1)
+                        postData(data._id, eth.txCountAt(data.args[0]))
+
+                        break
+
+                        case "codeAt":
+                        require(1)
+                        var code = eth.codeAt(data.args[0])
+                        postData(data._id, code);
+
+                        break
+
+                        case "blockByNumber":
+                        require(1)
+                        var block = eth.blockByNumber(data.args[0])
+                        postData(data._id, block)
+                        break
+
+                        case "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 "transactionByHash":
+                        case "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 "uncleByHash":
+                        case "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 "stateAt":
+                        require(2);
+
+                        var storage = eth.storageAt(data.args[0], data.args[1]);
+                        postData(data._id, storage)
+
+                        break
+
+                        case "call":
+                        require(1);
+                        var ret = eth.call(data.args)
+                        postData(data._id, ret)
+                        break
+
+                        case "balanceAt":
+                        require(1);
+
+                        postData(data._id, eth.balanceAt(data.args[0]));
+                        break
+
+                        case "watch":
+                        require(2)
+                        eth.watch(data.args[0], data.args[1])
+
+                        case "disconnect":
+                        require(1)
+                        postData(data._id, null)
+                        break;
+
+                        case "messages":
+                        require(1);
+
+                        var messages = JSON.parse(eth.getMessages(data.args[0]))
+                        postData(data._id, messages)
+                        break
+
+                        case "mutan":
+                        require(1)
+
+                        var code = eth.compileMutan(data.args[0])
+                        postData(data._id, "0x"+code)
+                        break;
+
+                        case "newFilterString":
+                        require(1)
+                        var id = eth.newFilterString(data.args[0])
+                        postData(data._id, id);
+                        break;
+
+                        case "newFilter":
+                        require(1)
+                        var id = eth.newFilter(data.args[0])
+
+                        postData(data._id, id);
+                        break;
+
+                        case "getMessages":
+                        require(1);
+
+                        var messages = eth.messages(data.args[0]);
+                        var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
+                        postData(data._id, m);
+
+                        break;
+
+                        case "deleteFilter":
+                        require(1);
+                        eth.uninstallFilter(data.args[0])
+                        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, data) {
+                webview.experimental.postMessage(JSON.stringify({data: data, _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
+                }
+            }
+        ]
+    }
+}

cmd/mist/assets/util/test.html

@@ -0,0 +1,43 @@
+<html>
+<head>
+<title>Utils</title>
+</head>
+<body onload="init();">
+<label>Nonce for 2ef47100e0787b915105fd5e3f4ff6752079d5cb</label>
+<p id="nonce"></p>
+
+<label>Connected peers</label>
+<p id="peers"></p>
+
+<label>Is mining</label>
+<p id="isMining"></p>
+
+<label>Is listening</label>
+<p id="isListen"></p>
+
+<label>Coinbase</label>
+<p id="coinbase"></p>
+
+<script type="text/javascript">
+
+function init() {
+	eth.getTxCountAt("2ef47100e0787b915105fd5e3f4ff6752079d5cb", function(nonce){
+			document.querySelector("#nonce").innerHTML = nonce;
+	})
+	eth.getPeerCount(function(peerLength){
+			document.querySelector("#peers").innerHTML = peerLength;
+	})
+	eth.getIsMining(function(mining){
+			document.querySelector("#isMining").innerHTML = mining;
+	})
+	eth.getIsListening(function(listen){
+			document.querySelector("#isListen").innerHTML = listen;
+	})
+	eth.getCoinBase(function(address){
+			document.querySelector("#coinbase").innerHTML = address;
+	})
+}
+</script>
+</body>
+</html>
+

cmd/mist/bindings.go

@@ -0,0 +1,134 @@
+// 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
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+)
+
+type plugin struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+}
+
+// LogPrint writes to the GUI log.
+func (gui *Gui) LogPrint(level logger.LogLevel, msg string) {
+	/*
+		str := strings.TrimRight(s, "\n")
+		lines := strings.Split(str, "\n")
+
+		view := gui.getObjectByName("infoView")
+		for _, line := range lines {
+			view.Call("addLog", line)
+		}
+	*/
+}
+func (gui *Gui) Transact(recipient, value, gas, gasPrice, d string) (string, error) {
+	var data string
+	if len(recipient) == 0 {
+		code, err := ethutil.Compile(d, false)
+		if err != nil {
+			return "", err
+		}
+		data = ethutil.Bytes2Hex(code)
+	} else {
+		data = ethutil.Bytes2Hex(utils.FormatTransactionData(d))
+	}
+
+	return gui.pipe.Transact(gui.privateKey(), recipient, value, gas, gasPrice, data)
+}
+
+func (gui *Gui) SetCustomIdentifier(customIdentifier string) {
+	gui.clientIdentity.SetCustomIdentifier(customIdentifier)
+	gui.config.Save("id", customIdentifier)
+}
+
+func (gui *Gui) GetCustomIdentifier() string {
+	return gui.clientIdentity.GetCustomIdentifier()
+}
+
+// functions that allow Gui to implement interface guilogger.LogSystem
+func (gui *Gui) SetLogLevel(level logger.LogLevel) {
+	gui.logLevel = level
+	gui.stdLog.SetLogLevel(level)
+	gui.config.Save("loglevel", level)
+}
+
+func (gui *Gui) GetLogLevel() logger.LogLevel {
+	return gui.logLevel
+}
+
+func (self *Gui) AddPlugin(pluginPath string) {
+	self.plugins[pluginPath] = plugin{Name: pluginPath, Path: pluginPath}
+
+	json, _ := json.MarshalIndent(self.plugins, "", "    ")
+	ethutil.WriteFile(ethutil.Config.ExecPath+"/plugins.json", json)
+}
+
+func (self *Gui) RemovePlugin(pluginPath string) {
+	delete(self.plugins, pluginPath)
+
+	json, _ := json.MarshalIndent(self.plugins, "", "    ")
+	ethutil.WriteFile(ethutil.Config.ExecPath+"/plugins.json", json)
+}
+
+// this extra function needed to give int typecast value to gui widget
+// that sets initial loglevel to default
+func (gui *Gui) GetLogLevelInt() int {
+	return int(gui.logLevel)
+}
+func (self *Gui) DumpState(hash, path string) {
+	var stateDump []byte
+
+	if len(hash) == 0 {
+		stateDump = self.eth.ChainManager().State().Dump()
+	} else {
+		var block *types.Block
+		if hash[0] == '#' {
+			i, _ := strconv.Atoi(hash[1:])
+			block = self.eth.ChainManager().GetBlockByNumber(uint64(i))
+		} else {
+			block = self.eth.ChainManager().GetBlock(ethutil.Hex2Bytes(hash))
+		}
+
+		if block == nil {
+			guilogger.Infof("block err: not found %s\n", hash)
+			return
+		}
+
+		stateDump = block.State().Dump()
+	}
+
+	file, err := os.OpenFile(path[7:], os.O_CREATE|os.O_RDWR, os.ModePerm)
+	if err != nil {
+		guilogger.Infoln("dump err: ", err)
+		return
+	}
+	defer file.Close()
+
+	guilogger.Infof("dumped state (%s) to %s\n", hash, path)
+
+	file.Write(stateDump)
+}

cmd/mist/debugger.go

@@ -0,0 +1,355 @@
+// 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
+
+package main
+
+import (
+	"fmt"
+	"math/big"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/vm"
+	"gopkg.in/qml.v1"
+)
+
+type DebuggerWindow struct {
+	win    *qml.Window
+	engine *qml.Engine
+	lib    *UiLib
+
+	vm *vm.DebugVm
+	Db *Debugger
+
+	state *state.StateDB
+}
+
+func NewDebuggerWindow(lib *UiLib) *DebuggerWindow {
+	engine := qml.NewEngine()
+	component, err := engine.LoadFile(lib.AssetPath("debugger/debugger.qml"))
+	if err != nil {
+		fmt.Println(err)
+
+		return nil
+	}
+
+	win := component.CreateWindow(nil)
+
+	w := &DebuggerWindow{engine: engine, win: win, lib: lib, vm: &vm.DebugVm{}}
+	w.Db = NewDebugger(w)
+
+	return w
+}
+
+func (self *DebuggerWindow) Show() {
+	context := self.engine.Context()
+	context.SetVar("dbg", self)
+
+	go func() {
+		self.win.Show()
+		self.win.Wait()
+	}()
+}
+
+func (self *DebuggerWindow) SetCode(code string) {
+	self.win.Set("codeText", code)
+}
+
+func (self *DebuggerWindow) SetData(data string) {
+	self.win.Set("dataText", data)
+}
+
+func (self *DebuggerWindow) SetAsm(data []byte) {
+	self.win.Root().Call("clearAsm")
+
+	dis := core.Disassemble(data)
+	for _, str := range dis {
+		self.win.Root().Call("setAsm", str)
+	}
+}
+
+func (self *DebuggerWindow) Compile(code string) {
+	var err error
+	script := ethutil.StringToByteFunc(code, func(s string) (ret []byte) {
+		ret, err = ethutil.Compile(s, true)
+		return
+	})
+
+	if err == nil {
+		self.SetAsm(script)
+	}
+}
+
+// Used by QML
+func (self *DebuggerWindow) AutoComp(code string) {
+	if self.Db.done {
+		self.Compile(code)
+	}
+}
+
+func (self *DebuggerWindow) ClearLog() {
+	self.win.Root().Call("clearLog")
+}
+
+func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, dataStr string) {
+	self.Stop()
+
+	defer func() {
+		if r := recover(); r != nil {
+			self.Logf("compile FAULT: %v", r)
+		}
+	}()
+
+	data := utils.FormatTransactionData(dataStr)
+
+	var err error
+	script := ethutil.StringToByteFunc(scriptStr, func(s string) (ret []byte) {
+		ret, err = ethutil.Compile(s, false)
+		return
+	})
+
+	if err != nil {
+		self.Logln(err)
+
+		return
+	}
+
+	var (
+		gas      = ethutil.Big(gasStr)
+		gasPrice = ethutil.Big(gasPriceStr)
+		value    = ethutil.Big(valueStr)
+		// Contract addr as test address
+		keyPair = self.lib.eth.KeyManager().KeyPair()
+	)
+
+	statedb := self.lib.eth.ChainManager().TransState()
+	account := self.lib.eth.ChainManager().TransState().GetAccount(keyPair.Address())
+	contract := statedb.NewStateObject([]byte{0})
+	contract.SetCode(script)
+	contract.SetBalance(value)
+
+	self.SetAsm(script)
+
+	block := self.lib.eth.ChainManager().CurrentBlock()
+
+	env := utils.NewEnv(statedb, block, account.Address(), value)
+
+	self.Logf("callsize %d", len(script))
+	go func() {
+		ret, err := env.Call(account, contract.Address(), data, gas, gasPrice, ethutil.Big0)
+		//ret, g, err := callerClosure.Call(evm, data)
+		tot := new(big.Int).Mul(env.Gas, gasPrice)
+		self.Logf("gas usage %v total price = %v (%v)", env.Gas, tot, ethutil.CurrencyToString(tot))
+		if err != nil {
+			self.Logln("exited with errors:", err)
+		} else {
+			if len(ret) > 0 {
+				self.Logf("exited: % x", ret)
+			} else {
+				self.Logf("exited: nil")
+			}
+		}
+
+		statedb.Reset()
+
+		if !self.Db.interrupt {
+			self.Db.done = true
+		} else {
+			self.Db.interrupt = false
+		}
+	}()
+}
+
+func (self *DebuggerWindow) Logf(format string, v ...interface{}) {
+	self.win.Root().Call("setLog", fmt.Sprintf(format, v...))
+}
+
+func (self *DebuggerWindow) Logln(v ...interface{}) {
+	str := fmt.Sprintln(v...)
+	self.Logf("%s", str[:len(str)-1])
+}
+
+func (self *DebuggerWindow) Next() {
+	self.Db.Next()
+}
+
+func (self *DebuggerWindow) Continue() {
+	self.vm.Stepping = false
+	self.Next()
+}
+
+func (self *DebuggerWindow) Stop() {
+	if !self.Db.done {
+		self.Db.Q <- true
+	}
+}
+
+func (self *DebuggerWindow) ExecCommand(command string) {
+	if len(command) > 0 {
+		cmd := strings.Split(command, " ")
+		switch cmd[0] {
+		case "help":
+			self.Logln("Debugger commands:")
+			self.Logln("break, bp                 Set breakpoint on instruction")
+			self.Logln("clear [log, break, bp]    Clears previous set sub-command(s)")
+		case "break", "bp":
+			if len(cmd) > 1 {
+				lineNo, err := strconv.Atoi(cmd[1])
+				if err != nil {
+					self.Logln(err)
+					break
+				}
+				self.Db.breakPoints = append(self.Db.breakPoints, int64(lineNo))
+				self.Logf("break point set on instruction %d", lineNo)
+			} else {
+				self.Logf("'%s' requires line number", cmd[0])
+			}
+		case "clear":
+			if len(cmd) > 1 {
+				switch cmd[1] {
+				case "break", "bp":
+					self.Db.breakPoints = nil
+
+					self.Logln("Breakpoints cleared")
+				case "log":
+					self.ClearLog()
+				default:
+					self.Logf("clear '%s' is not valid", cmd[1])
+				}
+			} else {
+				self.Logln("'clear' requires sub command")
+			}
+
+		default:
+			self.Logf("Unknown command %s", cmd[0])
+		}
+	}
+}
+
+type Debugger struct {
+	N               chan bool
+	Q               chan bool
+	done, interrupt bool
+	breakPoints     []int64
+	main            *DebuggerWindow
+	win             *qml.Window
+}
+
+func NewDebugger(main *DebuggerWindow) *Debugger {
+	db := &Debugger{make(chan bool), make(chan bool), true, false, nil, main, main.win}
+
+	return db
+}
+
+type storeVal struct {
+	Key, Value string
+}
+
+func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
+	self.main.Logln("break on instr:", pc)
+
+	return self.halting(pc, op, mem, stack, stateObject)
+}
+
+func (self *Debugger) StepHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
+	return self.halting(pc, op, mem, stack, stateObject)
+}
+
+func (self *Debugger) SetCode(byteCode []byte) {
+	self.main.SetAsm(byteCode)
+}
+
+func (self *Debugger) BreakPoints() []int64 {
+	return self.breakPoints
+}
+
+func (d *Debugger) halting(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
+	d.win.Root().Call("setInstruction", pc)
+	d.win.Root().Call("clearMem")
+	d.win.Root().Call("clearStack")
+	d.win.Root().Call("clearStorage")
+
+	addr := 0
+	for i := 0; i+16 <= mem.Len(); i += 16 {
+		dat := mem.Data()[i : i+16]
+		var str string
+
+		for _, d := range dat {
+			if unicode.IsGraphic(rune(d)) {
+				str += string(d)
+			} else {
+				str += "?"
+			}
+		}
+
+		d.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("%s  % x", str, dat)})
+		addr += 16
+	}
+
+	for _, val := range stack.Data() {
+		d.win.Root().Call("setStack", val.String())
+	}
+
+	stateObject.EachStorage(func(key string, node *ethutil.Value) {
+		d.win.Root().Call("setStorage", storeVal{fmt.Sprintf("% x", key), fmt.Sprintf("% x", node.Str())})
+	})
+
+	stackFrameAt := new(big.Int).SetBytes(mem.Get(0, 32))
+	psize := mem.Len() - int(new(big.Int).SetBytes(mem.Get(0, 32)).Uint64())
+	d.win.Root().ObjectByName("stackFrame").Set("text", fmt.Sprintf(`<b>stack ptr</b>: %v`, stackFrameAt))
+	d.win.Root().ObjectByName("stackSize").Set("text", fmt.Sprintf(`<b>stack size</b>: %d`, psize))
+	d.win.Root().ObjectByName("memSize").Set("text", fmt.Sprintf(`<b>mem size</b>: %v`, mem.Len()))
+
+out:
+	for {
+		select {
+		case <-d.N:
+			break out
+		case <-d.Q:
+			d.interrupt = true
+			d.clearBuffers()
+
+			return false
+		}
+	}
+
+	return true
+}
+
+func (d *Debugger) clearBuffers() {
+out:
+	// drain
+	for {
+		select {
+		case <-d.N:
+		case <-d.Q:
+		default:
+			break out
+		}
+	}
+}
+
+func (d *Debugger) Next() {
+	if !d.done {
+		d.N <- true
+	}
+}

cmd/mist/errors.go

@@ -0,0 +1,53 @@
+// 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
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/qml.v1"
+)
+
+func ErrorWindow(err error) {
+	engine := qml.NewEngine()
+	component, e := engine.LoadString("local", qmlErr)
+	if e != nil {
+		fmt.Println("err:", err)
+		os.Exit(1)
+	}
+
+	win := component.CreateWindow(nil)
+	win.Root().ObjectByName("label").Set("text", err.Error())
+	win.Show()
+	win.Wait()
+}
+
+const qmlErr = `
+import QtQuick 2.0; import QtQuick.Controls 1.0;
+ApplicationWindow {
+	width: 600; height: 150;
+	flags: Qt.CustomizeWindowHint | Qt.WindowTitleHint | Qt.WindowCloseButtonHint
+	title: "Error"
+	Text {
+		x: parent.width / 2 - this.width / 2;
+		y: parent.height / 2 - this.height / 2;
+		objectName: "label";
+	}
+}
+`

cmd/mist/ext_app.go

@@ -0,0 +1,143 @@
+// 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
+
+package main
+
+import (
+	"encoding/json"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/ui/qt"
+	"github.com/ethereum/go-ethereum/xeth"
+	"gopkg.in/qml.v1"
+)
+
+type AppContainer interface {
+	Create() error
+	Destroy()
+
+	Window() *qml.Window
+	Engine() *qml.Engine
+
+	NewBlock(*types.Block)
+	NewWatcher(chan bool)
+	Messages(state.Messages, string)
+	Post(string, int)
+}
+
+type ExtApplication struct {
+	*xeth.JSXEth
+	eth core.EthManager
+
+	events          event.Subscription
+	watcherQuitChan chan bool
+
+	filters map[string]*core.Filter
+
+	container AppContainer
+	lib       *UiLib
+}
+
+func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
+	return &ExtApplication{
+		JSXEth:          xeth.NewJSXEth(lib.eth),
+		eth:             lib.eth,
+		watcherQuitChan: make(chan bool),
+		filters:         make(map[string]*core.Filter),
+		container:       container,
+		lib:             lib,
+	}
+}
+
+func (app *ExtApplication) run() {
+	// Set the "eth" api on to the containers context
+	context := app.container.Engine().Context()
+	context.SetVar("eth", app)
+	context.SetVar("ui", app.lib)
+
+	err := app.container.Create()
+	if err != nil {
+		guilogger.Errorln(err)
+		return
+	}
+
+	// Subscribe to events
+	mux := app.lib.eth.EventMux()
+	app.events = mux.Subscribe(core.NewBlockEvent{}, state.Messages(nil))
+
+	// Call the main loop
+	go app.mainLoop()
+
+	app.container.NewWatcher(app.watcherQuitChan)
+
+	win := app.container.Window()
+	win.Show()
+	win.Wait()
+
+	app.stop()
+}
+
+func (app *ExtApplication) stop() {
+	app.events.Unsubscribe()
+
+	// Kill the main loop
+	app.watcherQuitChan <- true
+
+	app.container.Destroy()
+}
+
+func (app *ExtApplication) mainLoop() {
+	for ev := range app.events.Chan() {
+		switch ev := ev.(type) {
+		case core.NewBlockEvent:
+			app.container.NewBlock(ev.Block)
+
+		case state.Messages:
+			for id, filter := range app.filters {
+				msgs := filter.FilterMessages(ev)
+				if len(msgs) > 0 {
+					app.container.Messages(msgs, id)
+				}
+			}
+		}
+	}
+}
+
+func (self *ExtApplication) Watch(filterOptions map[string]interface{}, identifier string) {
+	self.filters[identifier] = qt.NewFilterFromMap(filterOptions, self.eth)
+}
+
+func (self *ExtApplication) GetMessages(object map[string]interface{}) string {
+	filter := qt.NewFilterFromMap(object, self.eth)
+
+	messages := filter.Find()
+	var msgs []javascript.JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, javascript.NewJSMessage(m))
+	}
+
+	b, err := json.Marshal(msgs)
+	if err != nil {
+		return "{\"error\":" + err.Error() + "}"
+	}
+
+	return string(b)
+}

cmd/mist/flags.go

@@ -0,0 +1,129 @@
+// 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
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/user"
+	"path"
+	"path/filepath"
+	"runtime"
+
+	"bitbucket.org/kardianos/osext"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+var (
+	Identifier      string
+	KeyRing         string
+	KeyStore        string
+	StartRpc        bool
+	StartWebSockets bool
+	RpcPort         int
+	UseUPnP         bool
+	OutboundPort    string
+	ShowGenesis     bool
+	AddPeer         string
+	MaxPeer         int
+	GenAddr         bool
+	UseSeed         bool
+	SecretFile      string
+	ExportDir       string
+	NonInteractive  bool
+	Datadir         string
+	LogFile         string
+	ConfigFile      string
+	DebugFile       string
+	LogLevel        int
+	VmType          int
+)
+
+// flags specific to gui client
+var AssetPath string
+
+//TODO: If we re-use the one defined in cmd.go the binary osx image crashes. If somebody finds out why we can dry this up.
+func defaultAssetPath() string {
+	var assetPath string
+	// If the current working directory is the go-ethereum dir
+	// assume a debug build and use the source directory as
+	// asset directory.
+	pwd, _ := os.Getwd()
+	if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist") {
+		assetPath = path.Join(pwd, "assets")
+	} else {
+		switch runtime.GOOS {
+		case "darwin":
+			// Get Binary Directory
+			exedir, _ := osext.ExecutableFolder()
+			assetPath = filepath.Join(exedir, "../Resources")
+		case "linux":
+			assetPath = "/usr/share/mist"
+		case "windows":
+			assetPath = "./assets"
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+func defaultDataDir() string {
+	usr, _ := user.Current()
+	return path.Join(usr.HomeDir, ".mist")
+}
+
+var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
+
+func Init() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	flag.IntVar(&VmType, "vm", 0, "Virtual Machine type: 0-1: standard, debug")
+	flag.StringVar(&Identifier, "id", "", "Custom client identifier")
+	flag.StringVar(&KeyRing, "keyring", "", "identifier for keyring to use")
+	flag.StringVar(&KeyStore, "keystore", "db", "system to store keyrings: db|file (db)")
+	flag.StringVar(&OutboundPort, "port", "30303", "listening port")
+	flag.BoolVar(&UseUPnP, "upnp", true, "enable UPnP support")
+	flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
+	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-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.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
+	flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
+	flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
+	flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
+	flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
+	flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
+	flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
+	flag.IntVar(&LogLevel, "loglevel", int(logger.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
+
+	flag.StringVar(&AssetPath, "asset_path", defaultAssetPath(), "absolute path to GUI assets directory")
+
+	flag.Parse()
+
+	if VmType >= int(vm.MaxVmTy) {
+		log.Fatal("Invalid VM type ", VmType)
+	}
+}

cmd/mist/gui.go

@@ -0,0 +1,533 @@
+// 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
+
+package main
+
+import "C"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"path"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/miner"
+	"github.com/ethereum/go-ethereum/wire"
+	"github.com/ethereum/go-ethereum/xeth"
+	"gopkg.in/qml.v1"
+)
+
+/*
+func LoadExtension(path string) (uintptr, error) {
+	lib, err := ffi.NewLibrary(path)
+	if err != nil {
+		return 0, err
+	}
+
+	so, err := lib.Fct("sharedObject", ffi.Pointer, nil)
+	if err != nil {
+		return 0, err
+	}
+
+	ptr := so()
+
+		err = lib.Close()
+		if err != nil {
+			return 0, err
+		}
+
+	return ptr.Interface().(uintptr), nil
+}
+*/
+/*
+	vec, errr := LoadExtension("/Users/jeffrey/Desktop/build-libqmltest-Desktop_Qt_5_2_1_clang_64bit-Debug/liblibqmltest_debug.dylib")
+	fmt.Printf("Fetched vec with addr: %#x\n", vec)
+	if errr != nil {
+		fmt.Println(errr)
+	} else {
+		context.SetVar("vec", (unsafe.Pointer)(vec))
+	}
+*/
+
+var guilogger = logger.NewLogger("GUI")
+
+type Gui struct {
+	// The main application window
+	win *qml.Window
+	// QML Engine
+	engine    *qml.Engine
+	component *qml.Common
+	qmlDone   bool
+	// The ethereum interface
+	eth *eth.Ethereum
+
+	// The public Ethereum library
+	uiLib *UiLib
+
+	txDb *ethdb.LDBDatabase
+
+	logLevel logger.LogLevel
+	open     bool
+
+	pipe *xeth.JSXEth
+
+	Session        string
+	clientIdentity *wire.SimpleClientIdentity
+	config         *ethutil.ConfigManager
+
+	plugins map[string]plugin
+
+	miner  *miner.Miner
+	stdLog logger.LogSystem
+}
+
+// Create GUI, but doesn't start it
+func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIdentity *wire.SimpleClientIdentity, session string, logLevel int) *Gui {
+	db, err := ethdb.NewLDBDatabase("tx_database")
+	if err != nil {
+		panic(err)
+	}
+
+	pipe := xeth.NewJSXEth(ethereum)
+	gui := &Gui{eth: ethereum, txDb: db, pipe: pipe, logLevel: logger.LogLevel(logLevel), Session: session, open: false, clientIdentity: clientIdentity, config: config, plugins: make(map[string]plugin)}
+	data, _ := ethutil.ReadAllFile(path.Join(ethutil.Config.ExecPath, "plugins.json"))
+	json.Unmarshal([]byte(data), &gui.plugins)
+
+	return gui
+}
+
+func (gui *Gui) Start(assetPath string) {
+	defer gui.txDb.Close()
+
+	guilogger.Infoln("Starting GUI")
+
+	// Register ethereum functions
+	qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
+		Init: func(p *xeth.JSBlock, obj qml.Object) { p.Number = 0; p.Hash = "" },
+	}, {
+		Init: func(p *xeth.JSTransaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
+	}, {
+		Init: func(p *xeth.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
+	}})
+	// Create a new QML engine
+	gui.engine = qml.NewEngine()
+	context := gui.engine.Context()
+	gui.uiLib = NewUiLib(gui.engine, gui.eth, assetPath)
+
+	// Expose the eth library and the ui library to QML
+	context.SetVar("gui", gui)
+	context.SetVar("eth", gui.uiLib)
+
+	// Load the main QML interface
+	data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
+
+	var win *qml.Window
+	var err error
+	var addlog = false
+	if len(data) == 0 {
+		win, err = gui.showKeyImport(context)
+	} else {
+		win, err = gui.showWallet(context)
+		addlog = true
+	}
+	if err != nil {
+		guilogger.Errorln("asset not found: you can set an alternative asset path on the command line using option 'asset_path'", err)
+
+		panic(err)
+	}
+
+	gui.open = true
+	win.Show()
+
+	// only add the gui guilogger after window is shown otherwise slider wont be shown
+	if addlog {
+		logger.AddLogSystem(gui)
+	}
+	win.Wait()
+
+	// need to silence gui guilogger after window closed otherwise logsystem hangs (but do not save loglevel)
+	gui.logLevel = logger.Silence
+	gui.open = false
+}
+
+func (gui *Gui) Stop() {
+	if gui.open {
+		gui.logLevel = logger.Silence
+		gui.open = false
+		gui.win.Hide()
+	}
+
+	gui.uiLib.jsEngine.Stop()
+
+	guilogger.Infoln("Stopped")
+}
+
+func (gui *Gui) showWallet(context *qml.Context) (*qml.Window, error) {
+	component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/main.qml"))
+	if err != nil {
+		return nil, err
+	}
+
+	gui.win = gui.createWindow(component)
+
+	gui.update()
+
+	return gui.win, nil
+}
+
+// The done handler will be called by QML when all views have been loaded
+func (gui *Gui) Done() {
+	gui.qmlDone = true
+}
+
+func (gui *Gui) ImportKey(filePath string) {
+}
+
+func (gui *Gui) showKeyImport(context *qml.Context) (*qml.Window, error) {
+	context.SetVar("lib", gui)
+	component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/first_run.qml"))
+	if err != nil {
+		return nil, err
+	}
+	return gui.createWindow(component), nil
+}
+
+func (gui *Gui) createWindow(comp qml.Object) *qml.Window {
+	win := comp.CreateWindow(nil)
+
+	gui.win = win
+	gui.uiLib.win = win
+
+	return gui.win
+}
+
+func (gui *Gui) ImportAndSetPrivKey(secret string) bool {
+	err := gui.eth.KeyManager().InitFromString(gui.Session, 0, secret)
+	if err != nil {
+		guilogger.Errorln("unable to import: ", err)
+		return false
+	}
+	guilogger.Errorln("successfully imported: ", err)
+	return true
+}
+
+func (gui *Gui) CreateAndSetPrivKey() (string, string, string, string) {
+	err := gui.eth.KeyManager().Init(gui.Session, 0, true)
+	if err != nil {
+		guilogger.Errorln("unable to create key: ", err)
+		return "", "", "", ""
+	}
+	return gui.eth.KeyManager().KeyPair().AsStrings()
+}
+
+func (gui *Gui) setInitialChain(ancientBlocks bool) {
+	sBlk := gui.eth.ChainManager().LastBlockHash()
+	blk := gui.eth.ChainManager().GetBlock(sBlk)
+	for ; blk != nil; blk = gui.eth.ChainManager().GetBlock(sBlk) {
+		sBlk = blk.PrevHash
+
+		gui.processBlock(blk, true)
+	}
+}
+
+func (gui *Gui) loadAddressBook() {
+	view := gui.getObjectByName("infoView")
+	nameReg := gui.pipe.World().Config().Get("NameReg")
+	if nameReg != nil {
+		nameReg.EachStorage(func(name string, value *ethutil.Value) {
+			if name[0] != 0 {
+				value.Decode()
+
+				view.Call("addAddress", struct{ Name, Address string }{name, ethutil.Bytes2Hex(value.Bytes())})
+			}
+		})
+	}
+}
+
+func (self *Gui) loadMergedMiningOptions() {
+	view := self.getObjectByName("mergedMiningModel")
+
+	nameReg := self.pipe.World().Config().Get("MergeMining")
+	if nameReg != nil {
+		i := 0
+		nameReg.EachStorage(func(name string, value *ethutil.Value) {
+			if name[0] != 0 {
+				value.Decode()
+
+				view.Call("addMergedMiningOption", struct {
+					Checked       bool
+					Name, Address string
+					Id, ItemId    int
+				}{false, name, ethutil.Bytes2Hex(value.Bytes()), 0, i})
+
+				i++
+			}
+		})
+	}
+}
+
+func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
+	pipe := xeth.New(gui.eth)
+	nameReg := pipe.World().Config().Get("NameReg")
+	addr := gui.address()
+
+	var inout string
+	if bytes.Compare(tx.Sender(), addr) == 0 {
+		inout = "send"
+	} else {
+		inout = "recv"
+	}
+
+	var (
+		ptx  = xeth.NewJSTx(tx, pipe.World().State())
+		send = nameReg.Storage(tx.From())
+		rec  = nameReg.Storage(tx.To())
+		s, r string
+	)
+
+	if core.MessageCreatesContract(tx) {
+		rec = nameReg.Storage(core.AddressFromMessage(tx))
+	}
+
+	if send.Len() != 0 {
+		s = strings.Trim(send.Str(), "\x00")
+	} else {
+		s = ethutil.Bytes2Hex(tx.Sender())
+	}
+	if rec.Len() != 0 {
+		r = strings.Trim(rec.Str(), "\x00")
+	} else {
+		if core.MessageCreatesContract(tx) {
+			r = ethutil.Bytes2Hex(core.AddressFromMessage(tx))
+		} else {
+			r = ethutil.Bytes2Hex(tx.To())
+		}
+	}
+	ptx.Sender = s
+	ptx.Address = r
+
+	if window == "post" {
+		//gui.getObjectByName("transactionView").Call("addTx", ptx, inout)
+	} else {
+		gui.getObjectByName("pendingTxView").Call("addTx", ptx, inout)
+	}
+}
+
+func (gui *Gui) readPreviousTransactions() {
+	it := gui.txDb.NewIterator()
+	for it.Next() {
+		tx := types.NewTransactionFromBytes(it.Value())
+
+		gui.insertTransaction("post", tx)
+
+	}
+	it.Release()
+}
+
+func (gui *Gui) processBlock(block *types.Block, initial bool) {
+	name := strings.Trim(gui.pipe.World().Config().Get("NameReg").Storage(block.Coinbase).Str(), "\x00")
+	b := xeth.NewJSBlock(block)
+	b.Name = name
+
+	gui.getObjectByName("chainView").Call("addBlock", b, initial)
+}
+
+func (gui *Gui) setWalletValue(amount, unconfirmedFunds *big.Int) {
+	var str string
+	if unconfirmedFunds != nil {
+		pos := "+"
+		if unconfirmedFunds.Cmp(big.NewInt(0)) < 0 {
+			pos = "-"
+		}
+		val := ethutil.CurrencyToString(new(big.Int).Abs(ethutil.BigCopy(unconfirmedFunds)))
+		str = fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(amount), pos, val)
+	} else {
+		str = fmt.Sprintf("%v", ethutil.CurrencyToString(amount))
+	}
+
+	gui.win.Root().Call("setWalletValue", str)
+}
+
+func (self *Gui) getObjectByName(objectName string) qml.Object {
+	return self.win.Root().ObjectByName(objectName)
+}
+
+// Simple go routine function that updates the list of peers in the GUI
+func (gui *Gui) update() {
+	// We have to wait for qml to be done loading all the windows.
+	for !gui.qmlDone {
+		time.Sleep(300 * time.Millisecond)
+	}
+
+	go func() {
+		go gui.setInitialChain(false)
+		gui.loadAddressBook()
+		gui.loadMergedMiningOptions()
+		gui.setPeerInfo()
+	}()
+
+	for _, plugin := range gui.plugins {
+		guilogger.Infoln("Loading plugin ", plugin.Name)
+
+		gui.win.Root().Call("addPlugin", plugin.Path, "")
+	}
+
+	peerUpdateTicker := time.NewTicker(5 * time.Second)
+	generalUpdateTicker := time.NewTicker(500 * time.Millisecond)
+	statsUpdateTicker := time.NewTicker(5 * time.Second)
+
+	state := gui.eth.ChainManager().TransState()
+
+	gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.address()).Balance())))
+
+	lastBlockLabel := gui.getObjectByName("lastBlockLabel")
+	miningLabel := gui.getObjectByName("miningLabel")
+
+	events := gui.eth.EventMux().Subscribe(
+		eth.ChainSyncEvent{},
+		eth.PeerListEvent{},
+		core.NewBlockEvent{},
+		core.TxPreEvent{},
+		core.TxPostEvent{},
+	)
+
+	go func() {
+		defer events.Unsubscribe()
+		for {
+			select {
+			case ev, isopen := <-events.Chan():
+				if !isopen {
+					return
+				}
+				switch ev := ev.(type) {
+				case core.NewBlockEvent:
+					gui.processBlock(ev.Block, false)
+					if bytes.Compare(ev.Block.Coinbase, gui.address()) == 0 {
+						gui.setWalletValue(gui.eth.ChainManager().State().GetBalance(gui.address()), nil)
+					}
+
+				case core.TxPreEvent:
+					tx := ev.Tx
+
+					tstate := gui.eth.ChainManager().TransState()
+					cstate := gui.eth.ChainManager().State()
+
+					taccount := tstate.GetAccount(gui.address())
+					caccount := cstate.GetAccount(gui.address())
+					unconfirmedFunds := new(big.Int).Sub(taccount.Balance(), caccount.Balance())
+
+					gui.setWalletValue(taccount.Balance(), unconfirmedFunds)
+					gui.insertTransaction("pre", tx)
+
+				case core.TxPostEvent:
+					tx := ev.Tx
+					object := state.GetAccount(gui.address())
+
+					if bytes.Compare(tx.Sender(), gui.address()) == 0 {
+						object.SubAmount(tx.Value())
+
+						gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+					} else if bytes.Compare(tx.To(), gui.address()) == 0 {
+						object.AddAmount(tx.Value())
+
+						gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+					}
+
+					gui.setWalletValue(object.Balance(), nil)
+					state.UpdateStateObject(object)
+
+				case eth.PeerListEvent:
+					gui.setPeerInfo()
+				}
+
+			case <-peerUpdateTicker.C:
+				gui.setPeerInfo()
+			case <-generalUpdateTicker.C:
+				statusText := "#" + gui.eth.ChainManager().CurrentBlock().Number.String()
+				lastBlockLabel.Set("text", statusText)
+				miningLabel.Set("text", "Mining @ "+strconv.FormatInt(gui.uiLib.miner.GetPow().GetHashrate(), 10)+"Khash")
+
+				blockLength := gui.eth.BlockPool().BlocksProcessed
+				chainLength := gui.eth.BlockPool().ChainLength
+
+				var (
+					pct      float64 = 1.0 / float64(chainLength) * float64(blockLength)
+					dlWidget         = gui.win.Root().ObjectByName("downloadIndicator")
+					dlLabel          = gui.win.Root().ObjectByName("downloadLabel")
+				)
+				dlWidget.Set("value", pct)
+				dlLabel.Set("text", fmt.Sprintf("%d / %d", blockLength, chainLength))
+
+			case <-statsUpdateTicker.C:
+				gui.setStatsPane()
+			}
+		}
+	}()
+}
+
+func (gui *Gui) setStatsPane() {
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+
+	statsPane := gui.getObjectByName("statsPane")
+	statsPane.Set("text", fmt.Sprintf(`###### Mist %s (%s) #######
+
+eth %d (p2p = %d)
+
+CPU:        # %d
+Goroutines: # %d
+CGoCalls:   # %d
+
+Alloc:      %d
+Heap Alloc: %d
+
+CGNext:     %x
+NumGC:      %d
+`, Version, runtime.Version(),
+		eth.ProtocolVersion, eth.P2PVersion,
+		runtime.NumCPU, runtime.NumGoroutine(), runtime.NumCgoCall(),
+		memStats.Alloc, memStats.HeapAlloc,
+		memStats.NextGC, memStats.NumGC,
+	))
+}
+
+func (gui *Gui) setPeerInfo() {
+	gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers))
+	gui.win.Root().Call("resetPeers")
+	for _, peer := range gui.pipe.Peers() {
+		gui.win.Root().Call("addPeer", peer)
+	}
+}
+
+func (gui *Gui) privateKey() string {
+	return ethutil.Bytes2Hex(gui.eth.KeyManager().PrivateKey())
+}
+
+func (gui *Gui) address() []byte {
+	return gui.eth.KeyManager().Address()
+}

cmd/mist/html_container.go

@@ -0,0 +1,164 @@
+// 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
+
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/xeth"
+	"github.com/howeyc/fsnotify"
+	"gopkg.in/qml.v1"
+)
+
+type HtmlApplication struct {
+	win     *qml.Window
+	webView qml.Object
+	engine  *qml.Engine
+	lib     *UiLib
+	path    string
+	watcher *fsnotify.Watcher
+}
+
+func NewHtmlApplication(path string, lib *UiLib) *HtmlApplication {
+	engine := qml.NewEngine()
+
+	return &HtmlApplication{engine: engine, lib: lib, path: path}
+
+}
+
+func (app *HtmlApplication) Create() error {
+	component, err := app.engine.LoadFile(app.lib.AssetPath("qml/webapp.qml"))
+	if err != nil {
+		return err
+	}
+
+	if filepath.Ext(app.path) == "eth" {
+		return errors.New("Ethereum package not yet supported")
+
+		// TODO
+		//ethutil.OpenPackage(app.path)
+	}
+
+	win := component.CreateWindow(nil)
+	win.Set("url", app.path)
+	webView := win.ObjectByName("webView")
+
+	app.win = win
+	app.webView = webView
+
+	return nil
+}
+
+func (app *HtmlApplication) RootFolder() string {
+	folder, err := url.Parse(app.path)
+	if err != nil {
+		return ""
+	}
+	return path.Dir(ethutil.WindonizePath(folder.RequestURI()))
+}
+func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
+	files, _ := ioutil.ReadDir(app.RootFolder())
+	var folders []os.FileInfo
+	for _, file := range files {
+		if file.IsDir() {
+			folders = append(folders, file)
+		}
+	}
+	return folders
+}
+
+func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
+	var err error
+
+	app.watcher, err = fsnotify.NewWatcher()
+	if err != nil {
+		guilogger.Infoln("Could not create new auto-reload watcher:", err)
+		return
+	}
+	err = app.watcher.Watch(app.RootFolder())
+	if err != nil {
+		guilogger.Infoln("Could not start auto-reload watcher:", err)
+		return
+	}
+	for _, folder := range app.RecursiveFolders() {
+		fullPath := app.RootFolder() + "/" + folder.Name()
+		app.watcher.Watch(fullPath)
+	}
+
+	go func() {
+	out:
+		for {
+			select {
+			case <-quitChan:
+				app.watcher.Close()
+				break out
+			case <-app.watcher.Event:
+				//guilogger.Debugln("Got event:", ev)
+				app.webView.Call("reload")
+			case err := <-app.watcher.Error:
+				// TODO: Do something here
+				guilogger.Infoln("Watcher error:", err)
+			}
+		}
+	}()
+
+}
+
+func (app *HtmlApplication) Engine() *qml.Engine {
+	return app.engine
+}
+
+func (app *HtmlApplication) Window() *qml.Window {
+	return app.win
+}
+
+func (app *HtmlApplication) NewBlock(block *types.Block) {
+	b := &xeth.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
+	app.webView.Call("onNewBlockCb", b)
+}
+
+func (self *HtmlApplication) Messages(messages state.Messages, id string) {
+	var msgs []javascript.JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, javascript.NewJSMessage(m))
+	}
+
+	b, _ := json.Marshal(msgs)
+
+	self.webView.Call("onWatchedCb", string(b), id)
+}
+
+func (app *HtmlApplication) Destroy() {
+	app.engine.Destroy()
+}
+
+func (app *HtmlApplication) Post(data string, seed int) {
+	fmt.Println("about to call 'post'")
+	app.webView.Call("post", seed, data)
+}

cmd/mist/main.go

@@ -0,0 +1,115 @@
+// 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
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/logger"
+	"gopkg.in/qml.v1"
+)
+
+const (
+	ClientIdentifier = "Mist"
+	Version          = "0.7.10"
+)
+
+var ethereum *eth.Ethereum
+
+func run() error {
+	// precedence: code-internal flag default < config file < environment variables < command line
+	Init() // parsing command line
+
+	tstart := time.Now()
+	config := utils.InitConfig(VmType, ConfigFile, Datadir, "ETH")
+
+	utils.InitDataDir(Datadir)
+
+	stdLog := utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	db := utils.NewDatabase()
+	err := utils.DBSanityCheck(db)
+	if err != nil {
+		ErrorWindow(err)
+
+		os.Exit(1)
+	}
+	keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
+
+	// create, import, export keys
+	utils.KeyTasks(keyManager, KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
+	clientIdentity := utils.NewClientIdentity(ClientIdentifier, Version, Identifier)
+	ethereum = utils.NewEthereum(db, clientIdentity, keyManager, UseUPnP, OutboundPort, MaxPeer)
+
+	if ShowGenesis {
+		utils.ShowGenesis(ethereum)
+	}
+
+	if StartRpc {
+		utils.StartRpc(ethereum, RpcPort)
+	}
+
+	gui := NewWindow(ethereum, config, clientIdentity, KeyRing, LogLevel)
+	gui.stdLog = stdLog
+
+	utils.RegisterInterrupt(func(os.Signal) {
+		gui.Stop()
+	})
+	go utils.StartEthereum(ethereum, UseSeed)
+
+	fmt.Println("ETH stack took", time.Since(tstart))
+
+	// gui blocks the main thread
+	gui.Start(AssetPath)
+
+	return nil
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	// This is a bit of a cheat, but ey!
+	os.Setenv("QTWEBKIT_INSPECTOR_SERVER", "127.0.0.1:99999")
+
+	qml.Run(run)
+
+	var interrupted = false
+	utils.RegisterInterrupt(func(os.Signal) {
+		interrupted = true
+	})
+
+	utils.HandleInterrupt()
+
+	if StartWebSockets {
+		utils.StartWebSockets(ethereum)
+	}
+
+	// we need to run the interrupt callbacks in case gui is closed
+	// this skips if we got here by actual interrupt stopping the GUI
+	if !interrupted {
+		utils.RunInterruptCallbacks(os.Interrupt)
+	}
+	// this blocks the thread
+	ethereum.WaitForShutdown()
+	logger.Flush()
+}

cmd/mist/qml_container.go

@@ -0,0 +1,85 @@
+// 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
+
+package main
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/xeth"
+	"gopkg.in/qml.v1"
+)
+
+type QmlApplication struct {
+	win    *qml.Window
+	engine *qml.Engine
+	lib    *UiLib
+	path   string
+}
+
+func NewQmlApplication(path string, lib *UiLib) *QmlApplication {
+	engine := qml.NewEngine()
+	return &QmlApplication{engine: engine, path: path, lib: lib}
+}
+
+func (app *QmlApplication) Create() error {
+	path := string(app.path)
+
+	// For some reason for windows we get /c:/path/to/something, windows doesn't like the first slash but is fine with the others so we are removing it
+	if app.path[0] == '/' && runtime.GOOS == "windows" {
+		path = app.path[1:]
+	}
+
+	component, err := app.engine.LoadFile(path)
+	if err != nil {
+		guilogger.Warnln(err)
+	}
+	app.win = component.CreateWindow(nil)
+
+	return nil
+}
+
+func (app *QmlApplication) Destroy() {
+	app.engine.Destroy()
+}
+
+func (app *QmlApplication) NewWatcher(quitChan chan bool) {
+}
+
+// Events
+func (app *QmlApplication) NewBlock(block *types.Block) {
+	pblock := &xeth.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
+	app.win.Call("onNewBlockCb", pblock)
+}
+
+func (self *QmlApplication) Messages(msgs state.Messages, id string) {
+	fmt.Println("IMPLEMENT QML APPLICATION MESSAGES METHOD")
+}
+
+// Getters
+func (app *QmlApplication) Engine() *qml.Engine {
+	return app.engine
+}
+func (app *QmlApplication) Window() *qml.Window {
+	return app.win
+}
+
+func (app *QmlApplication) Post(data string, s int) {}

cmd/mist/ui_lib.go

@@ -0,0 +1,374 @@
+// 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
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/miner"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/ui/qt"
+	"github.com/ethereum/go-ethereum/xeth"
+	"gopkg.in/qml.v1"
+)
+
+type memAddr struct {
+	Num   string
+	Value string
+}
+
+// UI Library that has some basic functionality exposed
+type UiLib struct {
+	*xeth.JSXEth
+	engine    *qml.Engine
+	eth       *eth.Ethereum
+	connected bool
+	assetPath string
+	// The main application window
+	win      *qml.Window
+	Db       *Debugger
+	DbWindow *DebuggerWindow
+
+	jsEngine *javascript.JSRE
+
+	filterCallbacks map[int][]int
+
+	miner *miner.Miner
+}
+
+func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
+	lib := &UiLib{JSXEth: xeth.NewJSXEth(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int)} //, filters: make(map[int]*xeth.JSFilter)}
+	lib.miner = miner.New(eth.KeyManager().Address(), eth)
+
+	return lib
+}
+
+func (self *UiLib) Notef(args []interface{}) {
+	guilogger.Infoln(args...)
+}
+
+func (self *UiLib) LookupDomain(domain string) string {
+	world := self.World()
+
+	if len(domain) > 32 {
+		domain = string(crypto.Sha3([]byte(domain)))
+	}
+	data := world.Config().Get("DnsReg").StorageString(domain).Bytes()
+
+	// Left padded = A record, Right padded = CNAME
+	if len(data) > 0 && data[0] == 0 {
+		data = bytes.TrimLeft(data, "\x00")
+		var ipSlice []string
+		for _, d := range data {
+			ipSlice = append(ipSlice, strconv.Itoa(int(d)))
+		}
+
+		return strings.Join(ipSlice, ".")
+	} else {
+		data = bytes.TrimRight(data, "\x00")
+
+		return string(data)
+	}
+}
+
+func (self *UiLib) LookupName(addr string) string {
+	var (
+		nameReg = self.World().Config().Get("NameReg")
+		lookup  = nameReg.Storage(ethutil.Hex2Bytes(addr))
+	)
+
+	if lookup.Len() != 0 {
+		return strings.Trim(lookup.Str(), "\x00")
+	}
+
+	return addr
+}
+
+func (self *UiLib) LookupAddress(name string) string {
+	var (
+		nameReg = self.World().Config().Get("NameReg")
+		lookup  = nameReg.Storage(ethutil.RightPadBytes([]byte(name), 32))
+	)
+
+	if lookup.Len() != 0 {
+		return ethutil.Bytes2Hex(lookup.Bytes())
+	}
+
+	return ""
+}
+
+func (self *UiLib) PastPeers() *ethutil.List {
+	return ethutil.NewList(eth.PastPeers())
+}
+
+func (self *UiLib) ImportTx(rlpTx string) {
+	tx := types.NewTransactionFromBytes(ethutil.Hex2Bytes(rlpTx))
+	err := self.eth.TxPool().Add(tx)
+	if err != nil {
+		guilogger.Infoln("import tx failed ", err)
+	}
+}
+
+func (self *UiLib) EvalJavascriptFile(path string) {
+	self.jsEngine.LoadExtFile(path[7:])
+}
+
+func (self *UiLib) EvalJavascriptString(str string) string {
+	value, err := self.jsEngine.Run(str)
+	if err != nil {
+		return err.Error()
+	}
+
+	return fmt.Sprintf("%v", value)
+}
+
+func (ui *UiLib) OpenQml(path string) {
+	container := NewQmlApplication(path[7:], ui)
+	app := NewExtApplication(container, ui)
+
+	go app.run()
+}
+
+func (ui *UiLib) OpenHtml(path string) {
+	container := NewHtmlApplication(path, ui)
+	app := NewExtApplication(container, ui)
+
+	go app.run()
+}
+
+func (ui *UiLib) OpenBrowser() {
+	ui.OpenHtml("file://" + ui.AssetPath("ext/home.html"))
+}
+
+func (ui *UiLib) Muted(content string) {
+	component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
+	if err != nil {
+		guilogger.Debugln(err)
+
+		return
+	}
+	win := component.CreateWindow(nil)
+	go func() {
+		path := "file://" + ui.AssetPath("muted/index.html")
+		win.Set("url", path)
+
+		win.Show()
+		win.Wait()
+	}()
+}
+
+func (ui *UiLib) Connect(button qml.Object) {
+	if !ui.connected {
+		ui.eth.Start(true)
+		ui.connected = true
+		button.Set("enabled", false)
+	}
+}
+
+func (ui *UiLib) ConnectToPeer(addr string) {
+	ui.eth.ConnectToPeer(addr)
+}
+
+func (ui *UiLib) AssetPath(p string) string {
+	return path.Join(ui.assetPath, p)
+}
+
+func (self *UiLib) StartDbWithContractAndData(contractHash, data string) {
+	dbWindow := NewDebuggerWindow(self)
+	object := self.eth.ChainManager().State().GetStateObject(ethutil.Hex2Bytes(contractHash))
+	if len(object.Code) > 0 {
+		dbWindow.SetCode("0x" + ethutil.Bytes2Hex(object.Code))
+	}
+	dbWindow.SetData("0x" + data)
+
+	dbWindow.Show()
+}
+
+func (self *UiLib) StartDbWithCode(code string) {
+	dbWindow := NewDebuggerWindow(self)
+	dbWindow.SetCode("0x" + code)
+	dbWindow.Show()
+}
+
+func (self *UiLib) StartDebugger() {
+	dbWindow := NewDebuggerWindow(self)
+
+	dbWindow.Show()
+}
+
+func (self *UiLib) NewFilter(object map[string]interface{}) (id int) {
+	filter := qt.NewFilterFromMap(object, self.eth)
+	filter.MessageCallback = func(messages state.Messages) {
+		self.win.Root().Call("invokeFilterCallback", xeth.ToJSMessages(messages), id)
+	}
+	id = self.eth.InstallFilter(filter)
+	return id
+}
+
+func (self *UiLib) NewFilterString(typ string) (id int) {
+	filter := core.NewFilter(self.eth)
+	filter.BlockCallback = func(block *types.Block) {
+		if self.win != nil && self.win.Root() != nil {
+			self.win.Root().Call("invokeFilterCallback", "{}", id)
+		} else {
+			fmt.Println("QML is lagging")
+		}
+	}
+	id = self.eth.InstallFilter(filter)
+	return id
+}
+
+func (self *UiLib) Messages(id int) *ethutil.List {
+	filter := self.eth.GetFilter(id)
+	if filter != nil {
+		messages := xeth.ToJSMessages(filter.Find())
+
+		return messages
+	}
+
+	return ethutil.EmptyList()
+}
+
+func (self *UiLib) UninstallFilter(id int) {
+	self.eth.UninstallFilter(id)
+}
+
+func mapToTxParams(object map[string]interface{}) map[string]string {
+	// Default values
+	if object["from"] == nil {
+		object["from"] = ""
+	}
+	if object["to"] == nil {
+		object["to"] = ""
+	}
+	if object["value"] == nil {
+		object["value"] = ""
+	}
+	if object["gas"] == nil {
+		object["gas"] = ""
+	}
+	if object["gasPrice"] == nil {
+		object["gasPrice"] = ""
+	}
+
+	var dataStr string
+	var data []string
+	if list, ok := object["data"].(*qml.List); ok {
+		list.Convert(&data)
+	} else if str, ok := object["data"].(string); ok {
+		data = []string{str}
+	}
+
+	for _, str := range data {
+		if ethutil.IsHex(str) {
+			str = str[2:]
+
+			if len(str) != 64 {
+				str = ethutil.LeftPadString(str, 64)
+			}
+		} else {
+			str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
+		}
+
+		dataStr += str
+	}
+	object["data"] = dataStr
+
+	conv := make(map[string]string)
+	for key, value := range object {
+		if v, ok := value.(string); ok {
+			conv[key] = v
+		}
+	}
+
+	return conv
+}
+
+func (self *UiLib) Transact(params map[string]interface{}) (string, error) {
+	object := mapToTxParams(params)
+
+	return self.JSXEth.Transact(
+		object["from"],
+		object["to"],
+		object["value"],
+		object["gas"],
+		object["gasPrice"],
+		object["data"],
+	)
+}
+
+func (self *UiLib) Compile(code string) (string, error) {
+	bcode, err := ethutil.Compile(code, false)
+	if err != nil {
+		return err.Error(), err
+	}
+
+	return ethutil.Bytes2Hex(bcode), err
+}
+
+func (self *UiLib) Call(params map[string]interface{}) (string, error) {
+	object := mapToTxParams(params)
+
+	return self.JSXEth.Execute(
+		object["to"],
+		object["value"],
+		object["gas"],
+		object["gasPrice"],
+		object["data"],
+	)
+}
+
+func (self *UiLib) AddLocalTransaction(to, data, gas, gasPrice, value string) int {
+	return self.miner.AddLocalTx(&miner.LocalTx{
+		To:       ethutil.Hex2Bytes(to),
+		Data:     ethutil.Hex2Bytes(data),
+		Gas:      gas,
+		GasPrice: gasPrice,
+		Value:    value,
+	}) - 1
+}
+
+func (self *UiLib) RemoveLocalTransaction(id int) {
+	self.miner.RemoveLocalTx(id)
+}
+
+func (self *UiLib) SetGasPrice(price string) {
+	self.miner.MinAcceptedGasPrice = ethutil.Big(price)
+}
+
+func (self *UiLib) ToggleMining() bool {
+	if !self.miner.Mining() {
+		self.miner.Start()
+
+		return true
+	} else {
+		self.miner.Stop()
+
+		return false
+	}
+}

cmd/peerserver/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"crypto/elliptic"
+	"fmt"
+	"log"
+	"net"
+	"os"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/p2p"
+)
+
+func main() {
+	logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
+	key, _ := crypto.GenerateKey()
+	marshaled := elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y)
+
+	srv := p2p.Server{
+		MaxPeers:   10,
+		Identity:   p2p.NewSimpleClientIdentity("Ethereum(G)", "0.1", "Peer Server Two", string(marshaled)),
+		ListenAddr: ":30301",
+		NAT:        p2p.UPNP(),
+	}
+	if err := srv.Start(); err != nil {
+		fmt.Println("could not start server:", err)
+		os.Exit(1)
+	}
+
+	// add seed peers
+	seed, err := net.ResolveTCPAddr("tcp", "poc-7.ethdev.com:30300")
+	if err != nil {
+		fmt.Println("couldn't resolve:", err)
+		os.Exit(1)
+	}
+	srv.SuggestPeer(seed.IP, seed.Port, nil)
+
+	select {}
+}

cmd/utils/cmd.go

@@ -0,0 +1,327 @@
+package utils
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"time"
+
+	"bitbucket.org/kardianos/osext"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/miner"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/wire"
+	"github.com/ethereum/go-ethereum/xeth"
+)
+
+var clilogger = logger.NewLogger("CLI")
+var interruptCallbacks = []func(os.Signal){}
+
+// Register interrupt handlers callbacks
+func RegisterInterrupt(cb func(os.Signal)) {
+	interruptCallbacks = append(interruptCallbacks, cb)
+}
+
+// go routine that call interrupt handlers in order of registering
+func HandleInterrupt() {
+	c := make(chan os.Signal, 1)
+	go func() {
+		signal.Notify(c, os.Interrupt)
+		for sig := range c {
+			clilogger.Errorf("Shutting down (%v) ... \n", sig)
+			RunInterruptCallbacks(sig)
+		}
+	}()
+}
+
+func RunInterruptCallbacks(sig os.Signal) {
+	for _, cb := range interruptCallbacks {
+		cb(sig)
+	}
+}
+
+func AbsolutePath(Datadir string, filename string) string {
+	if path.IsAbs(filename) {
+		return filename
+	}
+	return path.Join(Datadir, filename)
+}
+
+func openLogFile(Datadir string, filename string) *os.File {
+	path := AbsolutePath(Datadir, filename)
+	file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+	if err != nil {
+		panic(fmt.Sprintf("error opening log file '%s': %v", filename, err))
+	}
+	return file
+}
+
+func confirm(message string) bool {
+	fmt.Println(message, "Are you sure? (y/n)")
+	var r string
+	fmt.Scanln(&r)
+	for ; ; fmt.Scanln(&r) {
+		if r == "n" || r == "y" {
+			break
+		} else {
+			fmt.Printf("Yes or no?", r)
+		}
+	}
+	return r == "y"
+}
+
+func DBSanityCheck(db ethutil.Database) error {
+	d, _ := db.Get([]byte("ProtocolVersion"))
+	protov := ethutil.NewValue(d).Uint()
+	if protov != eth.ProtocolVersion && protov != 0 {
+		return fmt.Errorf("Database version mismatch. Protocol(%d / %d). `rm -rf %s`", protov, eth.ProtocolVersion, ethutil.Config.ExecPath+"/database")
+	}
+
+	return nil
+}
+
+func InitDataDir(Datadir string) {
+	_, err := os.Stat(Datadir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
+			os.Mkdir(Datadir, 0777)
+		}
+	}
+}
+
+func InitLogging(Datadir string, LogFile string, LogLevel int, DebugFile string) logger.LogSystem {
+	var writer io.Writer
+	if LogFile == "" {
+		writer = os.Stdout
+	} else {
+		writer = openLogFile(Datadir, LogFile)
+	}
+
+	sys := logger.NewStdLogSystem(writer, log.LstdFlags, logger.LogLevel(LogLevel))
+	logger.AddLogSystem(sys)
+	if DebugFile != "" {
+		writer = openLogFile(Datadir, DebugFile)
+		logger.AddLogSystem(logger.NewStdLogSystem(writer, log.LstdFlags, logger.DebugLevel))
+	}
+
+	return sys
+}
+
+func InitConfig(vmType int, ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
+	InitDataDir(Datadir)
+	cfg := ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
+	cfg.VmType = vmType
+
+	return cfg
+}
+
+func exit(err error) {
+	status := 0
+	if err != nil {
+		clilogger.Errorln("Fatal: ", err)
+		status = 1
+	}
+	logger.Flush()
+	os.Exit(status)
+}
+
+func NewDatabase() ethutil.Database {
+	db, err := ethdb.NewLDBDatabase("database")
+	if err != nil {
+		exit(err)
+	}
+	return db
+}
+
+func NewClientIdentity(clientIdentifier, version, customIdentifier string) *wire.SimpleClientIdentity {
+	return wire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
+}
+
+func NewEthereum(db ethutil.Database, clientIdentity wire.ClientIdentity, keyManager *crypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
+	ethereum, err := eth.New(db, clientIdentity, keyManager, eth.CapDefault, usePnp)
+	if err != nil {
+		clilogger.Fatalln("eth start err:", err)
+	}
+	ethereum.Port = OutboundPort
+	ethereum.MaxPeers = MaxPeer
+	return ethereum
+}
+
+func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
+	clilogger.Infof("Starting %s", ethereum.ClientIdentity())
+	ethereum.Start(UseSeed)
+	RegisterInterrupt(func(sig os.Signal) {
+		ethereum.Stop()
+		logger.Flush()
+	})
+}
+
+func ShowGenesis(ethereum *eth.Ethereum) {
+	clilogger.Infoln(ethereum.ChainManager().Genesis())
+	exit(nil)
+}
+
+func NewKeyManager(KeyStore string, Datadir string, db ethutil.Database) *crypto.KeyManager {
+	var keyManager *crypto.KeyManager
+	switch {
+	case KeyStore == "db":
+		keyManager = crypto.NewDBKeyManager(db)
+	case KeyStore == "file":
+		keyManager = crypto.NewFileKeyManager(Datadir)
+	default:
+		exit(fmt.Errorf("unknown keystore type: %s", KeyStore))
+	}
+	return keyManager
+}
+
+func DefaultAssetPath() string {
+	var assetPath string
+	// If the current working directory is the go-ethereum dir
+	// assume a debug build and use the source directory as
+	// asset directory.
+	pwd, _ := os.Getwd()
+	if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist") {
+		assetPath = path.Join(pwd, "assets")
+	} else {
+		switch runtime.GOOS {
+		case "darwin":
+			// Get Binary Directory
+			exedir, _ := osext.ExecutableFolder()
+			assetPath = filepath.Join(exedir, "../Resources")
+		case "linux":
+			assetPath = "/usr/share/mist"
+		case "windows":
+			assetPath = "./assets"
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+
+func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
+
+	var err error
+	switch {
+	case GenAddr:
+		if NonInteractive || confirm("This action overwrites your old private key.") {
+			err = keyManager.Init(KeyRing, 0, true)
+		}
+		exit(err)
+	case len(SecretFile) > 0:
+		SecretFile = ethutil.ExpandHomePath(SecretFile)
+
+		if NonInteractive || confirm("This action overwrites your old private key.") {
+			err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
+		}
+		exit(err)
+	case len(ExportDir) > 0:
+		err = keyManager.Init(KeyRing, 0, false)
+		if err == nil {
+			err = keyManager.Export(ExportDir)
+		}
+		exit(err)
+	default:
+		// Creates a keypair if none exists
+		err = keyManager.Init(KeyRing, 0, false)
+		if err != nil {
+			exit(err)
+		}
+	}
+	clilogger.Infof("Main address %x\n", keyManager.Address())
+}
+
+func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
+	var err error
+	ethereum.RpcServer, err = rpc.NewJsonRpcServer(xeth.NewJSXEth(ethereum), RpcPort)
+	if err != nil {
+		clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
+	} else {
+		go ethereum.RpcServer.Start()
+	}
+}
+
+var gminer *miner.Miner
+
+func GetMiner() *miner.Miner {
+	return gminer
+}
+
+func StartMining(ethereum *eth.Ethereum) bool {
+	if !ethereum.Mining {
+		ethereum.Mining = true
+		addr := ethereum.KeyManager().Address()
+
+		go func() {
+			clilogger.Infoln("Start mining")
+			if gminer == nil {
+				gminer = miner.New(addr, ethereum)
+			}
+			// Give it some time to connect with peers
+			time.Sleep(3 * time.Second)
+			for !ethereum.IsUpToDate() {
+				time.Sleep(5 * time.Second)
+			}
+			gminer.Start()
+		}()
+		RegisterInterrupt(func(os.Signal) {
+			StopMining(ethereum)
+		})
+		return true
+	}
+	return false
+}
+
+func FormatTransactionData(data string) []byte {
+	d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) {
+		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
+		for _, dataItem := range slice {
+			d := ethutil.FormatData(dataItem)
+			ret = append(ret, d...)
+		}
+		return
+	})
+
+	return d
+}
+
+func StopMining(ethereum *eth.Ethereum) bool {
+	if ethereum.Mining && gminer != nil {
+		gminer.Stop()
+		clilogger.Infoln("Stopped mining")
+		ethereum.Mining = false
+
+		return true
+	}
+
+	return false
+}
+
+// Replay block
+func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
+	block := ethereum.ChainManager().GetBlock(hash)
+	if block == nil {
+		return fmt.Errorf("unknown block %x", hash)
+	}
+
+	parent := ethereum.ChainManager().GetBlock(block.PrevHash)
+
+	_, err := ethereum.BlockManager().TransitionState(parent.State(), parent, block)
+	if err != nil {
+		return err
+	}
+
+	return nil
+
+}

cmd/utils/vm_env.go

@@ -0,0 +1,70 @@
+package utils
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+type VMEnv struct {
+	state *state.StateDB
+	block *types.Block
+
+	transactor []byte
+	value      *big.Int
+
+	depth int
+	Gas   *big.Int
+}
+
+func NewEnv(state *state.StateDB, block *types.Block, transactor []byte, value *big.Int) *VMEnv {
+	return &VMEnv{
+		state:      state,
+		block:      block,
+		transactor: transactor,
+		value:      value,
+	}
+}
+
+func (self *VMEnv) Origin() []byte        { return self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte      { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte      { return self.block.Coinbase }
+func (self *VMEnv) Time() int64           { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int  { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte     { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int       { return self.value }
+func (self *VMEnv) State() *state.StateDB { return self.state }
+func (self *VMEnv) GasLimit() *big.Int    { return self.block.GasLimit }
+func (self *VMEnv) Depth() int            { return self.depth }
+func (self *VMEnv) SetDepth(i int)        { self.depth = i }
+func (self *VMEnv) AddLog(log state.Log) {
+	self.state.AddLog(log)
+}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+	return vm.Transfer(from, to, amount)
+}
+
+func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution {
+	return core.NewExecution(self, addr, data, gas, price, value)
+}
+
+func (self *VMEnv) Call(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	exe := self.vm(addr, data, gas, price, value)
+	ret, err := exe.Call(addr, caller)
+	self.Gas = exe.Gas
+
+	return ret, err
+}
+func (self *VMEnv) CallCode(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	exe := self.vm(caller.Address(), data, gas, price, value)
+	return exe.Call(addr, caller)
+}
+
+func (self *VMEnv) Create(caller vm.ClosureRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ClosureRef) {
+	exe := self.vm(addr, data, gas, price, value)
+	return exe.Create(caller)
+}

cmd/utils/websockets.go

@@ -0,0 +1,161 @@
+package utils
+
+import (
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/websocket"
+	"github.com/ethereum/go-ethereum/xeth"
+)
+
+func args(v ...interface{}) []interface{} {
+	return v
+}
+
+type WebSocketServer struct {
+	ethereum        *eth.Ethereum
+	filterCallbacks map[int][]int
+}
+
+func NewWebSocketServer(eth *eth.Ethereum) *WebSocketServer {
+	return &WebSocketServer{eth, make(map[int][]int)}
+}
+
+func (self *WebSocketServer) Serv() {
+	pipe := xeth.NewJSXEth(self.ethereum)
+
+	wsServ := websocket.NewServer("/eth", ":40404")
+	wsServ.MessageFunc(func(c *websocket.Client, msg *websocket.Message) {
+		switch msg.Call {
+		case "compile":
+			data := ethutil.NewValue(msg.Args)
+			bcode, err := ethutil.Compile(data.Get(0).Str(), false)
+			if err != nil {
+				c.Write(args(nil, err.Error()), msg.Seed)
+			}
+
+			code := ethutil.Bytes2Hex(bcode)
+			c.Write(args(code, nil), msg.Seed)
+		case "getBlockByNumber":
+			args := msg.Arguments()
+
+			block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
+			c.Write(block, msg.Seed)
+
+		case "getKey":
+			c.Write(pipe.Key().PrivateKey, msg.Seed)
+		case "transact":
+			if mp, ok := msg.Args[0].(map[string]interface{}); ok {
+				object := mapToTxParams(mp)
+				c.Write(
+					args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"])),
+					msg.Seed,
+				)
+
+			}
+		case "getCoinBase":
+			c.Write(pipe.CoinBase(), msg.Seed)
+
+		case "getIsListening":
+			c.Write(pipe.IsListening(), msg.Seed)
+
+		case "getIsMining":
+			c.Write(pipe.IsMining(), msg.Seed)
+
+		case "getPeerCoint":
+			c.Write(pipe.PeerCount(), msg.Seed)
+
+		case "getCountAt":
+			args := msg.Arguments()
+
+			c.Write(pipe.TxCountAt(args.Get(0).Str()), msg.Seed)
+
+		case "getCodeAt":
+			args := msg.Arguments()
+
+			c.Write(len(pipe.CodeAt(args.Get(0).Str())), msg.Seed)
+
+		case "getBlockByHash":
+			args := msg.Arguments()
+
+			c.Write(pipe.BlockByHash(args.Get(0).Str()), msg.Seed)
+
+		case "getStorageAt":
+			args := msg.Arguments()
+
+			c.Write(pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str()), msg.Seed)
+
+		case "getBalanceAt":
+			args := msg.Arguments()
+
+			c.Write(pipe.BalanceAt(args.Get(0).Str()), msg.Seed)
+
+		case "getSecretToAddress":
+			args := msg.Arguments()
+
+			c.Write(pipe.SecretToAddress(args.Get(0).Str()), msg.Seed)
+
+		case "newFilter":
+		case "newFilterString":
+		case "messages":
+			// TODO
+		}
+
+	})
+
+	wsServ.Listen()
+}
+
+func StartWebSockets(eth *eth.Ethereum) {
+	sock := NewWebSocketServer(eth)
+	go sock.Serv()
+}
+
+// TODO This is starting to become a generic method. Move to utils
+func mapToTxParams(object map[string]interface{}) map[string]string {
+	// Default values
+	if object["from"] == nil {
+		object["from"] = ""
+	}
+	if object["to"] == nil {
+		object["to"] = ""
+	}
+	if object["value"] == nil {
+		object["value"] = ""
+	}
+	if object["gas"] == nil {
+		object["gas"] = ""
+	}
+	if object["gasPrice"] == nil {
+		object["gasPrice"] = ""
+	}
+
+	var dataStr string
+	var data []string
+	if str, ok := object["data"].(string); ok {
+		data = []string{str}
+	}
+
+	for _, str := range data {
+		if ethutil.IsHex(str) {
+			str = str[2:]
+
+			if len(str) != 64 {
+				str = ethutil.LeftPadString(str, 64)
+			}
+		} else {
+			str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
+		}
+
+		dataStr += str
+	}
+	object["data"] = dataStr
+
+	conv := make(map[string]string)
+	for key, value := range object {
+		if v, ok := value.(string); ok {
+			conv[key] = v
+		}
+	}
+
+	return conv
+}

compression/rle/read_write.go

@@ -0,0 +1,84 @@
+package rle
+
+import (
+	"bytes"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const (
+	token             byte = 0xfe
+	emptyShaToken          = 0xfd
+	emptyListShaToken      = 0xfe
+	tokenToken             = 0xff
+)
+
+var empty = crypto.Sha3([]byte(""))
+var emptyList = crypto.Sha3([]byte{0x80})
+
+func Decompress(dat []byte) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	for i := 0; i < len(dat); i++ {
+		if dat[i] == token {
+			if i+1 < len(dat) {
+				switch dat[i+1] {
+				case emptyShaToken:
+					buf.Write(empty)
+				case emptyListShaToken:
+					buf.Write(emptyList)
+				case tokenToken:
+					buf.WriteByte(token)
+				default:
+					buf.Write(make([]byte, int(dat[i+1]-2)))
+				}
+				i++
+			} else {
+				return nil, errors.New("error reading bytes. token encountered without proceeding bytes")
+			}
+		} else {
+			buf.WriteByte(dat[i])
+		}
+	}
+
+	return buf.Bytes(), nil
+}
+
+func compressChunk(dat []byte) (ret []byte, n int) {
+	switch {
+	case dat[0] == token:
+		return []byte{token, tokenToken}, 1
+	case len(dat) > 1 && dat[0] == 0x0 && dat[1] == 0x0:
+		j := 0
+		for j <= 254 && j < len(dat) {
+			if dat[j] != 0 {
+				break
+			}
+			j++
+		}
+		return []byte{token, byte(j + 2)}, j
+	case len(dat) >= 32:
+		if dat[0] == empty[0] && bytes.Compare(dat[:32], empty) == 0 {
+			return []byte{token, emptyShaToken}, 32
+		} else if dat[0] == emptyList[0] && bytes.Compare(dat[:32], emptyList) == 0 {
+			return []byte{token, emptyListShaToken}, 32
+		}
+		fallthrough
+	default:
+		return dat[:1], 1
+	}
+}
+
+func Compress(dat []byte) []byte {
+	buf := new(bytes.Buffer)
+
+	i := 0
+	for i < len(dat) {
+		b, n := compressChunk(dat[i:])
+		buf.Write(b)
+		i += n
+	}
+
+	return buf.Bytes()
+}

compression/rle/read_write_test.go

@@ -0,0 +1,118 @@
+package rle
+
+import (
+	"testing"
+
+	checker "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { checker.TestingT(t) }
+
+type CompressionRleSuite struct{}
+
+var _ = checker.Suite(&CompressionRleSuite{})
+
+func (s *CompressionRleSuite) TestDecompressSimple(c *checker.C) {
+	exp := []byte{0xc5, 0xd2, 0x46, 0x1, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x3, 0xc0, 0xe5, 0x0, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x4, 0x5d, 0x85, 0xa4, 0x70}
+	res, err := Decompress([]byte{token, 0xfd})
+	c.Assert(err, checker.IsNil)
+	c.Assert(res, checker.DeepEquals, exp)
+	// if bytes.Compare(res, exp) != 0 {
+	// 	t.Error("empty sha3", res)
+	// }
+
+	exp = []byte{0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x1, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21}
+	res, err = Decompress([]byte{token, 0xfe})
+	c.Assert(err, checker.IsNil)
+	c.Assert(res, checker.DeepEquals, exp)
+	// if bytes.Compare(res, exp) != 0 {
+	// 	t.Error("0x80 sha3", res)
+	// }
+
+	res, err = Decompress([]byte{token, 0xff})
+	c.Assert(err, checker.IsNil)
+	c.Assert(res, checker.DeepEquals, []byte{token})
+	// if bytes.Compare(res, []byte{token}) != 0 {
+	// 	t.Error("token", res)
+	// }
+
+	res, err = Decompress([]byte{token, 12})
+	c.Assert(err, checker.IsNil)
+	c.Assert(res, checker.DeepEquals, make([]byte, 10))
+	// if bytes.Compare(res, make([]byte, 10)) != 0 {
+	// 	t.Error("10 * zero", res)
+	// }
+}
+
+// func TestDecompressMulti(t *testing.T) {
+// 	res, err := Decompress([]byte{token, 0xfd, token, 0xfe, token, 12})
+// 	if err != nil {
+// 		t.Error(err)
+// 	}
+
+// 	var exp []byte
+// 	exp = append(exp, crypto.Sha3([]byte(""))...)
+// 	exp = append(exp, crypto.Sha3([]byte{0x80})...)
+// 	exp = append(exp, make([]byte, 10)...)
+
+// 	if bytes.Compare(res, res) != 0 {
+// 		t.Error("Expected", exp, "result", res)
+// 	}
+// }
+
+// func TestCompressSimple(t *testing.T) {
+// 	res := Compress([]byte{0, 0, 0, 0, 0})
+// 	if bytes.Compare(res, []byte{token, 7}) != 0 {
+// 		t.Error("5 * zero", res)
+// 	}
+
+// 	res = Compress(crypto.Sha3([]byte("")))
+// 	if bytes.Compare(res, []byte{token, emptyShaToken}) != 0 {
+// 		t.Error("empty sha", res)
+// 	}
+
+// 	res = Compress(crypto.Sha3([]byte{0x80}))
+// 	if bytes.Compare(res, []byte{token, emptyListShaToken}) != 0 {
+// 		t.Error("empty list sha", res)
+// 	}
+
+// 	res = Compress([]byte{token})
+// 	if bytes.Compare(res, []byte{token, tokenToken}) != 0 {
+// 		t.Error("token", res)
+// 	}
+// }
+
+// func TestCompressMulti(t *testing.T) {
+// 	in := []byte{0, 0, 0, 0, 0}
+// 	in = append(in, crypto.Sha3([]byte(""))...)
+// 	in = append(in, crypto.Sha3([]byte{0x80})...)
+// 	in = append(in, token)
+// 	res := Compress(in)
+
+// 	exp := []byte{token, 7, token, emptyShaToken, token, emptyListShaToken, token, tokenToken}
+// 	if bytes.Compare(res, exp) != 0 {
+// 		t.Error("expected", exp, "got", res)
+// 	}
+// }
+
+// func TestCompressDecompress(t *testing.T) {
+// 	var in []byte
+
+// 	for i := 0; i < 20; i++ {
+// 		in = append(in, []byte{0, 0, 0, 0, 0}...)
+// 		in = append(in, crypto.Sha3([]byte(""))...)
+// 		in = append(in, crypto.Sha3([]byte{0x80})...)
+// 		in = append(in, []byte{123, 2, 19, 89, 245, 254, 255, token, 98, 233}...)
+// 		in = append(in, token)
+// 	}
+
+// 	c := Compress(in)
+// 	d, err := Decompress(c)
+// 	if err != nil {
+// 		t.Error(err)
+// 	}
+
+// 	if bytes.Compare(d, in) != 0 {
+// 		t.Error("multi failed\n", d, "\n", in)
+// 	}
+// }

config.go

@@ -1,28 +0,0 @@
-package main
-
-import (
-	"flag"
-)
-
-var StartConsole bool
-var StartMining bool
-var UseUPnP bool
-var OutboundPort string
-var ShowGenesis bool
-var AddPeer string
-var MaxPeer int
-var GenAddr bool
-var UseSeed bool
-
-func Init() {
-	flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
-	flag.BoolVar(&StartMining, "m", false, "start dagger mining")
-	flag.BoolVar(&ShowGenesis, "g", false, "prints genesis header and exits")
-	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
-	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
-	flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
-	flag.StringVar(&OutboundPort, "p", "30303", "listening port")
-	flag.IntVar(&MaxPeer, "x", 5, "maximum desired peers")
-
-	flag.Parse()
-}

core/.gitignore

@@ -0,0 +1,12 @@
+# 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
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+

core/asm.go

@@ -0,0 +1,50 @@
+package core
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/vm"
+)
+
+func Disassemble(script []byte) (asm []string) {
+	pc := new(big.Int)
+	for {
+		if pc.Cmp(big.NewInt(int64(len(script)))) >= 0 {
+			return
+		}
+
+		// Get the memory location of pc
+		val := script[pc.Int64()]
+		// Get the opcode (it must be an opcode!)
+		op := vm.OpCode(val)
+
+		asm = append(asm, fmt.Sprintf("%04v: %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:
+			pc.Add(pc, ethutil.Big1)
+			a := int64(op) - int64(vm.PUSH1) + 1
+			if int(pc.Int64()+a) > len(script) {
+				return
+			}
+
+			data := script[pc.Int64() : pc.Int64()+a]
+			if len(data) == 0 {
+				data = []byte{0}
+			}
+			asm = append(asm, fmt.Sprintf("%04v: 0x%x", pc, data))
+
+			pc.Add(pc, big.NewInt(a-1))
+		}
+
+		pc.Add(pc, ethutil.Big1)
+	}
+
+	return asm
+}