Merge branch 'release/0.6.3'

remove mnemonic words initialisation

.gitmodules

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

LICENSE

@@ -1,21 +1,16 @@
-The MIT License (MIT)
+Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
 
-Copyright (c) 2013 Jeffrey Wilcke
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+You should have received a copy of the GNU General Public License
+along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+MA 02110-1301  USA

README.md

@@ -1,11 +1,13 @@
 Ethereum
 ========
 
-[![Build Status](https://travis-ci.org/ethereum/go-ethereum.png?branch=master)](https://travis-ci.org/ethereum/go-ethereum)
+Master [![Build
+Status](http://cpt-obvious.ethercasts.com:8010/buildstatusimage?builder=go-ethereum-master-docker)](http://cpt-obvious.ethercasts.com:8010/builders/go-ethereum-master-docker/builds/-1) Develop [![Build
+Status](http://cpt-obvious.ethercasts.com:8010/buildstatusimage?builder=go-ethereum-develop-docker)](http://cpt-obvious.ethercasts.com:8010/builders/go-ethereum-develop-docker/builds/-1)
 
 Ethereum Go Client © 2014 Jeffrey Wilcke.
 
-Current state: Proof of Concept 0.5.15.
+Current state: Proof of Concept 0.6.3.
 
 For the development package please see the [eth-go package](https://github.com/ethereum/eth-go).
 

ethereal/Makefile

@@ -1,22 +0,0 @@
-UNAME = $(shell uname)
-FILES=qml *.png
-GOPATH=$(PWD)
-
-
-# Default is building
-all:
-	go get -d
-	cp *.go $(GOPATH)/src/github.com/ethereum/go-ethereum
-	cp -r ui $(GOPATH)/src/github.com/ethereum/go-ethereum
-	go build
-
-install:
-# Linux build
-ifeq ($(UNAME),Linux)
-	cp -r assets/* /usr/share/ethereal
-	cp go-ethereum /usr/local/bin/ethereal
-endif
-# OS X build
-ifeq ($(UNAME),Darwin)
-	# Execute py script
-endif

ethereal/assets/debugger/debugger.qml

@@ -7,16 +7,21 @@ import QtQuick.Controls.Styles 1.1
 import Ethereum 1.0
 
 ApplicationWindow {
+	id: win
 	visible: false
 	title: "IceCREAM"
 	minimumWidth: 1280
 	minimumHeight: 700
 	width: 1290
-	height: 700
+	height: 750
 
 	property alias codeText: codeEditor.text
 	property alias dataText: rawDataField.text
 
+	onClosing: {
+		//compileTimer.stop()
+	}
+
 	MenuBar {
 		Menu {
 			title: "Debugger"
@@ -31,18 +36,57 @@ ApplicationWindow {
 				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: 200 }
+			TableViewColumn{ role: "value" ; title: "" ; width: asmTableView.width - 2 }
 			model: asmModel
 		}
 
@@ -66,6 +110,17 @@ ApplicationWindow {
 						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 {
@@ -178,7 +233,7 @@ ApplicationWindow {
 							}
 							height: parent.height
 							width: parent.width
-							TableViewColumn{ id: message ; role: "message" ; title: "log" ; width: logTableView.width }
+							TableViewColumn{ id: message ; role: "message" ; title: "log" ; width: logTableView.width - 2 }
 							model: logModel
 						}
 					}
@@ -187,7 +242,28 @@ ApplicationWindow {
 		}
 	}
 
+		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
 
@@ -208,13 +284,32 @@ ApplicationWindow {
 				}
 				text: "Next"
 			}
-			CheckBox {
-				id: breakEachLine
-				objectName: "breakEachLine"
-				text: "Break each instruction"
-				checked: true
+
+			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() {
@@ -261,7 +356,19 @@ ApplicationWindow {
 	}
 
 	function setLog(msg) {
-		logModel.insert(0, {message: 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() {

ethereal/assets/ext/ethereum.js

@@ -1,39 +1,124 @@
 // Main Ethereum library
 window.eth = {
 	prototype: Object(),
+	_callbacks: {},
+	_onCallbacks: {},
+
+    test: function() {
+        var t = undefined;
+	postData({call: "test"})
+        navigator.qt.onmessage = function(d) {console.log("onmessage called"); t = d; }
+        for(;;) {
+            if(t !== undefined) {
+                return t
+            }
+        }
+    },
+
+	mutan: function(code, cb) {
+		postData({call: "mutan", args: [code]}, cb)
+	},
+
+	toHex: function(str) {
+		var hex = "";
+		for(var i = 0; i < str.length; i++) {
+			var n = str.charCodeAt(i).toString(16);
+			hex += n.length < 2 ? '0' + n : n;
+		}
+
+		return hex;
+	},
+
+	toAscii: function(hex) {
+		// Find termination
+		var str = "";
+		var i = 0, l = hex.length;
+		for(; i < l; i+=2) {
+			var code = hex.charCodeAt(i)
+			if(code == 0) {
+				break;
+			}
+
+			str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+		}
+
+		return str;
+	},
+
+	fromAscii: function(str, pad) {
+		if(pad === undefined) {
+			pad = 32
+		}
+
+		var hex = this.toHex(str);
+
+		while(hex.length < pad*2)
+			hex += "00";
+
+		return hex
+	},
+
 
 	// Retrieve block
 	//
 	// Either supply a number or a string. Type is determent for the lookup method
 	// string - Retrieves the block by looking up the hash
 	// number - Retrieves the block by looking up the block number
-        getBlock: function(numberOrHash, cb) {
-                var func;
-                if(typeof numberOrHash == "string") {
-                        func =  "getBlockByHash";
-                } else {
-                        func =  "getBlockByNumber";
-                }
-                postData({call: func, args: [numberOrHash]}, cb);
-        },
+	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);
+	transact: function(params, cb) {
+		if(params === undefined) {
+			params = {};
+		}
+
+		if(params.endowment !== undefined)
+			params.value = params.endowment;
+		if(params.code !== undefined)
+			params.data = params.code;
+
+		// Make sure everything is string
+		var fields = ["to", "from", "value", "gas", "gasPrice"];
+		for(var i = 0; i < fields.length; i++) {
+			if(params[fields[i]] === undefined) {
+				params[fields[i]] = "";
+			}
+			params[fields[i]] = params[fields[i]].toString();
+		}
+
+		var data;
+		if(typeof params.data === "object") {
+			data = "";
+			for(var i = 0; i < params.data.length; i++) {
+				data += params.data[i]
+			}
+		} else {
+			data = params.data;
+		}
+
+		postData({call: "transact", args: [params.from, params.to, params.value, params.gas, params.gasPrice, "0x"+data]}, cb);
 	},
 
-	create: function(sec, value, gas, gasPrice, init, body, cb) {
-		postData({call: "create", args: [sec, value, gas, gasPrice, init, body]}, cb);
+	getMessages: function(filter, cb) {
+		postData({call: "messages", args: [filter]}, cb);
 	},
 
 	getStorageAt: function(address, storageAddress, cb) {
 		postData({call: "getStorage", args: [address, storageAddress]}, cb);
 	},
 
-	getStateKeyVals: function(address, cb){
-		postData({call: "getStateKeyVals", args: [address]}, cb);
+	getEachStorageAt: function(address, cb){
+		postData({call: "getEachStorage", args: [address]}, cb);
 	},
 
 	getKey: function(cb) {
@@ -66,6 +151,7 @@ window.eth = {
 		postData({call: "getSecretToAddress", args: [sec]}, cb);
 	},
 
+	/*
 	watch: function(address, storageAddrOrCb, cb) {
 		var ev;
 		if(cb === undefined) {
@@ -95,6 +181,16 @@ window.eth = {
 
 		postData({call: "disconnect", args: [address, storageAddrOrCb]});
 	},
+	*/
+
+       watch: function(options) {
+	       var filter = new Filter(options);
+	       filter.number = newWatchNum().toString()
+
+	       postData({call: "watch", args: [options, filter.number]})
+
+	       return filter;
+       },
 
 	set: function(props) {
 		postData({call: "set", args: props});
@@ -137,9 +233,63 @@ window.eth = {
 			}
 		}
 	},
-
-
 }
-window.eth._callbacks = {}
-window.eth._onCallbacks = {}
+
+
+var Filter = function(options) {
+	this.options = options;
+};
+Filter.prototype.changed = function(callback) {
+	// Register the watched:<number>. Qml will call the appropriate event if anything
+	// interesting happens in the land of Go.
+	eth.on("watched:"+this.number, callback)
+}
+Filter.prototype.getMessages = function(cb) {
+	return eth.getMessages(this.options, cb)
+}
+
+var watchNum = 0;
+function newWatchNum() {
+	return watchNum++;
+}
+
+function postData(data, cb) {
+	data._seed = Math.floor(Math.random() * 1000000)
+	if(cb) {
+		eth._callbacks[data._seed] = cb;
+	}
+
+	if(data.args === undefined) {
+		data.args = [];
+	}
+
+	navigator.qt.postMessage(JSON.stringify(data));
+}
+
+navigator.qt.onmessage = function(ev) {
+	var data = JSON.parse(ev.data)
+
+	if(data._event !== undefined) {
+		eth.trigger(data._event, data.data);
+	} else {
+		if(data._seed) {
+			var cb = eth._callbacks[data._seed];
+			if(cb) {
+				cb.call(this, data.data)
+
+				// Remove the "trigger" callback
+				delete eth._callbacks[ev._seed];
+			}
+		}
+	}
+}
+
+eth.on("chain:changed", function() {
+})
+
+eth.on("messages", { /* filters */}, function(messages){
+})
+
+eth.on("pending:changed", function() {
+})
 

ethereal/assets/ext/filter.js

@@ -0,0 +1,31 @@
+var Filter = function(options) {
+	this.callbacks = {};
+	this.seed = Math.floor(Math.random() * 1000000);
+	this.options = options;
+
+	if(options == "chain") {
+		eth.registerFilterString(options, this.seed);
+	} else if(typeof options === "object") {
+		eth.registerFilter(options, this.seed);
+	}
+};
+
+Filter.prototype.changed = function(callback) {
+	var cbseed = Math.floor(Math.random() * 1000000);
+	eth.registerFilterCallback(this.seed, cbseed);
+
+	var self = this;
+	message.connect(function(messages, seed, callbackSeed) {
+		if(seed ==  self.seed && callbackSeed == cbseed) {
+			callback.call(self, messages);
+		}
+	});
+};
+
+Filter.prototype.uninstall = function() {
+	eth.uninstallFilter(this.seed)
+}
+
+Filter.prototype.messages = function() {
+	return JSON.parse(eth.messages(this.options))
+}

ethereal/assets/ext/home.html

@@ -0,0 +1,22 @@
+<!doctype>
+<html>
+<head>
+<title>Ethereum</title>
+
+<style type="text/css">
+h1 {
+    text-align: center;
+    font-family: Courier;
+    font-size: 50pt;
+}
+</style>
+</head>
+
+<body>
+<h1>... Ethereum ...</h1>
+<ul>
+	<li><a href="http://std.eth">std::Service</a></li>
+</ul>
+</body>
+</html>
+

ethereal/assets/ext/pre.js

@@ -1,18 +1,3 @@
-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)
@@ -50,9 +35,3 @@ navigator.qt.onmessage = function(ev) {
 		}
 	}
 }
-
-window.onerror = function(message, file, lineNumber, column, errorObj) {
-	debug(file, message, lineNumber+":"+column, errorObj);
-
-	return false;
-}

ethereal/assets/ext/test.html

@@ -0,0 +1,44 @@
+<!doctype>
+<html>
+<head>
+<title>Tests</title>
+</head>
+
+<body>
+<button onclick="test();">Test me</button>
+
+<script type="text/javascript">
+function test() {
+	var filter = eth.watch({
+		latest: -1,
+		from: "e6716f9544a56c530d868e4bfbacb172315bdead",
+		altered: ["aabb", {id: "eeff", "at": "aabb"}],
+	});
+
+	filter.changed(function(messages) {
+		console.log("messages", messages)
+	})
+
+	filter.getMessages(function(messages) {
+			console.log("getMessages", messages)
+			});
+
+	eth.getEachStorageAt("9ef0f0d81e040012600b0c1abdef7c48f720f88a", function(entries) {
+			for(var i = 0; i < entries.length; i++) {
+				console.log(entries[i].key, " : ", entries[i].value)
+			}
+	})
+
+	eth.getBlock("f70097659f329a09642a27f11338d9269de64f1d4485786e36bfc410832148cd", function(block) {
+			console.log(block)
+	})
+
+	eth.mutan("var a = 10", function(code) {
+			console.log("code", code)
+	});
+}
+</script>
+
+</body>
+
+</html>

ethereal/assets/qml/views/chain.qml

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

ethereal/assets/qml/views/history.qml

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

ethereal/assets/qml/views/info.qml

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

ethereal/assets/qml/views/javascript.qml

@@ -0,0 +1,45 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0;
+import QtQuick.Layouts 1.0;
+import QtQuick.Dialogs 1.0;
+import QtQuick.Window 2.1;
+import QtQuick.Controls.Styles 1.1
+import Ethereum 1.0
+
+Rectangle {
+	property var title: "JavaScript"
+	property var iconSource: "../tx.png"
+	property var menuItem
+
+	objectName: "javascriptView"
+	visible: false
+	anchors.fill: parent
+
+	TextField {
+		id: input
+		anchors {
+			left: parent.left
+			right: parent.right
+			bottom: parent.bottom
+		}
+		height: 20
+
+		Keys.onReturnPressed: {
+			var res = eth.evalJavascriptString(this.text);
+			this.text = "";
+
+			output.append(res)
+		}
+	}
+
+	TextArea {
+		id: output
+		text: "> JSRE Ready..."
+		anchors {
+			top: parent.top
+			left: parent.left
+			right: parent.right
+			bottom: input.top
+		}
+	}
+}

ethereal/assets/qml/views/pending_tx.qml

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

ethereal/assets/qml/views/transaction.qml

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

ethereal/assets/qml/views/wallet.qml

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

ethereal/assets/qml/webapp.qml

@@ -2,6 +2,7 @@ import QtQuick 2.0
 import QtWebKit 3.0
 import QtWebKit.experimental 1.0
 import QtQuick.Controls 1.0;
+import QtQuick.Controls.Styles 1.0
 import QtQuick.Layouts 1.0;
 import QtQuick.Window 2.1;
 import Ethereum 1.0
@@ -9,8 +10,8 @@ import Ethereum 1.0
 ApplicationWindow {
 	id: window
 	title: "Ethereum"
-	width: 900
-	height: 600
+	width: 1000
+	height: 800
 	minimumHeight: 300
 
 	property alias url: webview.url
@@ -22,23 +23,117 @@ ApplicationWindow {
 		anchors.fill: parent
 		state: "inspectorShown"
 
+		RowLayout {
+			id: navBar
+			height: 40
+			anchors {
+				left: parent.left
+				right: parent.right
+				leftMargin: 7
+			}
+
+			Button {
+				id: back
+				onClicked: {
+					webview.goBack()
+				}
+				style: ButtonStyle {
+					background: Image {
+						source: "../back.png"
+						width: 30
+						height: 30
+					}
+				}
+			}
+
+			TextField {
+				anchors {
+					left: back.right
+					right: toggleInspector.left
+					leftMargin: 5
+					rightMargin: 5
+				}
+				id: uriNav
+				y: parent.height / 2 - this.height / 2
+
+				Keys.onReturnPressed: {
+					webview.url = this.text;
+				}
+			}
+
+			Button {
+				id: toggleInspector
+				anchors {
+					right: parent.right
+				}
+				iconSource: "../bug.png"
+				onClicked: {
+					if(inspector.visible == true){
+						inspector.visible = false
+					}else{
+						inspector.visible = true
+						inspector.url = webview.experimental.remoteInspectorUrl
+					}
+				}
+			}
+		}
+
+
 		WebView {
 			objectName: "webView"
 			id: webview
-			anchors.fill: parent
-			/*
-			 anchors {
-				 left: parent.left
-				 right: parent.right
-				 bottom: sizeGrip.top
-				 top: parent.top
-			 }
-			 */
+			anchors {
+				left: parent.left
+				right: parent.right
+				bottom: parent.bottom
+				top: navBar.bottom
+			}
 			onTitleChanged: { window.title = title }
+
+			property var cleanPath: false
+			onNavigationRequested: {
+				if(!this.cleanPath) {
+					var uri = request.url.toString();
+					if(!/.*\:\/\/.*/.test(uri)) {
+						uri = "http://" + uri;
+					}
+
+					var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/
+
+					if(reg.test(uri)) {
+						uri.replace(reg, function(match, pre, domain, path) {
+							uri = pre;
+
+							var lookup = ui.lookupDomain(domain.substring(0, domain.length - 4));
+							var ip = [];
+							for(var i = 0, l = lookup.length; i < l; i++) {
+								ip.push(lookup.charCodeAt(i))
+							}
+
+							if(ip.length != 0) {
+								uri += lookup;
+							} else {
+								uri += domain;
+							}
+
+							uri += path;
+						});
+					}
+
+					this.cleanPath = true;
+
+					webview.url = uri;
+				} else {
+					// Prevent inf loop.
+					this.cleanPath = false;
+				}
+			}
+
+
 			experimental.preferences.javascriptEnabled: true
 			experimental.preferences.navigatorQtObjectEnabled: true
 			experimental.preferences.developerExtrasEnabled: true
-			experimental.userScripts: [ui.assetPath("ext/pre.js"), ui.assetPath("ext/big.js"), ui.assetPath("ext/string.js"), ui.assetPath("ext/ethereum.js")]
+			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
@@ -46,105 +141,126 @@ ApplicationWindow {
 
 				try {
 					switch(data.call) {
-					case "getCoinBase":
-					      postData(data._seed, eth.getCoinBase())
+						case "getCoinBase":
+						postData(data._seed, eth.coinBase())
 
-					      break
-					case "getIsListening":
-					      postData(data._seed, eth.getIsListening())
+						break
 
-					      break
-					case "getIsMining":
-					      postData(data._seed, eth.getIsMining())
+						case "getIsListening":
+						postData(data._seed, eth.isListening())
 
-					      break
-					case "getPeerCount":
-					      postData(data._seed, eth.getPeerCount())
+						break
 
-					      break
+						case "getIsMining":
+						postData(data._seed, eth.isMining())
 
-					case "getTxCountAt":
-					      require(1)
-					      postData(data._seed, eth.getTxCountAt(data.args[0]))
+						break
 
-					      break
-					case "getBlockByNumber":
-						var block = eth.getBlock(data.args[0])
+						case "getPeerCount":
+						postData(data._seed, eth.peerCount())
+
+						break
+
+						case "getTxCountAt":
+						require(1)
+						postData(data._seed, eth.txCountAt(data.args[0]))
+
+						break
+
+						case "getBlockByNumber":
+						var block = eth.blockByNumber(data.args[0])
 						postData(data._seed, block)
 
 						break
-					case "getBlockByHash":
-						var block = eth.getBlock(data.args[0])
+
+						case "getBlockByHash":
+						var block = eth.blockByHash(data.args[0])
 						postData(data._seed, block)
 
 						break
-					case "transact":
+
+						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":
+						case "getStorage":
 						require(2);
 
-						var stateObject = eth.getStateObject(data.args[0])
-						var storage = stateObject.getStorage(data.args[1])
+						var stateObject = eth.stateObject(data.args[0])
+						var storage = stateObject.storageAt(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)
+
+						case "getEachStorage":
+						require(1);
+						var storage = JSON.parse(eth.eachStorage(data.args[0]))
+						postData(data._seed, storage)
 
 						break
-					case "getTransactionsFor":
-					      require(1);
-					      var txs = eth.getTransactionsFor(data.args[0], true)
-					      postData(data._seed, txs)
 
-					      break
-					case "getBalance":
+						case "getTransactionsFor":
+						require(1);
+						var txs = eth.transactionsFor(data.args[0], true)
+						postData(data._seed, txs)
+
+						break
+
+						case "getBalance":
 						require(1);
 
-						postData(data._seed, eth.getStateObject(data.args[0]).value());
+						postData(data._seed, eth.stateObject(data.args[0]).value());
 
 						break
-					case "getKey":
-						var key = eth.getKey().privateKey;
+
+						case "getKey":
+						var key = eth.key().privateKey;
 
 						postData(data._seed, key)
 						break
-					case "watch":
-						require(1)
-						eth.watch(data.args[0], data.args[1]);
-						break
-					case "disconnect":
+
+						/*
+						case "watch":
+							require(1)
+							eth.watch(data.args[0], data.args[1]);
+
+							break
+						*/
+					       case "watch":
+					       		require(2)
+							eth.watch(data.args[0], data.args[1])
+
+						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":
+
+						case "getSecretToAddress":
 						require(1)
 						postData(data._seed, eth.secretToAddress(data.args[0]))
+
 						break;
-					case "debug":
-						console.log(data.args[0]);
-						break;
+
+						case "messages":
+							require(1);
+
+							var messages = JSON.parse(eth.getMessages(data.args[0]))
+							postData(data._seed, messages)
+
+							break
+
+						case "mutan":
+							require(1)
+
+							var code = eth.compileMutan(data.args[0])
+							postData(data._seed, "0x"+code)
+
+							break;
 					}
 				} catch(e) {
 					console.log(data.call + ": " + e)
@@ -153,6 +269,11 @@ ApplicationWindow {
 				}
 			}
 
+			function post(seed, data) {
+				console.log("data", data)
+				postData(data._seed, data)
+			}
+
 			function require(args, num) {
 				if(args.length < num) {
 					throw("required argument count of "+num+" got "+args.length);
@@ -165,6 +286,11 @@ ApplicationWindow {
 				webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
 			}
 
+			function onWatchedCb(data, id) {
+				var messages = JSON.parse(data)
+				postEvent("watched:"+id, messages)
+			}
+
 			function onNewBlockCb(block) {
 				postEvent("block:new", block)
 			}
@@ -176,30 +302,7 @@ ApplicationWindow {
 				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
-					}
-				}
-				onDoubleClicked: {
-				  console.log('refreshing')
-				  webView.reload()
-				}
-				anchors.fill: parent
-			}
-		}
+
 
 		Rectangle {
 			id: sizeGrip
@@ -224,7 +327,6 @@ ApplicationWindow {
 		WebView {
 			id: inspector
 			visible: false
-			url: webview.experimental.remoteInspectorUrl
 			anchors {
 				left: root.left
 				right: root.right
@@ -238,7 +340,6 @@ ApplicationWindow {
 				name: "inspectorShown"
 				PropertyChanges {
 					target: inspector
-					url: webview.experimental.remoteInspectorUrl
 				}
 			}
 		]

ethereal/assets/samplecoin/samplecoin.css

@@ -1,34 +0,0 @@
-/* Space out content a bit */
-body {
-	padding-top: 20px;
-	padding-bottom: 20px;
-}
-
-/* Everything but the jumbotron gets side spacing for mobile first
- * views */
-.header,
-.marketing,
-.footer {
-	padding-right: 15px;
-	padding-left: 15px;
-}
-
-/* Custom page header */
-.header {
-	border-bottom: 1px solid #e5e5e5;
-}
-/* Make the masthead heading the same height as the navigation */
-.header h3 {
-	padding-bottom: 19px;
-	margin-top: 0;
-	margin-bottom: 0;
-	line-height: 40px;
-}
-
-.jumbotron {
-	text-align: center;
-	border-bottom: 1px solid #e5e5e5;
-
-	margin: 0 auto;
-	width: 300px;
-}

ethereal/assets/samplecoin/samplecoin.html

@@ -1,68 +0,0 @@
-<html>
-<head>
-<title>jeffcoin</title>
-
-<link rel="stylesheet" href="bootstrap.min.css">
-<link rel="stylesheet" href="bootstrap-theme.min.css">
-<link rel="stylesheet" href="samplecoin.css">
-<meta name="viewport" content="minimum-scale=1; maximum-scale=1; initial-scale=1;">
-
-<script type="text/javascript">
-
-var jefcoinAddr = "22fa3ebce6ef9ca661a960104d3087eec040011e"
-var mAddr = ""
-
-function createTransaction() {
-	var addr = ("0x" + document.querySelector("#addr").value).pad(32);
-	var amount = document.querySelector("#amount").value.pad(32);
-
-	var data = (addr + amount).unbin();
-	eth.transact(mAddr, jefcoinAddr, 0, "50000", "1000000", data, function(receipt) {
-		debug("received tx hash:", reciept.address)
-	})
-}
-
-function init() {
-	eth.getKey(function(sec) {
-		mAddr = sec;
-		eth.getSecretToAddress(sec, function(addr) {
-			eth.getStorageAt(jefcoinAddr, addr, function(storage) {
-				document.querySelector("#current-amount").innerHTML = storage;
-			});
-
-			eth.watch(jefcoinAddr, addr, function(addr, value) {
-				document.querySelector("#current-amount").innerHTML = value
-			});
-		});
-	});
-}
-
-</script>
-</head>
-
-<body onload="init();">
-<div class="container">
-	<div class="header">
-		<h3 class="text-muted">JeffCoin</h3>
-	</div>
-
-	<div class="jumbotron ">
-		<img src="icon.png">
-		<div>Amount: <strong id="current-amount"></strong></div>
-
-		<div id="transactions">
-			<div class="form-group">
-				<input id="addr" class="form-control" type="text" placeholder="Receiver address"></input><br>
-				<input id="amount" class="form-control" type="text" placeholder="Amount"></input><br>
-			</div>
-
-			<button class="btn btn-default" onclick="createTransaction();">Send Tx</button>
-		</div>
-	</div>
-</div>
-
-<div id="debug" style="border: 1px solid black; min-height: 30px;"></div>
-
-</body>
-</html>
-

ethereal/debugger.go

@@ -0,0 +1,320 @@
+package main
+
+import (
+	"fmt"
+	"math/big"
+	"strconv"
+	"strings"
+
+	"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"
+	"gopkg.in/qml.v1"
+)
+
+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 := utils.FormatTransactionData(dataStr)
+
+	var err error
+	script := ethutil.StringToByteFunc(scriptStr, func(s string) (ret []byte) {
+		ret, err = ethutil.Compile(s, false)
+		return
+	})
+
+	if err != nil {
+		self.Logln(err)
+
+		return
+	}
+
+	var (
+		gas      = ethutil.Big(gasStr)
+		gasPrice = ethutil.Big(gasPriceStr)
+		value    = ethutil.Big(valueStr)
+		// Contract addr as test address
+		keyPair = self.lib.eth.KeyManager().KeyPair()
+	)
+
+	state := self.lib.eth.StateManager().TransState()
+	account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
+	contract := ethstate.NewStateObject([]byte{0})
+	contract.Balance = value
+
+	self.SetAsm(script)
+
+	block := self.lib.eth.BlockChain().CurrentBlock
+
+	callerClosure := ethvm.NewClosure(&ethstate.Message{}, account, contract, script, gas, gasPrice)
+	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

@@ -1,11 +1,14 @@
-package ethui
+package main
 
 import (
-	"fmt"
+	"encoding/json"
+
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/go-qml/qml"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethreact"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/go-ethereum/javascript"
+	"gopkg.in/qml.v1"
 )
 
 type AppContainer interface {
@@ -16,34 +19,37 @@ type AppContainer interface {
 	Engine() *qml.Engine
 
 	NewBlock(*ethchain.Block)
-	ObjectChanged(*ethchain.StateObject)
-	StorageChanged(*ethchain.StorageState)
 	NewWatcher(chan bool)
+	Messages(ethstate.Messages, string)
+	Post(string, int)
 }
 
 type ExtApplication struct {
-	*ethpub.PEthereum
+	*ethpipe.JSPipe
+	eth ethchain.EthManager
 
-	blockChan       chan ethutil.React
-	changeChan      chan ethutil.React
+	blockChan       chan ethreact.Event
+	messageChan     chan ethreact.Event
 	quitChan        chan bool
 	watcherQuitChan chan bool
 
-	container        AppContainer
-	lib              *UiLib
-	registeredEvents []string
+	filters map[string]*ethchain.Filter
+
+	container AppContainer
+	lib       *UiLib
 }
 
 func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
 	app := &ExtApplication{
-		ethpub.NewPEthereum(lib.eth),
-		make(chan ethutil.React, 1),
-		make(chan ethutil.React, 1),
+		ethpipe.NewJSPipe(lib.eth),
+		lib.eth,
+		make(chan ethreact.Event, 100),
+		make(chan ethreact.Event, 100),
 		make(chan bool),
 		make(chan bool),
+		make(map[string]*ethchain.Filter),
 		container,
 		lib,
-		nil,
 	}
 
 	return app
@@ -57,8 +63,7 @@ func (app *ExtApplication) run() {
 
 	err := app.container.Create()
 	if err != nil {
-		fmt.Println(err)
-
+		logger.Errorln(err)
 		return
 	}
 
@@ -68,6 +73,7 @@ func (app *ExtApplication) run() {
 	// Subscribe to events
 	reactor := app.lib.eth.Reactor()
 	reactor.Subscribe("newBlock", app.blockChan)
+	reactor.Subscribe("messages", app.messageChan)
 
 	app.container.NewWatcher(app.watcherQuitChan)
 
@@ -82,9 +88,6 @@ 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
@@ -92,7 +95,6 @@ func (app *ExtApplication) stop() {
 
 	close(app.blockChan)
 	close(app.quitChan)
-	close(app.changeChan)
 
 	app.container.Destroy()
 }
@@ -107,26 +109,37 @@ out:
 			if block, ok := block.Resource.(*ethchain.Block); ok {
 				app.container.NewBlock(block)
 			}
-		case object := <-app.changeChan:
-			if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
-				app.container.ObjectChanged(stateObject)
-			} else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
-				app.container.StorageChanged(storageObject)
+		case msg := <-app.messageChan:
+			if messages, ok := msg.Resource.(ethstate.Messages); ok {
+				for id, filter := range app.filters {
+					msgs := filter.FilterMessages(messages)
+					if len(msgs) > 0 {
+						app.container.Messages(msgs, id)
+					}
+				}
 			}
 		}
 	}
 
 }
 
-func (app *ExtApplication) Watch(addr, storageAddr string) {
-	var event string
-	if len(storageAddr) == 0 {
-		event = "object:" + string(ethutil.FromHex(addr))
-		app.lib.eth.Reactor().Subscribe(event, app.changeChan)
-	} else {
-		event = "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr))
-		app.lib.eth.Reactor().Subscribe(event, app.changeChan)
+func (self *ExtApplication) Watch(filterOptions map[string]interface{}, identifier string) {
+	self.filters[identifier] = ethchain.NewFilterFromMap(filterOptions, self.eth)
+}
+
+func (self *ExtApplication) GetMessages(object map[string]interface{}) string {
+	filter := ethchain.NewFilterFromMap(object, self.eth)
+
+	messages := filter.Find()
+	var msgs []javascript.JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, javascript.NewJSMessage(m))
 	}
 
-	app.registeredEvents = append(app.registeredEvents, event)
+	b, err := json.Marshal(msgs)
+	if err != nil {
+		return "{\"error\":" + err.Error() + "}"
+	}
+
+	return string(b)
 }

ethereal/flags.go

@@ -13,6 +13,8 @@ import (
 )
 
 var Identifier string
+var KeyRing string
+var KeyStore string
 var StartRpc bool
 var RpcPort int
 var UseUPnP bool
@@ -22,8 +24,8 @@ var AddPeer string
 var MaxPeer int
 var GenAddr bool
 var UseSeed bool
-var ImportKey string
-var ExportKey bool
+var SecretFile string
+var ExportDir string
 var NonInteractive bool
 var Datadir string
 var LogFile string
@@ -34,6 +36,7 @@ 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
@@ -50,15 +53,14 @@ func defaultAssetPath() string {
 			assetPath = filepath.Join(exedir, "../Resources")
 		case "linux":
 			assetPath = "/usr/share/ethereal"
-		case "window":
-			fallthrough
+		case "windows":
+			assetPath = "./assets"
 		default:
 			assetPath = "."
 		}
 	}
 	return assetPath
 }
-
 func defaultDataDir() string {
 	usr, _ := user.Current()
 	return path.Join(usr.HomeDir, ".ethereal")
@@ -73,6 +75,8 @@ func Init() {
 	}
 
 	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")
@@ -81,9 +85,9 @@ func Init() {
 	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.BoolVar(&ExportKey, "export", false, "export private 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(&ImportKey, "import", "", "imports the given private key (hex)")
 	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)")

ethereal/gui.go

@@ -0,0 +1,600 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"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/ethpipe"
+	"github.com/ethereum/eth-go/ethreact"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/eth-go/ethwire"
+	"github.com/ethereum/go-ethereum/utils"
+	"gopkg.in/qml.v1"
+)
+
+var logger = ethlog.NewLogger("GUI")
+
+type plugin struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+}
+
+type Gui struct {
+	// The main application window
+	win *qml.Window
+	// QML Engine
+	engine    *qml.Engine
+	component *qml.Common
+	qmlDone   bool
+	// The ethereum interface
+	eth *eth.Ethereum
+
+	// The public Ethereum library
+	uiLib *UiLib
+
+	txDb *ethdb.LDBDatabase
+
+	logLevel ethlog.LogLevel
+	open     bool
+
+	pipe *ethpipe.JSPipe
+
+	Session        string
+	clientIdentity *ethwire.SimpleClientIdentity
+	config         *ethutil.ConfigManager
+
+	plugins map[string]plugin
+
+	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)
+	}
+
+	pipe := ethpipe.NewJSPipe(ethereum)
+	gui := &Gui{eth: ethereum, txDb: db, pipe: pipe, logLevel: ethlog.LogLevel(logLevel), Session: session, open: false, clientIdentity: clientIdentity, config: config, plugins: make(map[string]plugin)}
+	data, err := ethutil.ReadAllFile(ethutil.Config.ExecPath + "/plugins.json")
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println("plugins:", string(data))
+
+	json.Unmarshal([]byte(data), &gui.plugins)
+
+	return gui
+}
+
+func (gui *Gui) Start(assetPath string) {
+
+	defer gui.txDb.Close()
+
+	// Register ethereum functions
+	qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
+		Init: func(p *ethpipe.JSBlock, obj qml.Object) { p.Number = 0; p.Hash = "" },
+	}, {
+		Init: func(p *ethpipe.JSTransaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
+	}, {
+		Init: func(p *ethpipe.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
+	}})
+	// Create a new QML engine
+	gui.engine = qml.NewEngine()
+	context := gui.engine.Context()
+	gui.uiLib = NewUiLib(gui.engine, gui.eth, assetPath)
+
+	// Expose the eth library and the ui library to QML
+	context.SetVar("gui", gui)
+	context.SetVar("eth", gui.uiLib)
+
+	// Load the main QML interface
+	data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
+
+	var win *qml.Window
+	var err error
+	var addlog = false
+	if len(data) == 0 {
+		win, err = gui.showKeyImport(context)
+	} else {
+		win, err = gui.showWallet(context)
+		addlog = true
+	}
+	if err != nil {
+		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()
+	}
+
+	gui.uiLib.jsEngine.Stop()
+
+	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
+	}
+
+	gui.win = gui.createWindow(component)
+
+	gui.update()
+
+	return gui.win, nil
+}
+
+func (self *Gui) DumpState(hash, path string) {
+	var stateDump []byte
+
+	if len(hash) == 0 {
+		stateDump = self.eth.StateManager().CurrentState().Dump()
+	} else {
+		var block *ethchain.Block
+		if hash[0] == '#' {
+			i, _ := strconv.Atoi(hash[1:])
+			block = self.eth.BlockChain().GetBlockByNumber(uint64(i))
+		} else {
+			block = self.eth.BlockChain().GetBlock(ethutil.Hex2Bytes(hash))
+		}
+
+		if block == nil {
+			logger.Infof("block err: not found %s\n", hash)
+			return
+		}
+
+		stateDump = block.State().Dump()
+	}
+
+	file, err := os.OpenFile(path[7:], os.O_CREATE|os.O_RDWR, os.ModePerm)
+	if err != nil {
+		logger.Infoln("dump err: ", err)
+		return
+	}
+	defer file.Close()
+
+	logger.Infof("dumped state (%s) to %s\n", hash, path)
+
+	file.Write(stateDump)
+}
+
+// The done handler will be called by QML when all views have been loaded
+func (gui *Gui) Done() {
+	gui.qmlDone = true
+
+}
+
+func (gui *Gui) ImportKey(filePath string) {
+}
+
+func (gui *Gui) showKeyImport(context *qml.Context) (*qml.Window, error) {
+	context.SetVar("lib", gui)
+	component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/first_run.qml"))
+	if err != nil {
+		return nil, err
+	}
+	return gui.createWindow(component), nil
+}
+
+func (gui *Gui) createWindow(comp qml.Object) *qml.Window {
+	win := comp.CreateWindow(nil)
+
+	gui.win = win
+	gui.uiLib.win = win
+
+	return gui.win
+}
+
+func (gui *Gui) ImportAndSetPrivKey(secret string) bool {
+	err := gui.eth.KeyManager().InitFromString(gui.Session, 0, secret)
+	if err != nil {
+		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() {
+	view := gui.getObjectByName("infoView")
+	view.Call("clearAddress")
+
+	nameReg := gui.pipe.World().Config().Get("NameReg")
+	if nameReg != nil {
+		nameReg.EachStorage(func(name string, value *ethutil.Value) {
+			if name[0] != 0 {
+				value.Decode()
+
+				view.Call("addAddress", struct{ Name, Address string }{name, ethutil.Bytes2Hex(value.Bytes())})
+			}
+		})
+	}
+}
+
+func (gui *Gui) insertTransaction(window string, tx *ethchain.Transaction) {
+	nameReg := ethpipe.New(gui.eth).World().Config().Get("NameReg")
+	addr := gui.address()
+
+	var inout string
+	if bytes.Compare(tx.Sender(), addr) == 0 {
+		inout = "send"
+	} else {
+		inout = "recv"
+	}
+
+	var (
+		ptx  = ethpipe.NewJSTx(tx)
+		send = nameReg.Storage(tx.Sender())
+		rec  = nameReg.Storage(tx.Recipient)
+		s, r string
+	)
+
+	if tx.CreatesContract() {
+		rec = nameReg.Storage(tx.CreationAddress())
+	}
+
+	if send.Len() != 0 {
+		s = strings.Trim(send.Str(), "\x00")
+	} else {
+		s = ethutil.Bytes2Hex(tx.Sender())
+	}
+	if rec.Len() != 0 {
+		r = strings.Trim(rec.Str(), "\x00")
+	} else {
+		if tx.CreatesContract() {
+			r = ethutil.Bytes2Hex(tx.CreationAddress())
+		} else {
+			r = ethutil.Bytes2Hex(tx.Recipient)
+		}
+	}
+	ptx.Sender = s
+	ptx.Address = r
+
+	if window == "post" {
+		gui.getObjectByName("transactionView").Call("addTx", ptx, inout)
+	} else {
+		gui.getObjectByName("pendingTxView").Call("addTx", ptx, inout)
+	}
+}
+
+func (gui *Gui) readPreviousTransactions() {
+	it := gui.txDb.Db().NewIterator(nil, nil)
+	for it.Next() {
+		tx := ethchain.NewTransactionFromBytes(it.Value())
+
+		gui.insertTransaction("post", tx)
+
+	}
+	it.Release()
+}
+
+func (gui *Gui) processBlock(block *ethchain.Block, initial bool) {
+	name := strings.Trim(gui.pipe.World().Config().Get("NameReg").Storage(block.Coinbase).Str(), "\x00")
+	b := ethpipe.NewJSBlock(block)
+	b.Name = name
+
+	gui.getObjectByName("chainView").Call("addBlock", b, initial)
+}
+
+func (gui *Gui) setWalletValue(amount, unconfirmedFunds *big.Int) {
+	var str string
+	if unconfirmedFunds != nil {
+		pos := "+"
+		if unconfirmedFunds.Cmp(big.NewInt(0)) < 0 {
+			pos = "-"
+		}
+		val := ethutil.CurrencyToString(new(big.Int).Abs(ethutil.BigCopy(unconfirmedFunds)))
+		str = fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(amount), pos, val)
+	} else {
+		str = fmt.Sprintf("%v", ethutil.CurrencyToString(amount))
+	}
+
+	gui.win.Root().Call("setWalletValue", str)
+}
+
+func (self *Gui) getObjectByName(objectName string) qml.Object {
+	return self.win.Root().ObjectByName(objectName)
+}
+
+// Simple go routine function that updates the list of peers in the GUI
+func (gui *Gui) update() {
+	// We have to wait for qml to be done loading all the windows.
+	for !gui.qmlDone {
+		time.Sleep(500 * time.Millisecond)
+	}
+
+	go func() {
+		go gui.setInitialBlockChain()
+		gui.loadAddressBook()
+		gui.setPeerInfo()
+		gui.readPreviousTransactions()
+	}()
+
+	for _, plugin := range gui.plugins {
+		gui.win.Root().Call("addPlugin", plugin.Path, "")
+	}
+
+	var (
+		blockChan     = make(chan ethreact.Event, 100)
+		txChan        = make(chan ethreact.Event, 100)
+		objectChan    = make(chan ethreact.Event, 100)
+		peerChan      = make(chan ethreact.Event, 100)
+		chainSyncChan = make(chan ethreact.Event, 100)
+		miningChan    = make(chan ethreact.Event, 100)
+	)
+
+	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()).Balance)))
+	gui.getObjectByName("syncProgressIndicator").Set("visible", !gui.eth.IsUpToDate())
+
+	lastBlockLabel := gui.getObjectByName("lastBlockLabel")
+
+	go func() {
+		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()).Balance, nil)
+				}
+			case txMsg := <-txChan:
+				tx := txMsg.Resource.(*ethchain.Transaction)
+
+				if txMsg.Name == "newTx:pre" {
+					object := state.GetAccount(gui.address())
+
+					if bytes.Compare(tx.Sender(), gui.address()) == 0 {
+						unconfirmedFunds.Sub(unconfirmedFunds, tx.Value)
+					} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
+						unconfirmedFunds.Add(unconfirmedFunds, tx.Value)
+					}
+
+					gui.setWalletValue(object.Balance, unconfirmedFunds)
+
+					gui.insertTransaction("pre", tx)
+				} else {
+					object := state.GetAccount(gui.address())
+					if bytes.Compare(tx.Sender(), gui.address()) == 0 {
+						object.SubAmount(tx.Value)
+
+						gui.getObjectByName("transactionView").Call("addTx", ethpipe.NewJSTx(tx), "send")
+						gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+					} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
+						object.AddAmount(tx.Value)
+
+						gui.getObjectByName("transactionView").Call("addTx", ethpipe.NewJSTx(tx), "recv")
+						gui.txDb.Put(tx.Hash(), tx.RlpEncode())
+					}
+
+					gui.setWalletValue(object.Balance, 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.Name == "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)
+			}
+		}
+	}()
+
+	reactor := gui.eth.Reactor()
+
+	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 := gui.pipe.World().Config().Get("NameReg")
+	reactor.Subscribe("object:"+string(nameReg.Address()), objectChan)
+
+	reactor.Subscribe("peerList", peerChan)
+}
+
+func (gui *Gui) CopyToClipboard(data string) {
+	//clipboard.WriteAll("test")
+	fmt.Println("COPY currently BUGGED. Here are the contents:\n", data)
+}
+
+func (gui *Gui) setPeerInfo() {
+	gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers))
+
+	gui.win.Root().Call("resetPeers")
+	for _, peer := range gui.pipe.Peers() {
+		gui.win.Root().Call("addPeer", peer)
+	}
+}
+
+func (gui *Gui) privateKey() string {
+	return ethutil.Bytes2Hex(gui.eth.KeyManager().PrivateKey())
+}
+
+func (gui *Gui) address() []byte {
+	return gui.eth.KeyManager().Address()
+}
+
+func (gui *Gui) Transact(recipient, value, gas, gasPrice, d string) (*ethpipe.JSReceipt, error) {
+	var data string
+	if len(recipient) == 0 {
+		code, err := ethutil.Compile(d, false)
+		if err != nil {
+			return nil, err
+		}
+		data = ethutil.Bytes2Hex(code)
+	} else {
+		data = ethutil.Bytes2Hex(utils.FormatTransactionData(d))
+	}
+
+	return gui.pipe.Transact(gui.privateKey(), recipient, value, gas, gasPrice, data)
+}
+
+func (gui *Gui) SetCustomIdentifier(customIdentifier string) {
+	gui.clientIdentity.SetCustomIdentifier(customIdentifier)
+	gui.config.Save("id", customIdentifier)
+}
+
+func (gui *Gui) GetCustomIdentifier() string {
+	return gui.clientIdentity.GetCustomIdentifier()
+}
+
+// functions that allow Gui to implement interface 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
+}
+
+func (self *Gui) AddPlugin(pluginPath string) {
+	self.plugins[pluginPath] = plugin{Name: "SomeName", Path: pluginPath}
+
+	json, _ := json.MarshalIndent(self.plugins, "", "    ")
+	ethutil.WriteFile(ethutil.Config.ExecPath+"/plugins.json", json)
+}
+
+func (self *Gui) RemovePlugin(pluginPath string) {
+	delete(self.plugins, pluginPath)
+
+	json, _ := json.MarshalIndent(self.plugins, "", "    ")
+	ethutil.WriteFile(ethutil.Config.ExecPath+"/plugins.json", json)
+}
+
+// this extra function needed to give int typecast value to gui widget
+// that sets initial loglevel to default
+func (gui *Gui) GetLogLevelInt() int {
+	return int(gui.logLevel)
+}
+
+func (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")
+
+		view := gui.getObjectByName("infoView")
+		for _, line := range lines {
+			view.Call("addLog", line)
+		}
+	*/
+}

ethereal/html_container.go

@@ -1,18 +1,22 @@
-package ethui
+package main
 
 import (
+	"encoding/json"
 	"errors"
-	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/go-qml/qml"
-	"github.com/howeyc/fsnotify"
+	"fmt"
 	"io/ioutil"
-	"log"
 	"net/url"
 	"os"
 	"path"
 	"path/filepath"
+
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/howeyc/fsnotify"
+	"gopkg.in/qml.v1"
 )
 
 type HtmlApplication struct {
@@ -41,7 +45,7 @@ func (app *HtmlApplication) Create() error {
 		return errors.New("Ethereum package not yet supported")
 
 		// TODO
-		ethutil.OpenPackage(app.path)
+		//ethutil.OpenPackage(app.path)
 	}
 
 	win := component.CreateWindow(nil)
@@ -59,7 +63,7 @@ func (app *HtmlApplication) RootFolder() string {
 	if err != nil {
 		return ""
 	}
-	return path.Dir(folder.RequestURI())
+	return path.Dir(ethutil.WindonizePath(folder.RequestURI()))
 }
 func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
 	files, _ := ioutil.ReadDir(app.RootFolder())
@@ -77,11 +81,13 @@ func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
 
 	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 {
-		log.Fatal(err)
+		logger.Infoln("Could not start auto-reload watcher:", err)
+		return
 	}
 	for _, folder := range app.RecursiveFolders() {
 		fullPath := app.RootFolder() + "/" + folder.Name()
@@ -116,18 +122,26 @@ func (app *HtmlApplication) Window() *qml.Window {
 }
 
 func (app *HtmlApplication) NewBlock(block *ethchain.Block) {
-	b := &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
+	b := &ethpipe.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
 	app.webView.Call("onNewBlockCb", b)
 }
 
-func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) {
-	app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
-}
+func (self *HtmlApplication) Messages(messages ethstate.Messages, id string) {
+	var msgs []javascript.JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, javascript.NewJSMessage(m))
+	}
 
-func (app *HtmlApplication) StorageChanged(storageObject *ethchain.StorageState) {
-	app.webView.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
+	b, _ := json.Marshal(msgs)
+
+	self.webView.Call("onWatchedCb", string(b), id)
 }
 
 func (app *HtmlApplication) Destroy() {
 	app.engine.Destroy()
 }
+
+func (app *HtmlApplication) Post(data string, seed int) {
+	fmt.Println("about to call 'post'")
+	app.webView.Call("post", seed, data)
+}

ethereal/main.go

@@ -1,38 +1,42 @@
 package main
 
 import (
-	"github.com/ethereum/eth-go/ethlog"
-	"github.com/ethereum/go-ethereum/ethereal/ui"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/go-qml/qml"
 	"os"
 	"runtime"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/go-ethereum/utils"
+	"gopkg.in/qml.v1"
 )
 
-func main() {
-	runtime.GOMAXPROCS(runtime.NumCPU())
+const (
+	ClientIdentifier = "Ethereal"
+	Version          = "0.6.3"
+)
 
-	qml.Init(nil)
-
-	var interrupted = false
-	utils.RegisterInterrupt(func(os.Signal) {
-		interrupted = true
-	})
-
-	utils.HandleInterrupt()
+var ethereum *eth.Ethereum
 
+func run() error {
 	// precedence: code-internal flag default < config file < environment variables < command line
 	Init() // parsing command line
-	utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
+
+	config := utils.InitConfig(ConfigFile, Datadir, "ETH")
 
 	utils.InitDataDir(Datadir)
 
 	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
 
-	ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer)
+	db := utils.NewDatabase()
+
+	keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
 
 	// create, import, export keys
-	utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive)
+	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)
@@ -42,7 +46,7 @@ func main() {
 		utils.StartRpc(ethereum, RpcPort)
 	}
 
-	gui := ethui.New(ethereum, LogLevel)
+	gui := NewWindow(ethereum, config, clientIdentity, KeyRing, LogLevel)
 
 	utils.RegisterInterrupt(func(os.Signal) {
 		gui.Stop()
@@ -50,6 +54,26 @@ func main() {
 	utils.StartEthereum(ethereum, UseSeed)
 	// gui blocks the main thread
 	gui.Start(AssetPath)
+
+	return nil
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	// This is a bit of a cheat, but ey!
+	os.Setenv("QTWEBKIT_INSPECTOR_SERVER", "127.0.0.1:99999")
+
+	//qml.Init(nil)
+	qml.Run(run)
+
+	var interrupted = false
+	utils.RegisterInterrupt(func(os.Signal) {
+		interrupted = true
+	})
+
+	utils.HandleInterrupt()
+
 	// 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 {

ethereal/qml_container.go

@@ -1,10 +1,14 @@
-package ethui
+package main
 
 import (
+	"fmt"
+	"runtime"
+
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethstate"
 	"github.com/ethereum/eth-go/ethutil"
-	"github.com/go-qml/qml"
+	"gopkg.in/qml.v1"
 )
 
 type QmlApplication struct {
@@ -20,7 +24,14 @@ func NewQmlApplication(path string, lib *UiLib) *QmlApplication {
 }
 
 func (app *QmlApplication) Create() error {
-	component, err := app.engine.LoadFile(app.path)
+	path := string(app.path)
+
+	// For some reason for windows we get /c:/path/to/something, windows doesn't like the first slash but is fine with the others so we are removing it
+	if app.path[0] == '/' && runtime.GOOS == "windows" {
+		path = app.path[1:]
+	}
+
+	component, err := app.engine.LoadFile(path)
 	if err != nil {
 		logger.Warnln(err)
 	}
@@ -38,16 +49,12 @@ 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.Hex(block.Hash())}
+	pblock := &ethpipe.JSBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
 	app.win.Call("onNewBlockCb", pblock)
 }
 
-func (app *QmlApplication) ObjectChanged(stateObject *ethchain.StateObject) {
-	app.win.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
-}
-
-func (app *QmlApplication) StorageChanged(storageObject *ethchain.StorageState) {
-	app.win.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
+func (self *QmlApplication) Messages(msgs ethstate.Messages, id string) {
+	fmt.Println("IMPLEMENT QML APPLICATION MESSAGES METHOD")
 }
 
 // Getters
@@ -57,3 +64,5 @@ func (app *QmlApplication) Engine() *qml.Engine {
 func (app *QmlApplication) Window() *qml.Window {
 	return app.win
 }
+
+func (app *QmlApplication) Post(data string, s int) {}

ethereal/ui/debugger.go

@@ -1,234 +0,0 @@
-package ethui
-
-import (
-	"fmt"
-	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/go-qml/qml"
-	"math/big"
-	"strings"
-)
-
-type DebuggerWindow struct {
-	win    *qml.Window
-	engine *qml.Engine
-	lib    *UiLib
-	Db     *Debugger
-}
-
-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)
-	db := &Debugger{win, make(chan bool), make(chan bool), true, false, true}
-
-	return &DebuggerWindow{engine: engine, win: win, lib: lib, Db: db}
-}
-
-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 string) {
-	dis := ethchain.Disassemble(ethutil.FromHex(data))
-	for _, str := range dis {
-		self.win.Root().Call("setAsm", str)
-	}
-}
-
-func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, dataStr string) {
-	if !self.Db.done {
-		self.Db.Q <- true
-	}
-	self.Db.breakOnInstr = self.win.Root().ObjectByName("breakEachLine").Bool("checked")
-
-	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)
-		return
-	})
-
-	if err != nil {
-		self.Logln(err)
-
-		return
-	}
-
-	dis := ethchain.Disassemble(script)
-	self.win.Root().Call("clearAsm")
-	self.win.Root().Call("clearLog")
-
-	for _, str := range dis {
-		self.win.Root().Call("setAsm", str)
-	}
-
-	var (
-		gas      = ethutil.Big(gasStr)
-		gasPrice = ethutil.Big(gasPriceStr)
-		value    = ethutil.Big(valueStr)
-		// Contract addr as test address
-		keyPair  = ethutil.GetKeyRing().Get(0)
-		callerTx = ethchain.NewContractCreationTx(ethutil.Big(valueStr), gas, gasPrice, script)
-	)
-	callerTx.Sign(keyPair.PrivateKey)
-
-	state := self.lib.eth.BlockChain().CurrentBlock.State()
-	account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
-	contract := ethchain.MakeContract(callerTx, state)
-	contract.Amount = value
-	callerClosure := ethchain.NewClosure(account, contract, script, state, 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),
-	})
-	vm.Verbose = true
-
-	self.Db.done = false
-	self.Logf("callsize %d", len(script))
-	go func() {
-		ret, g, err := callerClosure.Call(vm, data, self.Db.halting)
-		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()
-}
-
-type Debugger struct {
-	win             *qml.Window
-	N               chan bool
-	Q               chan bool
-	done, interrupt bool
-	breakOnInstr    bool
-}
-
-type storeVal struct {
-	Key, Value string
-}
-
-func (d *Debugger) halting(pc int, op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack, stateObject *ethchain.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.State().EachStorage(func(key string, node *ethutil.Value) {
-		d.win.Root().Call("setStorage", storeVal{fmt.Sprintf("% x", key), fmt.Sprintf("% x", node.Str())})
-	})
-
-	if d.breakOnInstr {
-	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/ui/gui.go

@@ -1,389 +0,0 @@
-package ethui
-
-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/ethpub"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/go-qml/qml"
-	"math/big"
-	"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
-	lib   *EthLib
-	uiLib *UiLib
-
-	txDb *ethdb.LDBDatabase
-
-	addr []byte
-
-	pub      *ethpub.PEthereum
-	logLevel ethlog.LogLevel
-	open     bool
-}
-
-// Create GUI, but doesn't start it
-func New(ethereum *eth.Ethereum, logLevel int) *Gui {
-	lib := &EthLib{stateManager: ethereum.StateManager(), blockChain: ethereum.BlockChain(), txPool: ethereum.TxPool()}
-	db, err := ethdb.NewLDBDatabase("tx_database")
-	if err != nil {
-		panic(err)
-	}
-
-	// On first run we won't have any keys yet, so this would crash.
-	// Therefor we check if we are ready to actually start this process
-	var addr []byte
-	if ethutil.GetKeyRing().Len() != 0 {
-		addr = ethutil.GetKeyRing().Get(0).Address()
-	}
-
-	pub := ethpub.NewPEthereum(ethereum)
-
-	return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr, pub: pub, logLevel: ethlog.LogLevel(logLevel), open: false}
-}
-
-func (gui *Gui) Start(assetPath string) {
-	const version = "0.5.0 RC15"
-
-	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 = "" },
-	}})
-
-	ethutil.Config.SetClientString("Ethereal")
-
-	// 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
-	gui.SetLogLevel(ethlog.Silence)
-	gui.open = false
-}
-
-func (gui *Gui) Stop() {
-	if gui.open {
-		gui.SetLogLevel(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)
-		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)
-
-	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.lib)
-	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) setInitialBlockChain() {
-	sBlk := gui.eth.BlockChain().LastBlockHash
-	blk := gui.eth.BlockChain().GetBlock(sBlk)
-	for ; blk != nil; blk = gui.eth.BlockChain().GetBlock(sBlk) {
-		sBlk = blk.PrevHash
-
-		// Loop through all transactions to see if we missed any while being offline
-		for _, tx := range blk.Transactions() {
-			if bytes.Compare(tx.Sender(), gui.addr) == 0 || bytes.Compare(tx.Recipient, gui.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
-}
-
-var namereg = ethutil.FromHex("bb5f186604d057c1c5240ca2ae0f6430138ac010")
-
-func (gui *Gui) loadAddressBook() {
-	gui.win.Root().Call("clearAddress")
-	stateObject := gui.eth.StateManager().CurrentState().GetStateObject(namereg)
-	if stateObject != nil {
-		stateObject.State().EachStorage(func(name string, value *ethutil.Value) {
-			gui.win.Root().Call("addAddress", struct{ Name, Address string }{name, ethutil.Hex(value.Bytes())})
-		})
-	}
-}
-
-func (gui *Gui) readPreviousTransactions() {
-	it := gui.txDb.Db().NewIterator(nil, nil)
-	for it.Next() {
-		tx := ethchain.NewTransactionFromBytes(it.Value())
-
-		var inout string
-		if bytes.Compare(tx.Sender(), gui.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) {
-	gui.win.Root().Call("addBlock", ethpub.NewPBlock(block), 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)
-}
-
-// Simple go routine function that updates the list of peers in the GUI
-func (gui *Gui) update() {
-	reactor := gui.eth.Reactor()
-
-	blockChan := make(chan ethutil.React, 1)
-	txChan := make(chan ethutil.React, 1)
-	objectChan := make(chan ethutil.React, 1)
-	peerChan := make(chan ethutil.React, 1)
-
-	reactor.Subscribe("newBlock", blockChan)
-	reactor.Subscribe("newTx:pre", txChan)
-	reactor.Subscribe("newTx:post", txChan)
-	reactor.Subscribe("object:"+string(namereg), objectChan)
-	reactor.Subscribe("peerList", peerChan)
-
-	ticker := time.NewTicker(5 * time.Second)
-
-	state := gui.eth.StateManager().TransState()
-
-	unconfirmedFunds := new(big.Int)
-	gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.addr).Amount)))
-
-	for {
-		select {
-		case b := <-blockChan:
-			block := b.Resource.(*ethchain.Block)
-			gui.processBlock(block, false)
-			if bytes.Compare(block.Coinbase, gui.addr) == 0 {
-				gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.addr).Amount, nil)
-			}
-
-		case txMsg := <-txChan:
-			tx := txMsg.Resource.(*ethchain.Transaction)
-
-			if txMsg.Event == "newTx:pre" {
-				object := state.GetAccount(gui.addr)
-
-				if bytes.Compare(tx.Sender(), gui.addr) == 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.addr) == 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.addr)
-				if bytes.Compare(tx.Sender(), gui.addr) == 0 {
-					object.SubAmount(tx.Value)
-				} else if bytes.Compare(tx.Recipient, gui.addr) == 0 {
-					object.AddAmount(tx.Value)
-				}
-
-				gui.setWalletValue(object.Amount, nil)
-
-				state.UpdateStateObject(object)
-			}
-		case <-objectChan:
-			gui.loadAddressBook()
-		case <-peerChan:
-			gui.setPeerInfo()
-		case <-ticker.C:
-			gui.setPeerInfo()
-		}
-	}
-}
-
-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) RegisterName(name string) {
-	keyPair := ethutil.GetKeyRing().Get(0)
-	name = fmt.Sprintf("\"%s\"\n1", name)
-	gui.pub.Transact(ethutil.Hex(keyPair.PrivateKey), "namereg", "1000", "1000000", "150", name)
-}
-
-func (gui *Gui) Transact(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
-	keyPair := ethutil.GetKeyRing().Get(0)
-
-	return gui.pub.Transact(ethutil.Hex(keyPair.PrivateKey), recipient, value, gas, gasPrice, data)
-}
-
-func (gui *Gui) Create(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
-	keyPair := ethutil.GetKeyRing().Get(0)
-
-	return gui.pub.Transact(ethutil.Hex(keyPair.PrivateKey), recipient, value, gas, gasPrice, data)
-}
-
-func (gui *Gui) ChangeClientId(id string) {
-	ethutil.Config.SetIdentifier(id)
-}
-
-func (gui *Gui) ClientId() string {
-	return ethutil.Config.Identifier
-}
-
-// functions that allow Gui to implement interface ethlog.LogSystem
-func (gui *Gui) SetLogLevel(level ethlog.LogLevel) {
-	gui.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/ui/library.go

@@ -1,46 +0,0 @@
-package ethui
-
-import (
-	"fmt"
-	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/obscuren/secp256k1-go"
-	"strings"
-)
-
-type EthLib struct {
-	stateManager *ethchain.StateManager
-	blockChain   *ethchain.BlockChain
-	txPool       *ethchain.TxPool
-	Db           *Debugger
-}
-
-func (lib *EthLib) ImportAndSetPrivKey(privKey string) bool {
-	fmt.Println(privKey)
-	mnemonic := strings.Split(privKey, " ")
-	if len(mnemonic) == 24 {
-		fmt.Println("Got mnemonic key, importing.")
-		key := ethutil.MnemonicDecode(mnemonic)
-		utils.ImportPrivateKey(key)
-	} else if len(mnemonic) == 1 {
-		fmt.Println("Got hex key, importing.")
-		utils.ImportPrivateKey(privKey)
-	} else {
-		fmt.Println("Did not recognise format, exiting.")
-		return false
-	}
-	return true
-}
-
-func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) {
-	_, prv := secp256k1.GenerateKeyPair()
-	keyPair, err := ethutil.GetKeyRing().NewKeyPair(prv)
-	if err != nil {
-		panic(err)
-	}
-
-	mne := ethutil.MnemonicEncode(ethutil.Hex(keyPair.PrivateKey))
-	mnemonicString := strings.Join(mne, " ")
-	return mnemonicString, fmt.Sprintf("%x", keyPair.Address()), ethutil.Hex(keyPair.PrivateKey), ethutil.Hex(keyPair.PublicKey)
-}

ethereal/ui/ui_lib.go

@@ -1,100 +0,0 @@
-package ethui
-
-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.FromHex(contractHash))
-	if len(object.Script()) > 0 {
-		dbWindow.SetCode("0x" + ethutil.Hex(object.Script()))
-	}
-	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()
-}

ethereal/ui_lib.go

@@ -0,0 +1,251 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethcrypto"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+	"gopkg.in/qml.v1"
+)
+
+type memAddr struct {
+	Num   string
+	Value string
+}
+
+// UI Library that has some basic functionality exposed
+type UiLib struct {
+	*ethpipe.JSPipe
+	engine    *qml.Engine
+	eth       *eth.Ethereum
+	connected bool
+	assetPath string
+	// The main application window
+	win      *qml.Window
+	Db       *Debugger
+	DbWindow *DebuggerWindow
+
+	jsEngine *javascript.JSRE
+
+	filterCallbacks map[int][]int
+	filters         map[int]*GuiFilter
+}
+
+func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
+	return &UiLib{JSPipe: ethpipe.NewJSPipe(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int), filters: make(map[int]*GuiFilter)}
+}
+
+func (self *UiLib) LookupDomain(domain string) string {
+	world := self.World()
+
+	if len(domain) > 32 {
+		domain = string(ethcrypto.Sha3Bin([]byte(domain)))
+	}
+	data := world.Config().Get("DnsReg").StorageString(domain).Bytes()
+
+	// Left padded = A record, Right padded = CNAME
+	if data[0] == 0 {
+		data = bytes.TrimLeft(data, "\x00")
+		var ipSlice []string
+		for _, d := range data {
+			ipSlice = append(ipSlice, strconv.Itoa(int(d)))
+		}
+
+		return strings.Join(ipSlice, ".")
+	} else {
+		data = bytes.TrimRight(data, "\x00")
+
+		return string(data)
+	}
+}
+
+func (self *UiLib) ImportTx(rlpTx string) {
+	tx := ethchain.NewTransactionFromBytes(ethutil.Hex2Bytes(rlpTx))
+	self.eth.TxPool().QueueTransaction(tx)
+}
+
+func (self *UiLib) EvalJavascriptFile(path string) {
+	self.jsEngine.LoadExtFile(path[7:])
+}
+
+func (self *UiLib) EvalJavascriptString(str string) string {
+	value, err := self.jsEngine.Run(str)
+	if err != nil {
+		return err.Error()
+	}
+
+	return fmt.Sprintf("%v", value)
+}
+
+func (ui *UiLib) OpenQml(path string) {
+	container := NewQmlApplication(path[7:], ui)
+	app := NewExtApplication(container, ui)
+
+	go app.run()
+}
+
+func (ui *UiLib) OpenHtml(path string) {
+	container := NewHtmlApplication(path, ui)
+	app := NewExtApplication(container, ui)
+
+	go app.run()
+}
+
+func (ui *UiLib) OpenBrowser() {
+	ui.OpenHtml("file://" + ui.AssetPath("ext/home.html"))
+}
+
+func (ui *UiLib) Muted(content string) {
+	component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
+	if err != nil {
+		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)
+
+	dbWindow.Show()
+}
+
+func (self *UiLib) RegisterFilter(object map[string]interface{}, seed int) {
+	filter := &GuiFilter{ethpipe.NewJSFilterFromMap(object, self.eth), seed}
+	self.filters[seed] = filter
+
+	filter.MessageCallback = func(messages ethstate.Messages) {
+		for _, callbackSeed := range self.filterCallbacks[seed] {
+			self.win.Root().Call("invokeFilterCallback", filter.MessagesToJson(messages), seed, callbackSeed)
+		}
+	}
+
+}
+
+func (self *UiLib) RegisterFilterString(typ string, seed int) {
+	filter := &GuiFilter{ethpipe.NewJSFilterFromMap(nil, self.eth), seed}
+	self.filters[seed] = filter
+
+	if typ == "chain" {
+		filter.BlockCallback = func(block *ethchain.Block) {
+			for _, callbackSeed := range self.filterCallbacks[seed] {
+				self.win.Root().Call("invokeFilterCallback", "{}", seed, callbackSeed)
+			}
+		}
+	}
+}
+
+func (self *UiLib) RegisterFilterCallback(seed, cbSeed int) {
+	self.filterCallbacks[seed] = append(self.filterCallbacks[seed], cbSeed)
+}
+
+func (self *UiLib) UninstallFilter(seed int) {
+	filter := self.filters[seed]
+	if filter != nil {
+		filter.Uninstall()
+		delete(self.filters, seed)
+	}
+}
+
+type GuiFilter struct {
+	*ethpipe.JSFilter
+	seed int
+}
+
+func (self *UiLib) Transact(object map[string]interface{}) (*ethpipe.JSReceipt, error) {
+	// Default values
+	if object["from"] == nil {
+		object["from"] = ""
+	}
+	if object["to"] == nil {
+		object["to"] = ""
+	}
+	if object["value"] == nil {
+		object["value"] = ""
+	}
+	if object["gas"] == nil {
+		object["gas"] = ""
+	}
+	if object["gasPrice"] == nil {
+		object["gasPrice"] = ""
+	}
+
+	var dataStr string
+	var data []string
+	if list, ok := object["data"].(*qml.List); ok {
+		list.Convert(&data)
+	}
+
+	for _, str := range data {
+		if ethutil.IsHex(str) {
+			str = str[2:]
+
+			if len(str) != 64 {
+				str = ethutil.LeftPadString(str, 64)
+			}
+		} else {
+			str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
+		}
+
+		dataStr += str
+	}
+
+	return self.JSPipe.Transact(
+		object["from"].(string),
+		object["to"].(string),
+		object["value"].(string),
+		object["gas"].(string),
+		object["gasPrice"].(string),
+		dataStr,
+	)
+}

ethereum/cmd.go

@@ -1,14 +1,17 @@
 package main
 
 import (
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/go-ethereum/utils"
 	"io/ioutil"
 	"os"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/go-ethereum/ethereum/repl"
+	"github.com/ethereum/go-ethereum/javascript"
+	"github.com/ethereum/go-ethereum/utils"
 )
 
 func InitJsConsole(ethereum *eth.Ethereum) {
-	repl := NewJSRepl(ethereum)
+	repl := ethrepl.NewJSRepl(ethereum)
 	go repl.Start()
 	utils.RegisterInterrupt(func(os.Signal) {
 		repl.Stop()
@@ -24,7 +27,7 @@ func ExecJsFile(ethereum *eth.Ethereum, InputFile string) {
 	if err != nil {
 		logger.Fatalln(err)
 	}
-	re := NewJSRE(ethereum)
+	re := javascript.NewJSRE(ethereum)
 	utils.RegisterInterrupt(func(os.Signal) {
 		re.Stop()
 	})

ethereum/flags.go

@@ -3,13 +3,18 @@ package main
 import (
 	"flag"
 	"fmt"
-	"github.com/ethereum/eth-go/ethlog"
 	"os"
 	"os/user"
 	"path"
+
+	"github.com/ethereum/eth-go/ethlog"
 )
 
 var Identifier string
+var KeyRing string
+var DiffTool bool
+var DiffType string
+var KeyStore string
 var StartRpc bool
 var RpcPort int
 var UseUPnP bool
@@ -19,14 +24,17 @@ var AddPeer string
 var MaxPeer int
 var GenAddr bool
 var UseSeed bool
-var ImportKey string
-var ExportKey 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
+var Dump bool
+var DumpHash string
+var DumpNumber int
 
 // flags specific to cli client
 var StartMining bool
@@ -47,6 +55,8 @@ func Init() {
 	}
 
 	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")
@@ -55,13 +65,19 @@ func Init() {
 	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.BoolVar(&ExportKey, "export", false, "export private 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(&ImportKey, "import", "", "imports the given private key (hex)")
 	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(&Dump, "dump", false, "output the ethereum state in JSON format. Sub args [number, hash]")
+	flag.StringVar(&DumpHash, "hash", "", "specify arg in hex")
+	flag.IntVar(&DumpNumber, "number", -1, "specify arg in number")
 
 	flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
 	flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")

ethereum/main.go

@@ -1,9 +1,19 @@
 package main
 
 import (
-	"github.com/ethereum/eth-go/ethlog"
-	"github.com/ethereum/go-ethereum/utils"
+	"fmt"
+	"os"
 	"runtime"
+
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/utils"
+)
+
+const (
+	ClientIdentifier = "Ethereum(G)"
+	Version          = "0.6.3"
 )
 
 var logger = ethlog.NewLogger("CLI")
@@ -15,16 +25,56 @@ func main() {
 
 	// precedence: code-internal flag default < config file < environment variables < command line
 	Init() // parsing command line
-	utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
+
+	// If the difftool option is selected ignore all other log output
+	if DiffTool || Dump {
+		LogLevel = 0
+	}
+
+	utils.InitConfig(ConfigFile, Datadir, "ETH")
+	ethutil.Config.Diff = DiffTool
+	ethutil.Config.DiffType = DiffType
 
 	utils.InitDataDir(Datadir)
 
 	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
 
-	ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer)
+	db := utils.NewDatabase()
+
+	keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
 
 	// create, import, export keys
-	utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive)
+	utils.KeyTasks(keyManager, KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
+
+	clientIdentity := utils.NewClientIdentity(ClientIdentifier, Version, Identifier)
+
+	ethereum := utils.NewEthereum(db, clientIdentity, keyManager, UseUPnP, OutboundPort, MaxPeer)
+
+	if Dump {
+		var block *ethchain.Block
+
+		if len(DumpHash) == 0 && DumpNumber == -1 {
+			block = ethereum.BlockChain().CurrentBlock
+		} else if len(DumpHash) > 0 {
+			block = ethereum.BlockChain().GetBlock(ethutil.Hex2Bytes(DumpHash))
+		} else {
+			block = ethereum.BlockChain().GetBlockByNumber(uint64(DumpNumber))
+		}
+
+		if block == nil {
+			fmt.Fprintln(os.Stderr, "block not found")
+
+			// We want to output valid JSON
+			fmt.Println("{}")
+
+			os.Exit(1)
+		}
+
+		// Leave the Println. This needs clean output for piping
+		fmt.Printf("%s\n", block.State().Dump())
+
+		os.Exit(0)
+	}
 
 	if ShowGenesis {
 		utils.ShowGenesis(ethereum)

ethereum/repl.go

@@ -1,153 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/obscuren/otto"
-	"io"
-	"os"
-	"path"
-)
-
-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)
-}
-
-// 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(self.PEthereum.GetStateObject(addr))
-}
-
-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
-}

ethereum/repl/repl.go

@@ -0,0 +1,85 @@
+package ethrepl
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/javascript"
+)
+
+var logger = ethlog.NewLogger("REPL")
+
+type Repl interface {
+	Start()
+	Stop()
+}
+
+type JSRepl struct {
+	re *javascript.JSRE
+
+	prompt string
+
+	history *os.File
+
+	running bool
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+	hist, err := os.OpenFile(path.Join(ethutil.Config.ExecPath, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
+	if err != nil {
+		panic(err)
+	}
+
+	return &JSRepl{re: javascript.NewJSRE(ethereum), prompt: "> ", history: hist}
+}
+
+func (self *JSRepl) Start() {
+	if !self.running {
+		self.running = true
+		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

@@ -1,4 +1,4 @@
-package main
+package ethrepl
 
 // #cgo darwin CFLAGS: -I/usr/local/opt/readline/include
 // #cgo darwin LDFLAGS: -L/usr/local/opt/readline/lib
@@ -115,8 +115,8 @@ L:
 }
 
 func (self *JSRepl) PrintValue(v interface{}) {
-	method, _ := self.re.vm.Get("prettyPrint")
-	v, err := self.re.vm.ToValue(v)
+	method, _ := self.re.Vm.Get("prettyPrint")
+	v, err := self.re.Vm.ToValue(v)
 	if err == nil {
 		method.Call(method, v)
 	}

ethereum/repl/repl_windows.go

@@ -1,4 +1,4 @@
-package main
+package ethrepl
 
 import (
 	"bufio"

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 :-)"

javascript/javascript_runtime.go

@@ -1,29 +1,32 @@
-package main
+package javascript
 
 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/ethutil"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/obscuren/otto"
 	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethreact"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/obscuren/otto"
 )
 
 var jsrelogger = ethlog.NewLogger("JSRE")
 
 type JSRE struct {
 	ethereum *eth.Ethereum
-	vm       *otto.Otto
-	lib      *ethpub.PEthereum
+	Vm       *otto.Otto
+	pipe     *ethpipe.JSPipe
 
-	blockChan  chan ethutil.React
-	changeChan chan ethutil.React
+	blockChan  chan ethreact.Event
+	changeChan chan ethreact.Event
 	quitChan   chan bool
 
 	objectCb map[string][]otto.Value
@@ -32,9 +35,9 @@ type JSRE struct {
 func (jsre *JSRE) LoadExtFile(path string) {
 	result, err := ioutil.ReadFile(path)
 	if err == nil {
-		jsre.vm.Run(result)
+		jsre.Vm.Run(result)
 	} else {
-		jsrelogger.Debugln("Could not load file:", path)
+		jsrelogger.Infoln("Could not load file:", path)
 	}
 }
 
@@ -47,15 +50,15 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
 	re := &JSRE{
 		ethereum,
 		otto.New(),
-		ethpub.NewPEthereum(ethereum),
-		make(chan ethutil.React, 1),
-		make(chan ethutil.React, 1),
+		ethpipe.NewJSPipe(ethereum),
+		make(chan ethreact.Event, 10),
+		make(chan ethreact.Event, 10),
 		make(chan bool),
 		make(map[string][]otto.Value),
 	}
 
 	// Init the JS lib
-	re.vm.Run(jsLib)
+	re.Vm.Run(jsLib)
 
 	// Load extra javascript files
 	re.LoadIntFile("string.js")
@@ -64,7 +67,11 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
 	// We have to make sure that, whoever calls this, calls "Stop"
 	go re.mainLoop()
 
-	re.Bind("eth", &JSEthereum{re.lib, re.vm})
+	// Subscribe to events
+	reactor := ethereum.Reactor()
+	reactor.Subscribe("newBlock", re.blockChan)
+
+	re.Bind("eth", &JSEthereum{re.pipe, re.Vm, ethereum})
 
 	re.initStdFuncs()
 
@@ -74,11 +81,11 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
 }
 
 func (self *JSRE) Bind(name string, v interface{}) {
-	self.vm.Set(name, v)
+	self.Vm.Set(name, v)
 }
 
 func (self *JSRE) Run(code string) (otto.Value, error) {
-	return self.vm.Run(code)
+	return self.Vm.Run(code)
 }
 
 func (self *JSRE) Require(file string) error {
@@ -108,10 +115,6 @@ func (self *JSRE) Stop() {
 }
 
 func (self *JSRE) mainLoop() {
-	// Subscribe to events
-	reactor := self.ethereum.Reactor()
-	reactor.Subscribe("newBlock", self.blockChan)
-
 out:
 	for {
 		select {
@@ -120,24 +123,12 @@ out:
 		case block := <-self.blockChan:
 			if _, ok := block.Resource.(*ethchain.Block); ok {
 			}
-		case object := <-self.changeChan:
-			if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
-				for _, cb := range self.objectCb[ethutil.Hex(stateObject.Address())] {
-					val, _ := self.vm.ToValue(ethpub.NewPStateObject(stateObject))
-					cb.Call(cb, val)
-				}
-			} else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
-				for _, cb := range self.objectCb[ethutil.Hex(storageObject.StateAddress)+ethutil.Hex(storageObject.Address)] {
-					val, _ := self.vm.ToValue(ethpub.NewPStorageState(storageObject))
-					cb.Call(cb, val)
-				}
-			}
 		}
 	}
 }
 
 func (self *JSRE) initStdFuncs() {
-	t, _ := self.vm.Get("eth")
+	t, _ := self.Vm.Get("eth")
 	eth := t.Object()
 	eth.Set("watch", self.watch)
 	eth.Set("addPeer", self.addPeer)
@@ -145,19 +136,51 @@ func (self *JSRE) initStdFuncs() {
 	eth.Set("stopMining", self.stopMining)
 	eth.Set("startMining", self.startMining)
 	eth.Set("execBlock", self.execBlock)
+	eth.Set("dump", self.dump)
 }
 
 /*
  * The following methods are natively implemented javascript functions
  */
 
+func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
+	var state *ethstate.State
+
+	if len(call.ArgumentList) > 0 {
+		var block *ethchain.Block
+		if call.Argument(0).IsNumber() {
+			num, _ := call.Argument(0).ToInteger()
+			block = self.ethereum.BlockChain().GetBlockByNumber(uint64(num))
+		} else if call.Argument(0).IsString() {
+			hash, _ := call.Argument(0).ToString()
+			block = self.ethereum.BlockChain().GetBlock(ethutil.Hex2Bytes(hash))
+		} else {
+			fmt.Println("invalid argument for dump. Either hex string or number")
+		}
+
+		if block == nil {
+			fmt.Println("block not found")
+
+			return otto.UndefinedValue()
+		}
+
+		state = block.State()
+	} else {
+		state = self.ethereum.StateManager().CurrentState()
+	}
+
+	v, _ := self.Vm.ToValue(state.Dump())
+
+	return v
+}
+
 func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
-	v, _ := self.vm.ToValue(utils.StopMining(self.ethereum))
+	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))
+	v, _ := self.Vm.ToValue(utils.StartMining(self.ethereum))
 	return v
 }
 
@@ -178,12 +201,12 @@ func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
 	if storageCallback {
 		self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
 
-		event := "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr))
+		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.FromHex(addr))
+		event := "object:" + string(ethutil.Hex2Bytes(addr))
 		self.ethereum.Reactor().Subscribe(event, self.changeChan)
 	}
 
@@ -210,7 +233,7 @@ func (self *JSRE) require(call otto.FunctionCall) otto.Value {
 		return otto.UndefinedValue()
 	}
 
-	t, _ := self.vm.Get("exports")
+	t, _ := self.Vm.Get("exports")
 
 	return t
 }
@@ -221,7 +244,7 @@ func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
 		return otto.UndefinedValue()
 	}
 
-	err = utils.BlockDo(self.ethereum, ethutil.FromHex(hash))
+	err = utils.BlockDo(self.ethereum, ethutil.Hex2Bytes(hash))
 	if err != nil {
 		fmt.Println(err)
 		return otto.FalseValue()

javascript/js_lib.go

@@ -1,4 +1,4 @@
-package main
+package javascript
 
 const jsLib = `
 function pp(object) {

javascript/types.go

@@ -0,0 +1,138 @@
+package javascript
+
+import (
+	"fmt"
+
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethpipe"
+	"github.com/ethereum/eth-go/ethstate"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/obscuren/otto"
+)
+
+type JSStateObject struct {
+	*ethpipe.JSObject
+	eth *JSEthereum
+}
+
+func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
+	cb := call.Argument(0)
+	self.JSObject.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 {
+	*ethpipe.JSBlock
+	eth *JSEthereum
+}
+
+func (self *JSBlock) GetTransaction(hash string) otto.Value {
+	return self.eth.toVal(self.JSBlock.GetTransaction(hash))
+}
+
+type JSMessage struct {
+	To        string `json:"to"`
+	From      string `json:"from"`
+	Input     string `json:"input"`
+	Output    string `json:"output"`
+	Path      int    `json:"path"`
+	Origin    string `json:"origin"`
+	Timestamp int32  `json:"timestamp"`
+	Coinbase  string `json:"coinbase"`
+	Block     string `json:"block"`
+	Number    int32  `json:"number"`
+}
+
+func NewJSMessage(message *ethstate.Message) JSMessage {
+	return JSMessage{
+		To:        ethutil.Bytes2Hex(message.To),
+		From:      ethutil.Bytes2Hex(message.From),
+		Input:     ethutil.Bytes2Hex(message.Input),
+		Output:    ethutil.Bytes2Hex(message.Output),
+		Path:      message.Path,
+		Origin:    ethutil.Bytes2Hex(message.Origin),
+		Timestamp: int32(message.Timestamp),
+		Coinbase:  ethutil.Bytes2Hex(message.Origin),
+		Block:     ethutil.Bytes2Hex(message.Block),
+		Number:    int32(message.Number.Int64()),
+	}
+}
+
+type JSEthereum struct {
+	*ethpipe.JSPipe
+	vm       *otto.Otto
+	ethereum *eth.Ethereum
+}
+
+func (self *JSEthereum) GetBlock(hash string) otto.Value {
+	return self.toVal(&JSBlock{self.JSPipe.BlockByHash(hash), self})
+}
+
+func (self *JSEthereum) GetPeers() otto.Value {
+	return self.toVal(self.JSPipe.Peers())
+}
+
+func (self *JSEthereum) GetKey() otto.Value {
+	return self.toVal(self.JSPipe.Key())
+}
+
+func (self *JSEthereum) GetStateObject(addr string) otto.Value {
+	return self.toVal(&JSStateObject{ethpipe.NewJSObject(self.JSPipe.World().SafeGet(ethutil.Hex2Bytes(addr))), self})
+}
+
+func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
+	r, err := self.JSPipe.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.JSPipe.Transact(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
+}
+
+func (self *JSEthereum) Messages(object map[string]interface{}) otto.Value {
+	filter := ethchain.NewFilterFromMap(object, self.ethereum)
+
+	messages := filter.Find()
+	var msgs []JSMessage
+	for _, m := range messages {
+		msgs = append(msgs, NewJSMessage(m))
+	}
+
+	v, _ := self.vm.ToValue(msgs)
+
+	return v
+}

utils/cmd.go

@@ -2,19 +2,26 @@ package utils
 
 import (
 	"fmt"
-	"github.com/ethereum/eth-go"
-	"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"
 	"io"
 	"log"
 	"os"
 	"os/signal"
 	"path"
-	"strings"
+	"path/filepath"
+	"regexp"
+	"runtime"
 	"time"
+
+	"bitbucket.org/kardianos/osext"
+	"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/ethpipe"
+	"github.com/ethereum/eth-go/ethrpc"
+	"github.com/ethereum/eth-go/ethutil"
+	"github.com/ethereum/eth-go/ethwire"
 )
 
 var logger = ethlog.NewLogger("CLI")
@@ -77,7 +84,7 @@ func InitDataDir(Datadir string) {
 	_, err := os.Stat(Datadir)
 	if err != nil {
 		if os.IsNotExist(err) {
-			fmt.Printf("Debug logging directory '%s' doesn't exist, creating it\n", Datadir)
+			fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
 			os.Mkdir(Datadir, 0777)
 		}
 	}
@@ -97,19 +104,37 @@ func InitLogging(Datadir string, LogFile string, LogLevel int, DebugFile string)
 	}
 }
 
-func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) {
+func InitConfig(ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
 	InitDataDir(Datadir)
-	ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix)
-	ethutil.Config.Set("rpcport", "700")
+	return ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
 }
 
-func exit(status int) {
+func exit(err error) {
+	status := 0
+	if err != nil {
+		fmt.Println(err)
+		logger.Errorln("Fatal: ", err)
+		status = 1
+	}
 	ethlog.Flush()
 	os.Exit(status)
 }
 
-func NewEthereum(UseUPnP bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
-	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
+func NewDatabase() ethutil.Database {
+	db, err := ethdb.NewLDBDatabase("database")
+	if err != nil {
+		exit(err)
+	}
+	return db
+}
+
+func NewClientIdentity(clientIdentifier, version, customIdentifier string) *ethwire.SimpleClientIdentity {
+	logger.Infoln("identity created")
+	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)
 	}
@@ -119,7 +144,7 @@ func NewEthereum(UseUPnP bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
 }
 
 func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
-	logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver)
+	logger.Infof("Starting %s", ethereum.ClientIdentity())
 	ethereum.Start(UseSeed)
 	RegisterInterrupt(func(sig os.Signal) {
 		ethereum.Stop()
@@ -129,56 +154,81 @@ func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
 
 func ShowGenesis(ethereum *eth.Ethereum) {
 	logger.Infoln(ethereum.BlockChain().Genesis())
-	exit(0)
+	exit(nil)
 }
 
-func KeyTasks(GenAddr bool, ImportKey string, ExportKey bool, NonInteractive bool) {
+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) {
+
+	var err error
 	switch {
 	case GenAddr:
 		if NonInteractive || confirm("This action overwrites your old private key.") {
-			CreateKeyPair(true)
+			err = keyManager.Init(KeyRing, 0, true)
 		}
-		exit(0)
-	case len(ImportKey) > 0:
+		exit(err)
+	case len(SecretFile) > 0:
+		SecretFile = ethutil.ExpandHomePath(SecretFile)
+
 		if NonInteractive || confirm("This action overwrites your old private key.") {
-			// import should be from file
-			mnemonic := strings.Split(ImportKey, " ")
-			if len(mnemonic) == 24 {
-				logger.Infoln("Got mnemonic key, importing.")
-				key := ethutil.MnemonicDecode(mnemonic)
-				ImportPrivateKey(key)
-			} else if len(mnemonic) == 1 {
-				logger.Infoln("Got hex key, importing.")
-				ImportPrivateKey(ImportKey)
-			} else {
-				logger.Errorln("Did not recognise format, exiting.")
-			}
+			err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
 		}
-		exit(0)
-	case ExportKey: // this should be exporting to a filename
-		keyPair := ethutil.GetKeyRing().Get(0)
-		fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey)
-
-		exit(0)
+		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
-		CreateKeyPair(false)
+		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)
+	ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpipe.NewJSPipe(ethereum), RpcPort)
 	if err != nil {
 		logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
 	} else {
@@ -186,26 +236,27 @@ func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
 	}
 }
 
-var miner ethminer.Miner
+var miner *ethminer.Miner
+
+func GetMiner() *ethminer.Miner {
+	return miner
+}
 
 func StartMining(ethereum *eth.Ethereum) bool {
 	if !ethereum.Mining {
 		ethereum.Mining = true
-
-		if ethutil.GetKeyRing().Len() == 0 {
-			logger.Errorln("No address found, can't start mining")
-			ethereum.Mining = false
-			return true //????
-		}
-		keyPair := ethutil.GetKeyRing().Get(0)
-		addr := keyPair.Address()
+		addr := ethereum.KeyManager().Address()
 
 		go func() {
-			miner = ethminer.NewDefaultMiner(addr, ethereum)
+			logger.Infoln("Start mining")
+			if miner == nil {
+				miner = ethminer.NewDefaultMiner(addr, ethereum)
+			}
 			// Give it some time to connect with peers
 			time.Sleep(3 * time.Second)
-			logger.Infoln("Miner started")
-			miner := ethminer.NewDefaultMiner(addr, ethereum)
+			for !ethereum.IsUpToDate() {
+				time.Sleep(5 * time.Second)
+			}
 			miner.Start()
 		}()
 		RegisterInterrupt(func(os.Signal) {
@@ -216,13 +267,28 @@ func StartMining(ethereum *eth.Ethereum) bool {
 	return false
 }
 
+func FormatTransactionData(data string) []byte {
+	d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) {
+		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
+		for _, dataItem := range slice {
+			d := ethutil.FormatData(dataItem)
+			ret = append(ret, d...)
+		}
+		return
+	})
+
+	return d
+}
+
 func StopMining(ethereum *eth.Ethereum) bool {
-	if ethereum.Mining {
+	if ethereum.Mining && miner != nil {
 		miner.Stop()
-		logger.Infoln("Miner stopped")
+		logger.Infoln("Stopped mining")
 		ethereum.Mining = false
+
 		return true
 	}
+
 	return false
 }
 

utils/keys.go

@@ -1,108 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/obscuren/secp256k1-go"
-)
-
-func CreateKeyPair(force bool) {
-	if force {
-		ethutil.GetKeyRing().Reset()
-		fmt.Println("resetting")
-	}
-
-	if ethutil.GetKeyRing().Get(0) == nil {
-		_, prv := secp256k1.GenerateKeyPair()
-
-		keyPair, err := ethutil.GetKeyRing().NewKeyPair(prv)
-		if err != nil {
-			panic(err)
-		}
-
-		mne := ethutil.MnemonicEncode(ethutil.Hex(keyPair.PrivateKey))
-
-		fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey, mne)
-	}
-}
-
-func ImportPrivateKey(sec string) {
-	ethutil.GetKeyRing().Reset()
-
-	keyPair, err := ethutil.GetKeyRing().NewKeyPair(ethutil.FromHex(sec))
-	if err != nil {
-		panic(err)
-	}
-
-	mne := ethutil.MnemonicEncode(ethutil.Hex(keyPair.PrivateKey))
-
-	fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey, mne)
-}
-
-/*
-func CreateKeyPair(force bool) {
-	data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
-	if len(data) == 0 || force {
-		pub, prv := secp256k1.GenerateKeyPair()
-		pair := &ethutil.Key{PrivateKey: prv, PublicKey: pub}
-		ethutil.Config.Db.Put([]byte("KeyRing"), pair.RlpEncode())
-		mne := ethutil.MnemonicEncode(ethutil.Hex(prv))
-
-		fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, pair.Address(), prv, pub, mne)
-
-	}
-}
-*/
-
-/*
-func ImportPrivateKey(prvKey string) {
-	key := ethutil.FromHex(prvKey)
-	msg := []byte("tmp")
-	// Couldn't think of a better way to get the pub key
-	sig, _ := secp256k1.Sign(msg, key)
-	pub, _ := secp256k1.RecoverPubkey(msg, sig)
-	pair := &ethutil.Key{PrivateKey: key, PublicKey: pub}
-	ethutil.Config.Db.Put([]byte("KeyRing"), pair.RlpEncode())
-
-	fmt.Printf(`
-Importing private key
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-
-`, pair.Address(), key, pub)
-}
-*/

utils/vm_env.go

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