Merge branch 'release/v0.7.10'

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

.gitignore

@@ -9,5 +9,4 @@
 *un~
 .DS_Store
 */**/.DS_Store
-./ethereum/ethereum
-
+.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 Jeffrey Wilcke
+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,42 +1,75 @@
+[![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 Client © 2014 Jeffrey Wilcke.
 
-Current state: Proof of Concept 5.0 RC13.
+Current state: Proof of Concept 0.7
 
-For the development package please see the [eth-go package](https://github.com/ethereum/eth-go).
+Ethereum is currently in its testing phase. 
 
 Build
-=======
+=====
 
-To build Ethereal (GUI):
+To build Mist (GUI):
 
-`go get github.com/ethereum/go-ethereum/ethereal`
+`go get github.com/ethereum/go-ethereum/cmd/mist`
 
 To build the node (CLI):
 
-`go get github.com/ethereum/go-ethereum/ethereum`
+`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
-====================
+============================
 
 ```
-Shared between ethereum and ethereal
+== 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
--import  Import a private key
--genaddr Generates a new address and private key (destructive action)
--h       This
+
+= 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]
@@ -44,31 +77,34 @@ ethereum [options] [filename]
 filename   Load the given file and interpret as JavaScript
 -m       Start mining blocks
 
-Etheral only
+== Mist only ==
+
 -asset_path    absolute path to GUI assets directory
 ```
 
 Contribution
 ============
 
-If you would like to contribute to Ethereum Go, please fork, fix, commit and
-send a pull request to the main repository. Commits which do not comply with the coding standards explained below
-will be ignored. If you send a pull request, make sure that you
-commit to the `develop` branch and that you do not merge to `master`.
-Commits that are directly based off of the `master` branch instead of the `develop` branch will be ignored.
+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 (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.
 
-To make this process simpler try following the [git flow](http://nvie.com/posts/a-successful-git-branching-model/) branching model, as it sets this process up and streamlines work flow.
+To make life easier try [git flow](http://nvie.com/posts/a-successful-git-branching-model/) it sets
+this all up and streamlines your work flow.
 
 Coding standards
 ================
 
-Code should be formatted according to the [Go Formatting
+Sources should be formatted according to the [Go Formatting
 Style](http://golang.org/doc/effective_go.html#formatting).
 
-Unless struct fields are supposed to be directly accessible, provide
-getters and hide the fields through Go's exporting facility.
+Unless structs fields are supposed to be directly accesible, provide
+Getters and hide the fields through Go's exporting facility.
 
-Make comments in your code meaningful and only use them when necessary. Describe in detail what your code is trying to achieve. For example, this would be redundant and unnecessary commenting:
+When you comment put meaningfull comments. Describe in detail what you
+want to achieve.
 
 *wrong*
 
@@ -79,7 +115,12 @@ if x > y {
 }
 ```
 
-Everyone reading the source code should know what this code snippet was meant to achieve, and so those are **not** meaningful comments.
+Everyone reading the source probably know what you wanted to achieve
+with above code. Those are **not** meaningful comments.
 
-While this project is constantly tested and run, code tests should be written regardless. There is not time to evaluate every person's code specifically, so it is expected of you to write tests for the code so that it does not have to be tested manually. In fact, contributing by simply writing tests is perfectly fine!
+While the project isn't 100% tested I want you to write tests non the
+less. I haven't got time to evaluate everyone's code in detail so I
+expect you to write tests for me so I don't have to test your code
+manually. (If you want to contribute by just writing tests that's fine
+too!)
 

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

@@ -1,4 +1,21 @@
-package main
+// 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
@@ -9,6 +26,7 @@ package main
 // #include <readline/history.h>
 import "C"
 import (
+	"fmt"
 	"os"
 	"os/signal"
 	"strings"
@@ -102,7 +120,9 @@ L:
 					break L
 				}
 
-				addHistory(str[:len(str)-1]) //allow user to recall this line
+				hist := str[:len(str)-1]
+				addHistory(hist) //allow user to recall this line
+				self.history.WriteString(str)
 
 				self.parseInput(str)
 
@@ -113,9 +133,12 @@ L:
 }
 
 func (self *JSRepl) PrintValue(v interface{}) {
-	method, _ := self.re.vm.Get("prettyPrint")
-	v, err := self.re.vm.ToValue(v)
+	method, _ := self.re.Vm.Get("prettyPrint")
+	v, err := self.re.Vm.ToValue(v)
 	if err == nil {
-		method.Call(method, v)
+		val, err := method.Call(method, v)
+		if err == nil {
+			fmt.Printf("%v", val)
+		}
 	}
 }

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,164 @@
+/*
+	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 {
+	evm := vm.New(self, vm.DebugVmTy)
+
+	return core.NewExecution(evm, 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

@@ -1,3 +1,20 @@
+// 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 = {

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

@@ -1,3 +1,20 @@
+// 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

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/muted.js

@@ -1,3 +1,20 @@
+// 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)

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/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/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/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/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

@@ -1,18 +1,39 @@
-package ethui
+// 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"
-	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/go-qml/qml"
-	"github.com/howeyc/fsnotify"
+	"fmt"
 	"io/ioutil"
-	"log"
 	"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 {
@@ -41,7 +62,7 @@ func (app *HtmlApplication) Create() error {
 		return errors.New("Ethereum package not yet supported")
 
 		// TODO
-		ethutil.OpenPackage(app.path)
+		//ethutil.OpenPackage(app.path)
 	}
 
 	win := component.CreateWindow(nil)
@@ -59,7 +80,7 @@ func (app *HtmlApplication) RootFolder() string {
 	if err != nil {
 		return ""
 	}
-	return path.Dir(folder.RequestURI())
+	return path.Dir(ethutil.WindonizePath(folder.RequestURI()))
 }
 func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
 	files, _ := ioutil.ReadDir(app.RootFolder())
@@ -77,11 +98,13 @@ func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
 
 	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 {
-		log.Fatal(err)
+		guilogger.Infoln("Could not start auto-reload watcher:", err)
+		return
 	}
 	for _, folder := range app.RecursiveFolders() {
 		fullPath := app.RootFolder() + "/" + folder.Name()
@@ -96,11 +119,11 @@ func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
 				app.watcher.Close()
 				break out
 			case <-app.watcher.Event:
-				//ethutil.Config.Log.Debugln("Got event:", ev)
+				//guilogger.Debugln("Got event:", ev)
 				app.webView.Call("reload")
 			case err := <-app.watcher.Error:
 				// TODO: Do something here
-				ethutil.Config.Log.Infoln("Watcher error:", err)
+				guilogger.Infoln("Watcher error:", err)
 			}
 		}
 	}()
@@ -115,19 +138,27 @@ func (app *HtmlApplication) Window() *qml.Window {
 	return app.win
 }
 
-func (app *HtmlApplication) NewBlock(block *ethchain.Block) {
-	b := &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
+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 (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) {
-	app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
-}
+func (self *HtmlApplication) Messages(messages state.Messages, id string) {
+	var msgs []javascript.JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, javascript.NewJSMessage(m))
+	}
 
-func (app *HtmlApplication) StorageChanged(storageObject *ethchain.StorageState) {
-	app.webView.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
+	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)
+// 	}
+// }

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
+}

core/block_manager.go

@@ -0,0 +1,371 @@
+package core
+
+import (
+	"bytes"
+	"container/list"
+	"errors"
+	"fmt"
+	"math/big"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/pow"
+	"github.com/ethereum/go-ethereum/pow/ezp"
+	"github.com/ethereum/go-ethereum/state"
+	"github.com/ethereum/go-ethereum/wire"
+)
+
+var statelogger = logger.NewLogger("BLOCK")
+
+type Peer interface {
+	Inbound() bool
+	LastSend() time.Time
+	LastPong() int64
+	Host() []byte
+	Port() uint16
+	Version() string
+	PingTime() string
+	Connected() *int32
+	Caps() *ethutil.Value
+}
+
+type EthManager interface {
+	BlockManager() *BlockManager
+	ChainManager() *ChainManager
+	TxPool() *TxPool
+	Broadcast(msgType wire.MsgType, data []interface{})
+	PeerCount() int
+	IsMining() bool
+	IsListening() bool
+	Peers() *list.List
+	KeyManager() *crypto.KeyManager
+	ClientIdentity() wire.ClientIdentity
+	Db() ethutil.Database
+	EventMux() *event.TypeMux
+}
+
+type BlockManager struct {
+	// Mutex for locking the block processor. Blocks can only be handled one at a time
+	mutex sync.Mutex
+	// Canonical block chain
+	bc *ChainManager
+	// non-persistent key/value memory storage
+	mem map[string]*big.Int
+	// Proof of work used for validating
+	Pow pow.PoW
+
+	txpool *TxPool
+
+	// The last attempted block is mainly used for debugging purposes
+	// This does not have to be a valid block and will be set during
+	// 'Process' & canonical validation.
+	lastAttemptedBlock *types.Block
+
+	events event.Subscription
+
+	eventMux *event.TypeMux
+}
+
+func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockManager {
+	sm := &BlockManager{
+		mem:      make(map[string]*big.Int),
+		Pow:      ezp.New(),
+		bc:       chainManager,
+		eventMux: eventMux,
+		txpool:   txpool,
+	}
+
+	return sm
+}
+
+func (sm *BlockManager) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error) {
+	coinbase := statedb.GetOrNewStateObject(block.Coinbase)
+	coinbase.SetGasPool(block.CalcGasLimit(parent))
+
+	// Process the transactions on to current block
+	receipts, _, _, _, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), false)
+	if err != nil {
+		return nil, err
+	}
+
+	return receipts, nil
+}
+
+func (self *BlockManager) ApplyTransactions(coinbase *state.StateObject, state *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
+	var (
+		receipts           types.Receipts
+		handled, unhandled types.Transactions
+		erroneous          types.Transactions
+		totalUsedGas       = big.NewInt(0)
+		err                error
+		cumulativeSum      = new(big.Int)
+	)
+
+done:
+	for i, tx := range txs {
+		// If we are mining this block and validating we want to set the logs back to 0
+		state.EmptyLogs()
+
+		txGas := new(big.Int).Set(tx.Gas())
+
+		cb := state.GetStateObject(coinbase.Address())
+		st := NewStateTransition(cb, tx, state, block)
+		_, err = st.TransitionState()
+		if err != nil {
+			switch {
+			case IsNonceErr(err):
+				err = nil // ignore error
+				continue
+			case IsGasLimitErr(err):
+				unhandled = txs[i:]
+
+				break done
+			default:
+				statelogger.Infoln(err)
+				erroneous = append(erroneous, tx)
+				err = nil
+			}
+		}
+
+		txGas.Sub(txGas, st.gas)
+		cumulativeSum.Add(cumulativeSum, new(big.Int).Mul(txGas, tx.GasPrice()))
+
+		// Update the state with pending changes
+		state.Update(txGas)
+
+		cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas))
+		receipt := types.NewReceipt(state.Root(), cumulative)
+		receipt.SetLogs(state.Logs())
+		receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
+		chainlogger.Debugln(receipt)
+
+		// Notify all subscribers
+		if !transientProcess {
+			go self.eventMux.Post(TxPostEvent{tx})
+		}
+
+		receipts = append(receipts, receipt)
+		handled = append(handled, tx)
+
+		if ethutil.Config.Diff && ethutil.Config.DiffType == "all" {
+			state.CreateOutputForDiff()
+		}
+	}
+
+	block.Reward = cumulativeSum
+	block.GasUsed = totalUsedGas
+
+	return receipts, handled, unhandled, erroneous, err
+}
+
+func (sm *BlockManager) Process(block *types.Block) (td *big.Int, msgs state.Messages, err error) {
+	// Processing a blocks may never happen simultaneously
+	sm.mutex.Lock()
+	defer sm.mutex.Unlock()
+
+	if sm.bc.HasBlock(block.Hash()) {
+		return nil, nil, &KnownBlockError{block.Number, block.Hash()}
+	}
+
+	if !sm.bc.HasBlock(block.PrevHash) {
+		return nil, nil, ParentError(block.PrevHash)
+	}
+	parent := sm.bc.GetBlock(block.PrevHash)
+
+	return sm.ProcessWithParent(block, parent)
+}
+
+func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.Int, messages state.Messages, err error) {
+	sm.lastAttemptedBlock = block
+
+	state := parent.State().Copy()
+
+	// Defer the Undo on the Trie. If the block processing happened
+	// we don't want to undo but since undo only happens on dirty
+	// nodes this won't happen because Commit would have been called
+	// before that.
+	defer state.Reset()
+
+	// Block validation
+	if err = sm.ValidateBlock(block, parent); err != nil {
+		return
+	}
+
+	receipts, err := sm.TransitionState(state, parent, block)
+	if err != nil {
+		return
+	}
+
+	rbloom := types.CreateBloom(receipts)
+	if bytes.Compare(rbloom, block.LogsBloom) != 0 {
+		err = fmt.Errorf("unable to replicate block's bloom=%x", rbloom)
+		return
+	}
+
+	txSha := types.DeriveSha(block.Transactions())
+	if bytes.Compare(txSha, block.TxSha) != 0 {
+		err = fmt.Errorf("validating transaction root. received=%x got=%x", block.TxSha, txSha)
+		return
+	}
+
+	receiptSha := types.DeriveSha(receipts)
+	if bytes.Compare(receiptSha, block.ReceiptSha) != 0 {
+		//chainlogger.Debugf("validating receipt root. received=%x got=%x", block.ReceiptSha, receiptSha)
+		fmt.Printf("%x\n", ethutil.Encode(receipts))
+		err = fmt.Errorf("validating receipt root. received=%x got=%x", block.ReceiptSha, receiptSha)
+		return
+	}
+
+	if err = sm.AccumelateRewards(state, block, parent); err != nil {
+		return
+	}
+
+	state.Update(ethutil.Big0)
+
+	if !block.State().Cmp(state) {
+		err = fmt.Errorf("invalid merkle root. received=%x got=%x", block.Root(), state.Root())
+		return
+	}
+
+	// Calculate the new total difficulty and sync back to the db
+	if td, ok := sm.CalculateTD(block); ok {
+		// Sync the current block's state to the database and cancelling out the deferred Undo
+		state.Sync()
+
+		messages := state.Manifest().Messages
+		state.Manifest().Reset()
+
+		chainlogger.Infof("Processed block #%d (%x...)\n", block.Number, block.Hash()[0:4])
+
+		sm.txpool.RemoveSet(block.Transactions())
+
+		return td, messages, nil
+	} else {
+		return nil, nil, errors.New("total diff failed")
+	}
+}
+
+func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, bool) {
+	uncleDiff := new(big.Int)
+	for _, uncle := range block.Uncles {
+		uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
+	}
+
+	// TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
+	td := new(big.Int)
+	td = td.Add(sm.bc.Td(), uncleDiff)
+	td = td.Add(td, block.Difficulty)
+
+	// The new TD will only be accepted if the new difficulty is
+	// is greater than the previous.
+	if td.Cmp(sm.bc.Td()) > 0 {
+		return td, true
+	}
+
+	return nil, false
+}
+
+// Validates the current block. Returns an error if the block was invalid,
+// an uncle or anything that isn't on the current block chain.
+// Validation validates easy over difficult (dagger takes longer time = difficult)
+func (sm *BlockManager) ValidateBlock(block, parent *types.Block) error {
+	expd := CalcDifficulty(block, parent)
+	if expd.Cmp(block.Difficulty) < 0 {
+		return fmt.Errorf("Difficulty check failed for block %v, %v", block.Difficulty, expd)
+	}
+
+	diff := block.Time - parent.Time
+	if diff < 0 {
+		return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock().Time)
+	}
+
+	/* XXX
+	// New blocks must be within the 15 minute range of the last block.
+	if diff > int64(15*time.Minute) {
+		return ValidationError("Block is too far in the future of last block (> 15 minutes)")
+	}
+	*/
+
+	// Verify the nonce of the block. Return an error if it's not valid
+	if !sm.Pow.Verify(block /*block.HashNoNonce(), block.Difficulty, block.Nonce*/) {
+		return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Nonce))
+	}
+
+	return nil
+}
+
+func (sm *BlockManager) AccumelateRewards(statedb *state.StateDB, block, parent *types.Block) error {
+	reward := new(big.Int).Set(BlockReward)
+
+	knownUncles := ethutil.Set(parent.Uncles)
+	nonces := ethutil.NewSet(block.Nonce)
+	for _, uncle := range block.Uncles {
+		if nonces.Include(uncle.Nonce) {
+			// Error not unique
+			return UncleError("Uncle not unique")
+		}
+
+		uncleParent := sm.bc.GetBlock(uncle.PrevHash)
+		if uncleParent == nil {
+			return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.PrevHash[0:4]))
+		}
+
+		if uncleParent.Number.Cmp(new(big.Int).Sub(parent.Number, big.NewInt(6))) < 0 {
+			return UncleError("Uncle too old")
+		}
+
+		if knownUncles.Include(uncle.Hash()) {
+			return UncleError("Uncle in chain")
+		}
+
+		nonces.Insert(uncle.Nonce)
+
+		r := new(big.Int)
+		r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
+
+		uncleAccount := statedb.GetAccount(uncle.Coinbase)
+		uncleAccount.AddAmount(r)
+
+		reward.Add(reward, new(big.Int).Div(BlockReward, big.NewInt(32)))
+	}
+
+	// Get the account associated with the coinbase
+	account := statedb.GetAccount(block.Coinbase)
+	// Reward amount of ether to the coinbase address
+	account.AddAmount(reward)
+
+	statedb.Manifest().AddMessage(&state.Message{
+		To:     block.Coinbase,
+		Input:  nil,
+		Origin: nil,
+		Block:  block.Hash(), Timestamp: block.Time, Coinbase: block.Coinbase, Number: block.Number,
+		Value: new(big.Int).Add(reward, block.Reward),
+	})
+
+	return nil
+}
+
+func (sm *BlockManager) GetMessages(block *types.Block) (messages []*state.Message, err error) {
+	if !sm.bc.HasBlock(block.PrevHash) {
+		return nil, ParentError(block.PrevHash)
+	}
+
+	sm.lastAttemptedBlock = block
+
+	var (
+		parent = sm.bc.GetBlock(block.PrevHash)
+		state  = parent.State().Copy()
+	)
+
+	defer state.Reset()
+
+	sm.TransitionState(state, parent, block)
+	sm.AccumelateRewards(state, block, parent)
+
+	return state.Manifest().Messages, nil
+}