Merge branch 'release/poc5-rc9'

* Added watch

README.md

@@ -5,7 +5,7 @@ Ethereum
 
 Ethereum Go Client © 2014 Jeffrey Wilcke.
 
-Current state: Proof of Concept 5.0 RC1.
+Current state: Proof of Concept 5.0 RC9.
 
 For the development package please see the [eth-go package](https://github.com/ethereum/eth-go).
 
@@ -26,28 +26,25 @@ General command line options
 ====================
 
 ```
--c       Launch the developer console (node only)
+Shared between ethereum and ethereal
 -m       Start mining blocks
 -genaddr Generates a new address and private key (destructive action)
--p       Port on which the server will accept incomming connections (= 30303)
+-p       Port on which the server will accept incomming connections
--upnp    Enable UPnP (= false)
+-upnp    Enable UPnP
--x       Desired amount of peers (= 5)
+-x       Desired amount of peers
--h       This help
 -r       Start JSON RPC
--dir     Data directory used to store configs and databases (=".ethereum")
+-dir     Data directory used to store configs and databases
--import  Import a private key (hex)
+-import  Import a private key
-```
+-h       This
 
-Developer console commands
+Ethereum only
-==========================
+ethereum [options] [filename]
+-js        Start the JavaScript REPL
+filename   Load the given file and interpret as JavaScript
 
+Etheral only
+-asset_path    absolute path to GUI assets directory
 ```
-addp <host>:<port>	      Connect to the given host
-tx <addr> <amount>            Send <amount> Wei to the specified <addr>
-contract <value> <gasprice>   Creates a new contract and launches the editor
-```
-
-See the "help" command for *developer* options.
 
 Contribution
 ============

ethereal/assets/ext/big.js

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

ethereal/assets/ext/ethereum.js

@@ -36,6 +36,21 @@ window.eth = {
 		postData({call: "getKey"}, cb);
 	},
 
+	getTxCountAt: function(address, cb) {
+		postData({call: "getTxCountAt", args: [address]}, cb);
+	},
+	getIsMining: function(cb){
+		postData({call: "getIsMining"}, cb)
+	},
+	getIsListening: function(cb){
+		postData({call: "getIsListening"}, cb)
+	},
+	getCoinBase: function(cb){
+		postData({call: "getCoinBase"}, cb);
+	},
+	getPeerCount: function(cb){
+		postData({call: "getPeerCount"}, cb);
+	},
 	getBalanceAt: function(address, cb) {
 		postData({call: "getBalance", args: [address]}, cb);
 	},
@@ -115,122 +130,9 @@ window.eth = {
 			}
 		}
 	},
+
+
 }
 window.eth._callbacks = {}
 window.eth._onCallbacks = {}
 
-function hello() {
-	debug("hello")
-	window.dataTest = true;
-}
-
-function debug(/**/) {
-	var args = arguments;
-	var msg = ""
-	for(var i = 0; i < args.length; i++){
-		if(typeof args[i] === "object") {
-			msg += " " + JSON.stringify(args[i])
-		} else {
-			msg += args[i]
-		}
-	}
-
-	postData({call:"debug", args:[msg]})
-	document.getElementById("debug").innerHTML += "<br>" + msg
-}
-
-// Helper function for generating pseudo callbacks and sending data to the QML part of the application
-function postData(data, cb) {
-	data._seed = Math.floor(Math.random() * 1000000)
-	if(cb) {
-		eth._callbacks[data._seed] = cb;
-	}
-
-	if(data.args === undefined) {
-		data.args = [];
-	}
-
-	navigator.qt.postMessage(JSON.stringify(data));
-}
-
-navigator.qt.onmessage = function(ev) {
-	var data = JSON.parse(ev.data)
-
-	if(data._event !== undefined) {
-		eth.trigger(data._event, data.data);
-	} else {
-		if(data._seed) {
-			var cb = eth._callbacks[data._seed];
-			if(cb) {
-				// Figure out whether the returned data was an array
-				// array means multiple return arguments (multiple params)
-				if(data.data instanceof Array) {
-					cb.apply(this, data.data)
-				} else {
-					cb.call(this, data.data)
-				}
-
-				// Remove the "trigger" callback
-				delete eth._callbacks[ev._seed];
-			}
-		}
-	}
-}
-
-window.eth._0 = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-String.prototype.pad = function(len) {
-    var bin = this.bin();
-    var l = bin.length;
-    if(l < 32) {
-        return eth._0.substr(0, 32 - bin.length) + bin;
-    }
-
-    return bin;
-}
-
-String.prototype.unpad = function() {
-    var i, l;
-    for(i = 0, l = this.length; i < l; i++) {
-        if(this[i] != "\0") {
-            return this.substr(i, this.length);
-        }
-    }
-
-    return this.substr(i, this.length);
-}
-
-String.prototype.bin = function() {
-    if(this.substr(0, 2) == "0x") {
-        return this.hex2bin();
-    } else if(/^\d+$/.test(this)) {
-        return this.num2bin()
-    }
-
-    // Otherwise we'll return the "String" object instead of an actual string
-    return this.substr(0, this.length)
-}
-
-String.prototype.unbin = function() {
-    var i, l, o = '';
-    for(i = 0, l = this.length; i < l; i++) {
-        var n = this.charCodeAt(i).toString(16);
-        o += n.length < 2 ? '0' + n : n;
-    }
-
-    return "0x" + o;
-}
-
-String.prototype.hex2bin = function() {
-    bytes = []
-
-    for(var i=2; i< this.length-1; i+=2) {
-        bytes.push(parseInt(this.substr(i, 2), 16));
-    }
-
-    return String.fromCharCode.apply(String, bytes);
-}
-
-String.prototype.num2bin = function() {
-    return ("0x"+parseInt(this).toString(16)).bin()
-}
-

ethereal/assets/ext/pre.js

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

ethereal/assets/ext/string.js

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

ethereal/assets/qml/first_run.qml

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

ethereal/assets/qml/newTransaction/_new_contract.qml

@@ -61,7 +61,7 @@ Component {
 			id: txValue
 			width: 200
 			placeholderText: "Amount"
-			validator: IntValidator { }
+			validator: RegExpValidator { regExp: /\d*/ }
 			onTextChanged: {
 				contractFormReady()
 			}
@@ -69,7 +69,7 @@ Component {
 		TextField {
 			id: txGas
 			width: 200
-			validator: IntValidator { }
+			validator: RegExpValidator { regExp: /\d*/ }
 			placeholderText: "Gas"
 			onTextChanged: {
 				contractFormReady()
@@ -79,7 +79,7 @@ Component {
 			id: txGasPrice
 			width: 200
 			placeholderText: "Gas price"
-			validator: IntValidator { }
+			validator: RegExpValidator { regExp: /\d*/ }
 			onTextChanged: {
 				contractFormReady()
 			}
@@ -150,7 +150,7 @@ Component {
 			text: "Send"
 			onClicked: {
 				//this.enabled = false
-				var res = eth.createTx(txFuelRecipient.text, txValue.text, txGas.text, txGasPrice.text, codeView.text)
+				var res = eth.create(txFuelRecipient.text, txValue.text, txGas.text, txGasPrice.text, codeView.text)
 				if(res[1]) {
 					txResult.text = "Your contract <b>could not</b> be send over the network:\n<b>"
 					txResult.text += res[1].error()
@@ -158,7 +158,7 @@ Component {
 					mainContractColumn.state = "ERROR"
 				} else {
 					txResult.text = "Your transaction has been submitted:\n"
-					txOutput.text = res[0]
+					txOutput.text = res[0].address
 					mainContractColumn.state = "DONE"
 				}
 			}

ethereal/assets/qml/newTransaction/_simple_send.qml

@@ -56,9 +56,10 @@ Component {
 		}
 		TextField {
 			id: txSimpleValue
+			width: 200
 			placeholderText: "Amount"
 			anchors.rightMargin: 5
-			validator: IntValidator { }
+			validator: RegExpValidator { regExp: /\d*/ }
 			onTextChanged: { checkFormState() }
 		}
 		Button {
@@ -77,12 +78,12 @@ Component {
 			text: "Send"
 			onClicked: {
 				//this.enabled = false
-				var res = eth.createTx(txSimpleRecipient.text, txSimpleValue.text,"","","")
+				var res = eth.transact(txSimpleRecipient.text, txSimpleValue.text,"","","")
 				if(res[1]) {
 					txSimpleResult.text = "There has been an error broadcasting your transaction:" + res[1].error()
 				} else {
 					txSimpleResult.text = "Your transaction has been broadcasted over the network.\nYour transaction id is:"
-					txSimpleOutput.text = res[0]
+					txSimpleOutput.text = res[0].hash
 					this.visible = false
 					simpleSendColumn.state = "DONE"
 				}

ethereal/assets/qml/wallet.qml

@@ -67,6 +67,7 @@ ApplicationWindow {
 		networkView.visible = false
 		historyView.visible = false
 		newTxView.visible = false
+		infoView.visible = false
 		view.visible = true
 		//root.title = "Ethereal - " = view.title
 	}
@@ -84,7 +85,6 @@ ApplicationWindow {
 			//color: "#D9DDE7"
 			color: "#252525"
 
-
 			ColumnLayout {
 				y: 50
 				anchors.left: parent.left
@@ -120,6 +120,17 @@ ApplicationWindow {
 						}
 					}
 				}
+
+				Image {
+					source: ui.assetPath("net.png")
+					anchors.horizontalCenter: parent.horizontalCenter
+					MouseArea {
+						anchors.fill: parent
+						onClicked: {
+							setView(infoView)
+						}
+					}
+				}
 			}
 		}
 
@@ -143,6 +154,7 @@ ApplicationWindow {
 				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 }
@@ -217,6 +229,33 @@ ApplicationWindow {
 				}
 			}
 
+			Rectangle {
+				id: infoView
+				property var title: "Information"
+				visible: false
+				color: "#00000000"
+				anchors.fill: parent
+
+				Label {
+					id: addressLabel
+					text: "Address"
+					anchors {
+						margins: 5
+						top: parent.top
+						left: parent.left
+					}
+				}
+				TextField {
+					anchors {
+						margins: 5
+						left: addressLabel.right
+						top: parent.top
+					}
+					text: pub.getKey().address
+					width: 500
+				}
+			}
+
 			/*
 			 signal addPlugin(string name)
 			 Component {
@@ -365,7 +404,7 @@ ApplicationWindow {
 			anchors.left: aboutIcon.right
 			anchors.leftMargin: 10
 			font.pointSize: 12
-			text: "<h2>Ethereal</h2><br><h3>Development</h3>Jeffrey Wilcke<br>Maran Hidskes<br><h3>Binary Distribution</h3>Jarrad Hope<br>"
+			text: "<h2>Ethereal</h2><br><h3>Development</h3>Jeffrey Wilcke<br>Maran Hidskes<br>"
 		}
 
 	}
@@ -390,7 +429,6 @@ ApplicationWindow {
 			}
 		}
 		SplitView {
-
 			anchors.fill: parent
 			property var asmModel: ListModel {
 				id: asmModel
@@ -485,14 +523,14 @@ ApplicationWindow {
 		walletValueLabel.text = value
 	}
 
-	function addTx(tx) {
+	function addTx(tx, inout) {
 		var isContract
 		if (tx.contract == true){
 			isContract = "Yes"
 		}else{
 			isContract = "No"
 		}
-		txModel.insert(0, {hash: tx.hash, address: tx.address, value: tx.value, contract: isContract})
+		txModel.insert(0, {inout: inout, hash: tx.hash, address: tx.address, value: tx.value, contract: isContract})
 	}
 
 	function addBlock(block) {

ethereal/assets/qml/webapp.qml

@@ -39,7 +39,7 @@ ApplicationWindow {
 			experimental.preferences.javascriptEnabled: true
 			experimental.preferences.navigatorQtObjectEnabled: true
 			experimental.preferences.developerExtrasEnabled: true
-			experimental.userScripts: [ui.assetPath("ethereum.js")]
+			experimental.userScripts: [ui.assetPath("ext/pre.js"), ui.assetPath("ext/big.js"), ui.assetPath("ext/string.js"), ui.assetPath("ext/ethereum.js")]
 			experimental.onMessageReceived: {
 				console.log("[onMessageReceived]: ", message.data)
 				// TODO move to messaging.js
@@ -47,13 +47,37 @@ ApplicationWindow {
 
 				try {
 					switch(data.call) {
+					case "getCoinBase":
+					      postData(data._seed, eth.getCoinBase())
+
+					      break
+					case "getIsListening":
+					      postData(data._seed, eth.getIsListening())
+
+					      break
+					case "getIsMining":
+					      postData(data._seed, eth.getIsMining())
+
+					      break
+					case "getPeerCount":
+					      postData(data._seed, eth.getPeerCount())
+
+					      break
+
+					case "getTxCountAt":
+					      require(1)
+					      postData(data._seed, eth.getTxCountAt(data.args[0]))
+
+					      break
 					case "getBlockByNumber":
-						var block = eth.getBlock("b9b56cf6f907fbee21db0cd7cbc0e6fea2fe29503a3943e275c5e467d649cb06")	
+						var block = eth.getBlock(data.args[0])
 						postData(data._seed, block)
+
 						break
 					case "getBlockByHash":
-						var block = eth.getBlock("b9b56cf6f907fbee21db0cd7cbc0e6fea2fe29503a3943e275c5e467d649cb06")	
+						var block = eth.getBlock(data.args[0])
 						postData(data._seed, block)
+
 						break
 					case "transact":
 						require(5)
@@ -94,11 +118,14 @@ ApplicationWindow {
 						postData(data._seed, null)
 						break;
 					case "set":
+            console.log("'Set' has been depcrecated")
+          /*
 						for(var key in data.args) {
 							if(webview.hasOwnProperty(key)) {
 								window[key] = data.args[key];
 							}
 						}
+            */
 						break;
 					case "getSecretToAddress":
 						require(1)

ethereal/assets/samplecoin/samplecoin.html

@@ -5,31 +5,27 @@
 <link rel="stylesheet" href="bootstrap.min.css">
 <link rel="stylesheet" href="bootstrap-theme.min.css">
 <link rel="stylesheet" href="samplecoin.css">
-<script src="promise.min.js"></script>
 <meta name="viewport" content="minimum-scale=1; maximum-scale=1; initial-scale=1;">
 
 <script type="text/javascript">
 
-var jefcoinAddr = "3dff537f51350239abc95c76a5864aa605259e7d"
+var jefcoinAddr = "fc0a9436890478bb9b1c6ed7455c2535366f4a99"
 var mAddr = ""
 
 function createTransaction() {
-	var addr = document.querySelector("#addr").value;
+	var addr = ("0x" + document.querySelector("#addr").value).pad(32);
-	var amount = document.querySelector("#amount").value;
+	var amount = document.querySelector("#amount").value.pad(32);
 
-	var data = (("0x"+addr).pad(32) + amount.pad(32)).unbin()
+	var data = (addr + amount).unbin();
 	eth.transact(mAddr, jefcoinAddr, 0, "10000000", "250", data, function(receipt) {
 		debug("received tx hash:", reciept.address)
 	})
 }
 
 function init() {
-	eth.set({width: 500});
-
 	eth.getKey(function(sec) {
+		mAddr = sec;
 		eth.getSecretToAddress(sec, function(addr) {
-			mAddr = addr;
-
 			eth.getStorageAt(jefcoinAddr, addr, function(storage) {
 				document.querySelector("#current-amount").innerHTML = storage;
 			});

ethereal/assets/util/test.html

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

ethereal/config.go

@@ -4,9 +4,11 @@ import (
 	"flag"
 )
 
+var Identifier string
 var StartConsole bool
 var StartMining bool
 var StartRpc bool
+var RpcPort int
 var UseUPnP bool
 var OutboundPort string
 var ShowGenesis bool
@@ -20,6 +22,7 @@ var DataDir string
 var AssetPath string
 
 func Init() {
+	flag.StringVar(&Identifier, "i", "", "Custom client identifier")
 	flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
 	flag.BoolVar(&StartMining, "m", false, "start dagger mining")
 	flag.BoolVar(&StartRpc, "r", false, "start rpc server")
@@ -28,10 +31,11 @@ func Init() {
 	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.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
 	flag.StringVar(&OutboundPort, "p", "30303", "listening port")
 	flag.StringVar(&DataDir, "dir", ".ethereal", "ethereum data directory")
 	flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
-	flag.IntVar(&MaxPeer, "x", 5, "maximum desired peers")
+	flag.IntVar(&MaxPeer, "x", 10, "maximum desired peers")
 	flag.StringVar(&AssetPath, "asset_path", "", "absolute path to GUI assets directory")
 
 	flag.Parse()

ethereal/ethereum.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"github.com/ethereum/eth-go"
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethrpc"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/go-ethereum/ethereal/ui"
 	"github.com/ethereum/go-ethereum/utils"
@@ -41,8 +39,7 @@ func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
 	ethchain.InitFees()
-	ethutil.ReadConfig(DataDir)
+	ethutil.ReadConfig(DataDir, ethutil.LogFile|ethutil.LogStd, Identifier)
-	ethutil.Config.Seed = UseSeed
 
 	// Instantiated a eth stack
 	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
@@ -90,8 +87,19 @@ func main() {
 	}
 
 	if ExportKey {
-		key := ethutil.Config.Db.GetKeys()[0]
+		keyPair := ethutil.GetKeyRing().Get(0)
-		fmt.Printf("%x\n", key.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)
+
 		os.Exit(0)
 	}
 
@@ -100,9 +108,12 @@ func main() {
 		os.Exit(0)
 	}
 
+	if StartMining {
+		utils.DoMining(ethereum)
+	}
+
 	if StartRpc {
-		ethereum.RpcServer = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum.StateManager(), ethereum.BlockChain(), ethereum.TxPool()))
+		utils.DoRpc(ethereum, RpcPort)
-		go ethereum.RpcServer.Start()
 	}
 
 	log.Printf("Starting Ethereum GUI v%s\n", ethutil.Config.Ver)
@@ -111,5 +122,11 @@ func main() {
 	ethereum.MaxPeers = MaxPeer
 
 	gui := ethui.New(ethereum)
+
+	ethereum.Start(UseSeed)
+
 	gui.Start(AssetPath)
+
+	// Wait for shutdown
+	ethereum.WaitForShutdown()
 }

ethereal/ui/ext_app.go

@@ -18,14 +18,16 @@ type AppContainer interface {
 	NewBlock(*ethchain.Block)
 	ObjectChanged(*ethchain.StateObject)
 	StorageChanged(*ethchain.StorageState)
+	NewWatcher(chan bool)
 }
 
 type ExtApplication struct {
 	*ethpub.PEthereum
 
-	blockChan  chan ethutil.React
+	blockChan       chan ethutil.React
-	changeChan chan ethutil.React
+	changeChan      chan ethutil.React
-	quitChan   chan bool
+	quitChan        chan bool
+	watcherQuitChan chan bool
 
 	container        AppContainer
 	lib              *UiLib
@@ -34,10 +36,11 @@ type ExtApplication struct {
 
 func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
 	app := &ExtApplication{
-		ethpub.NewPEthereum(lib.eth.StateManager(), lib.eth.BlockChain(), lib.eth.TxPool()),
+		ethpub.NewPEthereum(lib.eth),
 		make(chan ethutil.React, 1),
 		make(chan ethutil.React, 1),
 		make(chan bool),
+		make(chan bool),
 		container,
 		lib,
 		nil,
@@ -66,6 +69,8 @@ func (app *ExtApplication) run() {
 	reactor := app.lib.eth.Reactor()
 	reactor.Subscribe("newBlock", app.blockChan)
 
+	app.container.NewWatcher(app.watcherQuitChan)
+
 	win := app.container.Window()
 	win.Show()
 	win.Wait()
@@ -83,6 +88,7 @@ func (app *ExtApplication) stop() {
 
 	// Kill the main loop
 	app.quitChan <- true
+	app.watcherQuitChan <- true
 
 	close(app.blockChan)
 	close(app.quitChan)

ethereal/ui/gui.go

@@ -23,11 +23,14 @@ type Gui struct {
 	eth *eth.Ethereum
 
 	// The public Ethereum library
-	lib *EthLib
+	lib   *EthLib
+	uiLib *UiLib
 
 	txDb *ethdb.LDBDatabase
 
 	addr []byte
+
+	pub *ethpub.PEthereum
 }
 
 // Create GUI, but doesn't start it
@@ -38,22 +41,22 @@ func New(ethereum *eth.Ethereum) *Gui {
 		panic(err)
 	}
 
-	data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
 	// 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 len(data) > 0 {
+	if ethutil.GetKeyRing().Len() != 0 {
-		key := ethutil.Config.Db.GetKeys()[0]
+		addr = ethutil.GetKeyRing().Get(0).Address()
-		addr = key.Address()
-
-		ethereum.StateManager().WatchAddr(addr)
 	}
 
-	return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr}
+	pub := ethpub.NewPEthereum(ethereum)
+
+	return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr, pub: pub}
 }
 
-func (ui *Gui) Start(assetPath string) {
+func (gui *Gui) Start(assetPath string) {
-	defer ui.txDb.Close()
+	const version = "0.5.0 RC9"
+
+	defer gui.txDb.Close()
 
 	// Register ethereum functions
 	qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
@@ -62,27 +65,27 @@ func (ui *Gui) Start(assetPath string) {
 		Init: func(p *ethpub.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
 	}})
 
-	ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.2"))
+	ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", version))
 	ethutil.Config.Log.Infoln("[GUI] Starting GUI")
 	// Create a new QML engine
-	ui.engine = qml.NewEngine()
+	gui.engine = qml.NewEngine()
-	context := ui.engine.Context()
+	context := gui.engine.Context()
 
 	// Expose the eth library and the ui library to QML
-	context.SetVar("eth", ui.lib)
+	context.SetVar("eth", gui)
-	uiLib := NewUiLib(ui.engine, ui.eth, assetPath)
+	context.SetVar("pub", gui.pub)
-	context.SetVar("ui", uiLib)
+	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 err error
-	var component qml.Object
-	firstRun := len(data) == 0
 
-	if firstRun {
+	var win *qml.Window
-		component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/first_run.qml"))
+	var err error
+	if len(data) == 0 {
+		win, err = gui.showKeyImport(context)
 	} else {
-		component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml"))
+		win, err = gui.showWallet(context)
 	}
 	if err != nil {
 		ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'")
@@ -90,130 +93,181 @@ func (ui *Gui) Start(assetPath string) {
 		panic(err)
 	}
 
-	ui.win = component.CreateWindow(nil)
+	win.Show()
-	uiLib.win = ui.win
+	win.Wait()
-	db := &Debugger{ui.win, make(chan bool)}
-	ui.lib.Db = db
-	uiLib.Db = db
 
-	// Register the ui as a block processor
+	gui.eth.Stop()
-	//ui.eth.BlockManager.SecondaryBlockProcessor = ui
-	//ui.eth.TxPool.SecondaryProcessor = ui
-
-	// Add the ui as a log system so we can log directly to the UGI
-	ethutil.Config.Log.AddLogSystem(ui)
-
-	// Loads previous blocks
-	if firstRun == false {
-		go ui.setInitialBlockChain()
-		go ui.readPreviousTransactions()
-		go ui.update()
-	}
-
-	ui.win.Show()
-	ui.win.Wait()
-
-	ui.eth.Stop()
 }
 
-func (ui *Gui) setInitialBlockChain() {
+func (gui *Gui) showWallet(context *qml.Context) (*qml.Window, error) {
+	component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/wallet.qml"))
+	if err != nil {
+		return nil, err
+	}
+
+	win := gui.createWindow(component)
+
+	go gui.setInitialBlockChain()
+	go gui.readPreviousTransactions()
+	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
+
+	db := &Debugger{gui.win, make(chan bool)}
+	gui.lib.Db = db
+	gui.uiLib.Db = db
+
+	return gui.win
+}
+
+func (gui *Gui) setInitialBlockChain() {
 	// Load previous 10 blocks
-	chain := ui.eth.BlockChain().GetChain(ui.eth.BlockChain().CurrentBlock.Hash(), 10)
+	chain := gui.eth.BlockChain().GetChain(gui.eth.BlockChain().CurrentBlock.Hash(), 10)
 	for _, block := range chain {
-		ui.ProcessBlock(block)
+		gui.processBlock(block)
 	}
 
 }
 
-func (ui *Gui) readPreviousTransactions() {
+func (gui *Gui) readPreviousTransactions() {
-	it := ui.txDb.Db().NewIterator(nil, nil)
+	it := gui.txDb.Db().NewIterator(nil, nil)
 	for it.Next() {
 		tx := ethchain.NewTransactionFromBytes(it.Value())
 
-		ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+		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 (ui *Gui) ProcessBlock(block *ethchain.Block) {
+func (gui *Gui) processBlock(block *ethchain.Block) {
-	ui.win.Root().Call("addBlock", ethpub.NewPBlock(block))
+	gui.win.Root().Call("addBlock", ethpub.NewPBlock(block))
+}
+
+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 (ui *Gui) update() {
+func (gui *Gui) update() {
-	txChan := make(chan ethchain.TxMsg, 1)
+	reactor := gui.eth.Reactor()
-	ui.eth.TxPool().Subscribe(txChan)
+
+	blockChan := make(chan ethutil.React, 1)
+	txChan := make(chan ethutil.React, 1)
+
+	reactor.Subscribe("newBlock", blockChan)
+	reactor.Subscribe("newTx:pre", txChan)
+	reactor.Subscribe("newTx:post", txChan)
+
+	state := gui.eth.StateManager().TransState()
 
-	account := ui.eth.StateManager().GetAddrState(ui.addr).Object
 	unconfirmedFunds := new(big.Int)
-	ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(account.Amount)))
+	gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.addr).Amount)))
-
-	addrState := ui.eth.StateManager().GetAddrState(ui.addr)
 
 	for {
 		select {
+		case b := <-blockChan:
+			block := b.Resource.(*ethchain.Block)
+			if bytes.Compare(block.Coinbase, gui.addr) == 0 {
+				gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.addr).Amount, nil)
+			}
+
 		case txMsg := <-txChan:
-			tx := txMsg.Tx
+			tx := txMsg.Resource.(*ethchain.Transaction)
 
-			if txMsg.Type == ethchain.TxPre {
+			if txMsg.Event == "newTx:pre" {
-				if bytes.Compare(tx.Sender(), ui.addr) == 0 && addrState.Nonce <= tx.Nonce {
+				object := state.GetAccount(gui.addr)
-					ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+
-					ui.txDb.Put(tx.Hash(), tx.RlpEncode())
+				if bytes.Compare(tx.Sender(), gui.addr) == 0 {
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "send")
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
 
-					addrState.Nonce += 1
 					unconfirmedFunds.Sub(unconfirmedFunds, tx.Value)
-				} else if bytes.Compare(tx.Recipient, ui.addr) == 0 {
+				} else if bytes.Compare(tx.Recipient, gui.addr) == 0 {
-					ui.win.Root().Call("addTx", ethpub.NewPTx(tx))
+					gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "recv")
-					ui.txDb.Put(tx.Hash(), tx.RlpEncode())
+					gui.txDb.Put(tx.Hash(), tx.RlpEncode())
 
 					unconfirmedFunds.Add(unconfirmedFunds, tx.Value)
 				}
 
-				pos := "+"
+				gui.setWalletValue(object.Amount, unconfirmedFunds)
-				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(account.Amount), pos, val)
-
-				ui.win.Root().Call("setWalletValue", str)
 			} else {
-				amount := account.Amount
+				object := state.GetAccount(gui.addr)
-				if bytes.Compare(tx.Sender(), ui.addr) == 0 {
+				if bytes.Compare(tx.Sender(), gui.addr) == 0 {
-					amount.Sub(account.Amount, tx.Value)
+					object.SubAmount(tx.Value)
-				} else if bytes.Compare(tx.Recipient, ui.addr) == 0 {
+				} else if bytes.Compare(tx.Recipient, gui.addr) == 0 {
-					amount.Add(account.Amount, tx.Value)
+					object.AddAmount(tx.Value)
 				}
 
-				ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(amount)))
+				gui.setWalletValue(object.Amount, nil)
+
+				state.UpdateStateObject(object)
 			}
 		}
-
-		/*
-			accountAmount := ui.eth.BlockManager.GetAddrState(ui.addr).Account.Amount
-			ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", accountAmount))
-
-			ui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", ui.eth.Peers().Len(), ui.eth.MaxPeers))
-
-			time.Sleep(1 * time.Second)
-		*/
-
 	}
 }
 
 // Logging functions that log directly to the GUI interface
-func (ui *Gui) Println(v ...interface{}) {
+func (gui *Gui) Println(v ...interface{}) {
 	str := strings.TrimRight(fmt.Sprintln(v...), "\n")
 	lines := strings.Split(str, "\n")
 	for _, line := range lines {
-		ui.win.Root().Call("addLog", line)
+		gui.win.Root().Call("addLog", line)
 	}
 }
 
-func (ui *Gui) Printf(format string, v ...interface{}) {
+func (gui *Gui) Printf(format string, v ...interface{}) {
 	str := strings.TrimRight(fmt.Sprintf(format, v...), "\n")
 	lines := strings.Split(str, "\n")
 	for _, line := range lines {
-		ui.win.Root().Call("addLog", line)
+		gui.win.Root().Call("addLog", line)
 	}
 }
+
+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.Create(ethutil.Hex(keyPair.PrivateKey), value, gas, gasPrice, data)
+}

ethereal/ui/html_container.go

@@ -6,6 +6,12 @@ import (
 	"github.com/ethereum/eth-go/ethpub"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/go-qml/qml"
+	"github.com/howeyc/fsnotify"
+	"io/ioutil"
+	"log"
+	"net/url"
+	"os"
+	"path"
 	"path/filepath"
 )
 
@@ -15,6 +21,7 @@ type HtmlApplication struct {
 	engine  *qml.Engine
 	lib     *UiLib
 	path    string
+	watcher *fsnotify.Watcher
 }
 
 func NewHtmlApplication(path string, lib *UiLib) *HtmlApplication {
@@ -47,6 +54,59 @@ func (app *HtmlApplication) Create() error {
 	return nil
 }
 
+func (app *HtmlApplication) RootFolder() string {
+	folder, err := url.Parse(app.path)
+	if err != nil {
+		return ""
+	}
+	return path.Dir(folder.RequestURI())
+}
+func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
+	files, _ := ioutil.ReadDir(app.RootFolder())
+	var folders []os.FileInfo
+	for _, file := range files {
+		if file.IsDir() {
+			folders = append(folders, file)
+		}
+	}
+	return folders
+}
+
+func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
+	var err error
+
+	app.watcher, err = fsnotify.NewWatcher()
+	if err != nil {
+		return
+	}
+	err = app.watcher.Watch(app.RootFolder())
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, folder := range app.RecursiveFolders() {
+		fullPath := app.RootFolder() + "/" + folder.Name()
+		app.watcher.Watch(fullPath)
+	}
+
+	go func() {
+	out:
+		for {
+			select {
+			case <-quitChan:
+				app.watcher.Close()
+				break out
+			case <-app.watcher.Event:
+				//ethutil.Config.Log.Debugln("Got event:", ev)
+				app.webView.Call("reload")
+			case err := <-app.watcher.Error:
+				// TODO: Do something here
+				ethutil.Config.Log.Infoln("Watcher error:", err)
+			}
+		}
+	}()
+
+}
+
 func (app *HtmlApplication) Engine() *qml.Engine {
 	return app.engine
 }

ethereal/ui/library.go

@@ -1,10 +1,8 @@
 package ethui
 
 import (
-	"encoding/hex"
 	"fmt"
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethpub"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/go-ethereum/utils"
 	"github.com/obscuren/secp256k1-go"
@@ -36,93 +34,13 @@ func (lib *EthLib) ImportAndSetPrivKey(privKey string) bool {
 }
 
 func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) {
-	pub, prv := secp256k1.GenerateKeyPair()
+	_, prv := secp256k1.GenerateKeyPair()
-	pair := &ethutil.Key{PrivateKey: prv, PublicKey: pub}
+	keyPair, err := ethutil.GetKeyRing().NewKeyPair(prv)
-	ethutil.Config.Db.Put([]byte("KeyRing"), pair.RlpEncode())
-	mne := ethutil.MnemonicEncode(ethutil.Hex(prv))
-	mnemonicString := strings.Join(mne, " ")
-	return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub)
-}
-
-func (lib *EthLib) GetKey() string {
-	return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address())
-}
-
-func (lib *EthLib) GetStateObject(address string) *ethpub.PStateObject {
-	stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address))
-	if stateObject != nil {
-		return ethpub.NewPStateObject(stateObject)
-	}
-
-	// See GetStorage for explanation on "nil"
-	return ethpub.NewPStateObject(nil)
-}
-
-func (lib *EthLib) Watch(addr, storageAddr string) {
-	//	lib.stateManager.Watch(ethutil.FromHex(addr), ethutil.FromHex(storageAddr))
-}
-
-func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
-	return lib.Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr)
-}
-
-func (lib *EthLib) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
-	var hash []byte
-	var contractCreation bool
-	if len(recipient) == 0 {
-		contractCreation = true
-	} else {
-		var err error
-		hash, err = hex.DecodeString(recipient)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	keyPair := ethutil.Config.Db.GetKeys()[0]
-	value := ethutil.Big(valueStr)
-	gas := ethutil.Big(gasStr)
-	gasPrice := ethutil.Big(gasPriceStr)
-	var tx *ethchain.Transaction
-	// Compile and assemble the given data
-	if contractCreation {
-		// Compile script
-		mainScript, initScript, err := utils.CompileScript(dataStr)
-		if err != nil {
-			return "", err
-		}
-
-		tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript)
-	} else {
-		lines := strings.Split(dataStr, "\n")
-		var data []byte
-		for _, line := range lines {
-			data = append(data, ethutil.BigToBytes(ethutil.Big(line), 256)...)
-		}
-
-		tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, data)
-	}
-	acc := lib.stateManager.GetAddrState(keyPair.Address())
-	tx.Nonce = acc.Nonce
-	tx.Sign(keyPair.PrivateKey)
-	lib.txPool.QueueTransaction(tx)
-
-	if contractCreation {
-		ethutil.Config.Log.Infof("Contract addr %x", tx.Hash()[12:])
-	} else {
-		ethutil.Config.Log.Infof("Tx hash %x", tx.Hash())
-	}
-
-	return ethutil.Hex(tx.Hash()), nil
-}
-
-func (lib *EthLib) GetBlock(hexHash string) *ethpub.PBlock {
-	hash, err := hex.DecodeString(hexHash)
 	if err != nil {
-		return nil
+		panic(err)
 	}
 
-	block := lib.blockChain.GetBlock(hash)
+	mne := ethutil.MnemonicEncode(ethutil.Hex(keyPair.PrivateKey))
-
+	mnemonicString := strings.Join(mne, " ")
-	return &ethpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
+	return mnemonicString, fmt.Sprintf("%x", keyPair.Address()), ethutil.Hex(keyPair.PrivateKey), ethutil.Hex(keyPair.PublicKey)
 }

ethereal/ui/ui_lib.go

@@ -59,14 +59,6 @@ func (ui *UiLib) OpenHtml(path string) {
 	go app.run()
 }
 
-func (ui *UiLib) Watch(addr, storageAddr string) {
-	if len(storageAddr) == 0 {
-		ui.eth.Reactor().Subscribe("storage:"+string(ethutil.FromHex(addr))+":"+string(ethutil.FromHex(storageAddr)), nil)
-	} else {
-		ui.eth.Reactor().Subscribe("object:"+string(ethutil.FromHex(addr)), nil)
-	}
-}
-
 func (ui *UiLib) Muted(content string) {
 	component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
 	if err != nil {
@@ -78,8 +70,6 @@ func (ui *UiLib) Muted(content string) {
 	go func() {
 		path := "file://" + ui.AssetPath("muted/index.html")
 		win.Set("url", path)
-		//debuggerPath := "file://" + ui.AssetPath("muted/debugger.html")
-		//win.Set("debugUrl", debuggerPath)
 
 		win.Show()
 		win.Wait()
@@ -88,7 +78,7 @@ func (ui *UiLib) Muted(content string) {
 
 func (ui *UiLib) Connect(button qml.Object) {
 	if !ui.connected {
-		ui.eth.Start()
+		ui.eth.Start(true)
 		ui.connected = true
 		button.Set("enabled", false)
 	}
@@ -131,7 +121,7 @@ func DefaultAssetPath() string {
 func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) {
 	state := ui.eth.BlockChain().CurrentBlock.State()
 
-	mainInput, _ := mutan.PreProcess(data)
+	mainInput, _ := mutan.PreParse(data)
 	callerScript, err := utils.Compile(mainInput)
 	if err != nil {
 		ethutil.Config.Log.Debugln(err)
@@ -145,13 +135,13 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string)
 	for _, str := range dis {
 		ui.win.Root().Call("setAsm", str)
 	}
-	callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasStr), ethutil.Big(gasPriceStr), callerScript, nil)
+	callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasStr), ethutil.Big(gasPriceStr), nil)
 
 	// Contract addr as test address
-	keyPair := ethutil.Config.Db.GetKeys()[0]
+	keyPair := ethutil.GetKeyRing().Get(0)
-	account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Object
+	account := ui.eth.StateManager().TransState().GetStateObject(keyPair.Address())
 	c := ethchain.MakeContract(callerTx, state)
-	callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), ethutil.Big(gasPriceStr), ethutil.Big(valueStr))
+	callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), ethutil.Big(gasPriceStr))
 
 	block := ui.eth.BlockChain().CurrentBlock
 	vm := ethchain.NewVm(state, ui.eth.StateManager(), ethchain.RuntimeVars{

ethereum/config.go

@@ -2,11 +2,14 @@ package main
 
 import (
 	"flag"
+	"fmt"
+	"os"
 )
 
-var StartConsole bool
+var Identifier string
 var StartMining bool
 var StartRpc bool
+var RpcPort int
 var UseUPnP bool
 var OutboundPort string
 var ShowGenesis bool
@@ -19,13 +22,20 @@ var ExportKey bool
 var LogFile string
 var DataDir string
 var NonInteractive bool
+var StartJsConsole bool
+var InputFile string
 
 func Init() {
-	flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "%s [options] [filename]:\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	flag.StringVar(&Identifier, "i", "", "custom client identifier")
 	flag.BoolVar(&StartMining, "m", false, "start dagger mining")
 	flag.BoolVar(&ShowGenesis, "g", false, "prints genesis header and exits")
-	//flag.BoolVar(&UseGui, "gui", true, "use the gui")
 	flag.BoolVar(&StartRpc, "r", false, "start rpc server")
+	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
 	flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
 	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
 	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
@@ -35,7 +45,10 @@ func Init() {
 	flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
 	flag.StringVar(&DataDir, "dir", ".ethereum", "ethereum data directory")
 	flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
-	flag.IntVar(&MaxPeer, "x", 5, "maximum desired peers")
+	flag.IntVar(&MaxPeer, "x", 10, "maximum desired peers")
+	flag.BoolVar(&StartJsConsole, "js", false, "exp")
 
 	flag.Parse()
+
+	InputFile = flag.Arg(0)
 }

ethereum/dev_console.go

@@ -1,259 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethdb"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/obscuren/mutan"
-	"os"
-	"strings"
-)
-
-type Console struct {
-	db       *ethdb.MemDatabase
-	trie     *ethutil.Trie
-	ethereum *eth.Ethereum
-}
-
-func NewConsole(s *eth.Ethereum) *Console {
-	db, _ := ethdb.NewMemDatabase()
-	trie := ethutil.NewTrie(db, "")
-
-	return &Console{db: db, trie: trie, ethereum: s}
-}
-
-func (i *Console) ValidateInput(action string, argumentLength int) error {
-	err := false
-	var expArgCount int
-
-	switch {
-	case action == "update" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "get" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "dag" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "decode" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "encode" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "gettx" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "tx" && argumentLength != 4:
-		err = true
-		expArgCount = 4
-	case action == "getaddr" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "contract" && argumentLength != 2:
-		err = true
-		expArgCount = 2
-	case action == "say" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "addp" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	case action == "block" && argumentLength != 1:
-		err = true
-		expArgCount = 1
-	}
-
-	if err {
-		return errors.New(fmt.Sprintf("'%s' requires %d args, got %d", action, expArgCount, argumentLength))
-	} else {
-		return nil
-	}
-}
-
-func (i *Console) Editor() string {
-	var buff bytes.Buffer
-	for {
-		reader := bufio.NewReader(os.Stdin)
-		str, _, err := reader.ReadLine()
-		if len(str) > 0 {
-			buff.Write(str)
-			buff.WriteString("\n")
-		}
-
-		if err != nil && err.Error() == "EOF" {
-			break
-		}
-	}
-
-	return buff.String()
-}
-
-func (i *Console) PrintRoot() {
-	root := ethutil.NewValue(i.trie.Root)
-	if len(root.Bytes()) != 0 {
-		fmt.Println(hex.EncodeToString(root.Bytes()))
-	} else {
-		fmt.Println(i.trie.Root)
-	}
-}
-
-func (i *Console) ParseInput(input string) bool {
-	scanner := bufio.NewScanner(strings.NewReader(input))
-	scanner.Split(bufio.ScanWords)
-
-	count := 0
-	var tokens []string
-	for scanner.Scan() {
-		count++
-		tokens = append(tokens, scanner.Text())
-	}
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintln(os.Stderr, "reading input:", err)
-	}
-
-	if len(tokens) == 0 {
-		return true
-	}
-
-	err := i.ValidateInput(tokens[0], count-1)
-	if err != nil {
-		fmt.Println(err)
-	} else {
-		switch tokens[0] {
-		case "update":
-			i.trie.Update(tokens[1], tokens[2])
-
-			i.PrintRoot()
-		case "get":
-			fmt.Println(i.trie.Get(tokens[1]))
-		case "root":
-			i.PrintRoot()
-		case "rawroot":
-			fmt.Println(i.trie.Root)
-		case "print":
-			i.db.Print()
-		case "dag":
-			fmt.Println(ethchain.DaggerVerify(ethutil.Big(tokens[1]), // hash
-				ethutil.BigPow(2, 36),   // diff
-				ethutil.Big(tokens[2]))) // nonce
-		case "decode":
-			value := ethutil.NewValueFromBytes([]byte(tokens[1]))
-			fmt.Println(value)
-		case "getaddr":
-			encoded, _ := hex.DecodeString(tokens[1])
-			addr := i.ethereum.BlockChain().CurrentBlock.State().GetAccount(encoded)
-			fmt.Println("addr:", addr)
-		case "block":
-			encoded, _ := hex.DecodeString(tokens[1])
-			block := i.ethereum.BlockChain().GetBlock(encoded)
-			info := block.BlockInfo()
-			fmt.Printf("++++++++++ #%d ++++++++++\n%v\n", info.Number, block)
-		case "say":
-			i.ethereum.Broadcast(ethwire.MsgTalkTy, []interface{}{tokens[1]})
-		case "addp":
-			i.ethereum.ConnectToPeer(tokens[1])
-		case "pcount":
-			fmt.Println("peers:", i.ethereum.Peers().Len())
-		case "encode":
-			fmt.Printf("%q\n", ethutil.Encode(tokens[1]))
-		case "tx":
-			recipient, err := hex.DecodeString(tokens[1])
-			if err != nil {
-				fmt.Println("recipient err:", err)
-			} else {
-				tx := ethchain.NewTransactionMessage(recipient, ethutil.Big(tokens[2]), ethutil.Big(tokens[3]), ethutil.Big(tokens[4]), nil)
-
-				key := ethutil.Config.Db.GetKeys()[0]
-				tx.Sign(key.PrivateKey)
-				i.ethereum.TxPool().QueueTransaction(tx)
-
-				fmt.Printf("%x\n", tx.Hash())
-			}
-		case "gettx":
-			addr, _ := hex.DecodeString(tokens[1])
-			data, _ := ethutil.Config.Db.Get(addr)
-			if len(data) != 0 {
-				decoder := ethutil.NewValueFromBytes(data)
-				fmt.Println(decoder)
-			} else {
-				fmt.Println("gettx: tx not found")
-			}
-		case "contract":
-			fmt.Println("Contract editor (Ctrl-D = done)")
-
-			mainInput, initInput := mutan.PreProcess(i.Editor())
-			mainScript, err := utils.Compile(mainInput)
-			if err != nil {
-				fmt.Println(err)
-
-				break
-			}
-			initScript, err := utils.Compile(initInput)
-			if err != nil {
-				fmt.Println(err)
-
-				break
-			}
-
-			contract := ethchain.NewContractCreationTx(ethutil.Big(tokens[0]), ethutil.Big(tokens[1]), ethutil.Big(tokens[1]), mainScript, initScript)
-
-			key := ethutil.Config.Db.GetKeys()[0]
-			contract.Sign(key.PrivateKey)
-
-			i.ethereum.TxPool().QueueTransaction(contract)
-
-			fmt.Printf("%x\n", contract.Hash()[12:])
-		case "exit", "quit", "q":
-			return false
-		case "help":
-			fmt.Printf("COMMANDS:\n" +
-				"\033[1m= DB =\033[0m\n" +
-				"update KEY VALUE - Updates/Creates a new value for the given key\n" +
-				"get KEY - Retrieves the given key\n" +
-				"root - Prints the hex encoded merkle root\n" +
-				"rawroot - Prints the raw merkle root\n" +
-				"block HASH - Prints the block\n" +
-				"getaddr ADDR - Prints the account associated with the address\n" +
-				"\033[1m= Dagger =\033[0m\n" +
-				"dag HASH NONCE - Verifies a nonce with the given hash with dagger\n" +
-				"\033[1m= Encoding =\033[0m\n" +
-				"decode STR\n" +
-				"encode STR\n" +
-				"\033[1m= Other =\033[0m\n" +
-				"addp HOST:PORT\n" +
-				"tx TO AMOUNT\n" +
-				"contract AMOUNT\n")
-
-		default:
-			fmt.Println("Unknown command:", tokens[0])
-		}
-	}
-
-	return true
-}
-
-func (i *Console) Start() {
-	fmt.Printf("Eth Console. Type (help) for help\n")
-	reader := bufio.NewReader(os.Stdin)
-	for {
-		fmt.Printf("eth >>> ")
-		str, _, err := reader.ReadLine()
-		if err != nil {
-			fmt.Println("Error reading input", err)
-		} else {
-			if !i.ParseInput(string(str)) {
-				return
-			}
-		}
-	}
-}

ethereum/ethereum.go

@@ -4,11 +4,9 @@ import (
 	"fmt"
 	"github.com/ethereum/eth-go"
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethminer"
-	"github.com/ethereum/eth-go/ethpub"
-	"github.com/ethereum/eth-go/ethrpc"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/go-ethereum/utils"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/signal"
@@ -18,16 +16,15 @@ import (
 
 const Debug = true
 
-// Register interrupt handlers so we can stop the ethereum
+func RegisterInterrupt(cb func(os.Signal)) {
-func RegisterInterrupts(s *eth.Ethereum) {
-	// Buffered chan of one is enough
-	c := make(chan os.Signal, 1)
-	// Notify about interrupts for now
-	signal.Notify(c, os.Interrupt)
 	go func() {
+		// Buffered chan of one is enough
+		c := make(chan os.Signal, 1)
+		// Notify about interrupts for now
+		signal.Notify(c, os.Interrupt)
+
 		for sig := range c {
-			fmt.Printf("Shutting down (%v) ... \n", sig)
+			cb(sig)
-			s.Stop()
 		}
 	}()
 }
@@ -55,7 +52,15 @@ func main() {
 	var logSys *log.Logger
 	flags := log.LstdFlags
 
-	ethutil.ReadConfig(DataDir)
+	var lt ethutil.LoggerType
+	if StartJsConsole || len(InputFile) > 0 {
+		lt = ethutil.LogFile
+	} else {
+		lt = ethutil.LogFile | ethutil.LogStd
+	}
+
+	ethutil.ReadConfig(DataDir, lt, Identifier)
+
 	logger := ethutil.Config.Log
 
 	if LogFile != "" {
@@ -67,13 +72,11 @@ func main() {
 		log.SetOutput(logfile)
 		logSys = log.New(logfile, "", flags)
 		logger.AddLogSystem(logSys)
-	}
+	} else {
-	/*else {
 		logSys = log.New(os.Stdout, "", flags)
-	}*/
+	}
 
 	ethchain.InitFees()
-	ethutil.Config.Seed = UseSeed
 
 	// Instantiated a eth stack
 	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
@@ -106,8 +109,19 @@ func main() {
 		}
 		os.Exit(0)
 	case ExportKey:
-		key := ethutil.Config.Db.GetKeys()[0]
+		keyPair := ethutil.GetKeyRing().Get(0)
-		logSys.Println(fmt.Sprintf("prvk: %x\n", key.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)
+
 		os.Exit(0)
 	case ShowGenesis:
 		logSys.Println(ethereum.BlockChain().Genesis())
@@ -123,47 +137,50 @@ func main() {
 	// Set the max peers
 	ethereum.MaxPeers = MaxPeer
 
-	if StartConsole {
+	// Set Mining status
-		err := os.Mkdir(ethutil.Config.ExecPath, os.ModePerm)
+	ethereum.Mining = StartMining
-		// Error is OK if the error is ErrExist
-		if err != nil && !os.IsExist(err) {
-			log.Panic("Unable to create EXECPATH:", err)
-		}
-
-		console := NewConsole(ethereum)
-		go console.Start()
-	}
-	if StartRpc {
-		ethereum.RpcServer = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum.StateManager(), ethereum.BlockChain(), ethereum.TxPool()))
-		go ethereum.RpcServer.Start()
-	}
-
-	RegisterInterrupts(ethereum)
-	ethereum.Start()
 
 	if StartMining {
-		logger.Infoln("Miner started")
+		utils.DoMining(ethereum)
-
-		// Fake block mining. It broadcasts a new block every 5 seconds
-		go func() {
-
-			if StartMining {
-				logger.Infoln("Miner started")
-
-				go func() {
-					data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
-					keyRing := ethutil.NewValueFromBytes(data)
-					addr := keyRing.Get(1).Bytes()
-
-					miner := ethminer.NewDefaultMiner(addr, ethereum)
-					miner.Start()
-
-				}()
-			}
-		}()
-
 	}
 
+	if StartJsConsole {
+		repl := NewJSRepl(ethereum)
+
+		go repl.Start()
+
+		RegisterInterrupt(func(os.Signal) {
+			repl.Stop()
+		})
+	} else if len(InputFile) > 0 {
+		file, err := os.Open(InputFile)
+		if err != nil {
+			ethutil.Config.Log.Fatal(err)
+		}
+
+		content, err := ioutil.ReadAll(file)
+		if err != nil {
+			ethutil.Config.Log.Fatal(err)
+		}
+
+		re := NewJSRE(ethereum)
+		RegisterInterrupt(func(os.Signal) {
+			re.Stop()
+		})
+		re.Run(string(content))
+	}
+
+	if StartRpc {
+		utils.DoRpc(ethereum, RpcPort)
+	}
+
+	RegisterInterrupt(func(sig os.Signal) {
+		fmt.Printf("Shutting down (%v) ... \n", sig)
+		ethereum.Stop()
+	})
+
+	ethereum.Start(UseSeed)
+
 	// Wait for shutdown
 	ethereum.WaitForShutdown()
 }

ethereum/javascript_runtime.go

@@ -0,0 +1,190 @@
+package main
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethchain"
+	"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/filepath"
+)
+
+type JSRE struct {
+	ethereum *eth.Ethereum
+	vm       *otto.Otto
+	lib      *ethpub.PEthereum
+
+	blockChan  chan ethutil.React
+	changeChan chan ethutil.React
+	quitChan   chan bool
+
+	objectCb map[string][]otto.Value
+}
+
+func NewJSRE(ethereum *eth.Ethereum) *JSRE {
+	re := &JSRE{
+		ethereum,
+		otto.New(),
+		ethpub.NewPEthereum(ethereum),
+		make(chan ethutil.React, 1),
+		make(chan ethutil.React, 1),
+		make(chan bool),
+		make(map[string][]otto.Value),
+	}
+
+	// Init the JS lib
+	re.vm.Run(jsLib)
+
+	// We have to make sure that, whoever calls this, calls "Stop"
+	go re.mainLoop()
+
+	re.Bind("eth", &JSEthereum{re.lib, re.vm})
+
+	re.initStdFuncs()
+
+	return re
+}
+
+func (self *JSRE) Bind(name string, v interface{}) {
+	self.vm.Set(name, v)
+}
+
+func (self *JSRE) Run(code string) (otto.Value, error) {
+	return self.vm.Run(code)
+}
+
+func (self *JSRE) Require(file string) error {
+	if len(filepath.Ext(file)) == 0 {
+		file += ".js"
+	}
+
+	fh, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+
+	content, _ := ioutil.ReadAll(fh)
+	self.Run("exports = {};(function() {" + string(content) + "})();")
+
+	return nil
+}
+
+func (self *JSRE) Stop() {
+	// Kill the main loop
+	self.quitChan <- true
+
+	close(self.blockChan)
+	close(self.quitChan)
+	close(self.changeChan)
+}
+
+func (self *JSRE) mainLoop() {
+	// Subscribe to events
+	reactor := self.ethereum.Reactor()
+	reactor.Subscribe("newBlock", self.blockChan)
+
+out:
+	for {
+		select {
+		case <-self.quitChan:
+			break out
+		case block := <-self.blockChan:
+			if _, ok := block.Resource.(*ethchain.Block); ok {
+			}
+		case object := <-self.changeChan:
+			if stateObject, ok := object.Resource.(*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")
+	eth := t.Object()
+	eth.Set("watch", self.watch)
+	eth.Set("addPeer", self.addPeer)
+	eth.Set("require", self.require)
+	eth.Set("stopMining", self.stopMining)
+	eth.Set("startMining", self.startMining)
+}
+
+/*
+ * The following methods are natively implemented javascript functions
+ */
+
+func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StopMining(self.ethereum))
+	return v
+}
+
+func (self *JSRE) startMining(call otto.FunctionCall) otto.Value {
+	v, _ := self.vm.ToValue(utils.StartMining(self.ethereum))
+	return v
+}
+
+// eth.watch
+func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
+	addr, _ := call.Argument(0).ToString()
+	var storageAddr string
+	var cb otto.Value
+	var storageCallback bool
+	if len(call.ArgumentList) > 2 {
+		storageCallback = true
+		storageAddr, _ = call.Argument(1).ToString()
+		cb = call.Argument(2)
+	} else {
+		cb = call.Argument(1)
+	}
+
+	if storageCallback {
+		self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
+
+		event := "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	} else {
+		self.objectCb[addr] = append(self.objectCb[addr], cb)
+
+		event := "object:" + string(ethutil.FromHex(addr))
+		self.ethereum.Reactor().Subscribe(event, self.changeChan)
+	}
+
+	return otto.UndefinedValue()
+}
+
+func (self *JSRE) addPeer(call otto.FunctionCall) otto.Value {
+	host, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.FalseValue()
+	}
+	self.ethereum.ConnectToPeer(host)
+
+	return otto.TrueValue()
+}
+
+func (self *JSRE) require(call otto.FunctionCall) otto.Value {
+	file, err := call.Argument(0).ToString()
+	if err != nil {
+		return otto.UndefinedValue()
+	}
+	if err := self.Require(file); err != nil {
+		fmt.Println("err:", err)
+		return otto.UndefinedValue()
+	}
+
+	t, _ := self.vm.Get("exports")
+
+	return t
+}

ethereum/js_lib.go

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

ethereum/repl.go

@@ -0,0 +1,110 @@
+package main
+
+import (
+	"fmt"
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/obscuren/otto"
+)
+
+type Repl interface {
+	Start()
+	Stop()
+}
+
+type JSRepl struct {
+	re *JSRE
+
+	prompt string
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+	return &JSRepl{re: NewJSRE(ethereum), prompt: "> "}
+}
+
+func (self *JSRepl) Start() {
+	self.read()
+}
+
+func (self *JSRepl) Stop() {
+	self.re.Stop()
+}
+
+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) 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) 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(err)
+
+		return otto.UndefinedValue()
+	}
+
+	return result
+}

ethereum/repl_darwin.go

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

ethereum/repl_linux.go

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

ethereum/repl_windows.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func (self *JSRepl) read() {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Printf(self.prompt)
+		str, _, err := reader.ReadLine()
+		if err != nil {
+			fmt.Println("Error reading input", err)
+		} else {
+			self.parseInput(string(str))
+		}
+	}
+}
+
+func (self *JSRepl) PrintValue(value otto.Value) {
+	fmt.Println(value)
+}

utils/cmd.go

@@ -0,0 +1,69 @@
+package utils
+
+import (
+	"github.com/ethereum/eth-go"
+	"github.com/ethereum/eth-go/ethminer"
+	"github.com/ethereum/eth-go/ethpub"
+	"github.com/ethereum/eth-go/ethrpc"
+	"github.com/ethereum/eth-go/ethutil"
+	"time"
+)
+
+func DoRpc(ethereum *eth.Ethereum, RpcPort int) {
+	var err error
+	ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort)
+	if err != nil {
+		ethutil.Config.Log.Infoln("Could not start RPC interface:", err)
+	} else {
+		go ethereum.RpcServer.Start()
+	}
+}
+
+var miner ethminer.Miner
+
+func DoMining(ethereum *eth.Ethereum) {
+	// Set Mining status
+	ethereum.Mining = true
+
+	if ethutil.GetKeyRing().Len() == 0 {
+		ethutil.Config.Log.Infoln("No address found, can't start mining")
+		return
+	}
+	keyPair := ethutil.GetKeyRing().Get(0)
+	addr := keyPair.Address()
+
+	go func() {
+		ethutil.Config.Log.Infoln("Miner started")
+
+		miner = ethminer.NewDefaultMiner(addr, ethereum)
+
+		// Give it some time to connect with peers
+		time.Sleep(3 * time.Second)
+
+		miner.Start()
+	}()
+}
+
+func StopMining(ethereum *eth.Ethereum) bool {
+	if ethereum.Mining {
+		miner.Stop()
+
+		ethutil.Config.Log.Infoln("Miner stopped")
+
+		ethereum.Mining = false
+
+		return true
+	}
+
+	return false
+}
+
+func StartMining(ethereum *eth.Ethereum) bool {
+	if !ethereum.Mining {
+		DoMining(ethereum)
+
+		return true
+	}
+
+	return false
+}

utils/compile.go

@@ -24,7 +24,7 @@ func Compile(script string) ([]byte, error) {
 
 func CompileScript(script string) ([]byte, []byte, error) {
 	// Preprocess
-	mainInput, initInput := mutan.PreProcess(script)
+	mainInput, initInput := mutan.PreParse(script)
 	// Compile main script
 	mainScript, err := Compile(mainInput)
 	if err != nil {

utils/keys.go

@@ -6,6 +6,60 @@ import (
 	"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 {
@@ -28,7 +82,9 @@ save these words so you can restore your account later: %s
 
 	}
 }
+*/
 
+/*
 func ImportPrivateKey(prvKey string) {
 	key := ethutil.FromHex(prvKey)
 	msg := []byte("tmp")
@@ -49,3 +105,4 @@ pubk: %x
 
 `, pair.Address(), key, pub)
 }
+*/