diff options
61 files changed, 2394 insertions, 451 deletions
diff --git a/.travis.yml b/.travis.yml index 4659503e9..0084bf9c2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,8 +11,8 @@ install: # - go get golang.org/x/tools/cmd/vet - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi - go get github.com/mattn/goveralls - - go get -d github.com/obscuren/qml && cd $HOME/gopath/src/github.com/obscuren/qml && git checkout v1 && cd $TRAVIS_BUILD_DIR - - ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get -d $ETH_DEPS; fi + - go get gopkg.in/check.v1 + - DEPS=$(go list -f '{{.Imports}}' ./... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$DEPS" ]; then go get -d -v $DEPS; fi before_script: - gofmt -l -w . - goimports -l -w . @@ -20,7 +20,9 @@ before_script: # - go vet ./... # - go test -race ./... script: - - ./gocoverage.sh && if [ "$COVERALLS_TOKEN" ]; then goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN; fi + - ./gocoverage.sh +after_success: + - if [ "$COVERALLS_TOKEN" ]; then goveralls -coverprofile=profile.cov -service=travis-ci -repotoken $COVERALLS_TOKEN; fi env: global: - PKG_CONFIG_PATH=/opt/qt54/lib/pkgconfig diff --git a/Dockerfile b/Dockerfile index 771d19746..6e29a638d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -21,13 +21,10 @@ RUN apt-get install -y qt54quickcontrols qt54webengine ## Build and install latest Go RUN git clone https://go.googlesource.com/go golang RUN cd golang && git checkout go1.4.1 -RUN cd golang/src && ./all.bash && go version +RUN cd golang/src && ./make.bash && go version -## Fetch and install QML -RUN go get -u -v -d github.com/obscuren/qml -WORKDIR $GOPATH/src/github.com/obscuren/qml -RUN git checkout v1 -RUN go install -v +# this is a workaround, to make sure that docker's cache is invalidated whenever the git repo changes +ADD https://api.github.com/repos/ethereum/go-ethereum/git/refs/heads/develop file_does_not_exist ## Fetch and install go-ethereum RUN go get -u -v -d github.com/ethereum/go-ethereum/... @@ -29,7 +29,7 @@ For further, detailed, build instruction please see the [Wiki](https://github.co Automated (dev) builds ====================== -* [[OS X](http://build.ethdev.com/builds/OSX%20Go%20develop%20branch/latest/app/)] +* [[OS X](http://build.ethdev.com/builds/OSX%20Go%20develop%20branch/Mist-OSX-latest.dmg)] * [Windows] Coming soon™ * [Linux] Coming soon™ diff --git a/cmd/ethereum/flags.go b/cmd/ethereum/flags.go index 99e094b47..1e6869a69 100644 --- a/cmd/ethereum/flags.go +++ b/cmd/ethereum/flags.go @@ -61,6 +61,7 @@ var ( ConfigFile string DebugFile string LogLevel int + LogFormat string Dump bool DumpHash string DumpNumber int @@ -110,6 +111,7 @@ func Init() { flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file") flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)") flag.IntVar(&LogLevel, "loglevel", int(logger.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)") + flag.StringVar(&LogFormat, "logformat", "std", "logformat: std,raw)") flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0") flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false") flag.BoolVar(&ShowGenesis, "genesis", false, "Dump the genesis block") diff --git a/cmd/mist/assets/backButton.png b/cmd/mist/assets/backButton.png Binary files differnew file mode 100644 index 000000000..eef997434 --- /dev/null +++ b/cmd/mist/assets/backButton.png diff --git a/cmd/mist/assets/backButton@2x.png b/cmd/mist/assets/backButton@2x.png Binary files differnew file mode 100644 index 000000000..b72fd73f4 --- /dev/null +++ b/cmd/mist/assets/backButton@2x.png diff --git a/cmd/mist/assets/examples/coin.html b/cmd/mist/assets/examples/coin.html index ed5063a05..546c6f13f 100644 --- a/cmd/mist/assets/examples/coin.html +++ b/cmd/mist/assets/examples/coin.html @@ -7,7 +7,7 @@ </head> <body> -<h1>JevCoin</h1> +<h1>JevCoin <code id="contract_addr"></code></h1> <div> <strong>Balance</strong> <span id="balance"></strong> @@ -20,7 +20,11 @@ <button onclick="transact()">Send</button> </div> +<hr> + <table width="100%" id="table"> + <tr><td style="width:40%;">Address</td><td>Balance</td></tr> + <tbody id="table_body"></tbody> </table> </body> @@ -29,8 +33,8 @@ var web3 = require('web3'); var eth = web3.eth; - web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); - var desc = [{ + web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8545')); + var desc = [{ "name": "balance(address)", "type": "function", "inputs": [{ @@ -54,57 +58,85 @@ }], "outputs": [] }, { - "name":"Changed", + "name":"received", "type":"event", "inputs": [ - {"name":"to","type":"address","indexed":true}, - {"name":"amount","type":"uint256","indexed":false}, + {"name":"from","type":"address","indexed":true}, + {"name":"amount","type":"uint256","indexed":true}, ], }]; - var address = web3.db.get("jevcoin", "address"); - if( address.length == 0 ) { - var code = "0x60056011565b60b88060356000396000f35b64e8d4a51000600033600160a060020a0316600052602052604060002081905550560060e060020a6000350480637bb98a68146028578063d0679d34146034578063e3d670d714604657005b602e60b3565b60006000f35b60406004356024356059565b60006000f35b604f6004356091565b8060005260206000f35b8060005281600160a060020a03167fb52dda022b6c1a1f40905a85f257f689aa5d69d850e49cf939d688fbe5af594660206000a25050565b6000600082600160a060020a03166000526020526040600020549050919050565b5b60008156"; - address = web3.eth.transact({ - data: code, - gasPrice: "1000000000000000", - gas: "10000", - }); - web3.db.put("jevcoin", "address", address); - } + var address = localStorage.getItem("address"); + // deploy if not exist + if (address == null) { + var code = "0x60056013565b61012b806100346000396000f35b6103e8600033600160a060020a0316600052602052604060002081905550560060e060020a6000350480637bb98a681461002b578063d0679d3414610039578063e3d670d71461004d57005b610033610126565b60006000f35b610047600435602435610062565b60006000f35b610058600435610104565b8060005260206000f35b80600033600160a060020a0316600052602052604060002054101561008657610100565b80600033600160a060020a0316600052602052604060002090815403908190555080600083600160a060020a0316600052602052604060002090815401908190555033600160a060020a0316600052806020527ff11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef60406000a15b5050565b6000600082600160a060020a03166000526020526040600020549050919050565b5b60008156"; + address = web3.eth.transact({data: code}); + localStorage.setItem("address", address); + } + document.querySelector("#contract_addr").innerHTML = address.toUpperCase(); var contract = web3.eth.contract(address, desc); - contract.Changed({to: "0xaa"}).changed(function(e) { - console.log("e: " + JSON.stringify(e)); + contract.received({from: eth.coinbase}).changed(function() { + refresh(); }); - contract.send( "0xaa", 10000 ); - function reflesh() { - document.querySelector("#balance").innerHTML = contract.balance(eth.coinbase); + eth.watch('chain').changed(function() { + refresh(); + }); + + function refresh() { + document.querySelector("#balance").innerHTML = contract.balance(eth.coinbase); - var table = document.querySelector("#table"); + var table = document.querySelector("#table_body"); table.innerHTML = ""; // clear var storage = eth.storageAt(address); + table.innerHTML = ""; for( var item in storage ) { - table.innerHTML += "<tr><td>"+item+"</td><td>"+web3.toDecimal(storage[item])+"</td></tr>"; + table.innerHTML += "<tr><td>"+item.toUpperCase()+"</td><td>"+web3.toDecimal(storage[item])+"</td></tr>"; } } function transact() { var to = document.querySelector("#address").value; - if( to.length == 0 ) { - to = "0x4205b06c2cfa0e30359edcab94543266cb6fa1d3"; - } else { - to = "0x"+to; - } + if( to.length == 0 ) { + to = "0x4205b06c2cfa0e30359edcab94543266cb6fa1d3"; + } else { + to = "0x"+to; + } var value = parseInt( document.querySelector("#amount").value ); - contract.transact({gas: "10000", gasprice: eth.gasPrice}).send( to, value ); + contract.send( to, value ); } - reflesh(); + refresh(); </script> </html> +<!-- +contract JevCoin { + function JevCoin() + { + balances[msg.sender] = 1000000; + } + + event changed(address indexed from, address indexed to); + function send(address to, uint value) + { + if( balances[msg.sender] < value ) return; + + balances[msg.sender] -= value; + balances[to] += value; + + changed(msg.sender, to); + } + + function balance(address who) constant returns(uint t) + { + t = balances[who]; + } + + mapping(address => uint256) balances; + } +-!> diff --git a/cmd/mist/assets/examples/coin.js b/cmd/mist/assets/examples/coin.js new file mode 100644 index 000000000..d69af5dcb --- /dev/null +++ b/cmd/mist/assets/examples/coin.js @@ -0,0 +1,64 @@ +var contract = web3.eth.contractFromAbi([ + { + "constant":false, + "inputs":[ + {"name":"_h","type":"hash256"} + ], + "name":"confirm", + "outputs":[], + "type":"function" + },{ + "constant":false, + "inputs":[ + {"name":_to,"type":"address"}, + {"name":"_value","type":"uint256"}, + {"name":"_data","type":"bytes"} + ], + "name":"execute", + "outputs":[ + {"name":"_r","type":"hash256"} + ], + "type":"function" + },{ + "constant":false, + "inputs":[ + {"name":"_to","type":"address"} + ],"name":"kill", + "outputs":[], + "type":"function" + },{ + "constant":false, + "inputs":[ + {"name":"_from","type":"address"}, + {"name":"_to","type":"address"} + ], + "name":"changeOwner", + "outputs":[], + "type":"function" + },{ + "inputs":[ + {"indexed":false,"name":"value","type":"uint256"} + ], + "name":"CashIn", + "type":"event" + },{ + "inputs":[ + {"indexed":true,"name":"out","type":"string32"}, + {"indexed":false,"name":"owner","type":"address"}, + {"indexed":false,"name":"value","type":"uint256"}, + {"indexed":false,"name":"to","type":"address"} + ], + "name":"SingleTransact", + "type":"event" + },{ + "inputs":[ + {"indexed":true,"name":"out","type":"string32"}, + {"indexed":false,"name":"owner","type":"address"}, + {"indexed":false,"name":"operation","type":"hash256"}, + {"indexed":false,"name":"value","type":"uint256"}, + {"indexed":false,"name":"to","type":"address"} + ], + "name":"MultiTransact", + "type":"event" + } +]); diff --git a/cmd/mist/assets/qml/fonts/Simple-Line-Icons.ttf b/cmd/mist/assets/qml/fonts/Simple-Line-Icons.ttf Binary files differnew file mode 100755 index 000000000..2194f1f87 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/Simple-Line-Icons.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-Black.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-Black.ttf Binary files differnew file mode 100644 index 000000000..be1a3108e --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Black.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-BlackIt.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-BlackIt.ttf Binary files differnew file mode 100644 index 000000000..ac5c4ef7c --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-BlackIt.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-Bold.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-Bold.ttf Binary files differnew file mode 100644 index 000000000..f47161c6b --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Bold.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-BoldIt.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-BoldIt.ttf Binary files differnew file mode 100644 index 000000000..6b3db698b --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-BoldIt.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLight.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLight.ttf Binary files differnew file mode 100644 index 000000000..0a3e51fdb --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLight.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLightIt.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLightIt.ttf Binary files differnew file mode 100644 index 000000000..a0eb86aca --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-ExtraLightIt.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-It.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-It.ttf Binary files differnew file mode 100644 index 000000000..fcc95fc7c --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-It.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-Light.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-Light.ttf Binary files differnew file mode 100644 index 000000000..9cae13c97 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Light.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-LightIt.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-LightIt.ttf Binary files differnew file mode 100644 index 000000000..2ed784284 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-LightIt.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-Regular.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-Regular.ttf Binary files differnew file mode 100644 index 000000000..8e8255e17 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Regular.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-Semibold.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-Semibold.ttf Binary files differnew file mode 100644 index 000000000..121ee9bbf --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-Semibold.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSansPro-SemiboldIt.ttf b/cmd/mist/assets/qml/fonts/SourceSansPro-SemiboldIt.ttf Binary files differnew file mode 100644 index 000000000..6ceaa885f --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSansPro-SemiboldIt.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSerifPro-Bold.ttf b/cmd/mist/assets/qml/fonts/SourceSerifPro-Bold.ttf Binary files differnew file mode 100644 index 000000000..ac7837fd9 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSerifPro-Bold.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSerifPro-Regular.ttf b/cmd/mist/assets/qml/fonts/SourceSerifPro-Regular.ttf Binary files differnew file mode 100644 index 000000000..7201a8890 --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSerifPro-Regular.ttf diff --git a/cmd/mist/assets/qml/fonts/SourceSerifPro-Semibold.ttf b/cmd/mist/assets/qml/fonts/SourceSerifPro-Semibold.ttf Binary files differnew file mode 100644 index 000000000..db2fc804b --- /dev/null +++ b/cmd/mist/assets/qml/fonts/SourceSerifPro-Semibold.ttf diff --git a/cmd/mist/assets/qml/main.qml b/cmd/mist/assets/qml/main.qml index 45d56e795..8f9a2d3cc 100644 --- a/cmd/mist/assets/qml/main.qml +++ b/cmd/mist/assets/qml/main.qml @@ -9,7 +9,1101 @@ import Ethereum 1.0 import "../ext/filter.js" as Eth import "../ext/http.js" as Http + ApplicationWindow { +<<<<<<< HEAD + id: root + + //flags: Qt.FramelessWindowHint + // Use this to make the window frameless. But then you'll need to do move and resize by hand + + property var ethx : Eth.ethx + property var catalog; + + width: 1200 + height: 820 + minimumHeight: 600 + minimumWidth: 800 + + title: "Mist" + + TextField { + id: copyElementHax + visible: false + } + + function copyToClipboard(text) { + copyElementHax.text = text + copyElementHax.selectAll() + copyElementHax.copy() + } + + // Takes care of loading all default plugins + Component.onCompleted: { + + catalog = addPlugin("./views/catalog.qml", {noAdd: true, close: false, section: "begin"}); + var wallet = addPlugin("./views/wallet.qml", {noAdd: true, close: false, section: "ethereum", active: true}); + + addPlugin("./views/miner.qml", {noAdd: true, close: false, section: "ethereum", active: true}); + addPlugin("./views/transaction.qml", {noAdd: true, close: false, section: "legacy"}); + addPlugin("./views/whisper.qml", {noAdd: true, close: false, section: "legacy"}); + addPlugin("./views/chain.qml", {noAdd: true, close: false, section: "legacy"}); + addPlugin("./views/pending_tx.qml", {noAdd: true, close: false, section: "legacy"}); + addPlugin("./views/info.qml", {noAdd: true, close: false, section: "legacy"}); + + mainSplit.setView(catalog.view, catalog.menuItem); + + //newBrowserTab("http://ethereum-dapp-catalog.meteor.com"); + + // Command setup + gui.sendCommand(0) + } + + function activeView(view, menuItem) { + mainSplit.setView(view, menuItem) + if (view.hideUrl) { + urlPane.visible = false; + mainView.anchors.top = rootView.top + } else { + urlPane.visible = true; + mainView.anchors.top = divider.bottom + } + } + + function addViews(view, path, options) { + var views = mainSplit.addComponent(view, options) + views.menuItem.path = path + + mainSplit.views.push(views); + + if(!options.noAdd) { + gui.addPlugin(path) + } + + return views + } + + function addPlugin(path, options) { + try { + if(typeof(path) === "string" && /^https?/.test(path)) { + console.log('load http') + Http.request(path, function(o) { + if(o.status === 200) { + var view = Qt.createQmlObject(o.responseText, mainView, path) + addViews(view, path, options) + } + }) + + return + } + + var component = Qt.createComponent(path); + if(component.status != Component.Ready) { + if(component.status == Component.Error) { + ethx.note("error: ", component.errorString()); + } + + return + } + + var view = mainView.createView(component, options) + var views = addViews(view, path, options) + + return views + } catch(e) { + console.log(e) + } + } + + function newBrowserTab(url) { + + var urlMatches = url.toString().match(/^[a-z]*\:\/\/([^\/?#]+)(?:[\/?#]|$)/i); + var requestedDomain = urlMatches && urlMatches[1]; + + var domainAlreadyOpen = false; + + console.log("requested: " + requestedDomain ) + + for(var i = 0; i < mainSplit.views.length; i++) { + if (mainSplit.views[i].view.url) { + var matches = mainSplit.views[i].view.url.toString().match(/^[a-z]*\:\/\/(?:www\.)?([^\/?#]+)(?:[\/?#]|$)/i); + var existingDomain = matches && matches[1]; + console.log("exists: " + existingDomain); + if (requestedDomain == existingDomain) { + domainAlreadyOpen = true; + mainSplit.views[i].view.url = url; + activeView(mainSplit.views[i].view, mainSplit.views[i].menuItem); + } + } + } + + if (!domainAlreadyOpen) { + var window = addPlugin("./views/browser.qml", {noAdd: true, close: true, section: "apps", active: true}); + window.view.url = url; + window.menuItem.title = "Mist"; + activeView(window.view, window.menuItem); + } + } + + + + menuBar: MenuBar { + Menu { + title: "File" + MenuItem { + text: "Import App" + shortcut: "Ctrl+o" + onTriggered: { + generalFileDialog.show(true, importApp) + } + } + + MenuItem { + text: "Add plugin" + onTriggered: { + generalFileDialog.show(true, function(path) { + addPlugin(path, {close: true, section: "apps"}) + }) + } + } + + MenuItem { + text: "New tab" + shortcut: "Ctrl+t" + onTriggered: { + activeView(catalog.view, catalog.menuItem); + } + } + + MenuSeparator {} + + MenuItem { + text: "Import key" + shortcut: "Ctrl+i" + onTriggered: { + generalFileDialog.show(true, function(path) { + gui.importKey(path) + }) + } + } + + MenuItem { + text: "Export keys" + shortcut: "Ctrl+e" + onTriggered: { + generalFileDialog.show(false, function(path) { + }) + } + } + + } + + Menu { + title: "Developer" + MenuItem { + iconSource: "../icecream.png" + text: "Debugger" + shortcut: "Ctrl+d" + onTriggered: eth.startDebugger() + } + + MenuItem { + text: "Import Tx" + onTriggered: { + txImportDialog.visible = true + } + } + + MenuItem { + text: "Run JS file" + onTriggered: { + generalFileDialog.show(true, function(path) { + eth.evalJavascriptFile(path) + }) + } + } + + MenuItem { + text: "Dump state" + onTriggered: { + generalFileDialog.show(false, function(path) { + // Empty hash for latest + gui.dumpState("", path) + }) + } + } + + MenuSeparator {} + } + + Menu { + title: "Network" + MenuItem { + text: "Add Peer" + shortcut: "Ctrl+p" + onTriggered: { + addPeerWin.visible = true + } + } + MenuItem { + text: "Show Peers" + shortcut: "Ctrl+e" + onTriggered: { + peerWindow.visible = true + } + } + } + + Menu { + title: "Help" + MenuItem { + text: "About" + onTriggered: { + aboutWin.visible = true + } + } + } + + Menu { + title: "GLOBAL SHORTCUTS" + visible: false + MenuItem { + visible: false + shortcut: "Ctrl+l" + onTriggered: { + url.focus = true + } + } + } + } + + statusBar: StatusBar { + //height: 32 + visible: false + + id: statusBar + Label { + //y: 6 + id: walletValueLabel + + font.pixelSize: 10 + styleColor: "#797979" + } + + Label { + //y: 6 + objectName: "miningLabel" + visible: true + font.pixelSize: 10 + anchors.right: lastBlockLabel.left + anchors.rightMargin: 5 + } + + Label { + id: lastBlockLabel + objectName: "lastBlockLabel" + visible: true + text: "---" + font.pixelSize: 10 + anchors.right: peerGroup.left + anchors.rightMargin: 5 + } + + ProgressBar { + visible: false + id: downloadIndicator + value: 0 + objectName: "downloadIndicator" + y: -4 + x: statusBar.width / 2 - this.width / 2 + width: 160 + } + + Label { + visible: false + objectName: "downloadLabel" + //y: 7 + anchors.left: downloadIndicator.right + anchors.leftMargin: 5 + font.pixelSize: 10 + text: "0 / 0" + } + + + RowLayout { + id: peerGroup + //y: 7 + anchors.right: parent.right + MouseArea { + onDoubleClicked: peerWindow.visible = true + anchors.fill: parent + } + + Label { + id: peerLabel + font.pixelSize: 10 + text: "0 / 0" + } + } + } + + + property var blockModel: ListModel { + id: blockModel + } + + SplitView { + property var views: []; + + id: mainSplit + anchors.fill: parent + //resizing: false // this is NOT where we remove that damning resizing handle.. + handleDelegate: Item { + //This handle is a way to remove the line between the split views + Rectangle { + anchors.fill: parent + } + } + + function setView(view, menu) { + for(var i = 0; i < views.length; i++) { + views[i].view.visible = false + views[i].menuItem.setSelection(false) + } + view.visible = true + menu.setSelection(true) + } + + function addComponent(view, options) { + view.visible = false + view.anchors.fill = mainView + + var menuItem = menu.createMenuItem(view, options); + if( view.hasOwnProperty("menuItem") ) { + view.menuItem = menuItem; + } + + if( view.hasOwnProperty("onReady") ) { + view.onReady.call(view) + } + + if( options.active ) { + setView(view, menuItem) + } + + + return {view: view, menuItem: menuItem} + } + + /********************* + * Main menu. + ********************/ + Rectangle { + id: menu + Layout.minimumWidth: 192 + Layout.maximumWidth: 192 + + FontLoader { + id: sourceSansPro + source: "fonts/SourceSansPro-Regular.ttf" + } + FontLoader { + source: "fonts/SourceSansPro-Semibold.ttf" + } + FontLoader { + source: "fonts/SourceSansPro-Bold.ttf" + } + FontLoader { + source: "fonts/SourceSansPro-Black.ttf" + } + FontLoader { + source: "fonts/SourceSansPro-Light.ttf" + } + FontLoader { + source: "fonts/SourceSansPro-ExtraLight.ttf" + } + FontLoader { + id: simpleLineIcons + source: "fonts/Simple-Line-Icons.ttf" + } + + Rectangle { + color: "steelblue" + anchors.fill: parent + + MouseArea { + anchors.fill: parent + property real lastMouseX: 0 + property real lastMouseY: 0 + onPressed: { + lastMouseX = mouseX + lastMouseY = mouseY + } + onPositionChanged: { + root.x += (mouseX - lastMouseX) + root.y += (mouseY - lastMouseY) + } + /*onDoubleClicked: { + //!maximized ? view.set_max() : view.set_normal()} + visibility = "Minimized" + }*/ + } + } + + + + anchors.top: parent.top + Rectangle { + width: parent.height + height: parent.width + anchors.centerIn: parent + rotation: 90 + + gradient: Gradient { + GradientStop { position: 0.0; color: "#E2DEDE" } + GradientStop { position: 0.1; color: "#EBE8E8" } + GradientStop { position: 1.0; color: "#EBE8E8" } + } + } + + Component { + id: menuItemTemplate + Rectangle { + id: menuItem + property var view; + property var path; + property var closable; + + property alias title: label.text + property alias icon: icon.source + property alias secondaryTitle: secondary.text + function setSelection(on) { + sel.visible = on + + if (this.closable == true) { + closeIcon.visible = on + } + } + + function setAsBigButton(on) { + newAppButton.visible = on + label.visible = !on + buttonLabel.visible = on + } + + width: 192 + height: 55 + color: "#00000000" + + anchors { + left: parent.left + leftMargin: 4 + } + + Rectangle { + // New App Button + id: newAppButton + visible: false + anchors.fill: parent + anchors.rightMargin: 8 + border.width: 0 + radius: 5 + height: 55 + width: 180 + color: "#F3F1F3" + } + + Rectangle { + id: sel + visible: false + anchors.fill: parent + color: "#00000000" + Rectangle { + id: r + anchors.fill: parent + border.width: 0 + radius: 5 + color: "#FAFAFA" + } + Rectangle { + anchors { + top: r.top + bottom: r.bottom + right: r.right + } + width: 10 + color: "#FAFAFA" + border.width:0 + + Rectangle { + // Small line on top of selection. What's this for? + anchors { + left: parent.left + right: parent.right + top: parent.top + } + height: 1 + color: "#FAFAFA" + } + + Rectangle { + // Small line on bottom of selection. What's this for again? + anchors { + left: parent.left + right: parent.right + bottom: parent.bottom + } + height: 1 + color: "#FAFAFA" + } + } + } + + MouseArea { + anchors.fill: parent + hoverEnabled: true + onClicked: { + activeView(view, menuItem); + } + onEntered: { + if (parent.closable == true) { + closeIcon.visible = sel.visible + } + + } + onExited: { + closeIcon.visible = false + } + } + + Image { + id: icon + height: 24 + width: 24 + anchors { + left: parent.left + verticalCenter: parent.verticalCenter + leftMargin: 6 + } + } + + Text { + id: buttonLabel + visible: false + text: "GO TO NEW APP" + font.family: sourceSansPro.name + font.weight: Font.DemiBold + anchors.horizontalCenter: parent.horizontalCenter + anchors.verticalCenter: parent.verticalCenter + color: "#AAA0A0" + } + + Text { + id: label + font.family: sourceSansPro.name + font.weight: Font.DemiBold + anchors { + left: icon.right + verticalCenter: parent.verticalCenter + leftMargin: 6 + // verticalCenterOffset: -10 + } + x:250 + color: "#665F5F" + font.pixelSize: 14 + } + + + Text { + id: secondary + font.family: sourceSansPro.name + font.weight: Font.Light + anchors { + left: icon.right + leftMargin: 6 + top: label.bottom + } + color: "#6691C2" + font.pixelSize: 12 + } + + Rectangle { + id: closeIcon + visible: false + width: 10 + height: 10 + color: "#FFFFFF" + anchors { + fill: icon + } + + MouseArea { + anchors.fill: parent + onClicked: { + menuItem.closeApp() + } + } + + Text { + + font.family: simpleLineIcons.name + anchors { + centerIn: parent + } + color: "#665F5F" + font.pixelSize: 18 + text: "\ue082" + } + } + + + + function closeApp() { + if(!this.closable) { return; } + + if(this.view.hasOwnProperty("onDestroy")) { + this.view.onDestroy.call(this.view) + } + + this.view.destroy() + this.destroy() + for (var i = 0; i < mainSplit.views.length; i++) { + var view = mainSplit.views[i]; + if (view.menuItem === this) { + mainSplit.views.splice(i, 1); + break; + } + } + gui.removePlugin(this.path) + activeView(mainSplit.views[0].view, mainSplit.views[0].menuItem); + } + } + } + + function createMenuItem(view, options) { + if(options === undefined) { + options = {}; + } + + var section; + switch(options.section) { + case "begin": + section = menuBegin + break; + case "ethereum": + section = menuDefault; + break; + case "legacy": + section = menuLegacy; + break; + default: + section = menuApps; + break; + } + + var comp = menuItemTemplate.createObject(section) + comp.view = view + comp.title = view.title + + if(view.hasOwnProperty("iconSource")) { + comp.icon = view.iconSource; + } + comp.closable = options.close; + + if (options.section === "begin") { + comp.setAsBigButton(true) + } + + return comp + } + + ColumnLayout { + id: menuColumn + y: 10 + width: parent.width + anchors.left: parent.left + anchors.right: parent.right + spacing: 3 + + + + ColumnLayout { + id: menuBegin + spacing: 3 + anchors { + left: parent.left + right: parent.right + } + } + + Rectangle { + height: 55 + color: "transparent" + Text { + text: "ETHEREUM" + font.family: sourceSansPro.name + font.weight: Font.DemiBold + anchors { + left: parent.left + top: parent.verticalCenter + leftMargin: 16 + } + color: "#AAA0A0" + } + } + + + ColumnLayout { + id: menuDefault + spacing: 3 + anchors { + left: parent.left + right: parent.right + } + } + + Rectangle { + height: 55 + color: "transparent" + Text { + text: "APPS" + font.family: sourceSansPro.name + font.weight: Font.DemiBold + anchors { + left: parent.left + top: parent.verticalCenter + leftMargin: 16 + } + color: "#AAA0A0" + } + } + + ColumnLayout { + id: menuApps + spacing: 3 + anchors { + left: parent.left + right: parent.right + } + } + + Rectangle { + height: 55 + color: "transparent" + Text { + text: "DEBUG" + font.family: sourceSansPro.name + font.weight: Font.DemiBold + anchors { + left: parent.left + top: parent.verticalCenter + leftMargin: 16 + } + color: "#AAA0A0" + } + } + + + ColumnLayout { + id: menuLegacy + spacing: 3 + anchors { + left: parent.left + right: parent.right + } + } + } + } + + /********************* + * Main view + ********************/ + Rectangle { + id: rootView + anchors.right: parent.right + anchors.left: menu.right + anchors.bottom: parent.bottom + anchors.top: parent.top + color: "#00000000" + + /*Rectangle { + id: urlPane + height: 40 + color: "#00000000" + anchors { + left: parent.left + right: parent.right + leftMargin: 5 + rightMargin: 5 + top: parent.top + topMargin: 5 + } + TextField { + id: url + objectName: "url" + placeholderText: "DApp URL" + anchors { + left: parent.left + right: parent.right + top: parent.top + topMargin: 5 + rightMargin: 5 + leftMargin: 5 + } + + Keys.onReturnPressed: { + if(/^https?/.test(this.text)) { + newBrowserTab(this.text); + } else { + addPlugin(this.text, {close: true, section: "apps"}) + } + } + } + + } + + // Border + Rectangle { + id: divider + anchors { + left: parent.left + right: parent.right + top: urlPane.bottom + } + z: -1 + height: 1 + color: "#CCCCCC" + }*/ + + Rectangle { + id: mainView + color: "#00000000" + anchors.right: parent.right + anchors.left: parent.left + anchors.bottom: parent.bottom + anchors.top: parent.top + + function createView(component) { + var view = component.createObject(mainView) + + return view; + } + } + } + } + + + /****************** + * Dialogs + *****************/ + FileDialog { + id: generalFileDialog + property var callback; + onAccepted: { + var path = this.fileUrl.toString(); + callback.call(this, path); + } + + function show(selectExisting, callback) { + generalFileDialog.callback = callback; + generalFileDialog.selectExisting = selectExisting; + + this.open(); + } + } + + + /****************** + * Wallet functions + *****************/ + function importApp(path) { + var ext = path.split('.').pop() + if(ext == "html" || ext == "htm") { + eth.openHtml(path) + }else if(ext == "qml"){ + addPlugin(path, {close: true, section: "apps"}) + } + } + + + function setWalletValue(value) { + walletValueLabel.text = value + } + + function loadPlugin(name) { + console.log("Loading plugin" + name) + var view = mainView.addPlugin(name) + } + + function setPeers(text) { + peerLabel.text = text + } + + function addPeer(peer) { + // We could just append the whole peer object but it cries if you try to alter them + peerModel.append({ip: peer.ip, port: peer.port, lastResponse:timeAgo(peer.lastSend), latency: peer.latency, version: peer.version, caps: peer.caps}) + } + + function resetPeers(){ + peerModel.clear() + } + + function timeAgo(unixTs){ + var lapsed = (Date.now() - new Date(unixTs*1000)) / 1000 + return (lapsed + " seconds ago") + } + + function convertToPretty(unixTs){ + var a = new Date(unixTs*1000); + var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']; + var year = a.getFullYear(); + var month = months[a.getMonth()]; + var date = a.getDate(); + var hour = a.getHours(); + var min = a.getMinutes(); + var sec = a.getSeconds(); + var time = date+' '+month+' '+year+' '+hour+':'+min+':'+sec ; + return time; + } + + /********************** + * Windows + *********************/ + Window { + id: peerWindow + //flags: Qt.CustomizeWindowHint | Qt.Tool | Qt.WindowCloseButtonHint + height: 200 + width: 700 + Rectangle { + anchors.fill: parent + property var peerModel: ListModel { + id: peerModel + } + TableView { + anchors.fill: parent + id: peerTable + model: peerModel + TableViewColumn{width: 200; role: "ip" ; title: "IP" } + TableViewColumn{width: 260; role: "version" ; title: "Version" } + TableViewColumn{width: 180; role: "caps" ; title: "Capabilities" } + } + } + } + + Window { + id: aboutWin + visible: false + title: "About" + minimumWidth: 350 + maximumWidth: 350 + maximumHeight: 280 + minimumHeight: 280 + + Image { + id: aboutIcon + height: 150 + width: 150 + fillMode: Image.PreserveAspectFit + smooth: true + source: "../facet.png" + x: 10 + y: 30 + } + + Text { + anchors.left: aboutIcon.right + anchors.leftMargin: 10 + anchors.top: parent.top + anchors.topMargin: 30 + font.pointSize: 12 + text: "<h2>Mist (0.7.10)</h2><br><h3>Development</h3>Jeffrey Wilcke<br>Viktor Trón<br>Felix Lange<br>Taylor Gerring<br>Daniel Nagy<br><h3>UX</h3>Alex van de Sande<br>" + } + } + + Window { + id: txImportDialog + minimumWidth: 270 + maximumWidth: 270 + maximumHeight: 50 + minimumHeight: 50 + TextField { + id: txImportField + width: 170 + anchors.verticalCenter: parent.verticalCenter + anchors.left: parent.left + anchors.leftMargin: 10 + onAccepted: { + } + } + Button { + anchors.left: txImportField.right + anchors.verticalCenter: parent.verticalCenter + anchors.leftMargin: 5 + text: "Import" + onClicked: { + eth.importTx(txImportField.text) + txImportField.visible = false + } + } + Component.onCompleted: { + addrField.focus = true + } + } + + Window { + id: addPeerWin + visible: false + minimumWidth: 300 + maximumWidth: 300 + maximumHeight: 50 + minimumHeight: 50 + title: "Connect to peer" + + ComboBox { + id: addrField + anchors.verticalCenter: parent.verticalCenter + anchors.left: parent.left + anchors.right: addPeerButton.left + anchors.leftMargin: 10 + anchors.rightMargin: 10 + onAccepted: { + eth.connectToPeer(addrField.currentText) + addPeerWin.visible = false + } + + editable: true + model: ListModel { id: pastPeers } + + Component.onCompleted: { + pastPeers.insert(0, {text: "poc-8.ethdev.com:30303"}) + /* + var ips = eth.pastPeers() + for(var i = 0; i < ips.length; i++) { + pastPeers.append({text: ips.get(i)}) + } + + pastPeers.insert(0, {text: "poc-7.ethdev.com:30303"}) + */ + } + } + + Button { + id: addPeerButton + anchors.right: parent.right + anchors.verticalCenter: parent.verticalCenter + anchors.rightMargin: 10 + text: "Add" + onClicked: { + eth.connectToPeer(addrField.currentText) + addPeerWin.visible = false + } + } + Component.onCompleted: { + addrField.focus = true + } + } + } +======= id: root property var ethx : Eth.ethx @@ -874,3 +1968,4 @@ ApplicationWindow { } } } +>>>>>>> 32a9c0ca809508c1648b8f44f3e09725af7a80d3 diff --git a/cmd/mist/assets/qml/views/browser.qml b/cmd/mist/assets/qml/views/browser.qml index 277a5b7eb..04b2229ec 100644 --- a/cmd/mist/assets/qml/views/browser.qml +++ b/cmd/mist/assets/qml/views/browser.qml @@ -56,12 +56,34 @@ Rectangle { //uriNav.text = uri.text.replace(/(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.\w{2,3})(.*)/, "$1$2<span style='color:#CCC'>$3</span>"); uriNav.text = uri; + } else { // Prevent inf loop. window.cleanPath = false; } } + function showFullUrlBar(on){ + if (on) { + //appTitle.visible = false + //appDomain.visible = false + + //uriNav.visible = true + clickAnywhereOnApp.visible = true + + navBar.state = "fullUrlVisible" + } else { + //appTitle.visible = true + //appDomain.visible = true + //uriNav.visible = false + clickAnywhereOnApp.visible = false + + navBar.state = "titleVisible" + + } + + } + Component.onCompleted: { } @@ -71,75 +93,234 @@ Rectangle { anchors.fill: parent state: "inspectorShown" + MouseArea { + id: clickAnywhereOnApp + z:15 + //hoverEnabled: true + anchors.fill: parent + /*hoverEnabled: true*/ + + onClicked: { + showFullUrlBar(false); + } + + /*Rectangle { + anchors.fill: parent + color: "#88888888" + }*/ + } + RowLayout { id: navBar - height: 40 + height: 74 + z: 20 anchors { left: parent.left right: parent.right - leftMargin: 7 } Button { id: back + onClicked: { webview.goBack() } + + anchors{ + left: parent.left + leftMargin: 6 + } + style: ButtonStyle { background: Image { - source: "../../back.png" - width: 30 + source: "../../backButton.png" + width: 20 height: 30 } } } - TextField { - anchors { + Rectangle { + id: appInfoPane + height: 28 + color: "#FFFFFF" + radius: 6 + + + MouseArea { + anchors.fill: parent + z: 10 + hoverEnabled: true + + onEntered: { + showFullUrlBar(true); + } + + } + + anchors { left: back.right - right: toggleInspector.left + right: parent.right leftMargin: 10 rightMargin: 10 } - text: webview.url; - id: uriNav - y: parent.height / 2 - this.height / 2 - Keys.onReturnPressed: { - webview.url = this.text; - } + Text { + id: appTitle + text: "LOADING" + font.bold: true + font.capitalization: Font.AllUppercase + horizontalAlignment: Text.AlignRight + verticalAlignment: Text.AlignVCenter + + anchors { + left: parent.left + right: parent.horizontalCenter + top: parent.top + bottom: parent.bottom + rightMargin: 10 + } + color: "#928484" + } + + Text { + id: appDomain + text: "loading domain" + font.bold: false + horizontalAlignment: Text.AlignLeft + verticalAlignment: Text.AlignVCenter + + anchors { + left: parent.horizontalCenter + right: parent.right + top: parent.top + bottom: parent.bottom + leftMargin: 10 + } + color: "#C0AFAF" + } + + + TextField { + id: uriNav + opacity: 0.0 + + anchors { + left: parent.left + right: parent.right + leftMargin: 16 + } + + horizontalAlignment: Text.AlignHCenter + + style: TextFieldStyle { + textColor: "#928484" + background: Rectangle { + border.width: 0 + color: "transparent" + } + } + text: webview.url; + y: parent.height / 2 - this.height / 2 + z: 20 + activeFocusOnPress: true + Keys.onReturnPressed: { + webview.url = this.text; + } + /* onFocusedChanged: { + if (focused) { + //uriNav.selectAll(); + } + }*/ + } + + z:2 } + + Rectangle { + id: appInfoPaneShadow + width: 10 + height: 30 + color: "#BDB6B6" + radius: 6 - Button { - id: toggleInspector - anchors { + anchors { + left: back.right right: parent.right + leftMargin:10 + rightMargin:10 + top: parent.top + topMargin: 23 } - iconSource: "../../bug.png" - onClicked: { - // XXX soon - return - if(inspector.visible == true){ - inspector.visible = false - }else{ - inspector.visible = true - inspector.url = webview.experimental.remoteInspectorUrl - } - } - } - } - // Border - Rectangle { - id: divider - anchors { - left: parent.left - right: parent.right - top: navBar.bottom + z:1 } - z: -1 - height: 1 - color: "#CCCCCC" + + Rectangle { + id: navBarBackground + anchors.fill: parent + gradient: Gradient { + GradientStop { position: 0.0; color: "#F6F1F2" } + GradientStop { position: 1.0; color: "#DED5D5" } + } + z:-1 + } + + states: [ + State { + name: "fullUrlVisible" + PropertyChanges { + target: appTitle + anchors.rightMargin: -50 + opacity: 0.0 + } + PropertyChanges { + target: appDomain + anchors.leftMargin: -50 + opacity: 0.0 + } + PropertyChanges { + target: uriNav + anchors.leftMargin: 0 + opacity: 1.0 + } + }, + State { + name: "titleVisible" + + PropertyChanges { + target: appTitle + anchors.rightMargin: 10 + opacity: 1.0 + } + PropertyChanges { + target: appDomain + anchors.leftMargin: 10 + opacity: 1.0 + } + PropertyChanges { + target: uriNav + anchors.leftMargin: -50 + opacity: 0.0 + } + } + + ] + + transitions: [ + // This adds a transition that defaults to applying to all state changes + + Transition { + + // This applies a default NumberAnimation to any changes a state change makes to x or y properties + NumberAnimation { + properties: "anchors.leftMargin, anchors.rightMargin, opacity" + easing.type: Easing.InOutQuad //Easing.InOutBack + duration: 300 + } + } + ] + } WebEngineView { @@ -149,16 +330,51 @@ Rectangle { left: parent.left right: parent.right bottom: parent.bottom - top: divider.bottom + top: navBar.bottom } - + z: 10 + onLoadingChanged: { if (loadRequest.status == WebEngineView.LoadSucceededStatus) { webview.runJavaScript("document.title", function(pageTitle) { menuItem.title = pageTitle; }); + + //var topBarStyle + webView.runJavaScript("document.querySelector(\"meta[name='ethereum-dapp-url-bar-style']\").getAttribute(\"content\")", function(topBarStyle){ + if (topBarStyle=="transparent") { + + // Adjust for a transparent sidebar Dapp + navBarBackground.visible = false; + back.visible = false; + appInfoPane.anchors.leftMargin = -16; + appInfoPaneShadow.anchors.leftMargin = -16; + webview.anchors.topMargin = -74; + webview.runJavaScript("document.querySelector('body').classList.add('ethereum-dapp-url-bar-style-transparent')") + + } else { + navBarBackground.visible = true; + back.visible = true; + appInfoPane.anchors.leftMargin = 0; + appInfoPaneShadow.anchors.leftMargin = 0; + webview.anchors.topMargin = 0; + + }; + }); + + + webview.runJavaScript(eth.readFile("bignumber.min.js")); webview.runJavaScript(eth.readFile("ethereum.js/dist/ethereum.js")); + + var cleanTitle = webview.url.toString() + var matches = cleanTitle.match(/^[a-z]*\:\/\/([^\/?#]+)(?:[\/?#]|$)/i); + var domain = matches && matches[1]; + + appDomain.text = domain //webview.url.replace("a", "z") + appTitle.text = webview.title + + showFullUrlBar(false); } } onJavaScriptConsoleMessage: { @@ -208,4 +424,3 @@ Rectangle { ] } } - diff --git a/cmd/mist/assets/qml/views/catalog.qml b/cmd/mist/assets/qml/views/catalog.qml new file mode 100644 index 000000000..a7832e9fa --- /dev/null +++ b/cmd/mist/assets/qml/views/catalog.qml @@ -0,0 +1,155 @@ +import QtQuick 2.0 +import QtQuick.Controls 1.0; +import QtQuick.Controls.Styles 1.0 +import QtQuick.Layouts 1.0; +import QtWebEngine 1.0 +//import QtWebEngine.experimental 1.0 +import QtQuick.Window 2.0; + + +Rectangle { + id: window + anchors.fill: parent + color: "#00000000" + + property var title: "Catalog" + property var iconSource: "" + property var menuItem + property var hideUrl: true + + property alias url: webview.url + property alias windowTitle: webview.title + property alias webView: webview + + + + property var cleanPath: false + property var open: function(url) { + if(!window.cleanPath) { + var uri = url; + if(!/.*\:\/\/.*/.test(uri)) { + uri = "http://" + uri; + } + + var reg = /(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.eth)(.*)/ + + if(reg.test(uri)) { + uri.replace(reg, function(match, pre, domain, path) { + uri = pre; + + var lookup = eth.lookupDomain(domain.substring(0, domain.length - 4)); + var ip = []; + for(var i = 0, l = lookup.length; i < l; i++) { + ip.push(lookup.charCodeAt(i)) + } + + if(ip.length != 0) { + uri += lookup; + } else { + uri += domain; + } + + uri += path; + }); + } + + window.cleanPath = true; + + webview.url = uri; + + //uriNav.text = uri.text.replace(/(^https?\:\/\/(?:www\.)?)([a-zA-Z0-9_\-]*\.\w{2,3})(.*)/, "$1$2<span style='color:#CCC'>$3</span>"); + uriNav.text = uri; + + } else { + // Prevent inf loop. + window.cleanPath = false; + } + } + + Component.onCompleted: { + } + + Item { + objectName: "root" + id: root + anchors.fill: parent + state: "inspectorShown" + + WebEngineView { + objectName: "webView" + id: webview + anchors.fill: parent + + property var protocol: "http://" + //property var domain: "localhost:3000" + property var domain: "ethereum-dapp-catalog.meteor.com" + url: protocol + domain + + //navigationRequest: WebEngineView.IgnoreRequest + // onLoadingChanged: { + // if (loadRequest.status == WebEngineView.LoadSucceededStatus) { + // webview.runJavaScript(eth.readFile("bignumber.min.js")); + // webview.runJavaScript(eth.readFile("ethereum.js/dist/ethereum.js")); + // } + // } + + //onNavigationRequested: { + // detect URL scheme prefix, most likely an external link + //var schemaRE = /^\w+:/; + //if (schemaRE.test(request.url)) { + // request.action = WebView.AcceptRequest; + //} else { + //request.action = WebView.IgnoreRequest; + // delegate request.url here + //} + //} + + onJavaScriptConsoleMessage: { + console.log(sourceID + ":" + lineNumber + ":" + JSON.stringify(message)); + } + + onNavigationRequested: { + var cleanTitle = request.url.toString() + var matches = cleanTitle.match(/^[a-z]*\:\/\/([^\/?#]+)(?:[\/?#]|$)/i); + var requestedDomain = matches && matches[1]; + + console.debug ("NavigationRequested: " + request.url + " navigationType=" + request.navigationType) + + if(request.navigationType==0){ + + if (requestedDomain === this.domain){ + request.action = WebEngineView.AcceptRequest; + } else { + request.action = WebEngineView.IgnoreRequest; + newBrowserTab(request.url); + } + + } + } + } + + + + WebEngineView { + id: inspector + visible: false + z:10 + anchors { + left: root.left + right: root.right + top: sizeGrip.bottom + bottom: root.bottom + } + + } + + states: [ + State { + name: "inspectorShown" + PropertyChanges { + target: inspector + } + } + ] + } +} diff --git a/cmd/mist/ext_app.go b/cmd/mist/ext_app.go index 20ec52e60..4831884e5 100644 --- a/cmd/mist/ext_app.go +++ b/cmd/mist/ext_app.go @@ -24,7 +24,6 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/ui/qt" "github.com/ethereum/go-ethereum/xeth" "github.com/obscuren/qml" @@ -39,7 +38,6 @@ type AppContainer interface { NewBlock(*types.Block) NewWatcher(chan bool) - Messages(state.Messages, string) Post(string, int) } @@ -79,10 +77,6 @@ func (app *ExtApplication) run() { return } - // Subscribe to events - mux := app.lib.eth.EventMux() - app.events = mux.Subscribe(core.NewBlockEvent{}, state.Messages(nil)) - // Call the main loop go app.mainLoop() @@ -126,23 +120,3 @@ func (app *ExtApplication) mainLoop() { func (self *ExtApplication) Watch(filterOptions map[string]interface{}, identifier string) { self.filters[identifier] = qt.NewFilterFromMap(filterOptions, self.eth) } - -func (self *ExtApplication) GetMessages(object map[string]interface{}) string { - /* TODO remove me - filter := qt.NewFilterFromMap(object, self.eth) - - messages := filter.Find() - var msgs []javascript.JSMessage - for _, m := range messages { - msgs = append(msgs, javascript.NewJSMessage(m)) - } - - b, err := json.Marshal(msgs) - if err != nil { - return "{\"error\":" + err.Error() + "}" - } - - return string(b) - */ - return "" -} diff --git a/cmd/mist/html_container.go b/cmd/mist/html_container.go index 0909a6abd..e4ea57b9b 100644 --- a/cmd/mist/html_container.go +++ b/cmd/mist/html_container.go @@ -31,7 +31,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/xeth" "github.com/howeyc/fsnotify" "github.com/obscuren/qml" @@ -144,19 +143,6 @@ func (app *HtmlApplication) NewBlock(block *types.Block) { app.webView.Call("onNewBlockCb", b) } -func (self *HtmlApplication) Messages(messages state.Messages, id string) { - /* TODO remove me - var msgs []javascript.JSMessage - for _, m := range messages { - msgs = append(msgs, javascript.NewJSMessage(m)) - } - - b, _ := json.Marshal(msgs) - - self.webView.Call("onWatchedCb", string(b), id) - */ -} - func (app *HtmlApplication) Destroy() { app.engine.Destroy() } diff --git a/cmd/mist/qml_container.go b/cmd/mist/qml_container.go index 9d76d8fe4..16a055bc0 100644 --- a/cmd/mist/qml_container.go +++ b/cmd/mist/qml_container.go @@ -22,12 +22,10 @@ package main import ( - "fmt" "runtime" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/xeth" "github.com/obscuren/qml" ) @@ -74,10 +72,6 @@ func (app *QmlApplication) NewBlock(block *types.Block) { app.win.Call("onNewBlockCb", pblock) } -func (self *QmlApplication) Messages(msgs state.Messages, id string) { - fmt.Println("IMPLEMENT QML APPLICATION MESSAGES METHOD") -} - // Getters func (app *QmlApplication) Engine() *qml.Engine { return app.engine diff --git a/core/block_processor.go b/core/block_processor.go index e6d4a1cda..8f5ee52b7 100644 --- a/core/block_processor.go +++ b/core/block_processor.go @@ -8,11 +8,9 @@ import ( "time" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" - "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/pow" "github.com/ethereum/go-ethereum/pow/ezp" "github.com/ethereum/go-ethereum/state" @@ -158,6 +156,9 @@ func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, state return receipts, handled, unhandled, erroneous, err } +// Process block will attempt to process the given block's transactions and applies them +// on top of the block's parent state (given it exists) and will return wether it was +// successful or not. func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, err error) { // Processing a blocks may never happen simultaneously sm.mutex.Lock() @@ -173,14 +174,14 @@ func (sm *BlockProcessor) Process(block *types.Block) (td *big.Int, err error) { } parent := sm.bc.GetBlock(header.ParentHash) - return sm.ProcessWithParent(block, parent) + return sm.processWithParent(block, parent) } -func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big.Int, err error) { +func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (td *big.Int, err error) { sm.lastAttemptedBlock = block + // Create a new state based on the parent's root (e.g., create copy) state := state.New(parent.Root(), sm.db) - //state := state.New(parent.Trie().Copy()) // Block validation if err = sm.ValidateBlock(block, parent); err != nil { @@ -194,18 +195,23 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big header := block.Header() + // Validate the received block's bloom with the one derived from the generated receipts. + // For valid blocks this should always validate to true. rbloom := types.CreateBloom(receipts) if bytes.Compare(rbloom, header.Bloom) != 0 { err = fmt.Errorf("unable to replicate block's bloom=%x", rbloom) return } + // The transactions Trie's root (R = (Tr [[H1, T1], [H2, T2], ... [Hn, Tn]])) + // can be used by light clients to make sure they've received the correct Txs txSha := types.DeriveSha(block.Transactions()) if bytes.Compare(txSha, header.TxHash) != 0 { err = fmt.Errorf("validating transaction root. received=%x got=%x", header.TxHash, txSha) return } + // Tre receipt Trie's root (R = (Tr [[H1, R1], ... [Hn, R1]])) receiptSha := types.DeriveSha(receipts) if bytes.Compare(receiptSha, header.ReceiptHash) != 0 { fmt.Println("receipts", receipts) @@ -213,12 +219,14 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big return } + // Accumulate static rewards; block reward, uncle's and uncle inclusion. if err = sm.AccumulateRewards(state, block, parent); err != nil { return } + // Commit state objects/accounts to a temporary trie (does not save) + // used to calculate the state root. state.Update(ethutil.Big0) - if !bytes.Equal(header.Root, state.Root()) { err = fmt.Errorf("invalid merkle root. received=%x got=%x", header.Root, state.Root()) return @@ -228,10 +236,6 @@ func (sm *BlockProcessor) ProcessWithParent(block, parent *types.Block) (td *big td = CalculateTD(block, parent) // Sync the current block's state to the database state.Sync() - // Set the block hashes for the current messages - state.Manifest().SetHash(block.Hash()) - // Reset the manifest XXX We need this? - state.Manifest().Reset() // Remove transactions from the pool sm.txpool.RemoveSet(block.Transactions()) @@ -311,27 +315,6 @@ func (sm *BlockProcessor) AccumulateRewards(statedb *state.StateDB, block, paren return nil } -func (sm *BlockProcessor) GetMessages(block *types.Block) (messages []*state.Message, err error) { - if !sm.bc.HasBlock(block.Header().ParentHash) { - return nil, ParentError(block.Header().ParentHash) - } - - sm.lastAttemptedBlock = block - - var ( - parent = sm.bc.GetBlock(block.Header().ParentHash) - //state = state.New(parent.Trie().Copy()) - state = state.New(parent.Root(), sm.db) - ) - - defer state.Reset() - - sm.TransitionState(state, parent, block) - sm.AccumulateRewards(state, block, parent) - - return state.Manifest().Messages, nil -} - func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error) { if !sm.bc.HasBlock(block.Header().ParentHash) { return nil, ParentError(block.Header().ParentHash) diff --git a/core/filter.go b/core/filter.go index 24d1f5a4a..b93fcc8a5 100644 --- a/core/filter.go +++ b/core/filter.go @@ -145,7 +145,7 @@ func (self *Filter) FilterLogs(logs state.Logs) state.Logs { // Filter the logs for interesting stuff Logs: for _, log := range logs { - if len(self.address) > 0 && !bytes.Equal(self.address, log.Address()) { + if !bytes.Equal(self.address, log.Address()) { continue } diff --git a/core/manager.go b/core/manager.go new file mode 100644 index 000000000..4671573b1 --- /dev/null +++ b/core/manager.go @@ -0,0 +1,22 @@ +package core + +import ( + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/p2p" +) + +type EthManager interface { + BlockProcessor() *BlockProcessor + ChainManager() *ChainManager + TxPool() *TxPool + PeerCount() int + IsMining() bool + IsListening() bool + Peers() []*p2p.Peer + KeyManager() *crypto.KeyManager + ClientIdentity() p2p.ClientIdentity + Db() ethutil.Database + EventMux() *event.TypeMux +} diff --git a/eth/backend.go b/eth/backend.go index 29cf7d836..684f15136 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -47,6 +47,9 @@ type Config struct { KeyManager *crypto.KeyManager } +var logger = ethlogger.NewLogger("SERV") +var jsonlogger = ethlogger.NewJsonLogger() + func (cfg *Config) parseBootNodes() []*discover.Node { var ns []*discover.Node for _, url := range strings.Split(cfg.BootNodes, " ") { @@ -96,7 +99,7 @@ type Ethereum struct { func New(config *Config) (*Ethereum, error) { // Boostrap database - logger := ethlogger.New(config.DataDir, config.LogFile, config.LogLevel) + logger := ethlogger.New(config.DataDir, config.LogFile, config.LogLevel, config.LogFormat) db, err := ethdb.NewLDBDatabase("blockchain") if err != nil { return nil, err @@ -236,6 +239,13 @@ func (s *Ethereum) Coinbase() []byte { // Start the ethereum func (s *Ethereum) Start() error { + jsonlogger.LogJson(ðlogger.LogStarting{ + ClientString: s.ClientIdentity().String(), + Coinbase: ethutil.Bytes2Hex(s.KeyManager().Address()), + ProtocolVersion: ProtocolVersion, + LogEvent: ethlogger.LogEvent{Guid: ethutil.Bytes2Hex(s.ClientIdentity().Pubkey())}, + }) + err := s.net.Start() if err != nil { return err diff --git a/eth/block_pool_test.go b/eth/block_pool_test.go index 94c3b43d2..331dbe504 100644 --- a/eth/block_pool_test.go +++ b/eth/block_pool_test.go @@ -613,6 +613,7 @@ func TestInvalidBlock(t *testing.T) { } func TestVerifyPoW(t *testing.T) { + t.Skip("***FIX*** This test is broken") logInit() _, blockPool, blockPoolTester := newTestBlockPool(t) blockPoolTester.blockChain[0] = nil diff --git a/ethdb/database.go b/ethdb/database.go index 47ddec9c0..f020af8f2 100644 --- a/ethdb/database.go +++ b/ethdb/database.go @@ -1,11 +1,11 @@ package ethdb import ( - "fmt" "path" + "fmt" - "github.com/ethereum/go-ethereum/compression/rle" "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/compression/rle" "github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb/iterator" ) diff --git a/event/filter/old_filter.go b/event/filter/eth_filter.go index ab0127ffb..295fcfbbf 100644 --- a/event/filter/old_filter.go +++ b/event/filter/eth_filter.go @@ -1,6 +1,7 @@ -// XXX This is the old filter system specifically for messages. This is till in used and could use some refactoring package filter +// TODO make use of the generic filtering system + import ( "sync" diff --git a/logger/log.go b/logger/log.go index 53065f870..baa3dfaf2 100644 --- a/logger/log.go +++ b/logger/log.go @@ -18,7 +18,7 @@ func openLogFile(datadir string, filename string) *os.File { return file } -func New(datadir string, logFile string, logLevel int) LogSystem { +func New(datadir string, logFile string, logLevel int, logFormat string) LogSystem { var writer io.Writer if logFile == "" { writer = os.Stdout @@ -26,7 +26,13 @@ func New(datadir string, logFile string, logLevel int) LogSystem { writer = openLogFile(datadir, logFile) } - sys := NewStdLogSystem(writer, log.LstdFlags, LogLevel(logLevel)) + var sys LogSystem + switch logFormat { + case "raw": + sys = NewRawLogSystem(writer, 0, LogLevel(logLevel)) + default: + sys = NewStdLogSystem(writer, log.LstdFlags, LogLevel(logLevel)) + } AddLogSystem(sys) return sys diff --git a/logger/loggers.go b/logger/loggers.go index 1bf7bfa0e..147b2b85f 100644 --- a/logger/loggers.go +++ b/logger/loggers.go @@ -13,28 +13,12 @@ logging of mutable state. package logger import ( + "encoding/json" "fmt" - "io" - "log" "os" - "sync" - "sync/atomic" ) -// LogSystem is implemented by log output devices. -// All methods can be called concurrently from multiple goroutines. -type LogSystem interface { - GetLogLevel() LogLevel - SetLogLevel(i LogLevel) - LogPrint(LogLevel, string) -} - -type message struct { - level LogLevel - msg string -} - -type LogLevel uint8 +type LogLevel uint32 const ( // Standard log levels @@ -44,102 +28,9 @@ const ( InfoLevel DebugLevel DebugDetailLevel + JsonLevel = 1000 ) -var ( - logMessageC = make(chan message) - addSystemC = make(chan LogSystem) - flushC = make(chan chan struct{}) - resetC = make(chan chan struct{}) -) - -func init() { - go dispatchLoop() -} - -// each system can buffer this many messages before -// blocking incoming log messages. -const sysBufferSize = 500 - -func dispatchLoop() { - var ( - systems []LogSystem - systemIn []chan message - systemWG sync.WaitGroup - ) - bootSystem := func(sys LogSystem) { - in := make(chan message, sysBufferSize) - systemIn = append(systemIn, in) - systemWG.Add(1) - go sysLoop(sys, in, &systemWG) - } - - for { - select { - case msg := <-logMessageC: - for _, c := range systemIn { - c <- msg - } - - case sys := <-addSystemC: - systems = append(systems, sys) - bootSystem(sys) - - case waiter := <-resetC: - // reset means terminate all systems - for _, c := range systemIn { - close(c) - } - systems = nil - systemIn = nil - systemWG.Wait() - close(waiter) - - case waiter := <-flushC: - // flush means reboot all systems - for _, c := range systemIn { - close(c) - } - systemIn = nil - systemWG.Wait() - for _, sys := range systems { - bootSystem(sys) - } - close(waiter) - } - } -} - -func sysLoop(sys LogSystem, in <-chan message, wg *sync.WaitGroup) { - for msg := range in { - if sys.GetLogLevel() >= msg.level { - sys.LogPrint(msg.level, msg.msg) - } - } - wg.Done() -} - -// Reset removes all active log systems. -// It blocks until all current messages have been delivered. -func Reset() { - waiter := make(chan struct{}) - resetC <- waiter - <-waiter -} - -// Flush waits until all current log messages have been dispatched to -// the active log systems. -func Flush() { - waiter := make(chan struct{}) - flushC <- waiter - <-waiter -} - -// AddLogSystem starts printing messages to the given LogSystem. -func AddLogSystem(sys LogSystem) { - addSystemC <- sys -} - // A Logger prints messages prefixed by a given tag. It provides named // Printf and Println style methods for all loglevels. Each ethereum // component should have its own logger with a unique prefix. @@ -223,26 +114,21 @@ func (logger *Logger) Fatalf(format string, v ...interface{}) { os.Exit(0) } -// NewStdLogSystem creates a LogSystem that prints to the given writer. -// The flag values are defined package log. -func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem { - logger := log.New(writer, "", flags) - return &stdLogSystem{logger, uint32(level)} +type JsonLogger struct { + Coinbase string } -type stdLogSystem struct { - logger *log.Logger - level uint32 +func NewJsonLogger() *JsonLogger { + return &JsonLogger{} } -func (t *stdLogSystem) LogPrint(level LogLevel, msg string) { - t.logger.Print(msg) -} +func (logger *JsonLogger) LogJson(v JsonLog) { + msgname := v.EventName() + obj := map[string]interface{}{ + msgname: v, + } -func (t *stdLogSystem) SetLogLevel(i LogLevel) { - atomic.StoreUint32(&t.level, uint32(i)) -} + jsontxt, _ := json.Marshal(obj) + logMessageC <- message{JsonLevel, string(jsontxt)} -func (t *stdLogSystem) GetLogLevel() LogLevel { - return LogLevel(atomic.LoadUint32(&t.level)) } diff --git a/logger/logsystem.go b/logger/logsystem.go new file mode 100644 index 000000000..8458b938f --- /dev/null +++ b/logger/logsystem.go @@ -0,0 +1,63 @@ +package logger + +import ( + "io" + "log" + "sync/atomic" +) + +// LogSystem is implemented by log output devices. +// All methods can be called concurrently from multiple goroutines. +type LogSystem interface { + GetLogLevel() LogLevel + SetLogLevel(i LogLevel) + LogPrint(LogLevel, string) +} + +// NewStdLogSystem creates a LogSystem that prints to the given writer. +// The flag values are defined package log. +func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem { + logger := log.New(writer, "", flags) + return &stdLogSystem{logger, uint32(level)} +} + +type stdLogSystem struct { + logger *log.Logger + level uint32 +} + +func (t *stdLogSystem) LogPrint(level LogLevel, msg string) { + t.logger.Print(msg) +} + +func (t *stdLogSystem) SetLogLevel(i LogLevel) { + atomic.StoreUint32(&t.level, uint32(i)) +} + +func (t *stdLogSystem) GetLogLevel() LogLevel { + return LogLevel(atomic.LoadUint32(&t.level)) +} + +// NewRawLogSystem creates a LogSystem that prints to the given writer without +// adding extra information. Suitable for preformatted output +func NewRawLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem { + logger := log.New(writer, "", 0) + return &rawLogSystem{logger, uint32(level)} +} + +type rawLogSystem struct { + logger *log.Logger + level uint32 +} + +func (t *rawLogSystem) LogPrint(level LogLevel, msg string) { + t.logger.Print(msg) +} + +func (t *rawLogSystem) SetLogLevel(i LogLevel) { + atomic.StoreUint32(&t.level, uint32(i)) +} + +func (t *rawLogSystem) GetLogLevel() LogLevel { + return LogLevel(atomic.LoadUint32(&t.level)) +} diff --git a/logger/sys.go b/logger/sys.go new file mode 100644 index 000000000..bd826b587 --- /dev/null +++ b/logger/sys.go @@ -0,0 +1,112 @@ +package logger + +import ( + "sync" +) + +type message struct { + level LogLevel + msg string +} + +var ( + logMessageC = make(chan message) + addSystemC = make(chan LogSystem) + flushC = make(chan chan struct{}) + resetC = make(chan chan struct{}) +) + +func init() { + go dispatchLoop() +} + +// each system can buffer this many messages before +// blocking incoming log messages. +const sysBufferSize = 500 + +func dispatchLoop() { + var ( + systems []LogSystem + systemIn []chan message + systemWG sync.WaitGroup + ) + bootSystem := func(sys LogSystem) { + in := make(chan message, sysBufferSize) + systemIn = append(systemIn, in) + systemWG.Add(1) + go sysLoop(sys, in, &systemWG) + } + + for { + select { + case msg := <-logMessageC: + for _, c := range systemIn { + c <- msg + } + + case sys := <-addSystemC: + systems = append(systems, sys) + bootSystem(sys) + + case waiter := <-resetC: + // reset means terminate all systems + for _, c := range systemIn { + close(c) + } + systems = nil + systemIn = nil + systemWG.Wait() + close(waiter) + + case waiter := <-flushC: + // flush means reboot all systems + for _, c := range systemIn { + close(c) + } + systemIn = nil + systemWG.Wait() + for _, sys := range systems { + bootSystem(sys) + } + close(waiter) + } + } +} + +func sysLoop(sys LogSystem, in <-chan message, wg *sync.WaitGroup) { + for msg := range in { + switch sys.(type) { + case *rawLogSystem: + // This is a semantic hack since rawLogSystem has little to do with JsonLevel + if msg.level == JsonLevel { + sys.LogPrint(msg.level, msg.msg) + } + default: + if sys.GetLogLevel() >= msg.level { + sys.LogPrint(msg.level, msg.msg) + } + } + } + wg.Done() +} + +// Reset removes all active log systems. +// It blocks until all current messages have been delivered. +func Reset() { + waiter := make(chan struct{}) + resetC <- waiter + <-waiter +} + +// Flush waits until all current log messages have been dispatched to +// the active log systems. +func Flush() { + waiter := make(chan struct{}) + flushC <- waiter + <-waiter +} + +// AddLogSystem starts printing messages to the given LogSystem. +func AddLogSystem(sys LogSystem) { + addSystemC <- sys +} diff --git a/logger/types.go b/logger/types.go new file mode 100644 index 000000000..f8dcb4e78 --- /dev/null +++ b/logger/types.go @@ -0,0 +1,360 @@ +package logger + +import ( + "time" +) + +type utctime8601 struct{} + +func (utctime8601) MarshalJSON() ([]byte, error) { + // FIX This should be re-formated for proper ISO 8601 + return []byte(`"` + time.Now().UTC().Format(time.RFC3339Nano)[:26] + `Z"`), nil +} + +type JsonLog interface { + EventName() string +} + +type LogEvent struct { + Guid string `json:"guid"` + Ts utctime8601 `json:"ts"` + // Level string `json:"level"` +} + +type LogStarting struct { + ClientString string `json:"version_string"` + Coinbase string `json:"coinbase"` + ProtocolVersion int `json:"eth_version"` + LogEvent +} + +func (l *LogStarting) EventName() string { + return "starting" +} + +type P2PConnecting struct { + RemoteId string `json:"remote_id"` + RemoteEndpoint string `json:"remote_endpoint"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PConnecting) EventName() string { + return "p2p.connecting" +} + +type P2PConnected struct { + NumConnections int `json:"num_connections"` + RemoteId string `json:"remote_id"` + LogEvent +} + +func (l *P2PConnected) EventName() string { + return "p2p.connected" +} + +type P2PHandshaked struct { + RemoteCapabilities []string `json:"remote_capabilities"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PHandshaked) EventName() string { + return "p2p.handshaked" +} + +type P2PDisconnected struct { + NumConnections int `json:"num_connections"` + RemoteId string `json:"remote_id"` + LogEvent +} + +func (l *P2PDisconnected) EventName() string { + return "p2p.disconnected" +} + +type P2PDisconnecting struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PDisconnecting) EventName() string { + return "p2p.disconnecting" +} + +type P2PDisconnectingBadHandshake struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PDisconnectingBadHandshake) EventName() string { + return "p2p.disconnecting.bad_handshake" +} + +type P2PDisconnectingBadProtocol struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PDisconnectingBadProtocol) EventName() string { + return "p2p.disconnecting.bad_protocol" +} + +type P2PDisconnectingReputation struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PDisconnectingReputation) EventName() string { + return "p2p.disconnecting.reputation" +} + +type P2PDisconnectingDHT struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PDisconnectingDHT) EventName() string { + return "p2p.disconnecting.dht" +} + +type P2PEthDisconnectingBadBlock struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PEthDisconnectingBadBlock) EventName() string { + return "p2p.eth.disconnecting.bad_block" +} + +type P2PEthDisconnectingBadTx struct { + Reason string `json:"reason"` + RemoteId string `json:"remote_id"` + NumConnections int `json:"num_connections"` + LogEvent +} + +func (l *P2PEthDisconnectingBadTx) EventName() string { + return "p2p.eth.disconnecting.bad_tx" +} + +type EthNewBlockMined struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockHexRlp string `json:"block_hexrlp"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockMined) EventName() string { + return "eth.newblock.mined" +} + +type EthNewBlockBroadcasted struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockBroadcasted) EventName() string { + return "eth.newblock.broadcasted" +} + +type EthNewBlockReceived struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockReceived) EventName() string { + return "eth.newblock.received" +} + +type EthNewBlockIsKnown struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockIsKnown) EventName() string { + return "eth.newblock.is_known" +} + +type EthNewBlockIsNew struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockIsNew) EventName() string { + return "eth.newblock.is_new" +} + +type EthNewBlockMissingParent struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockMissingParent) EventName() string { + return "eth.newblock.missing_parent" +} + +type EthNewBlockIsInvalid struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockIsInvalid) EventName() string { + return "eth.newblock.is_invalid" +} + +type EthNewBlockChainIsOlder struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockChainIsOlder) EventName() string { + return "eth.newblock.chain.is_older" +} + +type EthNewBlockChainIsCanonical struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockChainIsCanonical) EventName() string { + return "eth.newblock.chain.is_cannonical" +} + +type EthNewBlockChainNotCanonical struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockChainNotCanonical) EventName() string { + return "eth.newblock.chain.not_cannonical" +} + +type EthNewBlockChainSwitched struct { + BlockNumber int `json:"block_number"` + HeadHash string `json:"head_hash"` + OldHeadHash string `json:"old_head_hash"` + BlockHash string `json:"block_hash"` + BlockDifficulty int `json:"block_difficulty"` + BlockPrevHash string `json:"block_prev_hash"` + LogEvent +} + +func (l *EthNewBlockChainSwitched) EventName() string { + return "eth.newblock.chain.switched" +} + +type EthTxCreated struct { + TxHash string `json:"tx_hash"` + TxSender string `json:"tx_sender"` + TxAddress string `json:"tx_address"` + TxHexRLP string `json:"tx_hexrlp"` + TxNonce int `json:"tx_nonce"` + LogEvent +} + +func (l *EthTxCreated) EventName() string { + return "eth.tx.created" +} + +type EthTxReceived struct { + TxHash string `json:"tx_hash"` + TxAddress string `json:"tx_address"` + TxHexRLP string `json:"tx_hexrlp"` + RemoteId string `json:"remote_id"` + TxNonce int `json:"tx_nonce"` + LogEvent +} + +func (l *EthTxReceived) EventName() string { + return "eth.tx.received" +} + +type EthTxBroadcasted struct { + TxHash string `json:"tx_hash"` + TxSender string `json:"tx_sender"` + TxAddress string `json:"tx_address"` + TxNonce int `json:"tx_nonce"` + LogEvent +} + +func (l *EthTxBroadcasted) EventName() string { + return "eth.tx.broadcasted" +} + +type EthTxValidated struct { + TxHash string `json:"tx_hash"` + TxSender string `json:"tx_sender"` + TxAddress string `json:"tx_address"` + TxNonce int `json:"tx_nonce"` + LogEvent +} + +func (l *EthTxValidated) EventName() string { + return "eth.tx.validated" +} + +type EthTxIsInvalid struct { + TxHash string `json:"tx_hash"` + TxSender string `json:"tx_sender"` + TxAddress string `json:"tx_address"` + Reason string `json:"reason"` + TxNonce int `json:"tx_nonce"` + LogEvent +} + +func (l *EthTxIsInvalid) EventName() string { + return "eth.tx.is_invalid" +} diff --git a/rlp/encode.go b/rlp/encode.go index b453b5bf4..9d11d66bf 100644 --- a/rlp/encode.go +++ b/rlp/encode.go @@ -32,6 +32,48 @@ type Encoder interface { EncodeRLP(io.Writer) error } +// Flat wraps a value (which must encode as a list) so +// it encodes as the list's elements. +// +// Example: suppose you have defined a type +// +// type foo struct { A, B uint } +// +// Under normal encoding rules, +// +// rlp.Encode(foo{1, 2}) --> 0xC20102 +// +// This function can help you achieve the following encoding: +// +// rlp.Encode(rlp.Flat(foo{1, 2})) --> 0x0102 +func Flat(val interface{}) Encoder { + return flatenc{val} +} + +type flatenc struct{ val interface{} } + +func (e flatenc) EncodeRLP(out io.Writer) error { + // record current output position + var ( + eb = out.(*encbuf) + prevstrsize = len(eb.str) + prevnheads = len(eb.lheads) + ) + if err := eb.encode(e.val); err != nil { + return err + } + // check that a new list header has appeared + if len(eb.lheads) == prevnheads || eb.lheads[prevnheads].offset == prevstrsize-1 { + return fmt.Errorf("rlp.Flat: %T did not encode as list", e.val) + } + // remove the new list header + newhead := eb.lheads[prevnheads] + copy(eb.lheads[prevnheads:], eb.lheads[prevnheads+1:]) + eb.lheads = eb.lheads[:len(eb.lheads)-1] + eb.lhsize -= newhead.tagsize() + return nil +} + // Encode writes the RLP encoding of val to w. Note that Encode may // perform many small writes in some cases. Consider making w // buffered. @@ -123,6 +165,13 @@ func (head *listhead) encode(buf []byte) []byte { } } +func (head *listhead) tagsize() int { + if head.size < 56 { + return 1 + } + return 1 + intsize(uint64(head.size)) +} + func newencbuf() *encbuf { return &encbuf{sizebuf: make([]byte, 9)} } diff --git a/rlp/encode_test.go b/rlp/encode_test.go index 0309b9258..c283fbd57 100644 --- a/rlp/encode_test.go +++ b/rlp/encode_test.go @@ -183,6 +183,15 @@ var encTests = []encTest{ {val: &recstruct{5, nil}, output: "C205C0"}, {val: &recstruct{5, &recstruct{4, &recstruct{3, nil}}}, output: "C605C404C203C0"}, + // flat + {val: Flat(uint(1)), error: "rlp.Flat: uint did not encode as list"}, + {val: Flat(simplestruct{A: 3, B: "foo"}), output: "0383666F6F"}, + { + // value generates more list headers after the Flat + val: []interface{}{"foo", []uint{1, 2}, Flat([]uint{3, 4}), []uint{5, 6}, "bar"}, + output: "D083666F6FC201020304C2050683626172", + }, + // nil {val: (*uint)(nil), output: "80"}, {val: (*string)(nil), output: "80"}, diff --git a/rpc/http/server.go b/rpc/http/server.go index 7dcd6b867..10c8fa813 100644 --- a/rpc/http/server.go +++ b/rpc/http/server.go @@ -102,11 +102,11 @@ func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler { if reserr != nil { rpchttplogger.Warnln(reserr) jsonerr := &rpc.RpcErrorObject{-32603, reserr.Error()} - JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: &reqParsed.ID, Error: jsonerr}) + JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: reqParsed.ID, Error: jsonerr}) return } - rpchttplogger.Debugf("Generated response: %T %s", response, response) + rpchttplogger.DebugDetailf("Generated response: %T %s", response, response) JSON.Send(w, &rpc.RpcSuccessResponse{JsonRpc: jsonrpcver, ID: reqParsed.ID, Result: response}) } diff --git a/rpc/message.go b/rpc/message.go index 78dc6e2ff..7983e003d 100644 --- a/rpc/message.go +++ b/rpc/message.go @@ -34,20 +34,20 @@ const ( ) type RpcRequest struct { + ID interface{} `json:"id"` JsonRpc string `json:"jsonrpc"` - ID int `json:"id"` Method string `json:"method"` Params []json.RawMessage `json:"params"` } type RpcSuccessResponse struct { - ID int `json:"id"` + ID interface{} `json:"id"` JsonRpc string `json:"jsonrpc"` Result interface{} `json:"result"` } type RpcErrorResponse struct { - ID *int `json:"id"` + ID interface{} `json:"id"` JsonRpc string `json:"jsonrpc"` Error *RpcErrorObject `json:"error"` } diff --git a/rpc/util.go b/rpc/util.go index 509d9a17d..679d83754 100644 --- a/rpc/util.go +++ b/rpc/util.go @@ -47,7 +47,6 @@ func (self JsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) // Convert JSON to native types d := json.NewDecoder(req.Body) - // d.UseNumber() defer req.Body.Close() err := d.Decode(&reqParsed) @@ -55,6 +54,7 @@ func (self JsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) rpclogger.Errorln("Error decoding JSON: ", err) return reqParsed, err } + rpclogger.DebugDetailf("Parsed request: %s", reqParsed) return reqParsed, nil diff --git a/rpc/ws/server.go b/rpc/ws/server.go index 6be4e8ce9..100713c10 100644 --- a/rpc/ws/server.go +++ b/rpc/ws/server.go @@ -94,9 +94,10 @@ func sockHandler(api *rpc.EthereumApi) websocket.Handler { var jsonrpcver string = "2.0" fn := func(conn *websocket.Conn) { for { - wslogger.Debugln("Handling request") + wslogger.Debugln("Handling connection") var reqParsed rpc.RpcRequest + // reqParsed, reqerr := JSON.ParseRequestBody(conn.Request()) if err := websocket.JSON.Receive(conn, &reqParsed); err != nil { jsonerr := &rpc.RpcErrorObject{-32700, rpc.ErrorParseRequest} JSON.Send(conn, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: nil, Error: jsonerr}) @@ -108,7 +109,7 @@ func sockHandler(api *rpc.EthereumApi) websocket.Handler { if reserr != nil { wslogger.Warnln(reserr) jsonerr := &rpc.RpcErrorObject{-32603, reserr.Error()} - JSON.Send(conn, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: &reqParsed.ID, Error: jsonerr}) + JSON.Send(conn, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: reqParsed.ID, Error: jsonerr}) continue } diff --git a/state/manifest.go b/state/manifest.go deleted file mode 100644 index 994019a08..000000000 --- a/state/manifest.go +++ /dev/null @@ -1,61 +0,0 @@ -package state - -import ( - "fmt" - "math/big" -) - -// Object manifest -// -// The object manifest is used to keep changes to the state so we can keep track of the changes -// that occurred during a state transitioning phase. -type Manifest struct { - Messages Messages -} - -func NewManifest() *Manifest { - m := &Manifest{} - m.Reset() - - return m -} - -func (m *Manifest) Reset() { - m.Messages = nil -} - -func (self *Manifest) AddMessage(msg *Message) *Message { - self.Messages = append(self.Messages, msg) - - return msg -} - -func (self *Manifest) SetHash(hash []byte) { - for _, message := range self.Messages { - message.Block = hash - } -} - -type Messages []*Message -type Message struct { - To, From []byte - Input []byte - Output []byte - Path int - Origin []byte - Timestamp int64 - Coinbase []byte - Block []byte - Number *big.Int - Value *big.Int - - ChangedAddresses [][]byte -} - -func (self *Message) AddStorageChange(addr []byte) { - self.ChangedAddresses = append(self.ChangedAddresses, addr) -} - -func (self *Message) String() string { - return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d value: %v", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path, self.Value) -} diff --git a/state/statedb.go b/state/statedb.go index af054ff09..c83d59ed7 100644 --- a/state/statedb.go +++ b/state/statedb.go @@ -22,8 +22,6 @@ type StateDB struct { stateObjects map[string]*StateObject - manifest *Manifest - refund map[string]*big.Int logs Logs @@ -32,7 +30,7 @@ type StateDB struct { // Create a new state from a given trie func New(root []byte, db ethutil.Database) *StateDB { trie := trie.New(ethutil.CopyBytes(root), db) - return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest(), refund: make(map[string]*big.Int)} + return &StateDB{db: db, trie: trie, stateObjects: make(map[string]*StateObject), refund: make(map[string]*big.Int)} } func (self *StateDB) EmptyLogs() { @@ -47,6 +45,13 @@ func (self *StateDB) Logs() Logs { return self.logs } +func (self *StateDB) Refund(addr []byte, gas *big.Int) { + if self.refund[string(addr)] == nil { + self.refund[string(addr)] = new(big.Int) + } + self.refund[string(addr)].Add(self.refund[string(addr)], gas) +} + // Retrieve the balance from the given address or 0 if object not found func (self *StateDB) GetBalance(addr []byte) *big.Int { stateObject := self.GetStateObject(addr) @@ -57,13 +62,6 @@ func (self *StateDB) GetBalance(addr []byte) *big.Int { return ethutil.Big0 } -func (self *StateDB) Refund(addr []byte, gas *big.Int) { - if self.refund[string(addr)] == nil { - self.refund[string(addr)] = new(big.Int) - } - self.refund[string(addr)].Add(self.refund[string(addr)], gas) -} - func (self *StateDB) AddBalance(addr []byte, amount *big.Int) { stateObject := self.GetStateObject(addr) if stateObject != nil { @@ -103,6 +101,7 @@ func (self *StateDB) SetCode(addr, code []byte) { } } +// TODO vars func (self *StateDB) GetState(a, b []byte) []byte { stateObject := self.GetStateObject(a) if stateObject != nil { @@ -212,25 +211,21 @@ func (s *StateDB) Cmp(other *StateDB) bool { } func (self *StateDB) Copy() *StateDB { - if self.trie != nil { - state := New(nil, self.db) - state.trie = self.trie.Copy() - for k, stateObject := range self.stateObjects { - state.stateObjects[k] = stateObject.Copy() - } - - for addr, refund := range self.refund { - state.refund[addr] = new(big.Int).Set(refund) - } - - logs := make(Logs, len(self.logs)) - copy(logs, self.logs) - state.logs = logs + state := New(nil, self.db) + state.trie = self.trie.Copy() + for k, stateObject := range self.stateObjects { + state.stateObjects[k] = stateObject.Copy() + } - return state + for addr, refund := range self.refund { + state.refund[addr] = new(big.Int).Set(refund) } - return nil + logs := make(Logs, len(self.logs)) + copy(logs, self.logs) + state.logs = logs + + return state } func (self *StateDB) Set(state *StateDB) { @@ -301,10 +296,6 @@ func (self *StateDB) Update(gasUsed *big.Int) { } } -func (self *StateDB) Manifest() *Manifest { - return self.manifest -} - // Debug stuff func (self *StateDB) CreateOutputForDiff() { for _, stateObject := range self.stateObjects { diff --git a/trie/iterator.go b/trie/iterator.go index f0dae28bb..3b3ddd751 100644 --- a/trie/iterator.go +++ b/trie/iterator.go @@ -23,7 +23,6 @@ func (self *Iterator) Next() bool { self.Key = []byte(DecodeCompact(k)) return len(k) > 0 - } func (self *Iterator) next(node Node, key []byte) []byte { @@ -67,7 +66,7 @@ func (self *Iterator) next(node Node, key []byte) []byte { if BeginsWith(key, k) { ret = self.next(cnode, skey) } else if bytes.Compare(k, key[:len(k)]) > 0 { - ret = self.key(node) + return self.key(node) } if ret != nil { diff --git a/trie/trie_test.go b/trie/trie_test.go index ffb78d4f2..4b185f355 100644 --- a/trie/trie_test.go +++ b/trie/trie_test.go @@ -257,3 +257,42 @@ func BenchmarkUpdate(b *testing.B) { } trie.Hash() } + +type kv struct { + k, v []byte + t bool +} + +func TestLargeData(t *testing.T) { + trie := NewEmpty() + vals := make(map[string]*kv) + + for i := byte(1); i < 255; i++ { + value := &kv{ethutil.LeftPadBytes([]byte{i}, 32), []byte{i}, false} + value2 := &kv{ethutil.LeftPadBytes([]byte{10, i}, 32), []byte{i}, false} + trie.Update(value.k, value.v) + trie.Update(value2.k, value2.v) + vals[string(value.k)] = value + vals[string(value2.k)] = value2 + fmt.Println(value, "\n", value2) + } + + it := trie.Iterator() + for it.Next() { + vals[string(it.Key)].t = true + } + + var untouched []*kv + for _, value := range vals { + if !value.t { + untouched = append(untouched, value) + } + } + + if len(untouched) > 0 { + t.Errorf("Missed %d nodes", len(untouched)) + for _, value := range untouched { + t.Error(value) + } + } +} diff --git a/ui/qt/qwhisper/whisper.go b/ui/qt/qwhisper/whisper.go index 98bfc69b0..2bc455b0b 100644 --- a/ui/qt/qwhisper/whisper.go +++ b/ui/qt/qwhisper/whisper.go @@ -106,7 +106,7 @@ func (self *Whisper) Messages(id int) (messages *ethutil.List) { func filterFromMap(opts map[string]interface{}) (f whisper.Filter) { if to, ok := opts["to"].(string); ok { - f.To = crypto.ToECDSA(fromHex(to)) + f.To = crypto.ToECDSAPub(fromHex(to)) } if from, ok := opts["from"].(string); ok { f.From = crypto.ToECDSAPub(fromHex(from)) @@ -38,13 +38,6 @@ func New(env Environment) *Vm { func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { self.env.SetDepth(self.env.Depth() + 1) - msg := self.env.State().Manifest().AddMessage(&state.Message{ - To: me.Address(), From: caller.Address(), - Input: callData, - Origin: self.env.Origin(), - Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(), - Value: value, - }) context := NewContext(caller, me, code, gas, price) vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData) @@ -618,8 +611,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I val, loc := stack.Popn() statedb.SetState(context.Address(), loc.Bytes(), val) - msg.AddStorageChange(loc.Bytes()) - self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes()) case JUMP: jump(pc, stack.Pop()) @@ -670,7 +661,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I dataGas.Mul(dataGas, GasCreateByte) if context.UseGas(dataGas) { ref.SetCode(ret) - msg.Output = ret } addr = ref.Address() @@ -713,7 +703,6 @@ func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.I vmlogger.Debugln(err) } else { stack.Push(ethutil.BigTrue) - msg.Output = ret mem.Set(retOffset.Uint64(), retSize.Uint64(), ret) } diff --git a/whisper/filter.go b/whisper/filter.go index 4315aa556..b33f2c1a2 100644 --- a/whisper/filter.go +++ b/whisper/filter.go @@ -3,7 +3,7 @@ package whisper import "crypto/ecdsa" type Filter struct { - To *ecdsa.PrivateKey + To *ecdsa.PublicKey From *ecdsa.PublicKey Topics [][]byte Fn func(*Message) diff --git a/whisper/message.go b/whisper/message.go index 23b5cfb0e..5d9e5b5c1 100644 --- a/whisper/message.go +++ b/whisper/message.go @@ -12,6 +12,8 @@ type Message struct { Signature []byte Payload []byte Sent int64 + + To *ecdsa.PublicKey } func NewMessage(payload []byte) *Message { diff --git a/whisper/whisper.go b/whisper/whisper.go index cc0348422..066f2c4ea 100644 --- a/whisper/whisper.go +++ b/whisper/whisper.go @@ -118,7 +118,7 @@ func (self *Whisper) GetIdentity(key *ecdsa.PublicKey) *ecdsa.PrivateKey { func (self *Whisper) Watch(opts Filter) int { return self.filters.Install(filter.Generic{ - Str1: string(crypto.FromECDSA(opts.To)), + Str1: string(crypto.FromECDSAPub(opts.To)), Str2: string(crypto.FromECDSAPub(opts.From)), Data: bytesToMap(opts.Topics), Fn: func(data interface{}) { @@ -256,6 +256,8 @@ func (self *Whisper) postEvent(envelope *Envelope) { func (self *Whisper) open(envelope *Envelope) (*Message, *ecdsa.PrivateKey) { for _, key := range self.keys { if message, err := envelope.Open(key); err == nil || (err != nil && err == ecies.ErrInvalidPublicKey) { + message.To = &key.PublicKey + return message, key } } diff --git a/whisper/whisper_test.go b/whisper/whisper_test.go index c5ad73021..3e3945a0a 100644 --- a/whisper/whisper_test.go +++ b/whisper/whisper_test.go @@ -11,7 +11,7 @@ func TestEvent(t *testing.T) { whisper := New() id := whisper.NewIdentity() whisper.Watch(Filter{ - To: id, + To: &id.PublicKey, Fn: func(msg *Message) { res <- msg }, diff --git a/xeth/types.go b/xeth/types.go index 2c6c52675..b13317b03 100644 --- a/xeth/types.go +++ b/xeth/types.go @@ -235,33 +235,3 @@ func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *R toHex(address), } } - -type Message struct { - To string `json:"to"` - From string `json:"from"` - Input string `json:"input"` - Output string `json:"output"` - Path int32 `json:"path"` - Origin string `json:"origin"` - Timestamp int32 `json:"timestamp"` - Coinbase string `json:"coinbase"` - Block string `json:"block"` - Number int32 `json:"number"` - Value string `json:"value"` -} - -func NewMessage(message *state.Message) Message { - return Message{ - To: toHex(message.To), - From: toHex(message.From), - Input: toHex(message.Input), - Output: toHex(message.Output), - Path: int32(message.Path), - Origin: toHex(message.Origin), - Timestamp: int32(message.Timestamp), - Coinbase: toHex(message.Origin), - Block: toHex(message.Block), - Number: int32(message.Number.Int64()), - Value: message.Value.String(), - } -} diff --git a/xeth/whisper.go b/xeth/whisper.go index 52f4593e4..d9c7e1614 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -64,7 +64,7 @@ func (self *Whisper) HasIdentity(key string) bool { func (self *Whisper) Watch(opts *Options) int { filter := whisper.Filter{ - To: crypto.ToECDSA(fromHex(opts.To)), + To: crypto.ToECDSAPub(fromHex(opts.To)), From: crypto.ToECDSAPub(fromHex(opts.From)), Topics: whisper.TopicsFromString(opts.Topics...), } @@ -99,8 +99,9 @@ type Options struct { type WhisperMessage struct { ref *whisper.Message Payload string `json:"payload"` + To string `json:"to"` From string `json:"from"` - Sent int64 `json:"time"` + Sent int64 `json:"sent"` } func NewWhisperMessage(msg *whisper.Message) WhisperMessage { @@ -108,6 +109,7 @@ func NewWhisperMessage(msg *whisper.Message) WhisperMessage { ref: msg, Payload: toHex(msg.Payload), From: toHex(crypto.FromECDSAPub(msg.Recover())), + To: toHex(crypto.FromECDSAPub(msg.To)), Sent: msg.Sent, } } diff --git a/xeth/xeth.go b/xeth/xeth.go index 02e68e697..75d83f80b 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -191,15 +191,6 @@ func (self *XEth) FromNumber(str string) string { return ethutil.BigD(fromHex(str)).String() } -func ToMessages(messages state.Messages) *ethutil.List { - var msgs []Message - for _, m := range messages { - msgs = append(msgs, NewMessage(m)) - } - - return ethutil.NewList(msgs) -} - func (self *XEth) PushTx(encodedTx string) (string, error) { tx := types.NewTransactionFromBytes(fromHex(encodedTx)) err := self.eth.TxPool().Add(tx) |
