Merge branch 'release/0.6.0'

Revert "ethreact - Feature/ethutil refactor"

.gitignore

@@ -9,4 +9,6 @@
 *un~
 .DS_Store
 */**/.DS_Store
+ethereum/ethereum
+ethereal/ethereal
 

.gitmodules

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

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013 Geff Obscura
+Copyright (c) 2013 Jeffrey Wilcke
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -3,79 +3,72 @@ Ethereum
 
 [![Build Status](https://travis-ci.org/ethereum/go-ethereum.png?branch=master)](https://travis-ci.org/ethereum/go-ethereum)
 
-Ethereum Go developer client (c) [0255c7881](https://github.com/ethereum/go-ethereum#copy)
+Ethereum Go Client © 2014 Jeffrey Wilcke.
 
-A fair warning; Ethereum is not yet to be used in production. There's no
-test-net and you aren't mining real blocks (just one which is the genesis block).
+Current state: Proof of Concept 0.6.0.
 
-
-Ethereum Go is split up in several sub packages Please refer to each
-individual package for more information.
-  1. [eth](https://github.com/ethereum/eth-go)
-  2. [ethchain](https://github.com/ethereum/ethchain-go)
-  3. [ethwire](https://github.com/ethereum/ethwire-go)
-  4. [ethdb](https://github.com/ethereum/ethdb-go)
-  5. [ethutil](https://github.com/ethereum/ethutil-go)
-
-The [eth](https://github.com/ethereum/eth-go) is the top-level package
-of the Ethereum protocol. It functions as the Ethereum bootstrapping and
-peer communication layer. The [ethchain](https://github.com/ethereum/ethchain-go)
-contains the Ethereum blockchain, block manager, transaction and
-transaction handlers. The [ethwire](https://github.com/ethereum/ethwire-go) contains
-the Ethereum [wire protocol](http://wiki.ethereum.org/index.php/Wire_Protocol) which can be used
-to hook in to the Ethereum network. [ethutil](https://github.com/ethereum/ethutil-go) contains
-utility functions which are not Ethereum specific. The utility package
-contains the [patricia trie](http://wiki.ethereum.org/index.php/Patricia_Tree),
-[RLP Encoding](http://wiki.ethereum.org/index.php/RLP) and hex encoding
-helpers. The [ethdb](https://github.com/ethereum/ethdb-go) package
-contains the LevelDB interface and memory DB interface.
-
-This executable is the front-end (currently nothing but a dev console) for
-the Ethereum Go implementation.
-
-Deps
-====
-
-Ethereum Go makes use of a modified `secp256k1-go` and therefor GMP.
-
-Ubuntu 12+
-* `apt-get install gmp-dev`
- 
-OS X 10.9+: 
-* `brew install gmp`
+For the development package please see the [eth-go package](https://github.com/ethereum/eth-go).
 
 Build
 =======
 
-`go get -u -t github.com/ethereum/go-ethereum`
+To build Ethereal (GUI):
 
+`go get github.com/ethereum/go-ethereum/ethereal`
 
-Command line options
+To build the node (CLI):
+
+`go get github.com/ethereum/go-ethereum/ethereum`
+
+For further, detailed, build instruction please see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go))
+
+General command line options
 ====================
 
 ```
--c      launch the developer console
--m      start mining fake blocks and broadcast fake messages to the net
+Shared between ethereum and ethereal
+-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
+
+Ethereum only
+ethereum [options] [filename]
+-js        Start the JavaScript REPL
+filename   Load the given file and interpret as JavaScript
+-m       Start mining blocks
+
+Etheral only
+-asset_path    absolute path to GUI assets directory
 ```
 
 Contribution
 ============
 
-If you'd like to contribute to Ethereum Go please fork, fix, commit and
-send a pull request. Commits who do not comply with the coding standards
-are ignored.
+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.
+
+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.
 
 Coding standards
 ================
 
-Sources should be formatted according to the [Go Formatting
+Code should be formatted according to the [Go Formatting
 Style](http://golang.org/doc/effective_go.html#formatting).
 
-Unless structs fields are supposed to be directly accesible, provide
-Getters and hide the fields through Go's exporting facility.
+Unless struct fields are supposed to be directly accessible, provide
+getters and hide the fields through Go's exporting facility.
 
-When you comment put meaningfull comments. Describe in detail what you
-want to achieve.
+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:
 
 *wrong*
 
@@ -86,15 +79,7 @@ if x > y {
 }
 ```
 
-Everyone reading the source probably know what you wanted to achieve
-with above code. Those are **not** meaningful comments.
+Everyone reading the source code should know what this code snippet was meant to achieve, and so those are **not** meaningful comments.
 
-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!)
+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!
 
-### Copy
-
-69bce990a619e747b4f57483724b0e8a1732bb3b44ccf70b0dd6abd272af94550fc9d8b21232d33ebf30d38a148612f68e936094b4daeb9ea7174088a439070401 0255c78815d4f056f84c96de438ed9e38c69c0f8af24f5032248be5a79fe9071c3

dev_console.go

@@ -1,212 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/ethchain-go"
-	"github.com/ethereum/ethdb-go"
-	"github.com/ethereum/ethutil-go"
-	"github.com/ethereum/ethwire-go"
-	_ "math/big"
-	"os"
-	"strings"
-)
-
-type Console struct {
-	db       *ethdb.MemDatabase
-	trie     *ethutil.Trie
-	ethereum *eth.Ethereum
-}
-
-func NewConsole(s *eth.Ethereum) *Console {
-	db, _ := ethdb.NewMemDatabase()
-	trie := ethutil.NewTrie(db, "")
-
-	return &Console{db: db, trie: trie, ethereum: s}
-}
-
-func (i *Console) ValidateInput(action string, argumentLength int) error {
-	err := false
-	var expArgCount int
-
-	switch {
-	case action == "update" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "get" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "dag" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "decode" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "encode" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "gettx" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "tx" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "getaddr" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "contract" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "say" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "addp" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	}
-
-	if err {
-		return errors.New(fmt.Sprintf("'%s' requires %d args, got %d", action, expArgCount, argumentLength))
-	} else {
-		return nil
-	}
-}
-
-func (i *Console) PrintRoot() {
-	root := ethutil.Conv(i.trie.Root)
-	if len(root.AsBytes()) != 0 {
-		fmt.Println(hex.EncodeToString(root.AsBytes()))
-	} else {
-		fmt.Println(i.trie.Root)
-	}
-}
-
-func (i *Console) ParseInput(input string) bool {
-	scanner := bufio.NewScanner(strings.NewReader(input))
-	scanner.Split(bufio.ScanWords)
-
-	count := 0
-	var tokens []string
-	for scanner.Scan() {
-		count++
-		tokens = append(tokens, scanner.Text())
-	}
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintln(os.Stderr, "reading input:", err)
-	}
-
-	if len(tokens) == 0 {
-		return true
-	}
-
-	err := i.ValidateInput(tokens[0], count-1)
-	if err != nil {
-		fmt.Println(err)
-	} else {
-		switch tokens[0] {
-		case "update":
-			i.trie.Update(tokens[1], tokens[2])
-
-			i.PrintRoot()
-		case "get":
-			fmt.Println(i.trie.Get(tokens[1]))
-		case "root":
-			i.PrintRoot()
-		case "rawroot":
-			fmt.Println(i.trie.Root)
-		case "print":
-			i.db.Print()
-		case "dag":
-			fmt.Println(ethchain.DaggerVerify(ethutil.Big(tokens[1]), // hash
-				ethutil.BigPow(2, 36),   // diff
-				ethutil.Big(tokens[2]))) // nonce
-		case "decode":
-			value := ethutil.NewRlpValueFromBytes([]byte(tokens[1]))
-			fmt.Println(value)
-		case "getaddr":
-			encoded, _ := hex.DecodeString(tokens[1])
-			d := i.ethereum.BlockManager.BlockChain().CurrentBlock.State().Get(string(encoded))
-			if d != "" {
-				decoder := ethutil.NewRlpValueFromBytes([]byte(d))
-				fmt.Println(decoder)
-			} else {
-				fmt.Println("getaddr: address unknown")
-			}
-		case "say":
-			i.ethereum.Broadcast(ethwire.MsgTalkTy, []interface{}{tokens[1]})
-		case "addp":
-			i.ethereum.ConnectToPeer(tokens[1])
-		case "pcount":
-			fmt.Println("peers:", i.ethereum.Peers().Len())
-		case "encode":
-			fmt.Printf("%q\n", ethutil.Encode(tokens[1]))
-		case "tx":
-			recipient, err := hex.DecodeString(tokens[1])
-			if err != nil {
-				fmt.Println("recipient err:", err)
-			} else {
-				tx := ethchain.NewTransaction(recipient, ethutil.Big(tokens[2]), []string{""})
-				tx.Sign([]byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
-				fmt.Printf("%x\n", tx.Hash())
-				i.ethereum.TxPool.QueueTransaction(tx)
-			}
-
-		case "gettx":
-			addr, _ := hex.DecodeString(tokens[1])
-			data, _ := ethutil.Config.Db.Get(addr)
-			if len(data) != 0 {
-				decoder := ethutil.NewRlpValueFromBytes(data)
-				fmt.Println(decoder)
-			} else {
-				fmt.Println("gettx: tx not found")
-			}
-		case "contract":
-			contract := ethchain.NewTransaction([]byte{}, ethutil.Big(tokens[1]), []string{"PUSH", "1234"})
-			fmt.Printf("%x\n", contract.Hash())
-
-			i.ethereum.TxPool.QueueTransaction(contract)
-		case "exit", "quit", "q":
-			return false
-		case "help":
-			fmt.Printf("COMMANDS:\n" +
-				"\033[1m= DB =\033[0m\n" +
-				"update KEY VALUE - Updates/Creates a new value for the given key\n" +
-				"get KEY - Retrieves the given key\n" +
-				"root - Prints the hex encoded merkle root\n" +
-				"rawroot - Prints the raw merkle root\n" +
-				"\033[1m= Dagger =\033[0m\n" +
-				"dag HASH NONCE - Verifies a nonce with the given hash with dagger\n" +
-				"\033[1m= Encoding =\033[0m\n" +
-				"decode STR\n" +
-				"encode STR\n" +
-				"\033[1m= Other =\033[0m\n" +
-				"addp HOST:PORT\n" +
-				"tx TO AMOUNT\n" +
-				"contract AMOUNT\n")
-
-		default:
-			fmt.Println("Unknown command:", tokens[0])
-		}
-	}
-
-	return true
-}
-
-func (i *Console) Start() {
-	fmt.Printf("Eth Console. Type (help) for help\n")
-	reader := bufio.NewReader(os.Stdin)
-	for {
-		fmt.Printf("eth >>> ")
-		str, _, err := reader.ReadLine()
-		if err != nil {
-			fmt.Println("Error reading input", err)
-		} else {
-			if !i.ParseInput(string(str)) {
-				return
-			}
-		}
-	}
-}

ethereal/assets/debugger/debugger.qml

@@ -0,0 +1,377 @@
+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: {
+		//compileTimer.stop()
+	}
+
+	MenuBar {
+		Menu {
+			title: "Debugger"
+			MenuItem {
+				text: "Run"
+				shortcut: "Ctrl+r"
+				onTriggered: debugCurrent()
+			}
+
+			MenuItem {
+				text: "Next"
+				shortcut: "Ctrl+n"
+				onTriggered: dbg.next()
+			}
+
+			MenuItem {
+				text: "Continue"
+				shortcut: "Ctrl+g"
+				onTriggered: dbg.continue()
+			}
+			MenuItem {
+				text: "Command"
+				shortcut: "Ctrl+l"
+				onTriggered: {
+					dbgCommand.focus = true
+				}
+			}
+			MenuItem {
+				text: "Focus code"
+				shortcut: "Ctrl+1"
+				onTriggered: {
+					codeEditor.focus = true
+				}
+			}
+			MenuItem {
+				text: "Focus data"
+				shortcut: "Ctrl+2"
+				onTriggered: {
+					rawDataField.focus = true
+				}
+			}
+
+			/*
+			MenuItem {
+				text: "Close window"
+				shortcut: "Ctrl+w"
+				onTriggered: {
+					win.close()
+				}
+			}
+			*/
+		}
+	}
+
+
+	SplitView {
+		anchors.fill: parent
+		property var asmModel: ListModel {
+			id: asmModel
+		}
+
+		TableView {
+			id: asmTableView
+			width: 200
+			TableViewColumn{ role: "value" ; title: "" ; width: asmTableView.width - 2 }
+			model: asmModel
+		}
+
+		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: "Temp" ; width: 200 }
+							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: 750}
+							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}
+							TableViewColumn{ role: "value" ; title: "Storage" ; width:  storageTableView.width / 2}
+							model: storageModel
+						}
+					}
+
+					Rectangle {
+						height: 200
+						width: parent.width
+						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()
+			}
+		}
+	}
+
+	toolBar: ToolBar {
+		height: 30
+		RowLayout {
+			spacing: 5
+
+			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;\nvar ret;\n\nin[0] = \"arg1\"\nin[1] = 0xdeadbeef\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)
+	}
+
+	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()
+	}
+}

ethereal/assets/ext/big.js

@@ -0,0 +1,380 @@
+var bigInt = (function () {
+    var base = 10000000, logBase = 7;
+    var sign = {
+        positive: false,
+        negative: true
+    };
+
+    var normalize = function (first, second) {
+        var a = first.value, b = second.value;
+        var length = a.length > b.length ? a.length : b.length;
+        for (var i = 0; i < length; i++) {
+            a[i] = a[i] || 0;
+            b[i] = b[i] || 0;
+        }
+        for (var i = length - 1; i >= 0; i--) {
+            if (a[i] === 0 && b[i] === 0) {
+                a.pop();
+                b.pop();
+            } else break;
+        }
+        if (!a.length) a = [0], b = [0];
+        first.value = a;
+        second.value = b;
+    };
+
+    var parse = function (text, first) {
+        if (typeof text === "object") return text;
+        text += "";
+        var s = sign.positive, value = [];
+        if (text[0] === "-") {
+            s = sign.negative;
+            text = text.slice(1);
+        }
+	var base = 10;
+        if (text.slice(0, 2) == "0x") {
+            base = 16;
+            text = text.slice(2);
+        }
+	else {
+	        var texts = text.split("e");
+		if (texts.length > 2) throw new Error("Invalid integer");
+		if (texts[1]) {
+		    var exp = texts[1];
+		    if (exp[0] === "+") exp = exp.slice(1);
+		    exp = parse(exp);
+		    if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers");
+		    while (exp.notEquals(0)) {
+		        texts[0] += "0";
+		        exp = exp.prev();
+		    }
+		}
+	        text = texts[0];
+	}
+        if (text === "-0") text = "0";
+	text = text.toUpperCase();
+        var isValid = (base == 16 ? /^[0-9A-F]*$/ : /^[0-9]+$/).test(text);
+        if (!isValid) throw new Error("Invalid integer");
+	if (base == 16) {
+		var val = bigInt(0);
+		while (text.length) {
+			v = text.charCodeAt(0) - 48;
+			if (v > 9)
+				v -= 7;
+			text = text.slice(1);
+			val = val.times(16).plus(v);
+		}
+		return val;
+	}
+	else {
+		while (text.length) {
+		    var divider = text.length > logBase ? text.length - logBase : 0;
+		    value.push(+text.slice(divider));
+		    text = text.slice(0, divider);
+		}
+	        var val = bigInt(value, s);
+	        if (first) normalize(first, val);
+        	return val;
+	}
+    };
+
+    var goesInto = function (a, b) {
+        var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive);
+        if (a.equals(0)) throw new Error("Cannot divide by 0");
+        var n = 0;
+        do {
+            var inc = 1;
+            var c = bigInt(a.value, sign.positive), t = c.times(10);
+            while (t.lesser(b)) {
+                c = t;
+                inc *= 10;
+                t = t.times(10);
+            }
+            while (c.lesserOrEquals(b)) {
+                b = b.minus(c);
+                n += inc;
+            }
+        } while (a.lesserOrEquals(b));
+
+        return {
+            remainder: b.value,
+            result: n
+        };
+    };
+
+    var bigInt = function (value, s) {
+        var self = {
+            value: value,
+            sign: s
+        };
+        var o = {
+            value: value,
+            sign: s,
+            negate: function (m) {
+                var first = m || self;
+                return bigInt(first.value, !first.sign);
+            },
+            abs: function (m) {
+                var first = m || self;
+                return bigInt(first.value, sign.positive);
+            },
+            add: function (n, m) {
+                var s, first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m));
+                else second = parse(n, first);
+                s = first.sign;
+                if (first.sign !== second.sign) {
+                    first = bigInt(first.value, sign.positive);
+                    second = bigInt(second.value, sign.positive);
+                    return s === sign.positive ?
+						o.subtract(first, second) :
+						o.subtract(second, first);
+                }
+                normalize(first, second);
+                var a = first.value, b = second.value;
+                var result = [],
+					carry = 0;
+                for (var i = 0; i < a.length || carry > 0; i++) {
+                    var sum = (a[i] || 0) + (b[i] || 0) + carry;
+                    carry = sum >= base ? 1 : 0;
+                    sum -= carry * base;
+                    result.push(sum);
+                }
+                return bigInt(result, s);
+            },
+            plus: function (n, m) {
+                return o.add(n, m);
+            },
+            subtract: function (n, m) {
+                var first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m));
+                else second = parse(n, first);
+                if (first.sign !== second.sign) return o.add(first, o.negate(second));
+                if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first));
+                if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first));
+                var a = first.value, b = second.value;
+                var result = [],
+					borrow = 0;
+                for (var i = 0; i < a.length; i++) {
+                    var tmp = a[i] - borrow;
+                    borrow = tmp < b[i] ? 1 : 0;
+                    var minuend = (borrow * base) + tmp - b[i];
+                    result.push(minuend);
+                }
+                return bigInt(result, sign.positive);
+            },
+            minus: function (n, m) {
+                return o.subtract(n, m);
+            },
+            multiply: function (n, m) {
+                var s, first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m));
+                else second = parse(n, first);
+                s = first.sign !== second.sign;
+                var a = first.value, b = second.value;
+                var resultSum = [];
+                for (var i = 0; i < a.length; i++) {
+                    resultSum[i] = [];
+                    var j = i;
+                    while (j--) {
+                        resultSum[i].push(0);
+                    }
+                }
+                var carry = 0;
+                for (var i = 0; i < a.length; i++) {
+                    var x = a[i];
+                    for (var j = 0; j < b.length || carry > 0; j++) {
+                        var y = b[j];
+                        var product = y ? (x * y) + carry : carry;
+                        carry = product > base ? Math.floor(product / base) : 0;
+                        product -= carry * base;
+                        resultSum[i].push(product);
+                    }
+                }
+                var max = -1;
+                for (var i = 0; i < resultSum.length; i++) {
+                    var len = resultSum[i].length;
+                    if (len > max) max = len;
+                }
+                var result = [], carry = 0;
+                for (var i = 0; i < max || carry > 0; i++) {
+                    var sum = carry;
+                    for (var j = 0; j < resultSum.length; j++) {
+                        sum += resultSum[j][i] || 0;
+                    }
+                    carry = sum > base ? Math.floor(sum / base) : 0;
+                    sum -= carry * base;
+                    result.push(sum);
+                }
+                return bigInt(result, s);
+            },
+            times: function (n, m) {
+                return o.multiply(n, m);
+            },
+            divmod: function (n, m) {
+                var s, first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m));
+                else second = parse(n, first);
+                s = first.sign !== second.sign;
+                if (bigInt(first.value, first.sign).equals(0)) return {
+                    quotient: bigInt([0], sign.positive),
+                    remainder: bigInt([0], sign.positive)
+                };
+                if (second.equals(0)) throw new Error("Cannot divide by zero");
+                var a = first.value, b = second.value;
+                var result = [], remainder = [];
+                for (var i = a.length - 1; i >= 0; i--) {
+                    var n = [a[i]].concat(remainder);
+                    var quotient = goesInto(b, n);
+                    result.push(quotient.result);
+                    remainder = quotient.remainder;
+                }
+                result.reverse();
+                return {
+                    quotient: bigInt(result, s),
+                    remainder: bigInt(remainder, first.sign)
+                };
+            },
+            divide: function (n, m) {
+                return o.divmod(n, m).quotient;
+            },
+            over: function (n, m) {
+                return o.divide(n, m);
+            },
+            mod: function (n, m) {
+                return o.divmod(n, m).remainder;
+            },
+            pow: function (n, m) {
+                var first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m));
+                else second = parse(n, first);
+                var a = first, b = second;
+                if (b.lesser(0)) return ZERO;
+                if (b.equals(0)) return ONE;
+                var result = bigInt(a.value, a.sign);
+
+                if (b.mod(2).equals(0)) {
+                    var c = result.pow(b.over(2));
+                    return c.times(c);
+                } else {
+                    return result.times(result.pow(b.minus(1)));
+                }
+            },
+            next: function (m) {
+                var first = m || self;
+                return o.add(first, 1);
+            },
+            prev: function (m) {
+                var first = m || self;
+                return o.subtract(first, 1);
+            },
+            compare: function (n, m) {
+                var first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m, first));
+                else second = parse(n, first);
+                normalize(first, second);
+                if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0;
+                if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1;
+                var multiplier = first.sign === sign.positive ? 1 : -1;
+                var a = first.value, b = second.value;
+                for (var i = a.length - 1; i >= 0; i--) {
+                    if (a[i] > b[i]) return 1 * multiplier;
+                    if (b[i] > a[i]) return -1 * multiplier;
+                }
+                return 0;
+            },
+            compareAbs: function (n, m) {
+                var first = self, second;
+                if (m) (first = parse(n)) && (second = parse(m, first));
+                else second = parse(n, first);
+                first.sign = second.sign = sign.positive;
+                return o.compare(first, second);
+            },
+            equals: function (n, m) {
+                return o.compare(n, m) === 0;
+            },
+            notEquals: function (n, m) {
+                return !o.equals(n, m);
+            },
+            lesser: function (n, m) {
+                return o.compare(n, m) < 0;
+            },
+            greater: function (n, m) {
+                return o.compare(n, m) > 0;
+            },
+            greaterOrEquals: function (n, m) {
+                return o.compare(n, m) >= 0;
+            },
+            lesserOrEquals: function (n, m) {
+                return o.compare(n, m) <= 0;
+            },
+            isPositive: function (m) {
+                var first = m || self;
+                return first.sign === sign.positive;
+            },
+            isNegative: function (m) {
+                var first = m || self;
+                return first.sign === sign.negative;
+            },
+            isEven: function (m) {
+                var first = m || self;
+                return first.value[0] % 2 === 0;
+            },
+            isOdd: function (m) {
+                var first = m || self;
+                return first.value[0] % 2 === 1;
+            },
+            toString: function (m) {
+                var first = m || self;
+                var str = "", len = first.value.length;
+                while (len--) {
+                    if (first.value[len].toString().length === 8) str += first.value[len];
+                    else str += (base.toString() + first.value[len]).slice(-logBase);
+                }
+                while (str[0] === "0") {
+                    str = str.slice(1);
+                }
+                if (!str.length) str = "0";
+                var s = (first.sign === sign.positive || str == "0") ? "" : "-";
+                return s + str;
+            },
+            toHex: function (m) {
+                var first = m || self;
+                var str = "";
+				var l = this.abs();
+                while (l > 0) {
+					var qr = l.divmod(256);
+					var b = qr.remainder.toJSNumber();
+					str = (b >> 4).toString(16) + (b & 15).toString(16) + str;
+                    l = qr.quotient;
+                }
+                return (this.isNegative() ? "-" : "") + "0x" + str;
+            },
+            toJSNumber: function (m) {
+                return +o.toString(m);
+            },
+            valueOf: function (m) {
+                return o.toJSNumber(m);
+            }
+        };
+        return o;
+    };
+
+    var ZERO = bigInt([0], sign.positive);
+    var ONE = bigInt([1], sign.positive);
+    var MINUS_ONE = bigInt([1], sign.negative);
+
+    var fnReturn = function (a) {
+        if (typeof a === "undefined") return ZERO;
+        return parse(a);
+    };
+    fnReturn.zero = ZERO;
+    fnReturn.one = ONE;
+    fnReturn.minusOne = MINUS_ONE;
+    return fnReturn;
+})();
+
+if (typeof module !== "undefined") {
+    module.exports = bigInt;
+}
+

ethereal/assets/ext/ethereum.js

@@ -0,0 +1,145 @@
+// Main Ethereum library
+window.eth = {
+	prototype: Object(),
+
+	// 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(sec, recipient, value, gas, gasPrice, data, cb) {
+		postData({call: "transact", args: [sec, recipient, value, gas, gasPrice, data]}, cb);
+	},
+
+	create: function(sec, value, gas, gasPrice, init, body, cb) {
+		postData({call: "create", args: [sec, value, gas, gasPrice, init, body]}, cb);
+	},
+
+	getStorageAt: function(address, storageAddress, cb) {
+		postData({call: "getStorage", args: [address, storageAddress]}, cb);
+	},
+
+	getStateKeyVals: function(address, cb){
+		postData({call: "getStateKeyVals", 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]});
+	},
+
+	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);
+				}
+			}
+		}
+	},
+
+
+}
+window.eth._callbacks = {}
+window.eth._onCallbacks = {}
+

ethereal/assets/ext/pre.js

@@ -0,0 +1,58 @@
+function debug(/**/) {
+	var args = arguments;
+	var msg = ""
+	for(var i = 0; i < args.length; i++){
+		if(typeof args[i] === "object") {
+			msg += " " + JSON.stringify(args[i])
+		} else {
+			msg += " " + args[i]
+		}
+	}
+
+	postData({call:"debug", args:[msg]})
+	document.getElementById("debug").innerHTML += "<br>" + msg
+}
+
+// Helper function for generating pseudo callbacks and sending data to the QML part of the application
+function postData(data, cb) {
+	data._seed = Math.floor(Math.random() * 1000000)
+	if(cb) {
+		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) {
+				// Figure out whether the returned data was an array
+				// array means multiple return arguments (multiple params)
+				if(data.data instanceof Array) {
+					cb.apply(this, data.data)
+				} else {
+					cb.call(this, data.data)
+				}
+
+				// Remove the "trigger" callback
+				delete eth._callbacks[ev._seed];
+			}
+		}
+	}
+}
+
+window.onerror = function(message, file, lineNumber, column, errorObj) {
+	debug(file, message, lineNumber+":"+column, errorObj);
+
+	return false;
+}

ethereal/assets/ext/string.js

@@ -0,0 +1,58 @@
+String.prototype.pad = function(l, r) {
+	if (r === undefined) {
+		r = l
+		if (!(this.substr(0, 2) == "0x" || /^\d+$/.test(this)))
+			l = 0
+	}
+	var ret = this.bin();
+	while (ret.length < l)
+		ret = "\0" + ret
+	while (ret.length < r)
+		ret = ret + "\0"
+	return ret;
+}
+
+String.prototype.unpad = function() {
+	var i = this.length;
+	while (i && this[i - 1] == "\0")
+		--i
+	return this.substr(0, i)
+}
+
+String.prototype.bin = function() {
+	if (this.substr(0, 2) == "0x") {
+		bytes = []
+		var i = 2;
+
+		// Check if it's odd - pad with a zero if so.
+		if (this.length % 2)
+			bytes.push(parseInt(this.substr(i++, 1), 16))
+
+		for (; i < this.length - 1; i += 2)
+			bytes.push(parseInt(this.substr(i, 2), 16));
+
+		return String.fromCharCode.apply(String, bytes);
+	} else if (/^\d+$/.test(this))
+		return bigInt(this.substr(0)).toHex().bin()
+
+	// Otherwise we'll return the "String" object instead of an actual string
+	return this.substr(0, this.length)
+}
+
+String.prototype.unbin = function() {
+	var i, l, o = '';
+	for(i = 0, l = this.length; i < l; i++) {
+		var n = this.charCodeAt(i).toString(16);
+		o += n.length < 2 ? '0' + n : n;
+	}
+
+	return "0x" + o;
+}
+
+String.prototype.dec = function() {
+	return bigInt(this.substr(0)).toString()
+}
+
+String.prototype.hex = function() {
+	return bigInt(this.substr(0)).toHex()
+}

ethereal/assets/muted/codemirror.css

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

ethereal/assets/muted/debugger.html

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

ethereal/assets/muted/eclipse.css

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

ethereal/assets/muted/index.html

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

ethereal/assets/muted/lib/go.js

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

ethereal/assets/muted/lib/matchbrackets.js

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

ethereal/assets/muted/muted.js

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

ethereal/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)
+	}
+}

ethereal/assets/qml/first_run.qml

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

ethereal/assets/qml/muted.qml

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

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

ethereal/assets/qml/transactions.qml

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

ethereal/assets/qml/webapp.qml

@@ -0,0 +1,245 @@
+import QtQuick 2.0
+import QtWebKit 3.0
+import QtWebKit.experimental 1.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Window 2.1;
+import Ethereum 1.0
+
+ApplicationWindow {
+	id: window
+	title: "Ethereum"
+	width: 900
+	height: 600
+	minimumHeight: 300
+
+	property alias url: webview.url
+	property alias webView: webview
+
+	Item {
+		objectName: "root"
+		id: root
+		anchors.fill: parent
+		state: "inspectorShown"
+
+		WebView {
+			objectName: "webView"
+			id: webview
+			anchors.fill: parent
+			/*
+			 anchors {
+				 left: parent.left
+				 right: parent.right
+				 bottom: sizeGrip.top
+				 top: parent.top
+			 }
+			 */
+			onTitleChanged: { window.title = title }
+			experimental.preferences.javascriptEnabled: true
+			experimental.preferences.navigatorQtObjectEnabled: true
+			experimental.preferences.developerExtrasEnabled: true
+			experimental.userScripts: ["../ext/pre.js", "../ext/big.js", "../ext/string.js", "../ext/ethereum.js"]
+			experimental.onMessageReceived: {
+				console.log("[onMessageReceived]: ", message.data)
+				// TODO move to messaging.js
+				var data = JSON.parse(message.data)
+
+				try {
+					switch(data.call) {
+					case "getCoinBase":
+					      postData(data._seed, eth.getCoinBase())
+
+					      break
+					case "getIsListening":
+					      postData(data._seed, eth.getIsListening())
+
+					      break
+					case "getIsMining":
+					      postData(data._seed, eth.getIsMining())
+
+					      break
+					case "getPeerCount":
+					      postData(data._seed, eth.getPeerCount())
+
+					      break
+
+					case "getTxCountAt":
+					      require(1)
+					      postData(data._seed, eth.getTxCountAt(data.args[0]))
+
+					      break
+					case "getBlockByNumber":
+						var block = eth.getBlock(data.args[0])
+						postData(data._seed, block)
+
+						break
+					case "getBlockByHash":
+						var block = eth.getBlock(data.args[0])
+						postData(data._seed, block)
+
+						break
+					case "transact":
+						require(5)
+
+						var tx = eth.transact(data.args[0], data.args[1], data.args[2],data.args[3],data.args[4],data.args[5])
+						postData(data._seed, tx)
+
+						break
+					case "create":
+						postData(data._seed, null)
+
+						break
+					case "getStorage":
+						require(2);
+
+						var stateObject = eth.getStateObject(data.args[0])
+						var storage = stateObject.getStorage(data.args[1])
+						postData(data._seed, storage)
+
+						break
+					case "getStateKeyVals":
+					      require(1);
+					      var stateObject = eth.getStateObject(data.args[0]).stateKeyVal(true)
+					      postData(data._seed,stateObject)
+
+						break
+					case "getTransactionsFor":
+					      require(1);
+					      var txs = eth.getTransactionsFor(data.args[0], true)
+					      postData(data._seed, txs)
+
+					      break
+					case "getBalance":
+						require(1);
+
+						postData(data._seed, eth.getStateObject(data.args[0]).value());
+
+						break
+					case "getKey":
+						var key = eth.getKey().privateKey;
+
+						postData(data._seed, key)
+						break
+					case "watch":
+						require(1)
+						eth.watch(data.args[0], data.args[1]);
+						break
+					case "disconnect":
+						require(1)
+						postData(data._seed, null)
+						break;
+					case "set":
+            console.log("'Set' has been depcrecated")
+          /*
+						for(var key in data.args) {
+							if(webview.hasOwnProperty(key)) {
+								window[key] = data.args[key];
+							}
+						}
+            */
+						break;
+					case "getSecretToAddress":
+						require(1)
+						postData(data._seed, eth.secretToAddress(data.args[0]))
+						break;
+					case "debug":
+						console.log(data.args[0]);
+						break;
+					}
+				} catch(e) {
+					console.log(data.call + ": " + e)
+
+					postData(data._seed, null);
+				}
+			}
+
+			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, _seed: seed}))
+			}
+			function postEvent(event, data) {
+				webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
+			}
+
+			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: toggleInspector
+			color: "#bcbcbc"
+			visible: true
+			height: 12
+			width: 12
+			anchors {
+				right: root.right
+			}
+			MouseArea {
+				onClicked: {
+					if(inspector.visible == true){
+						inspector.visible = false
+					}else{
+						inspector.visible = true
+            inspector.url = webview.experimental.remoteInspectorUrl
+					}
+				}
+				onDoubleClicked: {
+				  console.log('refreshing')
+				  webView.reload()
+				}
+				anchors.fill: parent
+			}
+		}
+
+		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
+				}
+			}
+		]
+	}
+}

ethereal/assets/util/test.html

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

ethereal/debugger.go

@@ -0,0 +1,339 @@
+package main
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/eth-go/ethvm"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/go-qml/qml"
+	"math/big"
+	"strconv"
+	"strings"
+)
+
+type DebuggerWindow struct {
+	win    *qml.Window
+	engine *qml.Engine
+	lib    *UiLib
+
+	vm *ethvm.Vm
+	Db *Debugger
+
+	state *ethstate.State
+}
+
+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: &ethvm.Vm{}}
+	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 := ethchain.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) {
+	if !self.Db.done {
+		self.Db.Q <- true
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			self.Logf("compile FAULT: %v", r)
+		}
+	}()
+
+	data := ethutil.StringToByteFunc(dataStr, func(s string) (ret []byte) {
+		slice := strings.Split(dataStr, "\n")
+		for _, dataItem := range slice {
+			d := ethutil.FormatData(dataItem)
+			ret = append(ret, d...)
+		}
+		return
+	})
+
+	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()
+	)
+
+	state := self.lib.eth.StateManager().TransState()
+	account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
+	contract := ethstate.NewStateObject([]byte{0})
+	contract.Amount = value
+
+	self.SetAsm(script)
+
+	callerClosure := ethvm.NewClosure(account, contract, script, gas, gasPrice)
+
+	block := self.lib.eth.BlockChain().CurrentBlock
+
+	/*
+		vm := ethchain.NewVm(state, self.lib.eth.StateManager(), ethchain.RuntimeVars{
+			Block:       block,
+			Origin:      account.Address(),
+			BlockNumber: block.Number,
+			PrevHash:    block.PrevHash,
+			Coinbase:    block.Coinbase,
+			Time:        block.Time,
+			Diff:        block.Difficulty,
+			Value:       ethutil.Big(valueStr),
+		})
+	*/
+	env := utils.NewEnv(state, block, account.Address(), value)
+	vm := ethvm.New(env)
+	vm.Verbose = true
+	vm.Dbg = self.Db
+
+	self.vm = vm
+	self.Db.done = false
+	self.Logf("callsize %d", len(script))
+	go func() {
+		ret, g, err := callerClosure.Call(vm, data)
+		tot := new(big.Int).Mul(g, gasPrice)
+		self.Logf("gas usage %v total price = %v (%v)", g, 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")
+			}
+		}
+
+		state.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) 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 ethvm.OpCode, mem *ethvm.Memory, stack *ethvm.Stack, stateObject *ethstate.StateObject) bool {
+	self.main.Logln("break on instr:", pc)
+
+	return self.halting(pc, op, mem, stack, stateObject)
+}
+
+func (self *Debugger) StepHook(pc int, op ethvm.OpCode, mem *ethvm.Memory, stack *ethvm.Stack, stateObject *ethstate.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 ethvm.OpCode, mem *ethvm.Memory, stack *ethvm.Stack, stateObject *ethstate.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+32 <= mem.Len(); i += 32 {
+		d.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])})
+		addr++
+	}
+
+	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())})
+	})
+
+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
+	}
+}

ethereal/ext_app.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/go-qml/qml"
+)
+
+type AppContainer interface {
+	Create() error
+	Destroy()
+
+	Window() *qml.Window
+	Engine() *qml.Engine
+
+	NewBlock(*ethchain.Block)
+	ObjectChanged(*ethstate.StateObject)
+	StorageChanged(*ethstate.StorageState)
+	NewWatcher(chan bool)
+}
+
+type ExtApplication struct {
+	*ethpub.PEthereum
+
+	blockChan       chan ethutil.React
+	changeChan      chan ethutil.React
+	quitChan        chan bool
+	watcherQuitChan chan bool
+
+	container        AppContainer
+	lib              *UiLib
+	registeredEvents []string
+}
+
+func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
+	app := &ExtApplication{
+		ethpub.NewPEthereum(lib.eth),
+		make(chan ethutil.React, 1),
+		make(chan ethutil.React, 1),
+		make(chan bool),
+		make(chan bool),
+		container,
+		lib,
+		nil,
+	}
+
+	return app
+}
+
+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 {
+		fmt.Println(err)
+
+		return
+	}
+
+	// Call the main loop
+	go app.mainLoop()
+
+	// Subscribe to events
+	reactor := app.lib.eth.Reactor()
+	reactor.Subscribe("newBlock", app.blockChan)
+
+	app.container.NewWatcher(app.watcherQuitChan)
+
+	win := app.container.Window()
+	win.Show()
+	win.Wait()
+
+	app.stop()
+}
+
+func (app *ExtApplication) stop() {
+	// Clean up
+	reactor := app.lib.eth.Reactor()
+	reactor.Unsubscribe("newBlock", app.blockChan)
+	for _, event := range app.registeredEvents {
+		reactor.Unsubscribe(event, app.changeChan)
+	}
+
+	// Kill the main loop
+	app.quitChan <- true
+	app.watcherQuitChan <- true
+
+	close(app.blockChan)
+	close(app.quitChan)
+	close(app.changeChan)
+
+	app.container.Destroy()
+}
+
+func (app *ExtApplication) mainLoop() {
+out:
+	for {
+		select {
+		case <-app.quitChan:
+			break out
+		case block := <-app.blockChan:
+			if block, ok := block.Resource.(*ethchain.Block); ok {
+				app.container.NewBlock(block)
+			}
+		case object := <-app.changeChan:
+			if stateObject, ok := object.Resource.(*ethstate.StateObject); ok {
+				app.container.ObjectChanged(stateObject)
+			} else if storageObject, ok := object.Resource.(*ethstate.StorageState); ok {
+				app.container.StorageChanged(storageObject)
+			}
+		}
+	}
+
+}
+
+func (app *ExtApplication) Watch(addr, storageAddr string) {
+	var event string
+	if len(storageAddr) == 0 {
+		event = "object:" + string(ethutil.Hex2Bytes(addr))
+		app.lib.eth.Reactor().Subscribe(event, app.changeChan)
+	} else {
+		event = "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
+		app.lib.eth.Reactor().Subscribe(event, app.changeChan)
+	}
+
+	app.registeredEvents = append(app.registeredEvents, event)
+}

ethereal/flags.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"bitbucket.org/kardianos/osext"
+	"flag"
+	"fmt"
+	"github.com/ethereum/eth-go/ethlog"
+	"os"
+	"os/user"
+	"path"
+	"path/filepath"
+	"runtime"
+)
+
+var Identifier string
+var KeyRing string
+var KeyStore string
+var StartRpc bool
+var RpcPort int
+var UseUPnP bool
+var OutboundPort string
+var ShowGenesis bool
+var AddPeer string
+var MaxPeer int
+var GenAddr bool
+var UseSeed bool
+var SecretFile string
+var ExportDir string
+var NonInteractive bool
+var Datadir string
+var LogFile string
+var ConfigFile string
+var DebugFile string
+var LogLevel 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", "ethereal") {
+		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/ethereal"
+		case "windows":
+			assetPath = "./assets"
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+func defaultDataDir() string {
+	usr, _ := user.Current()
+	return path.Join(usr.HomeDir, ".ethereal")
+}
+
+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.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", 10, "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(&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(ethlog.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()
+}

ethereal/gui.go

@@ -0,0 +1,459 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethdb"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethminer"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/eth-go/ethwire"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/go-qml/qml"
+	"math/big"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var logger = ethlog.NewLogger("GUI")
+
+type Gui struct {
+	// The main application window
+	win *qml.Window
+	// QML Engine
+	engine    *qml.Engine
+	component *qml.Common
+	// The ethereum interface
+	eth *eth.Ethereum
+
+	// The public Ethereum library
+	uiLib *UiLib
+
+	txDb *ethdb.LDBDatabase
+
+	pub      *ethpub.PEthereum
+	logLevel ethlog.LogLevel
+	open     bool
+
+	Session        string
+	clientIdentity *ethwire.SimpleClientIdentity
+	config         *ethutil.ConfigManager
+
+	miner *ethminer.Miner
+}
+
+// Create GUI, but doesn't start it
+func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIdentity *ethwire.SimpleClientIdentity, session string, logLevel int) *Gui {
+	db, err := ethdb.NewLDBDatabase("tx_database")
+	if err != nil {
+		panic(err)
+	}
+
+	pub := ethpub.NewPEthereum(ethereum)
+
+	return &Gui{eth: ethereum, txDb: db, pub: pub, logLevel: ethlog.LogLevel(logLevel), Session: session, open: false, clientIdentity: clientIdentity, config: config}
+}
+
+func (gui *Gui) Start(assetPath string) {
+
+	defer gui.txDb.Close()
+
+	// Register ethereum functions
+	qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
+		Init: func(p *ethpub.PBlock, obj qml.Object) { p.Number = 0; p.Hash = "" },
+	}, {
+		Init: func(p *ethpub.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
+	}, {
+		Init: func(p *ethpub.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
+	}})
+
+	// Create a new QML engine
+	gui.engine = qml.NewEngine()
+	context := gui.engine.Context()
+
+	// Expose the eth library and the ui library to QML
+	context.SetVar("eth", gui)
+	context.SetVar("pub", gui.pub)
+	gui.uiLib = NewUiLib(gui.engine, gui.eth, assetPath)
+	context.SetVar("ui", 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 {
+		logger.Errorln("asset not found: you can set an alternative asset path on the command line using option 'asset_path'", err)
+
+		panic(err)
+	}
+
+	logger.Infoln("Starting GUI")
+	gui.open = true
+	win.Show()
+	// only add the gui logger after window is shown otherwise slider wont be shown
+	if addlog {
+		ethlog.AddLogSystem(gui)
+	}
+	win.Wait()
+	// need to silence gui logger after window closed otherwise logsystem hangs (but do not save loglevel)
+	gui.logLevel = ethlog.Silence
+	gui.open = false
+}
+
+func (gui *Gui) Stop() {
+	if gui.open {
+		gui.logLevel = ethlog.Silence
+		gui.open = false
+		gui.win.Hide()
+	}
+	logger.Infoln("Stopped")
+}
+
+func (gui *Gui) ToggleMining() {
+	var txt string
+	if gui.eth.Mining {
+		utils.StopMining(gui.eth)
+		txt = "Start mining"
+	} else {
+		utils.StartMining(gui.eth)
+		gui.miner = utils.GetMiner()
+		txt = "Stop mining"
+	}
+
+	gui.win.Root().Set("miningButtonText", txt)
+}
+
+func (gui *Gui) showWallet(context *qml.Context) (*qml.Window, error) {
+	component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/wallet.qml"))
+	if err != nil {
+		return nil, err
+	}
+
+	win := gui.createWindow(component)
+
+	go func() {
+		gui.setInitialBlockChain()
+		gui.loadAddressBook()
+		gui.readPreviousTransactions()
+		gui.setPeerInfo()
+	}()
+
+	go gui.update()
+
+	return win, nil
+}
+
+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 {
+		logger.Errorln("unable to import: ", err)
+		return false
+	}
+	logger.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 {
+		logger.Errorln("unable to create key: ", err)
+		return "", "", "", ""
+	}
+	return gui.eth.KeyManager().KeyPair().AsStrings()
+}
+
+func (gui *Gui) setInitialBlockChain() {
+	sBlk := gui.eth.BlockChain().LastBlockHash
+	blk := gui.eth.BlockChain().GetBlock(sBlk)
+	for ; blk != nil; blk = gui.eth.BlockChain().GetBlock(sBlk) {
+		sBlk = blk.PrevHash
+		addr := gui.address()
+
+		// Loop through all transactions to see if we missed any while being offline
+		for _, tx := range blk.Transactions() {
+			if bytes.Compare(tx.Sender(), addr) == 0 || bytes.Compare(tx.Recipient, addr) == 0 {
+				if ok, _ := gui.txDb.Get(tx.Hash()); ok == nil {
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+				}
+
+			}
+		}
+
+		gui.processBlock(blk, true)
+	}
+}
+
+type address struct {
+	Name, Address string
+}
+
+func (gui *Gui) loadAddressBook() {
+	gui.win.Root().Call("clearAddress")
+
+	nameReg := ethpub.EthereumConfig(gui.eth.StateManager()).NameReg()
+	if nameReg != nil {
+		nameReg.EachStorage(func(name string, value *ethutil.Value) {
+			if name[0] != 0 {
+				value.Decode()
+				gui.win.Root().Call("addAddress", struct{ Name, Address string }{name, ethutil.Bytes2Hex(value.Bytes())})
+			}
+		})
+	}
+}
+
+func (gui *Gui) readPreviousTransactions() {
+	it := gui.txDb.Db().NewIterator(nil, nil)
+	addr := gui.address()
+	for it.Next() {
+		tx := ethchain.NewTransactionFromBytes(it.Value())
+
+		var inout string
+		if bytes.Compare(tx.Sender(), addr) == 0 {
+			inout = "send"
+		} else {
+			inout = "recv"
+		}
+
+		gui.win.Root().Call("addTx", ethpub.NewPTx(tx), inout)
+
+	}
+	it.Release()
+}
+
+func (gui *Gui) processBlock(block *ethchain.Block, initial bool) {
+	name := ethpub.FindNameInNameReg(gui.eth.StateManager(), block.Coinbase)
+	b := ethpub.NewPBlock(block)
+	b.Name = name
+
+	gui.win.Root().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() {
+	reactor := gui.eth.Reactor()
+
+	var (
+		blockChan     = make(chan ethutil.React, 1)
+		txChan        = make(chan ethutil.React, 1)
+		objectChan    = make(chan ethutil.React, 1)
+		peerChan      = make(chan ethutil.React, 1)
+		chainSyncChan = make(chan ethutil.React, 1)
+		miningChan    = make(chan ethutil.React, 1)
+	)
+
+	reactor.Subscribe("newBlock", blockChan)
+	reactor.Subscribe("newTx:pre", txChan)
+	reactor.Subscribe("newTx:post", txChan)
+	reactor.Subscribe("chainSync", chainSyncChan)
+	reactor.Subscribe("miner:start", miningChan)
+	reactor.Subscribe("miner:stop", miningChan)
+
+	nameReg := ethpub.EthereumConfig(gui.eth.StateManager()).NameReg()
+	if nameReg != nil {
+		reactor.Subscribe("object:"+string(nameReg.Address()), objectChan)
+	}
+	reactor.Subscribe("peerList", peerChan)
+
+	peerUpdateTicker := time.NewTicker(5 * time.Second)
+	generalUpdateTicker := time.NewTicker(1 * time.Second)
+
+	state := gui.eth.StateManager().TransState()
+
+	unconfirmedFunds := new(big.Int)
+	gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.address()).Amount)))
+	gui.getObjectByName("syncProgressIndicator").Set("visible", !gui.eth.IsUpToDate())
+
+	lastBlockLabel := gui.getObjectByName("lastBlockLabel")
+
+	for {
+		select {
+		case b := <-blockChan:
+			block := b.Resource.(*ethchain.Block)
+			gui.processBlock(block, false)
+			if bytes.Compare(block.Coinbase, gui.address()) == 0 {
+				gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.address()).Amount, nil)
+			}
+
+		case txMsg := <-txChan:
+			tx := txMsg.Resource.(*ethchain.Transaction)
+
+			if txMsg.Event == "newTx:pre" {
+				object := state.GetAccount(gui.address())
+
+				if bytes.Compare(tx.Sender(), gui.address()) == 0 {
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "send")
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+
+					unconfirmedFunds.Sub(unconfirmedFunds, tx.Value)
+				} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "recv")
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+
+					unconfirmedFunds.Add(unconfirmedFunds, tx.Value)
+				}
+
+				gui.setWalletValue(object.Amount, unconfirmedFunds)
+			} else {
+				object := state.GetAccount(gui.address())
+				if bytes.Compare(tx.Sender(), gui.address()) == 0 {
+					object.SubAmount(tx.Value)
+				} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
+					object.AddAmount(tx.Value)
+				}
+
+				gui.setWalletValue(object.Amount, nil)
+
+				state.UpdateStateObject(object)
+			}
+		case msg := <-chainSyncChan:
+			sync := msg.Resource.(bool)
+			gui.win.Root().ObjectByName("syncProgressIndicator").Set("visible", sync)
+
+		case <-objectChan:
+			gui.loadAddressBook()
+		case <-peerChan:
+			gui.setPeerInfo()
+		case <-peerUpdateTicker.C:
+			gui.setPeerInfo()
+		case msg := <-miningChan:
+			if msg.Event == "miner:start" {
+				gui.miner = msg.Resource.(*ethminer.Miner)
+			} else {
+				gui.miner = nil
+			}
+
+		case <-generalUpdateTicker.C:
+			statusText := "#" + gui.eth.BlockChain().CurrentBlock.Number.String()
+			if gui.miner != nil {
+				pow := gui.miner.GetPow()
+				if pow.GetHashrate() != 0 {
+					statusText = "Mining @ " + strconv.FormatInt(pow.GetHashrate(), 10) + "Khash - " + statusText
+				}
+			}
+			lastBlockLabel.Set("text", statusText)
+		}
+	}
+}
+
+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.pub.GetPeers() {
+		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()
+}
+
+func (gui *Gui) RegisterName(name string) {
+	name = fmt.Sprintf("\"register\"\n\"%s\"", name)
+
+	gui.pub.Transact(gui.privateKey(), "NameReg", "", "10000", "10000000000000", name)
+}
+
+func (gui *Gui) Transact(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
+	return gui.pub.Transact(gui.privateKey(), recipient, value, gas, gasPrice, data)
+}
+
+func (gui *Gui) Create(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
+	return gui.pub.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 ethlog.LogSystem
+func (gui *Gui) SetLogLevel(level ethlog.LogLevel) {
+	gui.logLevel = level
+	gui.config.Save("loglevel", level)
+}
+
+func (gui *Gui) GetLogLevel() ethlog.LogLevel {
+	return gui.logLevel
+}
+
+// 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 (gui *Gui) Println(v ...interface{}) {
+	gui.printLog(fmt.Sprintln(v...))
+}
+
+func (gui *Gui) Printf(format string, v ...interface{}) {
+	gui.printLog(fmt.Sprintf(format, v...))
+}
+
+// Print function that logs directly to the GUI
+func (gui *Gui) printLog(s string) {
+	str := strings.TrimRight(s, "\n")
+	lines := strings.Split(str, "\n")
+	for _, line := range lines {
+		gui.win.Root().Call("addLog", line)
+	}
+}

ethereal/html_container.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"errors"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/go-qml/qml"
+	"github.com/howeyc/fsnotify"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+type HtmlApplication struct {
+	win     *qml.Window
+	webView qml.Object
+	engine  *qml.Engine
+	lib     *UiLib
+	path    string
+	watcher *fsnotify.Watcher
+}
+
+func NewHtmlApplication(path string, lib *UiLib) *HtmlApplication {
+	engine := qml.NewEngine()
+
+	return &HtmlApplication{engine: engine, lib: lib, path: path}
+
+}
+
+func (app *HtmlApplication) Create() error {
+	component, err := app.engine.LoadFile(app.lib.AssetPath("qml/webapp.qml"))
+	if err != nil {
+		return err
+	}
+
+	if filepath.Ext(app.path) == "eth" {
+		return errors.New("Ethereum package not yet supported")
+
+		// TODO
+		ethutil.OpenPackage(app.path)
+	}
+
+	win := component.CreateWindow(nil)
+	win.Set("url", app.path)
+	webView := win.ObjectByName("webView")
+
+	app.win = win
+	app.webView = webView
+
+	return nil
+}
+
+func (app *HtmlApplication) RootFolder() string {
+	folder, err := url.Parse(app.path)
+	if err != nil {
+		return ""
+	}
+	return path.Dir(ethutil.WindonizePath(folder.RequestURI()))
+}
+func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
+	files, _ := ioutil.ReadDir(app.RootFolder())
+	var folders []os.FileInfo
+	for _, file := range files {
+		if file.IsDir() {
+			folders = append(folders, file)
+		}
+	}
+	return folders
+}
+
+func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
+	var err error
+
+	app.watcher, err = fsnotify.NewWatcher()
+	if err != nil {
+		logger.Infoln("Could not create new auto-reload watcher:", err)
+		return
+	}
+	err = app.watcher.Watch(app.RootFolder())
+	if err != nil {
+		logger.Infoln("Could not start auto-reload watcher:", err)
+		return
+	}
+	for _, folder := range app.RecursiveFolders() {
+		fullPath := app.RootFolder() + "/" + folder.Name()
+		app.watcher.Watch(fullPath)
+	}
+
+	go func() {
+	out:
+		for {
+			select {
+			case <-quitChan:
+				app.watcher.Close()
+				break out
+			case <-app.watcher.Event:
+				//logger.Debugln("Got event:", ev)
+				app.webView.Call("reload")
+			case err := <-app.watcher.Error:
+				// TODO: Do something here
+				logger.Infoln("Watcher error:", err)
+			}
+		}
+	}()
+
+}
+
+func (app *HtmlApplication) Engine() *qml.Engine {
+	return app.engine
+}
+
+func (app *HtmlApplication) Window() *qml.Window {
+	return app.win
+}
+
+func (app *HtmlApplication) NewBlock(block *ethchain.Block) {
+	b := &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
+	app.webView.Call("onNewBlockCb", b)
+}
+
+func (app *HtmlApplication) ObjectChanged(stateObject *ethstate.StateObject) {
+	app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
+}
+
+func (app *HtmlApplication) StorageChanged(storageObject *ethstate.StorageState) {
+	app.webView.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
+}
+
+func (app *HtmlApplication) Destroy() {
+	app.engine.Destroy()
+}

ethereal/main.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/go-qml/qml"
+	"os"
+	"runtime"
+)
+
+const (
+	ClientIdentifier = "Ethereal"
+	Version          = "0.6.0"
+)
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	qml.Init(nil)
+
+	var interrupted = false
+	utils.RegisterInterrupt(func(os.Signal) {
+		interrupted = true
+	})
+
+	utils.HandleInterrupt()
+
+	// precedence: code-internal flag default < config file < environment variables < command line
+	Init() // parsing command line
+
+	config := utils.InitConfig(ConfigFile, Datadir, "ETH")
+
+	utils.InitDataDir(Datadir)
+
+	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	db := utils.NewDatabase()
+
+	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)
+
+	utils.RegisterInterrupt(func(os.Signal) {
+		gui.Stop()
+	})
+	utils.StartEthereum(ethereum, UseSeed)
+	// gui blocks the main thread
+	gui.Start(AssetPath)
+	// 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()
+	ethlog.Flush()
+}

ethereal/qml_container.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/go-qml/qml"
+	"runtime"
+)
+
+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 string(app.path[0]) == "/" && runtime.GOOS == "windows" {
+		path = app.path[1:]
+	}
+
+	component, err := app.engine.LoadFile(path)
+	if err != nil {
+		logger.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 *ethchain.Block) {
+	pblock := &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
+	app.win.Call("onNewBlockCb", pblock)
+}
+
+func (app *QmlApplication) ObjectChanged(stateObject *ethstate.StateObject) {
+	app.win.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
+}
+
+func (app *QmlApplication) StorageChanged(storageObject *ethstate.StorageState) {
+	app.win.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
+}
+
+// Getters
+func (app *QmlApplication) Engine() *qml.Engine {
+	return app.engine
+}
+func (app *QmlApplication) Window() *qml.Window {
+	return app.win
+}

ethereal/ui_lib.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/go-qml/qml"
+	"path"
+)
+
+type memAddr struct {
+	Num   string
+	Value string
+}
+
+// UI Library that has some basic functionality exposed
+type UiLib struct {
+	engine    *qml.Engine
+	eth       *eth.Ethereum
+	connected bool
+	assetPath string
+	// The main application window
+	win      *qml.Window
+	Db       *Debugger
+	DbWindow *DebuggerWindow
+}
+
+func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
+	return &UiLib{engine: engine, eth: eth, assetPath: assetPath}
+}
+
+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) Muted(content string) {
+	component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
+	if err != nil {
+		logger.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.StateManager().CurrentState().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)
+	//self.DbWindow = dbWindow
+
+	dbWindow.Show()
+}

ethereum.go

@@ -1,115 +0,0 @@
-package main
-
-import (
-	"encoding/hex"
-	"flag"
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/ethchain-go"
-	"github.com/ethereum/ethutil-go"
-	_ "github.com/ethereum/ethwire-go"
-	"log"
-	"os"
-	"os/signal"
-	"runtime"
-)
-
-const Debug = true
-
-var StartConsole bool
-var StartMining bool
-var UseUPnP bool
-var OutboundPort string
-var ShowGenesis bool
-
-func Init() {
-	flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
-	flag.BoolVar(&StartMining, "m", false, "start dagger mining")
-	flag.BoolVar(&ShowGenesis, "g", false, "prints genesis header and exits")
-	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
-	flag.StringVar(&OutboundPort, "port", "30303", "listening port")
-
-	flag.Parse()
-}
-
-// Register interrupt handlers so we can stop the ethereum
-func RegisterInterupts(s *eth.Ethereum) {
-	// Buffered chan of one is enough
-	c := make(chan os.Signal, 1)
-	// Notify about interrupts for now
-	signal.Notify(c, os.Interrupt)
-	go func() {
-		for sig := range c {
-			fmt.Printf("Shutting down (%v) ... \n", sig)
-
-			s.Stop()
-		}
-	}()
-}
-
-func main() {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-	Init()
-
-	ethchain.InitFees()
-	ethutil.ReadConfig()
-
-	// Instantiated a eth stack
-	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
-	if err != nil {
-		log.Println(err)
-		return
-	}
-
-	if ShowGenesis {
-		fmt.Println(ethereum.BlockManager.BlockChain().Genesis())
-		os.Exit(0)
-	}
-
-	log.Printf("Starting Ethereum v%s\n", ethutil.Config.Ver)
-
-	if StartConsole {
-		err := os.Mkdir(ethutil.Config.ExecPath, os.ModePerm)
-		// Error is OK if the error is ErrExist
-		if err != nil && !os.IsExist(err) {
-			log.Panic("Unable to create EXECPATH:", err)
-		}
-
-		console := NewConsole(ethereum)
-		go console.Start()
-	}
-
-	RegisterInterupts(ethereum)
-
-	ethereum.Start()
-
-	if StartMining {
-		log.Printf("Dev Test Mining started...\n")
-
-		// Fake block mining. It broadcasts a new block every 5 seconds
-		go func() {
-			pow := &ethchain.EasyPow{}
-			addr, _ := hex.DecodeString("82c3b0b72cf62f1a9ce97c64da8072efa28225d8")
-
-			for {
-				txs := ethereum.TxPool.Flush()
-				// Create a new block which we're going to mine
-				block := ethereum.BlockManager.BlockChain().NewBlock(addr, txs)
-				// Apply all transactions to the block
-				ethereum.BlockManager.ApplyTransactions(block, block.Transactions())
-				// Search the nonce
-				block.Nonce = pow.Search(block)
-				err := ethereum.BlockManager.ProcessBlock(block)
-				if err != nil {
-					log.Println(err)
-				} else {
-					//ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.RlpValue().Value})
-					log.Println("\n+++++++ MINED BLK +++++++\n", block.String())
-				}
-			}
-		}()
-	}
-
-	// Wait for shutdown
-	ethereum.WaitForShutdown()
-}

ethereum/cmd.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/go-ethereum/ethereum/repl"
+	"github.com/ethereum/go-ethereum/utils"
+	"io/ioutil"
+	"os"
+)
+
+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 {
+		logger.Fatalln(err)
+	}
+	content, err := ioutil.ReadAll(file)
+	if err != nil {
+		logger.Fatalln(err)
+	}
+	re := ethrepl.NewJSRE(ethereum)
+	utils.RegisterInterrupt(func(os.Signal) {
+		re.Stop()
+	})
+	re.Run(string(content))
+}

ethereum/flags.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"github.com/ethereum/eth-go/ethlog"
+	"os"
+	"os/user"
+	"path"
+)
+
+var Identifier string
+var KeyRing string
+var DiffTool bool
+var DiffType string
+var KeyStore string
+var StartRpc bool
+var RpcPort int
+var UseUPnP bool
+var OutboundPort string
+var ShowGenesis bool
+var AddPeer string
+var MaxPeer int
+var GenAddr bool
+var UseSeed bool
+var SecretFile string
+var ExportDir string
+var NonInteractive bool
+var Datadir string
+var LogFile string
+var ConfigFile string
+var DebugFile string
+var LogLevel int
+
+// flags specific to cli client
+var StartMining bool
+var StartJsConsole bool
+var 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.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", 10, "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(&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(ethlog.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(&StartMining, "mine", false, "start dagger mining")
+	flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")
+
+	flag.Parse()
+
+	InputFile = flag.Arg(0)
+}

ethereum/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/utils"
+	"runtime"
+)
+
+const (
+	ClientIdentifier = "Ethereum(G)"
+	Version          = "0.6.0"
+)
+
+var logger = ethlog.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 {
+		LogLevel = 0
+	}
+
+	utils.InitConfig(ConfigFile, Datadir, "ETH")
+	ethutil.Config.Diff = DiffTool
+	ethutil.Config.DiffType = DiffType
+
+	utils.InitDataDir(Datadir)
+
+	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	db := utils.NewDatabase()
+
+	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 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)
+	}
+
+	utils.StartEthereum(ethereum, UseSeed)
+
+	// this blocks the thread
+	ethereum.WaitForShutdown()
+	ethlog.Flush()
+}

ethereum/repl/javascript_runtime.go

@@ -0,0 +1,232 @@
+package ethrepl
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/obscuren/otto"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+var jsrelogger = ethlog.NewLogger("JSRE")
+
+type JSRE struct {
+	ethereum *eth.Ethereum
+	vm       *otto.Otto
+	lib      *ethpub.PEthereum
+
+	blockChan  chan ethutil.React
+	changeChan chan ethutil.React
+	quitChan   chan bool
+
+	objectCb map[string][]otto.Value
+}
+
+func (jsre *JSRE) LoadExtFile(path string) {
+	result, err := ioutil.ReadFile(path)
+	if err == nil {
+		jsre.vm.Run(result)
+	} else {
+		jsrelogger.Debugln("Could not load file:", path)
+	}
+}
+
+func (jsre *JSRE) LoadIntFile(file string) {
+	assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal", "assets", "ext")
+	jsre.LoadExtFile(path.Join(assetPath, file))
+}
+
+func NewJSRE(ethereum *eth.Ethereum) *JSRE {
+	re := &JSRE{
+		ethereum,
+		otto.New(),
+		ethpub.NewPEthereum(ethereum),
+		make(chan ethutil.React, 1),
+		make(chan ethutil.React, 1),
+		make(chan bool),
+		make(map[string][]otto.Value),
+	}
+
+	// Init the JS lib
+	re.vm.Run(jsLib)
+
+	// Load extra javascript files
+	re.LoadIntFile("string.js")
+	re.LoadIntFile("big.js")
+
+	// We have to make sure that, whoever calls this, calls "Stop"
+	go re.mainLoop()
+
+	re.Bind("eth", &JSEthereum{re.lib, re.vm})
+
+	re.initStdFuncs()
+
+	jsrelogger.Infoln("started")
+
+	return re
+}
+
+func (self *JSRE) Bind(name string, v interface{}) {
+	self.vm.Set(name, v)
+}
+
+func (self *JSRE) Run(code string) (otto.Value, error) {
+	return self.vm.Run(code)
+}
+
+func (self *JSRE) Require(file string) error {
+	if len(filepath.Ext(file)) == 0 {
+		file += ".js"
+	}
+
+	fh, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+
+	content, _ := ioutil.ReadAll(fh)
+	self.Run("exports = {};(function() {" + string(content) + "})();")
+
+	return nil
+}
+
+func (self *JSRE) Stop() {
+	// Kill the main loop
+	self.quitChan <- true
+
+	close(self.blockChan)
+	close(self.quitChan)
+	close(self.changeChan)
+	jsrelogger.Infoln("stopped")
+}
+
+func (self *JSRE) mainLoop() {
+	// Subscribe to events
+	reactor := self.ethereum.Reactor()
+	reactor.Subscribe("newBlock", self.blockChan)
+
+out:
+	for {
+		select {
+		case <-self.quitChan:
+			break out
+		case block := <-self.blockChan:
+			if _, ok := block.Resource.(*ethchain.Block); ok {
+			}
+		case object := <-self.changeChan:
+			if stateObject, ok := object.Resource.(*ethstate.StateObject); ok {
+				for _, cb := range self.objectCb[ethutil.Bytes2Hex(stateObject.Address())] {
+					val, _ := self.vm.ToValue(ethpub.NewPStateObject(stateObject))
+					cb.Call(cb, val)
+				}
+			} else if storageObject, ok := object.Resource.(*ethstate.StorageState); ok {
+				for _, cb := range self.objectCb[ethutil.Bytes2Hex(storageObject.StateAddress)+ethutil.Bytes2Hex(storageObject.Address)] {
+					val, _ := self.vm.ToValue(ethpub.NewPStorageState(storageObject))
+					cb.Call(cb, val)
+				}
+			}
+		}
+	}
+}
+
+func (self *JSRE) initStdFuncs() {
+	t, _ := self.vm.Get("eth")
+	eth := t.Object()
+	eth.Set("watch", self.watch)
+	eth.Set("addPeer", self.addPeer)
+	eth.Set("require", self.require)
+	eth.Set("stopMining", self.stopMining)
+	eth.Set("startMining", self.startMining)
+	eth.Set("execBlock", self.execBlock)
+}
+
+/*
+ * The following methods are natively implemented javascript functions
+ */
+
+func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StopMining(self.ethereum))
+	return v
+}
+
+func (self *JSRE) startMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StartMining(self.ethereum))
+	return v
+}
+
+// eth.watch
+func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
+	addr, _ := call.Argument(0).ToString()
+	var storageAddr string
+	var cb otto.Value
+	var storageCallback bool
+	if len(call.ArgumentList) > 2 {
+		storageCallback = true
+		storageAddr, _ = call.Argument(1).ToString()
+		cb = call.Argument(2)
+	} else {
+		cb = call.Argument(1)
+	}
+
+	if storageCallback {
+		self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
+
+		event := "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	} else {
+		self.objectCb[addr] = append(self.objectCb[addr], cb)
+
+		event := "object:" + string(ethutil.Hex2Bytes(addr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	}
+
+	return otto.UndefinedValue()
+}
+
+func (self *JSRE) addPeer(call otto.FunctionCall) otto.Value {
+	host, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.FalseValue()
+	}
+	self.ethereum.ConnectToPeer(host)
+
+	return otto.TrueValue()
+}
+
+func (self *JSRE) require(call otto.FunctionCall) otto.Value {
+	file, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.UndefinedValue()
+	}
+	if err := self.Require(file); err != nil {
+		fmt.Println("err:", err)
+		return otto.UndefinedValue()
+	}
+
+	t, _ := self.vm.Get("exports")
+
+	return t
+}
+
+func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
+	hash, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.UndefinedValue()
+	}
+
+	err = utils.BlockDo(self.ethereum, ethutil.Hex2Bytes(hash))
+	if err != nil {
+		fmt.Println(err)
+		return otto.FalseValue()
+	}
+
+	return otto.TrueValue()
+}

ethereum/repl/js_lib.go

@@ -0,0 +1,53 @@
+package ethrepl
+
+const jsLib = `
+function pp(object) {
+    var str = "";
+
+    if(object instanceof Array) {
+        str += "[ ";
+        for(var i = 0, l = object.length; i < l; i++) {
+            str += pp(object[i]);
+
+            if(i < l-1) {
+                str += ", ";
+            }
+        }
+        str += " ]";
+    } else if(typeof(object) === "object") {
+        str += "{ ";
+        var last = Object.keys(object).sort().pop()
+        for(var k in object) {
+            str += k + ": " + pp(object[k]);
+
+            if(k !== last) {
+                str += ", ";
+            }
+        }
+        str += " }";
+    } else if(typeof(object) === "string") {
+        str += "\033[32m'" + object + "'";
+    } else if(typeof(object) === "undefined") {
+        str += "\033[1m\033[30m" + object;
+    } else if(typeof(object) === "number") {
+        str += "\033[31m" + object;
+    } else if(typeof(object) === "function") {
+	str += "\033[35m[Function]";
+    } else {
+        str += object;                    
+    }
+
+    str += "\033[0m";
+
+    return str;
+}
+
+function prettyPrint(/* */) {
+    var args = arguments;
+    for(var i = 0, l = args.length; i < l; i++) {
+	    console.log(pp(args[i]))
+    }
+}
+
+var print = prettyPrint;
+`

ethereum/repl/repl.go

@@ -0,0 +1,83 @@
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
+	"io"
+	"os"
+	"path"
+)
+
+var logger = ethlog.NewLogger("REPL")
+
+type Repl interface {
+	Start()
+	Stop()
+}
+
+type JSRepl struct {
+	re *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: NewJSRE(ethereum), prompt: "> ", history: hist}
+}
+
+func (self *JSRepl) Start() {
+	if !self.running {
+		self.running = true
+		logger.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()
+		logger.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)
+}

ethereum/repl/repl_darwin.go

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

ethereum/repl/repl_linux.go

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

ethereum/repl/repl_windows.go

@@ -0,0 +1,24 @@
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+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 {
+			self.parseInput(string(str))
+		}
+	}
+}
+
+func (self *JSRepl) PrintValue(value otto.Value) {
+	fmt.Println(value)
+}

ethereum/repl/types.go

@@ -0,0 +1,95 @@
+package ethrepl
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/obscuren/otto"
+)
+
+type JSStateObject struct {
+	*ethpub.PStateObject
+	eth *JSEthereum
+}
+
+func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
+	cb := call.Argument(0)
+	self.PStateObject.EachStorage(func(key string, value *ethutil.Value) {
+		value.Decode()
+
+		cb.Call(self.eth.toVal(self), self.eth.toVal(key), self.eth.toVal(ethutil.Bytes2Hex(value.Bytes())))
+	})
+
+	return otto.UndefinedValue()
+}
+
+// The JSEthereum object attempts to wrap the PEthereum object and returns
+// meaningful javascript objects
+type JSBlock struct {
+	*ethpub.PBlock
+	eth *JSEthereum
+}
+
+func (self *JSBlock) GetTransaction(hash string) otto.Value {
+	return self.eth.toVal(self.PBlock.GetTransaction(hash))
+}
+
+type JSEthereum struct {
+	*ethpub.PEthereum
+	vm *otto.Otto
+}
+
+func (self *JSEthereum) GetBlock(hash string) otto.Value {
+	return self.toVal(&JSBlock{self.PEthereum.GetBlock(hash), self})
+}
+
+func (self *JSEthereum) GetPeers() otto.Value {
+	return self.toVal(self.PEthereum.GetPeers())
+}
+
+func (self *JSEthereum) GetKey() otto.Value {
+	return self.toVal(self.PEthereum.GetKey())
+}
+
+func (self *JSEthereum) GetStateObject(addr string) otto.Value {
+	return self.toVal(&JSStateObject{self.PEthereum.GetStateObject(addr), self})
+}
+
+func (self *JSEthereum) GetStateKeyVals(addr string) otto.Value {
+	return self.toVal(self.PEthereum.GetStateObject(addr).StateKeyVal(false))
+}
+
+func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
+	r, err := self.PEthereum.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
+	if err != nil {
+		fmt.Println(err)
+
+		return otto.UndefinedValue()
+	}
+
+	return self.toVal(r)
+}
+
+func (self *JSEthereum) Create(key, valueStr, gasStr, gasPriceStr, scriptStr string) otto.Value {
+	r, err := self.PEthereum.Create(key, valueStr, gasStr, gasPriceStr, scriptStr)
+
+	if err != nil {
+		fmt.Println(err)
+
+		return otto.UndefinedValue()
+	}
+
+	return self.toVal(r)
+}
+
+func (self *JSEthereum) toVal(v interface{}) otto.Value {
+	result, err := self.vm.ToValue(v)
+
+	if err != nil {
+		fmt.Println("Value unknown:", err)
+
+		return otto.UndefinedValue()
+	}
+
+	return result
+}

install.sh

@@ -0,0 +1,57 @@
+#!/bin/sh
+
+if [ "$1" == "" ]; then
+	echo "Usage $0 executable branch ethereum develop"
+	echo "executable    ethereum or ethereal"
+	echo "branch        develop or master"
+	exit
+fi
+
+exe=$1
+branch=$2
+
+# Test if go is installed
+command -v go >/dev/null 2>&1 || { echo >&2 "Unable to find 'go'. This script requires go."; exit 1; }
+
+# Test if $GOPATH is set
+if [ "$GOPATH" == "" ]; then
+	echo "\$GOPATH not set"
+	exit
+fi
+
+echo "go get -u -d github.com/ethereum/go-ethereum/$exe"
+go get -v -u -d github.com/ethereum/go-ethereum/$exe
+if [ $? != 0 ]; then
+	echo "go get failed"
+	exit
+fi
+
+echo "serpent-go"
+cd $GOPATH/src/github.com/obscuren/serpent-go
+
+echo "init submodule"
+git submodule init
+git submodule update
+
+echo "eth-go"
+cd $GOPATH/src/github.com/ethereum/eth-go
+git checkout $branch
+
+echo "go-ethereum"
+cd $GOPATH/src/github.com/ethereum/go-ethereum/$exe
+git checkout $branch
+
+if [ "$exe" == "ethereal" ]; then
+	echo "Building ethereal GUI. Assuming Qt is installed. If this step"
+	echo "fails; please refer to: https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go)"
+else
+	echo "Building ethereum CLI."
+fi
+
+go install
+if [ $? == 0 ]; then
+	echo "go install failed"
+	exit
+fi
+
+echo "done. Please run $exe :-)"

test_runner.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-)
-
-type TestSource struct {
-	Inputs      map[string]string
-	Expectation string
-}
-
-func NewTestSource(source string) *TestSource {
-	s := &TestSource{}
-	err := json.Unmarshal([]byte(source), s)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	return s
-}
-
-type TestRunner struct {
-	source *TestSource
-}
-
-func NewTestRunner(t *testing.T) *TestRunner {
-	return &TestRunner{}
-}
-
-func (runner *TestRunner) RunFromString(input string, Cb func(*TestSource)) {
-	source := NewTestSource(input)
-	Cb(source)
-}

test_runner_test.go

@@ -1,36 +0,0 @@
-package main
-
-/*
-import (
-	"encoding/hex"
-	_ "fmt"
-	"github.com/ethereum/ethdb-go"
-	"github.com/ethereum/ethutil-go"
-	"testing"
-)
-
-var testsource = `
-{
-	"inputs":{
-		"doe": "reindeer",
-		"dog": "puppy",
-		"dogglesworth": "cat"
-	},
-	"expectation":"e378927bfc1bd4f01a2e8d9f59bd18db8a208bb493ac0b00f93ce51d4d2af76c"
-}`
-
-func TestTestRunner(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	trie := ethutil.NewTrie(db, "")
-
-	runner := NewTestRunner(t)
-	runner.RunFromString(testsource, func(source *TestSource) {
-		for key, value := range source.Inputs {
-			trie.Update(key, value)
-		}
-		if hex.EncodeToString(trie.Root.([]byte)) != source.Expectation {
-			t.Error("trie root did not match")
-		}
-	})
-}
-*/

testing.go

@@ -1,33 +0,0 @@
-package main
-
-/*
-
-import (
-  _"fmt"
-)
-
-// This will eventually go away
-var Db *MemDatabase
-
-func Testing() {
-  db, _ := NewMemDatabase()
-  Db = db
-
-  bm := NewBlockManager()
-
-  tx := NewTransaction("\x00", 20, []string{"PUSH"})
-  txData := tx.RlpEncode()
-  //fmt.Printf("%q\n", txData)
-
-  copyTx := &Transaction{}
-  copyTx.RlpDecode(txData)
-  //fmt.Println(tx)
-  //fmt.Println(copyTx)
-
-  tx2 := NewTransaction("\x00", 20, []string{"SET 10 6", "LD 10 10"})
-
-  blck := CreateTestBlock([]*Transaction{tx2, tx})
-
-  bm.ProcessBlock( blck )
-}
-*/

utils/cmd.go

@@ -0,0 +1,301 @@
+package utils
+
+import (
+	"bitbucket.org/kardianos/osext"
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethcrypto"
+	"github.com/ethereum/eth-go/ethdb"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethminer"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethrpc"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/eth-go/ethwire"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"path"
+	"path/filepath"
+	"runtime"
+	"time"
+)
+
+var logger = ethlog.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 {
+			logger.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 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) {
+	var writer io.Writer
+	if LogFile == "" {
+		writer = os.Stdout
+	} else {
+		writer = openLogFile(Datadir, LogFile)
+	}
+	ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.LogLevel(LogLevel)))
+	if DebugFile != "" {
+		writer = openLogFile(Datadir, DebugFile)
+		ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.DebugLevel))
+	}
+}
+
+func InitConfig(ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
+	InitDataDir(Datadir)
+	return ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
+}
+
+func exit(err error) {
+	status := 0
+	if err != nil {
+		fmt.Println(err)
+		logger.Errorln("Fatal: ", err)
+		status = 1
+	}
+	ethlog.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) *ethwire.SimpleClientIdentity {
+	return ethwire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
+}
+
+func NewEthereum(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *ethcrypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
+	ethereum, err := eth.New(db, clientIdentity, keyManager, eth.CapDefault, usePnp)
+	if err != nil {
+		logger.Fatalln("eth start err:", err)
+	}
+	ethereum.Port = OutboundPort
+	ethereum.MaxPeers = MaxPeer
+	return ethereum
+}
+
+func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
+	logger.Infof("Starting %s", ethereum.ClientIdentity())
+	ethereum.Start(UseSeed)
+	RegisterInterrupt(func(sig os.Signal) {
+		ethereum.Stop()
+		ethlog.Flush()
+	})
+}
+
+func ShowGenesis(ethereum *eth.Ethereum) {
+	logger.Infoln(ethereum.BlockChain().Genesis())
+	exit(nil)
+}
+
+func NewKeyManager(KeyStore string, Datadir string, db ethutil.Database) *ethcrypto.KeyManager {
+	var keyManager *ethcrypto.KeyManager
+	switch {
+	case KeyStore == "db":
+		keyManager = ethcrypto.NewDBKeyManager(db)
+	case KeyStore == "file":
+		keyManager = ethcrypto.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", "ethereal") {
+		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/ethereal"
+		case "windows":
+			assetPath = "./assets"
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+
+func KeyTasks(keyManager *ethcrypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
+	ethcrypto.InitWords(DefaultAssetPath()) // Init mnemonic word list
+
+	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)
+		}
+	}
+}
+
+func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
+	var err error
+	ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort)
+	if err != nil {
+		logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
+	} else {
+		go ethereum.RpcServer.Start()
+	}
+}
+
+var miner *ethminer.Miner
+
+func GetMiner() *ethminer.Miner {
+	return miner
+}
+
+func StartMining(ethereum *eth.Ethereum) bool {
+	if !ethereum.Mining {
+		ethereum.Mining = true
+
+		addr := ethereum.KeyManager().Address()
+
+		go func() {
+			if miner == nil {
+				miner = ethminer.NewDefaultMiner(addr, ethereum)
+			}
+
+			// Give it some time to connect with peers
+			time.Sleep(3 * time.Second)
+			for !ethereum.IsUpToDate() {
+				time.Sleep(5 * time.Second)
+			}
+
+			logger.Infoln("Miner started")
+			miner.Start()
+		}()
+		RegisterInterrupt(func(os.Signal) {
+			StopMining(ethereum)
+		})
+		return true
+	}
+	return false
+}
+
+func StopMining(ethereum *eth.Ethereum) bool {
+	if ethereum.Mining && miner != nil {
+		miner.Stop()
+
+		logger.Infoln("Miner stopped")
+
+		ethereum.Mining = false
+
+		return true
+	}
+
+	return false
+}
+
+// Replay block
+func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
+	block := ethereum.BlockChain().GetBlock(hash)
+	if block == nil {
+		return fmt.Errorf("unknown block %x", hash)
+	}
+
+	parent := ethereum.BlockChain().GetBlock(block.PrevHash)
+
+	_, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block)
+	if err != nil {
+		return err
+	}
+
+	return nil
+
+}

utils/vm_env.go

@@ -0,0 +1,33 @@
+package utils
+
+import (
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethstate"
+	"math/big"
+)
+
+type VMEnv struct {
+	state *ethstate.State
+	block *ethchain.Block
+
+	transactor []byte
+	value      *big.Int
+}
+
+func NewEnv(state *ethstate.State, block *ethchain.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) Value() *big.Int        { return self.value }
+func (self *VMEnv) State() *ethstate.State { return self.state }