Re-wrote ethereum.js

mist/assets/debugger/debugger.qml

@@ -221,7 +221,7 @@ ApplicationWindow {
                             }
                             height: parent.height
                             width: 300
-                            TableViewColumn{ role: "value" ; title: "Temp" ; width: 200 }
+                            TableViewColumn{ role: "value" ; title: "Local VM stack" ; width: stackTableView.width - 2 }
                             model: stackModel
                         }
 
@@ -233,7 +233,7 @@ ApplicationWindow {
                             height: parent.height
                             width: parent.width - stackTableView.width
                             TableViewColumn{ id:mnumColmn ; role: "num" ; title: "#" ; width: 50 }
-                            TableViewColumn{ role: "value" ; title: "Memory" ; width: 750 }
+                            TableViewColumn{ role: "value" ; title: "Memory" ; width: 650 }
                             model: memModel
                         }
                     }
@@ -248,8 +248,8 @@ ApplicationWindow {
                             }
                             height: parent.height
                             width: parent.width
-                            TableViewColumn{ id: key ; role: "key" ; title: "#" ; width: storageTableView.width / 2}
+                            TableViewColumn{ id: key ; role: "key" ; title: "#" ; width: storageTableView.width / 2 - 1}
-                            TableViewColumn{ role: "value" ; title: "Storage" ; width:  storageTableView.width / 2}
+                            TableViewColumn{ role: "value" ; title: "Storage" ; width:  storageTableView.width / 2 - 1}
                             model: storageModel
                         }
                     }

mist/assets/ext/filter.js

@@ -31,11 +31,11 @@ Filter.prototype.changed = function(callback) {
     this.callbacks.push(callback);
 
 	var self = this;
-	message.connect(function(messages, id) {
+	messages.connect(function(messages, id) {
 		if(id ==  self.id) {
-            for(var i = 0; i < self.callbacks.length; i++) {
+			for(var i = 0; i < self.callbacks.length; i++) {
-                self.callbacks[i].call(self, messages);
+				self.callbacks[i].call(self, messages);
-            }
+			}
 		}
 	});
 };

mist/assets/ext/html_messaging.js

@@ -12,15 +12,46 @@
 
 	window.eth = {
 		_callbacks: {},
-		_onCallbacks: {},
+		_events: {},
 		prototype: Object(),
 
-		coinbase: function() {
+		toHex: function(str) {
-			return new Promise(function(resolve, reject) {
+			var hex = "";
-				postData({call: "getCoinBase"}, function(coinbase) {
+			for(var i = 0; i < str.length; i++) {
-					resolve(coinbase);
+				var n = str.charCodeAt(i).toString(16);
-				});
+				hex += n.length < 2 ? '0' + n : n;
-			});
+			}
+
+			return hex;
+		},
+
+		toAscii: function(hex) {
+			// Find termination
+			var str = "";
+			var i = 0, l = hex.length;
+			for(; i < l; i+=2) {
+				var code = hex.charCodeAt(i)
+				if(code == 0) {
+					break;
+				}
+
+				str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+			}
+
+			return str;
+		},
+
+		fromAscii: function(str, pad) {
+			if(pad === undefined) {
+				pad = 32
+			}
+
+			var hex = this.toHex(str);
+
+			while(hex.length < pad*2)
+				hex += "00";
+
+			return hex
 		},
 
 		block: function(numberOrHash) {
@@ -107,17 +138,316 @@
 			});
 		},
 
-		key: function() {
+		balanceAt: function(address) {
+			var promises = [];
+
+			if(isPromise(address)) {
+				promises.push(address.then(function(_address) { address = _address; }));
+			}
+
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "getBalanceAt", args: [address]}, function(balance) {
+						resolve(balance);
+					});
+				});
+			});
+		},
+
+		countAt: function(address) {
+			var promises = [];
+
+			if(isPromise(address)) {
+				promises.push(address.then(function(_address) { address = _address; }));
+			}
+
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "getCountAt", args: [address]}, function(count) {
+						resolve(count);
+					});
+				});
+			});
+		},
+
+		codeAt: function(address) {
+			var promises = [];
+
+			if(isPromise(address)) {
+				promises.push(address.then(function(_address) { address = _address; }));
+			}
+
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "getCodeAt", args: [address]}, function(code) {
+						resolve(code);
+					});
+				});
+			});
+		},
+
+		storageAt: function(address, storageAddress) {
+			var promises = [];
+
+			if(isPromise(address)) {
+				promises.push(address.then(function(_address) { address = _address; }));
+			}
+
+			if(isPromise(storageAddress)) {
+				promises.push(storageAddress.then(function(_sa) { storageAddress = _sa; }));
+			}
+
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "getStorageAt", args: [address, storageAddress]}, function(entry) {
+						resolve(entry);
+					});
+				});
+			});
+		},
+
+		stateAt: function(address, storageAddress) {
+			return this.storageAt(address, storageAddress);
+		},
+
+		call: function(params) {
+			if(params === undefined) {
+				params = {};
+			}
+
+			if(params.endowment !== undefined)
+				params.value = params.endowment;
+			if(params.code !== undefined)
+				params.data = params.code;
+
+
+			var promises = []
+			if(isPromise(params.to)) {
+				promises.push(params.to.then(function(_to) { params.to = _to; }));
+			}
+			if(isPromise(params.from)) {
+				promises.push(params.from.then(function(_from) { params.from = _from; }));
+			}
+
+			if(isPromise(params.data)) {
+				promises.push(params.data.then(function(_code) { params.data = _code; }));
+			} else {
+				if(typeof params.data === "object") {
+					data = "";
+					for(var i = 0; i < params.data.length; i++) {
+						data += params.data[i]
+					}
+				} else {
+					data = params.data;
+				}
+			}
+
+			// Make sure everything is string
+			var fields = ["value", "gas", "gasPrice"];
+			for(var i = 0; i < fields.length; i++) {
+				if(params[fields[i]] === undefined) {
+					params[fields[i]] = "";
+				}
+				params[fields[i]] = params[fields[i]].toString();
+			}
+
+			// Load promises then call the last "transact".
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "call", args: params}, function(data) {
+						if(data[1])
+							reject(data[0]);
+						else
+							resolve(data[0]);
+					});
+				});
+			})
+		},
+
+		watch: function(params) {
+			return new Filter(params);
+		},
+
+		secretToAddress: function(key) {
+			var promises = [];
+			if(isPromise(key)) {
+				promises.push(key.then(function(_key) { key = _key; }));
+			}
+
+			return Q.all(promises).then(function() {
+				return new Promise(function(resolve, reject) {
+					postData({call: "getSecretToAddress", args: [key]}, function(address) {
+						resolve(address);
+					});
+				});
+			});
+		},
+
+		on: function(event, cb) {
+			if(eth._events[event] === undefined) {
+				eth._events[event] = [];
+			}
+
+			eth._events[event].push(cb);
+
+			return this
+		},
+
+		off: function(event, cb) {
+			if(eth._events[event] !== undefined) {
+				var callbacks = eth._events[event];
+				for(var i = 0; i < callbacks.length; i++) {
+					if(callbacks[i] === cb) {
+						delete callbacks[i];
+					}
+				}
+			}
+
+			return this
+		},
+
+		trigger: function(event, data) {
+			var callbacks = eth._events[event];
+			if(callbacks !== undefined) {
+				for(var i = 0; i < callbacks.length; i++) {
+					// Figure out whether the returned data was an array
+					// array means multiple return arguments (multiple params)
+					if(data instanceof Array) {
+						callbacks[i].apply(this, data);
+					} else {
+						callbacks[i].call(this, data);
+					}
+				}
+			}
+		},
+	};
+
+	// Eth object properties
+	Object.defineProperty(eth, "key", {
+		get: function() {
 			return new Promise(function(resolve, reject) {
 				postData({call: "getKey"}, function(k) {
 					resolve(k);
 				});
 			});
+		},
+	});
+
+	Object.defineProperty(eth, "gasPrice", {
+		get: function() {
+			return "1000000000000"
 		}
+	});
+
+	Object.defineProperty(eth, "coinbase", {
+		get: function() {
+			return new Promise(function(resolve, reject) {
+				postData({call: "getCoinBase"}, function(coinbase) {
+					resolve(coinbase);
+				});
+			});
+		},
+	});
+
+	Object.defineProperty(eth, "listening", {
+		get: function() {
+			return new Promise(function(resolve, reject) {
+				postData({call: "getIsListening"}, function(listening) {
+					resolve(listening);
+				});
+			});
+		},
+	});
+
+
+	Object.defineProperty(eth, "mining", {
+		get: function() {
+			return new Promise(function(resolve, reject) {
+				postData({call: "getIsMining"}, function(mining) {
+					resolve(mining);
+				});
+			});
+		},
+	});
+
+	Object.defineProperty(eth, "peerCount", {
+		get: function() {
+			return new Promise(function(resolve, reject) {
+				postData({call: "getPeerCount"}, function(peerCount) {
+					resolve(peerCount);
+				});
+			});
+		},
+	});
+
+	var filters = [];
+	var Filter = function(options) {
+		filters.push(this);
+
+		this.callbacks = [];
+		this.options = options;
+
+		var call;
+		if(options === "chain") {
+			call = "newFilterString"
+		} else if(typeof options === "object") {
+			call = "newFilter"
+		}
+
+		var self = this; // Cheaper than binding
+		this.promise = new Promise(function(resolve, reject) {
+			postData({call: call, args: [options]}, function(id) {
+				self.id = id;
+
+				resolve(id);
+			});
+		});
+	};
+
+	Filter.prototype.changed = function(callback) {
+		var self = this;
+		this.promise.then(function(id) {
+			self.callbacks.push(callback);
+		});
 	};
 
+	Filter.prototype.trigger = function(messages, id) {
+		if(id == this.id) {
+			for(var i = 0; i < this.callbacks.length; i++) {
+				this.callbacks[i].call(this, messages);
+			}
+		}
+	};
+
+	Filter.prototype.uninstall = function() {
+		this.promise.then(function(id) {
+			postData({call: "uninstallFilter", args:[id]});
+		});
+	};
+
+	Filter.prototype.messages = function() {
+		var self=this;
+		return Q.all([this.promise]).then(function() {
+			var id = self.id
+			return new Promise(function(resolve, reject) {
+				postData({call: "getMessages", args: [id]}, function(messages) {
+					resolve(messages);
+				});
+			});
+		});
+	};
+
+	// Register to the messages callback. "messages" will be emitted when new messages
+	// from the client have been created.
+	eth.on("messages", function(messages, id) {
+		for(var i = 0; i < filters.length; i++) {
+			filters[i].trigger(messages, id);
+		}
+	});
+
+	var g_seed = 1;
 	function postData(data, cb) {
-		data._seed = Math.floor(Math.random() * 1000000)
+		data._seed = g_seed;
 		if(cb) {
 			eth._callbacks[data._seed] = cb;
 		}
@@ -126,6 +456,8 @@
 			data.args = [];
 		}
 
+		g_seed++;
+
 		navigator.qt.postMessage(JSON.stringify(data));
 	}
 

mist/assets/ext/pre.js

@@ -1,41 +1,3 @@
-// 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];
-			}
-		}
-	}
-}
-
 if(typeof(Promise) === "undefined") {
 	window.Promise = Q.Promise;
 }

mist/assets/qml/wallet.qml

@@ -14,20 +14,22 @@ ApplicationWindow {
 
     property alias miningButtonText: miningButton.text
     property var ethx : Eth.ethx
+    property var web
 
-    width: 900
+    width: 1024
-    height: 600
+    height: 750
     minimumHeight: 300
 
     title: "Mist"
 
     // This signal is used by the filter API. The filter API connects using this signal handler from
     // the different QML files and plugins.
-    signal message(var callback, int seed);
+    signal messages(var messages, int id);
     function invokeFilterCallback(data, receiverSeed) {
         //var messages = JSON.parse(data)
         // Signal handler
-        message(data, receiverSeed);
+        messages(data, receiverSeed);
+	root.web.messages(data, receiverSeed);
     }
 
     TextField {
@@ -44,7 +46,7 @@ ApplicationWindow {
     // Takes care of loading all default plugins
     Component.onCompleted: {
         addPlugin("./views/wallet.qml", {noAdd: true, close: false, section: "ethereum", active: true});
-        addPlugin("./webapp.qml", {noAdd: true, close: false, section: "ethereum", active: true});
+        root.web = addPlugin("./webapp.qml", {noAdd: true, close: false, section: "ethereum", active: true});
 
         addPlugin("./views/transaction.qml", {noAdd: true, close: false, section: "legacy"});
         addPlugin("./views/chain.qml", {noAdd: true, close: false, section: "legacy"});

mist/assets/qml/webapp.qml

@@ -10,265 +10,279 @@ import Ethereum 1.0
 import "../ext/qml_messaging.js" as Messaging
 
 //ApplicationWindow {
-Rectangle {
+	Rectangle {
-	id: window
+		id: window
-	property var title: "Browser"
+		property var title: "Browser"
-	property var iconSource: "../browser.png"
+		property var iconSource: "../browser.png"
-	property var menuItem
+		property var menuItem
 
-	property alias url: webview.url
+		property alias url: webview.url
-	property alias webView: webview
+		property alias webView: webview
 
-	Component.onCompleted: {
+		Component.onCompleted: {
-		webview.url = "http://etherian.io"
+			webview.url = "http://etherian.io"
-	}
+		}
 
-	Item {
+		signal messages(var messages, int id);
-		objectName: "root"
+		onMessages: {
-		id: root
+			// Bit of a cheat to get proper JSON
-		anchors.fill: parent
+			var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
-		state: "inspectorShown"
+			webview.postEvent("messages", [m, id]);
-
+		}
-		RowLayout {
-			id: navBar
-			height: 40
-			anchors {
-				left: parent.left
-				right: parent.right
-				leftMargin: 7
-			}
 
-			Button {
+		Item {
-				id: back
+			objectName: "root"
-				onClicked: {
+			id: root
-					webview.goBack()
+			anchors.fill: parent
-				}
+			state: "inspectorShown"
-				style: ButtonStyle {
-					background: Image {
-						source: "../back.png"
-						width: 30
-						height: 30
-					}
-				}
-			}
 
-			TextField {
+			RowLayout {
+				id: navBar
+				height: 40
 				anchors {
-					left: back.right
+					left: parent.left
-					right: toggleInspector.left
+					right: parent.right
-					leftMargin: 5
+					leftMargin: 7
-					rightMargin: 5
 				}
-				text: "http://etherian.io"
-				id: uriNav
-				y: parent.height / 2 - this.height / 2
 
-				Keys.onReturnPressed: {
+				Button {
-					webview.url = this.text;
+					id: back
+					onClicked: {
+						webview.goBack()
+					}
+					style: ButtonStyle {
+						background: Image {
+							source: "../back.png"
+							width: 30
+							height: 30
+						}
+					}
 				}
-			}
 
-			Button {
+				TextField {
-				id: toggleInspector
+					anchors {
-				anchors {
+						left: back.right
-					right: parent.right
+						right: toggleInspector.left
+						leftMargin: 5
+						rightMargin: 5
+					}
+					text: "http://etherian.io"
+					id: uriNav
+					y: parent.height / 2 - this.height / 2
+
+					Keys.onReturnPressed: {
+						webview.url = this.text;
+					}
 				}
-				iconSource: "../bug.png"
+
-				onClicked: {
+				Button {
-					if(inspector.visible == true){
+					id: toggleInspector
-						inspector.visible = false
+					anchors {
-					}else{
+						right: parent.right
-						inspector.visible = true
+					}
-						inspector.url = webview.experimental.remoteInspectorUrl
+					iconSource: "../bug.png"
+					onClicked: {
+						if(inspector.visible == true){
+							inspector.visible = false
+						}else{
+							inspector.visible = true
+							inspector.url = webview.experimental.remoteInspectorUrl
+						}
 					}
 				}
 			}
-		}
 
 
-		WebView {
+			WebView {
-			objectName: "webView"
+				objectName: "webView"
-			id: webview
+				id: webview
-			anchors {
+				anchors {
-				left: parent.left
+					left: parent.left
-				right: parent.right
+					right: parent.right
-				bottom: parent.bottom
+					bottom: parent.bottom
-				top: navBar.bottom
+					top: navBar.bottom
-			}
+				}
 
-			property var cleanPath: false
+				property var cleanPath: false
-			onNavigationRequested: {
+				onNavigationRequested: {
-				if(!this.cleanPath) {
+					if(!this.cleanPath) {
-					var uri = request.url.toString();
+						var uri = request.url.toString();
-					if(!/.*\:\/\/.*/.test(uri)) {
+						if(!/.*\:\/\/.*/.test(uri)) {
-						uri = "http://" + uri;
+							uri = "http://" + uri;
+						}
+
+						var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/
+
+						if(reg.test(uri)) {
+							uri.replace(reg, function(match, pre, domain, path) {
+								uri = pre;
+
+								var lookup = eth.lookupDomain(domain.substring(0, domain.length - 4));
+								var ip = [];
+								for(var i = 0, l = lookup.length; i < l; i++) {
+									ip.push(lookup.charCodeAt(i))
+								}
+
+								if(ip.length != 0) {
+									uri += lookup;
+								} else {
+									uri += domain;
+								}
+
+								uri += path;
+							});
+						}
+
+						this.cleanPath = true;
+
+						webview.url = uri;
+					} else {
+						// Prevent inf loop.
+						this.cleanPath = false;
 					}
+				}
 
-					var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/
+				function sendMessage(data) {
-
+					webview.experimental.postMessage(JSON.stringify(data))
-					if(reg.test(uri)) {
+				}
-						uri.replace(reg, function(match, pre, domain, path) {
-							uri = pre;
-
-							var lookup = eth.lookupDomain(domain.substring(0, domain.length - 4));
-							var ip = [];
-							for(var i = 0, l = lookup.length; i < l; i++) {
-								ip.push(lookup.charCodeAt(i))
-							}
-
-							if(ip.length != 0) {
-								uri += lookup;
-							} else {
-								uri += domain;
-							}
 
-							uri += path;
+				onTitleChanged: {
-						});
+					var data = Messaging.HandleMessage(title);
+					if(data) {
+						sendMessage(data)
 					}
-
-					this.cleanPath = true;
-
-					webview.url = uri;
-				} else {
-					// Prevent inf loop.
-					this.cleanPath = false;
 				}
-			}
 
-			function sendMessage(data) {
+				experimental.preferences.javascriptEnabled: true
-				//this.experimental.evaluateJavaScript("window.____returnData="+JSON.stringify(data));
+				experimental.preferences.navigatorQtObjectEnabled: true
-				webview.experimental.postMessage(JSON.stringify(data))
+				experimental.preferences.developerExtrasEnabled: true
-			}
+				experimental.userScripts: ["../ext/q.js", "../ext/pre.js", "../ext/big.js", "../ext/string.js", "../ext/html_messaging.js"]
-
+				experimental.onMessageReceived: {
-			onTitleChanged: {
+					console.log("[onMessageReceived]: ", message.data)
-				var data = Messaging.HandleMessage(title);
+					// TODO move to messaging.js
-				if(data) {
+					var data = JSON.parse(message.data)
-					sendMessage(data)
+
-				}
+					try {
-			}
+						switch(data.call) {
+							case "compile":
+							postData(data._seed, eth.compile(data.args[0]))
+							break
 
-			experimental.preferences.javascriptEnabled: true
+							case "getCoinBase":
-			experimental.preferences.navigatorQtObjectEnabled: true
+							postData(data._seed, eth.coinBase())
-			experimental.preferences.developerExtrasEnabled: true
-			experimental.userScripts: ["../ext/q.js", "../ext/pre.js", "../ext/big.js", "../ext/string.js", "../ext/html_messaging.js"]
-			experimental.onMessageReceived: {
-				console.log("[onMessageReceived]: ", message.data)
-				// TODO move to messaging.js
-				var data = JSON.parse(message.data)
 
-				try {
+							break
-					switch(data.call) {
-						case "compile":
-						postData(data._seed, eth.compile(data.args[0]))
-						break
 
-						case "getCoinBase":
+							case "getIsListening":
-						postData(data._seed, eth.coinBase())
+							postData(data._seed, eth.isListening())
 
-						break
+							break
 
-						case "getIsListening":
+							case "getIsMining":
-						postData(data._seed, eth.isListening())
+							postData(data._seed, eth.isMining())
 
-						break
+							break
 
-						case "getIsMining":
+							case "getPeerCount":
-						postData(data._seed, eth.isMining())
+							postData(data._seed, eth.peerCount())
 
-						break
+							break
 
-						case "getPeerCount":
+							case "getCountAt":
-						postData(data._seed, eth.peerCount())
+							require(1)
+							postData(data._seed, eth.txCountAt(data.args[0]))
 
-						break
+							break
 
-						case "getTxCountAt":
+							case "getCodeAt":
-						require(1)
+							require(1)
-						postData(data._seed, eth.txCountAt(data.args[0]))
+							var code = eth.codeAt(data.args[0])
+							postData(data._seed, code);
 
-						break
+							break
 
-						case "getBlockByNumber":
+							case "getBlockByNumber":
-						var block = eth.blockByNumber(data.args[0])
+							var block = eth.blockByNumber(data.args[0])
-						postData(data._seed, block)
+							postData(data._seed, block)
 
-						break
+							break
 
-						case "getBlockByHash":
+							case "getBlockByHash":
-						var block = eth.blockByHash(data.args[0])
+							var block = eth.blockByHash(data.args[0])
-						postData(data._seed, block)
+							postData(data._seed, block)
 
-						break
+							break
 
-						case "transact":
+							case "transact":
-						require(5)
+							require(5)
 
-						var tx = eth.transact(data.args)
+							var tx = eth.transact(data.args)
-						console.log("transactx", tx)
+							postData(data._seed, tx)
-						postData(data._seed, tx)
 
-						break
+							break
 
-						case "getStorage":
+							case "getStorageAt":
-						require(2);
+							require(2);
 
-						var stateObject = eth.stateObject(data.args[0])
+							var storage = eth.storageAt(data.args[0], data.args[1]);
-						var storage = stateObject.storageAt(data.args[1])
+							postData(data._seed, storage)
-						postData(data._seed, storage)
 
-						break
+							break
 
-						case "getEachStorage":
+							case "call":
-						require(1);
+							require(1);
-						var storage = JSON.parse(eth.eachStorage(data.args[0]))
+							var ret = eth.call(data.args)
-						postData(data._seed, storage)
+							postData(data._seed, ret)
 
-						break
+							break
 
-						case "getTransactionsFor":
+							case "getEachStorage":
-						require(1);
+							require(1);
-						var txs = eth.transactionsFor(data.args[0], true)
+							var storage = JSON.parse(eth.eachStorage(data.args[0]))
-						postData(data._seed, txs)
+							postData(data._seed, storage)
 
-						break
+							break
 
-						case "getBalance":
+							case "getTransactionsFor":
-						require(1);
+							require(1);
+							var txs = eth.transactionsFor(data.args[0], true)
+							postData(data._seed, txs)
 
-						postData(data._seed, eth.stateObject(data.args[0]).value());
+							break
 
-						break
+							case "getBalanceAt":
+							require(1);
 
-						case "getKey":
+							postData(data._seed, eth.balanceAt(data.args[0]));
-						var key = eth.key().privateKey;
 
-						postData(data._seed, key)
+							break
-						break
 
-						/*
+							case "getKey":
-						case "watch":
+							var key = eth.key().privateKey;
-							require(1)
-							eth.watch(data.args[0], data.args[1]);
 
+							postData(data._seed, key)
 							break
-						*/
+
-					       case "watch":
+							case "watch":
-					       		require(2)
+							require(2)
 							eth.watch(data.args[0], data.args[1])
 
-						case "disconnect":
+							case "disconnect":
-						require(1)
+							require(1)
-						postData(data._seed, null)
+							postData(data._seed, null)
+
+							break;
 
-						break;
+							case "getSecretToAddress":
+							require(1)
 
-						case "getSecretToAddress":
+							var addr = eth.secretToAddress(data.args[0])
-						require(1)
+							console.log("getsecret", addr)
-						postData(data._seed, eth.secretToAddress(data.args[0]))
+							postData(data._seed, addr)
 
-						break;
+							break;
 
-						case "messages":
+							case "messages":
 							require(1);
 
 							var messages = JSON.parse(eth.getMessages(data.args[0]))
@@ -276,94 +290,120 @@ Rectangle {
 
 							break
 
-						case "mutan":
+							case "mutan":
 							require(1)
 
 							var code = eth.compileMutan(data.args[0])
 							postData(data._seed, "0x"+code)
 
 							break;
-					}
-				} catch(e) {
-					console.log(data.call + ": " + e)
 
-					postData(data._seed, null);
+							case "newFilterString":
+							require(1)
+							var id = eth.newFilterString(data.args[0])
+							postData(data._seed, id);
+							break;
+							case "newFilter":
+							require(1)
+							var id = eth.newFilter(data.args[0])
+
+							postData(data._seed, id);
+							break;
+
+							case "getMessages":
+							require(1);
+
+							var messages = eth.messages(data.args[0]);
+							var m = JSON.parse(JSON.parse(JSON.stringify(messages)))
+							postData(data._seed, m);
+
+							break;
+
+							case "deleteFilter":
+							require(1);
+							eth.uninstallFilter(data.args[0])
+							break;
+						}
+					} catch(e) {
+						console.log(data.call + ": " + e)
+
+						postData(data._seed, null);
+					}
 				}
-			}
 
-			function post(seed, data) {
-				console.log("data", data)
-				postData(data._seed, data)
-			}
 
-			function require(args, num) {
+				function post(seed, data) {
-				if(args.length < num) {
+					postData(data._seed, data)
-					throw("required argument count of "+num+" got "+args.length);
 				}
-			}
-			function postData(seed, data) {
-				webview.experimental.postMessage(JSON.stringify({data: data, _seed: seed}))
-			}
-			function postEvent(event, data) {
-				webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
-			}
 
-			function onWatchedCb(data, id) {
+				function require(args, num) {
-				var messages = JSON.parse(data)
+					if(args.length < num) {
-				postEvent("watched:"+id, messages)
+						throw("required argument count of "+num+" got "+args.length);
-			}
+					}
+				}
+				function postData(seed, data) {
+					webview.experimental.postMessage(JSON.stringify({data: data, _seed: seed}))
+				}
+				function postEvent(event, data) {
+					webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
+				}
 
-			function onNewBlockCb(block) {
+				function onWatchedCb(data, id) {
-				postEvent("block:new", block)
+					var messages = JSON.parse(data)
-			}
+					postEvent("watched:"+id, messages)
-			function onObjectChangeCb(stateObject) {
+				}
-				postEvent("object:"+stateObject.address(), stateObject)
+
-			}
+				function onNewBlockCb(block) {
-			function onStorageChangeCb(storageObject) {
+					postEvent("block:new", block)
-				var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
+				}
-				postEvent(ev, [storageObject.address, storageObject.value])
+				function onObjectChangeCb(stateObject) {
+					postEvent("object:"+stateObject.address(), stateObject)
+				}
+				function onStorageChangeCb(storageObject) {
+					var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
+					postEvent(ev, [storageObject.address, storageObject.value])
+				}
 			}
-		}
 
 
-		Rectangle {
+			Rectangle {
-			id: sizeGrip
+				id: sizeGrip
-			color: "gray"
+				color: "gray"
-			visible: false
+				visible: false
-			height: 10
+				height: 10
-			anchors {
+				anchors {
-				left: root.left
+					left: root.left
-				right: root.right
+					right: root.right
-			}
+				}
-			y: Math.round(root.height * 2 / 3)
+				y: Math.round(root.height * 2 / 3)
-
+
-			MouseArea {
+				MouseArea {
-				anchors.fill: parent
+					anchors.fill: parent
-				drag.target: sizeGrip
+					drag.target: sizeGrip
-				drag.minimumY: 0
+					drag.minimumY: 0
-				drag.maximumY: root.height
+					drag.maximumY: root.height
-				drag.axis: Drag.YAxis
+					drag.axis: Drag.YAxis
+				}
 			}
-		}
 
-		WebView {
+			WebView {
-			id: inspector
+				id: inspector
-			visible: false
+				visible: false
-			anchors {
+				anchors {
-				left: root.left
+					left: root.left
-				right: root.right
+					right: root.right
-				top: sizeGrip.bottom
+					top: sizeGrip.bottom
-				bottom: root.bottom
+					bottom: root.bottom
+				}
 			}
-		}
 
-		states: [
+			states: [
-			State {
+				State {
-				name: "inspectorShown"
+					name: "inspectorShown"
-				PropertyChanges {
+					PropertyChanges {
-					target: inspector
+						target: inspector
+					}
 				}
-			}
+			]
-		]
+		}
 	}
-}

mist/debugger.go

@@ -276,7 +276,7 @@ func (d *Debugger) halting(pc int, op ethvm.OpCode, mem *ethvm.Memory, stack *et
 	d.win.Root().Call("clearStorage")
 
 	addr := 0
-	for i := 0; i+32 <= mem.Len(); i += 16 {
+	for i := 0; i+16 <= mem.Len(); i += 16 {
 		dat := mem.Data()[i : i+16]
 		var str string
 

mist/ui_lib.go

@@ -37,7 +37,6 @@ type UiLib struct {
 	jsEngine *javascript.JSRE
 
 	filterCallbacks map[int][]int
-	//filters         map[int]*ethpipe.JSFilter
 }
 
 func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
@@ -201,7 +200,7 @@ func (self *UiLib) UninstallFilter(id int) {
 	self.eth.UninstallFilter(id)
 }
 
-func (self *UiLib) Transact(object map[string]interface{}) (*ethpipe.JSReceipt, error) {
+func mapToTxParams(object map[string]interface{}) map[string]string {
 	// Default values
 	if object["from"] == nil {
 		object["from"] = ""
@@ -223,6 +222,8 @@ func (self *UiLib) Transact(object map[string]interface{}) (*ethpipe.JSReceipt,
 	var data []string
 	if list, ok := object["data"].(*qml.List); ok {
 		list.Convert(&data)
+	} else if str, ok := object["data"].(string); ok {
+		data = []string{str}
 	}
 
 	for _, str := range data {
@@ -238,14 +239,29 @@ func (self *UiLib) Transact(object map[string]interface{}) (*ethpipe.JSReceipt,
 
 		dataStr += str
 	}
+	object["data"] = dataStr
+	fmt.Println(object)
+
+	conv := make(map[string]string)
+	for key, value := range object {
+		if v, ok := value.(string); ok {
+			conv[key] = v
+		}
+	}
+
+	return conv
+}
+
+func (self *UiLib) Transact(params map[string]interface{}) (*ethpipe.JSReceipt, error) {
+	object := mapToTxParams(params)
 
 	return self.JSPipe.Transact(
-		object["from"].(string),
+		object["from"],
-		object["to"].(string),
+		object["to"],
-		object["value"].(string),
+		object["value"],
-		object["gas"].(string),
+		object["gas"],
-		object["gasPrice"].(string),
+		object["gasPrice"],
-		dataStr,
+		object["data"],
 	)
 }
 
@@ -257,3 +273,15 @@ func (self *UiLib) Compile(code string) (string, error) {
 
 	return ethutil.Bytes2Hex(bcode), err
 }
+
+func (self *UiLib) Call(params map[string]interface{}) (string, error) {
+	object := mapToTxParams(params)
+
+	return self.JSPipe.Execute(
+		object["to"],
+		object["value"],
+		object["gas"],
+		object["gasPrice"],
+		object["data"],
+	)
+}