Merge pull request #2735 from ethereum/release/1.4

Geth 1.4.8 "DAO Wars"

.github/CONTRIBUTING.md

@@ -8,7 +8,7 @@ and help.
 ## Contributing
 
 If you'd like to contribute to go-ethereum please fork, fix, commit and
-send a pull request. Commits who do not comply with the coding standards
+send a pull request. Commits which do not comply with the coding standards
 are ignored (use gofmt!). If you send pull requests make absolute sure that you
 commit on the `develop` branch and that you do not merge to master.
 Commits that are directly based on master are simply ignored.

.travis.yml

@@ -1,10 +1,12 @@
 language: go
 go:
   - 1.4.2
+  - 1.5.4
+  - 1.6.2
 install:
   # - go get code.google.com/p/go.tools/cmd/goimports
   # - go get github.com/golang/lint/golint
-  # - go get golang.org/x/tools/cmd/vet 
+  # - go get golang.org/x/tools/cmd/vet
   - go get golang.org/x/tools/cmd/cover
 before_script:
   # - gofmt -l -w .
@@ -24,6 +26,6 @@ notifications:
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/e09ccdce1048c5e03445
-    on_success: change 
+    on_success: change
     on_failure: always
-    on_start: false 
+    on_start: false

Godeps/Godeps.json

@@ -1,6 +1,7 @@
 {
 	"ImportPath": "github.com/ethereum/go-ethereum",
 	"GoVersion": "go1.5.2",
+	"GodepVersion": "v74",
 	"Packages": [
 		"./..."
 	],
@@ -13,11 +14,6 @@
 			"ImportPath": "github.com/cespare/cp",
 			"Rev": "165db2f241fd235aec29ba6d9b1ccd5f1c14637c"
 		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-215-g0ab42fd",
-			"Rev": "0ab42fd482c27cf2c95e7794ad3bb2082c2ab2d7"
-		},
 		{
 			"ImportPath": "github.com/davecgh/go-spew/spew",
 			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
@@ -155,6 +151,10 @@
 			"ImportPath": "github.com/rs/cors",
 			"Rev": "5950cf11d77f8a61b432a25dd4d444b4ced01379"
 		},
+		{
+			"ImportPath": "github.com/rs/xhandler",
+			"Rev": "d9d9599b6aaf6a058cb7b1f48291ded2cbd13390"
+		},
 		{
 			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
 			"Rev": "917f41c560270110ceb73c5b38be2a9127387071"
@@ -319,6 +319,11 @@
 		{
 			"ImportPath": "gopkg.in/karalabe/cookiejar.v2/collections/prque",
 			"Rev": "8dcd6a7f4951f6ff3ee9cbb919a06d8925822e57"
+		},
+		{
+			"ImportPath": "gopkg.in/urfave/cli.v1",
+			"Comment": "v1.17.0",
+			"Rev": "01857ac33766ce0c93856370626f9799281c14f4"
 		}
 	]
 }

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete

@@ -1,14 +0,0 @@
-#! /bin/bash
-
-: ${PROG:=$(basename ${BASH_SOURCE})}
-
-_cli_bash_autocomplete() {
-     local cur opts base
-     COMPREPLY=()
-     cur="${COMP_WORDS[COMP_CWORD]}"
-     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-     return 0
- }
-  
- complete -F _cli_bash_autocomplete $PROG

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete

@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete

Godeps/_workspace/src/github.com/rs/xhandler/.travis.yml

@@ -1,7 +0,0 @@
-language: go
-go:
-- 1.5
-- tip
-matrix:
-  allow_failures:
-      - go: tip

Godeps/_workspace/src/github.com/rs/xhandler/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2015 Olivier Poitrey <rs@dailymotion.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is furnished
-to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

Godeps/_workspace/src/github.com/rs/xhandler/README.md

@@ -1,134 +0,0 @@
-# XHandler
-
-[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/rs/xhandler) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/xhandler/master/LICENSE) [![Build Status](https://travis-ci.org/rs/xhandler.svg?branch=master)](https://travis-ci.org/rs/xhandler) [![Coverage](http://gocover.io/_badge/github.com/rs/xhandler)](http://gocover.io/github.com/rs/xhandler)
-
-XHandler is a bridge between [net/context](https://godoc.org/golang.org/x/net/context) and `http.Handler`.
-
-It lets you enforce `net/context` in your handlers without sacrificing compatibility with existing `http.Handlers` nor imposing a specific router.
-
-Thanks to `net/context` deadline management, `xhandler` is able to enforce a per request deadline and will cancel the context when the client closes the connection unexpectedly.
-
-You may create your own `net/context` aware handler pretty much the same way as you would do with http.Handler.
-
-Read more about xhandler on [Dailymotion engineering blog](http://engineering.dailymotion.com/our-way-to-go/).
-
-## Installing
-
-    go get -u github.com/rs/xhandler
-
-## Usage
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/rs/cors"
-	"github.com/rs/xhandler"
-	"golang.org/x/net/context"
-)
-
-type myMiddleware struct {
-	next xhandler.HandlerC
-}
-
-func (h myMiddleware) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	ctx = context.WithValue(ctx, "test", "World")
-	h.next.ServeHTTPC(ctx, w, r)
-}
-
-func main() {
-	c := xhandler.Chain{}
-
-	// Add close notifier handler so context is cancelled when the client closes
-	// the connection
-	c.UseC(xhandler.CloseHandler)
-
-	// Add timeout handler
-	c.UseC(xhandler.TimeoutHandler(2 * time.Second))
-
-	// Middleware putting something in the context
-	c.UseC(func(next xhandler.HandlerC) xhandler.HandlerC {
-		return myMiddleware{next: next}
-	})
-
-	// Mix it with a non-context-aware middleware handler
-	c.Use(cors.Default().Handler)
-
-	// Final handler (using handlerFuncC), reading from the context
-	xh := xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-		value := ctx.Value("test").(string)
-		w.Write([]byte("Hello " + value))
-	})
-
-	// Bridge context aware handlers with http.Handler using xhandler.Handle()
-	http.Handle("/test", c.Handler(xh))
-
-	if err := http.ListenAndServe(":8080", nil); err != nil {
-		log.Fatal(err)
-	}
-}
-```
-
-### Using xmux
-
-Xhandler comes with an optional context aware [muxer](https://github.com/rs/xmux) forked from [httprouter](https://github.com/julienschmidt/httprouter):
-
-```go
-package main
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/rs/xhandler"
-	"github.com/rs/xmux"
-	"golang.org/x/net/context"
-)
-
-func main() {
-	c := xhandler.Chain{}
-
-	// Append a context-aware middleware handler
-	c.UseC(xhandler.CloseHandler)
-
-	// Another context-aware middleware handler
-	c.UseC(xhandler.TimeoutHandler(2 * time.Second))
-
-	mux := xmux.New()
-
-	// Use c.Handler to terminate the chain with your final handler
-	mux.GET("/welcome/:name", xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
-		fmt.Fprintf(w, "Welcome %s!", xmux.Params(ctx).Get("name"))
-	}))
-
-	if err := http.ListenAndServe(":8080", c.Handler(mux)); err != nil {
-		log.Fatal(err)
-	}
-}
-```
-
-See [xmux](https://github.com/rs/xmux) for more examples.
-
-## Context Aware Middleware
-
-Here is a list of `net/context` aware middleware handlers implementing `xhandler.HandlerC` interface.
-
-Feel free to put up a PR linking your middleware if you have built one:
-
-| Middleware | Author | Description |
-| ---------- | ------ | ----------- |
-| [xmux](https://github.com/rs/xmux) | [Olivier Poitrey](https://github.com/rs) | HTTP request muxer |
-| [xlog](https://github.com/rs/xlog) | [Olivier Poitrey](https://github.com/rs) | HTTP handler logger |
-| [xstats](https://github.com/rs/xstats) | [Olivier Poitrey](https://github.com/rs) | A generic client for service instrumentation |
-| [xaccess](https://github.com/rs/xaccess) | [Olivier Poitrey](https://github.com/rs) | HTTP handler access logger with [xlog](https://github.com/rs/xlog) and [xstats](https://github.com/rs/xstats) |
-| [cors](https://github.com/rs/cors) | [Olivier Poitrey](https://github.com/rs) | [Cross Origin Resource Sharing](http://www.w3.org/TR/cors/) (CORS) support |
-
-## Licenses
-
-All source code is licensed under the [MIT License](https://raw.github.com/rs/xhandler/master/LICENSE).

Godeps/_workspace/src/github.com/rs/xhandler/chain.go

@@ -1,93 +0,0 @@
-package xhandler
-
-import (
-	"net/http"
-
-	"golang.org/x/net/context"
-)
-
-// Chain is an helper to chain middleware handlers together for an easier
-// management.
-type Chain []func(next HandlerC) HandlerC
-
-// UseC appends a context-aware handler to the middleware chain.
-func (c *Chain) UseC(f func(next HandlerC) HandlerC) {
-	*c = append(*c, f)
-}
-
-// Use appends a standard http.Handler to the middleware chain without
-// lossing track of the context when inserted between two context aware handlers.
-//
-// Caveat: the f function will be called on each request so you are better to put
-// any initialization sequence outside of this function.
-func (c *Chain) Use(f func(next http.Handler) http.Handler) {
-	xf := func(next HandlerC) HandlerC {
-		return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-			n := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				next.ServeHTTPC(ctx, w, r)
-			})
-			f(n).ServeHTTP(w, r)
-		})
-	}
-	*c = append(*c, xf)
-}
-
-// Handler wraps the provided final handler with all the middleware appended to
-// the chain and return a new standard http.Handler instance.
-// The context.Background() context is injected automatically.
-func (c Chain) Handler(xh HandlerC) http.Handler {
-	ctx := context.Background()
-	return c.HandlerCtx(ctx, xh)
-}
-
-// HandlerFC is an helper to provide a function (HandlerFuncC) to Handler().
-//
-// HandlerFC is equivalent to:
-//  c.Handler(xhandler.HandlerFuncC(xhc))
-func (c Chain) HandlerFC(xhf HandlerFuncC) http.Handler {
-	ctx := context.Background()
-	return c.HandlerCtx(ctx, HandlerFuncC(xhf))
-}
-
-// HandlerH is an helper to provide a standard http handler (http.HandlerFunc)
-// to Handler(). Your final handler won't have access the context though.
-func (c Chain) HandlerH(h http.Handler) http.Handler {
-	ctx := context.Background()
-	return c.HandlerCtx(ctx, HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-		h.ServeHTTP(w, r)
-	}))
-}
-
-// HandlerF is an helper to provide a standard http handler function
-// (http.HandlerFunc) to Handler(). Your final handler won't have access
-// the context though.
-func (c Chain) HandlerF(hf http.HandlerFunc) http.Handler {
-	ctx := context.Background()
-	return c.HandlerCtx(ctx, HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-		hf(w, r)
-	}))
-}
-
-// HandlerCtx wraps the provided final handler with all the middleware appended to
-// the chain and return a new standard http.Handler instance.
-func (c Chain) HandlerCtx(ctx context.Context, xh HandlerC) http.Handler {
-	return New(ctx, c.HandlerC(xh))
-}
-
-// HandlerC wraps the provided final handler with all the middleware appended to
-// the chain and returns a HandlerC instance.
-func (c Chain) HandlerC(xh HandlerC) HandlerC {
-	for i := len(c) - 1; i >= 0; i-- {
-		xh = c[i](xh)
-	}
-	return xh
-}
-
-// HandlerCF wraps the provided final handler func with all the middleware appended to
-// the chain and returns a HandlerC instance.
-//
-// HandlerCF is equivalent to:
-//  c.HandlerC(xhandler.HandlerFuncC(xhc))
-func (c Chain) HandlerCF(xhc HandlerFuncC) HandlerC {
-	return c.HandlerC(HandlerFuncC(xhc))
-}

Godeps/_workspace/src/github.com/rs/xhandler/middleware.go

@@ -1,59 +0,0 @@
-package xhandler
-
-import (
-	"net/http"
-	"time"
-
-	"golang.org/x/net/context"
-)
-
-// CloseHandler returns a Handler cancelling the context when the client
-// connection close unexpectedly.
-func CloseHandler(next HandlerC) HandlerC {
-	return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-		// Cancel the context if the client closes the connection
-		if wcn, ok := w.(http.CloseNotifier); ok {
-			var cancel context.CancelFunc
-			ctx, cancel = context.WithCancel(ctx)
-			defer cancel()
-
-			notify := wcn.CloseNotify()
-			go func() {
-				select {
-				case <-notify:
-					cancel()
-				case <-ctx.Done():
-				}
-			}()
-		}
-
-		next.ServeHTTPC(ctx, w, r)
-	})
-}
-
-// TimeoutHandler returns a Handler which adds a timeout to the context.
-//
-// Child handlers have the responsability to obey the context deadline and to return
-// an appropriate error (or not) response in case of timeout.
-func TimeoutHandler(timeout time.Duration) func(next HandlerC) HandlerC {
-	return func(next HandlerC) HandlerC {
-		return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-			ctx, _ = context.WithTimeout(ctx, timeout)
-			next.ServeHTTPC(ctx, w, r)
-		})
-	}
-}
-
-// If is a special handler that will skip insert the condNext handler only if a condition
-// applies at runtime.
-func If(cond func(ctx context.Context, w http.ResponseWriter, r *http.Request) bool, condNext func(next HandlerC) HandlerC) func(next HandlerC) HandlerC {
-	return func(next HandlerC) HandlerC {
-		return HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-			if cond(ctx, w, r) {
-				condNext(next).ServeHTTPC(ctx, w, r)
-			} else {
-				next.ServeHTTPC(ctx, w, r)
-			}
-		})
-	}
-}

Godeps/_workspace/src/github.com/rs/xhandler/xhandler.go

@@ -1,42 +0,0 @@
-// Package xhandler provides a bridge between http.Handler and net/context.
-//
-// xhandler enforces net/context in your handlers without sacrificing
-// compatibility with existing http.Handlers nor imposing a specific router.
-//
-// Thanks to net/context deadline management, xhandler is able to enforce
-// a per request deadline and will cancel the context in when the client close
-// the connection unexpectedly.
-//
-// You may create net/context aware middlewares pretty much the same way as
-// you would do with http.Handler.
-package xhandler
-
-import (
-	"net/http"
-
-	"golang.org/x/net/context"
-)
-
-// HandlerC is a net/context aware http.Handler
-type HandlerC interface {
-	ServeHTTPC(context.Context, http.ResponseWriter, *http.Request)
-}
-
-// HandlerFuncC type is an adapter to allow the use of ordinary functions
-// as a xhandler.Handler. If f is a function with the appropriate signature,
-// xhandler.HandlerFuncC(f) is a xhandler.Handler object that calls f.
-type HandlerFuncC func(context.Context, http.ResponseWriter, *http.Request)
-
-// ServeHTTPC calls f(ctx, w, r).
-func (f HandlerFuncC) ServeHTTPC(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	f(ctx, w, r)
-}
-
-// New creates a conventional http.Handler injecting the provided root
-// context to sub handlers. This handler is used as a bridge between conventional
-// http.Handler and context aware handlers.
-func New(ctx context.Context, h HandlerC) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		h.ServeHTTPC(ctx, w, r)
-	})
-}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/.travis.yml

@@ -2,18 +2,22 @@ language: go
 sudo: false
 
 go:
-- 1.0.3
 - 1.1.2
 - 1.2.2
 - 1.3.3
-- 1.4.2
+- 1.4
-- 1.5.1
+- 1.5.4
+- 1.6.2
 - tip
 
 matrix:
   allow_failures:
     - go: tip
 
+before_script:
+- go get github.com/meatballhat/gfmxr/...
+
 script:
 - go vet ./...
 - go test -v ./...
+- gfmxr -c $(grep -c 'package main' README.md) -s README.md

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/CHANGELOG.md

@@ -0,0 +1,310 @@
+# Change Log
+
+**ATTN**: This project uses [semantic versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [1.17.0] - 2016-05-09
+### Added
+- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc`
+- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool`
+- Support for hiding commands by setting `Hidden: true` -- this will hide the
+  commands in help output
+
+### Changed
+- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer
+  quoted in help text output.
+- All flag types now include `(default: {value})` strings following usage when a
+  default value can be (reasonably) detected.
+- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent
+  with non-slice flag types
+- Apps now exit with a code of 3 if an unknown subcommand is specified
+  (previously they printed "No help topic for...", but still exited 0. This
+  makes it easier to script around apps built using `cli` since they can trust
+  that a 0 exit code indicated a successful execution.
+- cleanups based on [Go Report Card
+  feedback](https://goreportcard.com/report/github.com/codegangsta/cli)
+
+## [1.16.0] - 2016-05-02
+### Added
+- `Hidden` field on all flag struct types to omit from generated help text
+
+### Changed
+- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from
+generated help text via the `Hidden` field
+
+### Fixed
+- handling of error values in `HandleAction` and `HandleExitCoder`
+
+## [1.15.0] - 2016-04-30
+### Added
+- This file!
+- Support for placeholders in flag usage strings
+- `App.Metadata` map for arbitrary data/state management
+- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after
+parsing.
+- Support for nested lookup of dot-delimited keys in structures loaded from
+YAML.
+
+### Changed
+- The `App.Action` and `Command.Action` now prefer a return signature of
+`func(*cli.Context) error`, as defined by `cli.ActionFunc`.  If a non-nil
+`error` is returned, there may be two outcomes:
+    - If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called
+    automatically
+    - Else the error is bubbled up and returned from `App.Run`
+- Specifying an `Action` with the legacy return signature of
+`func(*cli.Context)` will produce a deprecation message to stderr
+- Specifying an `Action` that is not a `func` type will produce a non-zero exit
+from `App.Run`
+- Specifying an `Action` func that has an invalid (input) signature will
+produce a non-zero exit from `App.Run`
+
+### Deprecated
+- <a name="deprecated-cli-app-runandexitonerror"></a>
+`cli.App.RunAndExitOnError`, which should now be done by returning an error
+that fulfills `cli.ExitCoder` to `cli.App.Run`.
+- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for
+`cli.App.Action` of `func(*cli.Context)`, which should now have a return
+signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`.
+
+### Fixed
+- Added missing `*cli.Context.GlobalFloat64` method
+
+## [1.14.0] - 2016-04-03 (backfilled 2016-04-25)
+### Added
+- Codebeat badge
+- Support for categorization via `CategorizedHelp` and `Categories` on app.
+
+### Changed
+- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`.
+
+### Fixed
+- Ensure version is not shown in help text when `HideVersion` set.
+
+## [1.13.0] - 2016-03-06 (backfilled 2016-04-25)
+### Added
+- YAML file input support.
+- `NArg` method on context.
+
+## [1.12.0] - 2016-02-17 (backfilled 2016-04-25)
+### Added
+- Custom usage error handling.
+- Custom text support in `USAGE` section of help output.
+- Improved help messages for empty strings.
+- AppVeyor CI configuration.
+
+### Changed
+- Removed `panic` from default help printer func.
+- De-duping and optimizations.
+
+### Fixed
+- Correctly handle `Before`/`After` at command level when no subcommands.
+- Case of literal `-` argument causing flag reordering.
+- Environment variable hints on Windows.
+- Docs updates.
+
+## [1.11.1] - 2015-12-21 (backfilled 2016-04-25)
+### Changed
+- Use `path.Base` in `Name` and `HelpName`
+- Export `GetName` on flag types.
+
+### Fixed
+- Flag parsing when skipping is enabled.
+- Test output cleanup.
+- Move completion check to account for empty input case.
+
+## [1.11.0] - 2015-11-15 (backfilled 2016-04-25)
+### Added
+- Destination scan support for flags.
+- Testing against `tip` in Travis CI config.
+
+### Changed
+- Go version in Travis CI config.
+
+### Fixed
+- Removed redundant tests.
+- Use correct example naming in tests.
+
+## [1.10.2] - 2015-10-29 (backfilled 2016-04-25)
+### Fixed
+- Remove unused var in bash completion.
+
+## [1.10.1] - 2015-10-21 (backfilled 2016-04-25)
+### Added
+- Coverage and reference logos in README.
+
+### Fixed
+- Use specified values in help and version parsing.
+- Only display app version and help message once.
+
+## [1.10.0] - 2015-10-06 (backfilled 2016-04-25)
+### Added
+- More tests for existing functionality.
+- `ArgsUsage` at app and command level for help text flexibility.
+
+### Fixed
+- Honor `HideHelp` and `HideVersion` in `App.Run`.
+- Remove juvenile word from README.
+
+## [1.9.0] - 2015-09-08 (backfilled 2016-04-25)
+### Added
+- `FullName` on command with accompanying help output update.
+- Set default `$PROG` in bash completion.
+
+### Changed
+- Docs formatting.
+
+### Fixed
+- Removed self-referential imports in tests.
+
+## [1.8.0] - 2015-06-30 (backfilled 2016-04-25)
+### Added
+- Support for `Copyright` at app level.
+- `Parent` func at context level to walk up context lineage.
+
+### Fixed
+- Global flag processing at top level.
+
+## [1.7.1] - 2015-06-11 (backfilled 2016-04-25)
+### Added
+- Aggregate errors from `Before`/`After` funcs.
+- Doc comments on flag structs.
+- Include non-global flags when checking version and help.
+- Travis CI config updates.
+
+### Fixed
+- Ensure slice type flags have non-nil values.
+- Collect global flags from the full command hierarchy.
+- Docs prose.
+
+## [1.7.0] - 2015-05-03 (backfilled 2016-04-25)
+### Changed
+- `HelpPrinter` signature includes output writer.
+
+### Fixed
+- Specify go 1.1+ in docs.
+- Set `Writer` when running command as app.
+
+## [1.6.0] - 2015-03-23 (backfilled 2016-04-25)
+### Added
+- Multiple author support.
+- `NumFlags` at context level.
+- `Aliases` at command level.
+
+### Deprecated
+- `ShortName` at command level.
+
+### Fixed
+- Subcommand help output.
+- Backward compatible support for deprecated `Author` and `Email` fields.
+- Docs regarding `Names`/`Aliases`.
+
+## [1.5.0] - 2015-02-20 (backfilled 2016-04-25)
+### Added
+- `After` hook func support at app and command level.
+
+### Fixed
+- Use parsed context when running command as subcommand.
+- Docs prose.
+
+## [1.4.1] - 2015-01-09 (backfilled 2016-04-25)
+### Added
+- Support for hiding `-h / --help` flags, but not `help` subcommand.
+- Stop flag parsing after `--`.
+
+### Fixed
+- Help text for generic flags to specify single value.
+- Use double quotes in output for defaults.
+- Use `ParseInt` instead of `ParseUint` for int environment var values.
+- Use `0` as base when parsing int environment var values.
+
+## [1.4.0] - 2014-12-12 (backfilled 2016-04-25)
+### Added
+- Support for environment variable lookup "cascade".
+- Support for `Stdout` on app for output redirection.
+
+### Fixed
+- Print command help instead of app help in `ShowCommandHelp`.
+
+## [1.3.1] - 2014-11-13 (backfilled 2016-04-25)
+### Added
+- Docs and example code updates.
+
+### Changed
+- Default `-v / --version` flag made optional.
+
+## [1.3.0] - 2014-08-10 (backfilled 2016-04-25)
+### Added
+- `FlagNames` at context level.
+- Exposed `VersionPrinter` var for more control over version output.
+- Zsh completion hook.
+- `AUTHOR` section in default app help template.
+- Contribution guidelines.
+- `DurationFlag` type.
+
+## [1.2.0] - 2014-08-02
+### Added
+- Support for environment variable defaults on flags plus tests.
+
+## [1.1.0] - 2014-07-15
+### Added
+- Bash completion.
+- Optional hiding of built-in help command.
+- Optional skipping of flag parsing at command level.
+- `Author`, `Email`, and `Compiled` metadata on app.
+- `Before` hook func support at app and command level.
+- `CommandNotFound` func support at app level.
+- Command reference available on context.
+- `GenericFlag` type.
+- `Float64Flag` type.
+- `BoolTFlag` type.
+- `IsSet` flag helper on context.
+- More flag lookup funcs at context level.
+- More tests &amp; docs.
+
+### Changed
+- Help template updates to account for presence/absence of flags.
+- Separated subcommand help template.
+- Exposed `HelpPrinter` var for more control over help output.
+
+## [1.0.0] - 2013-11-01
+### Added
+- `help` flag in default app flag set and each command flag set.
+- Custom handling of argument parsing errors.
+- Command lookup by name at app level.
+- `StringSliceFlag` type and supporting `StringSlice` type.
+- `IntSliceFlag` type and supporting `IntSlice` type.
+- Slice type flag lookups by name at context level.
+- Export of app and command help functions.
+- More tests &amp; docs.
+
+## 0.1.0 - 2013-07-22
+### Added
+- Initial implementation.
+
+[Unreleased]: https://github.com/codegangsta/cli/compare/v1.17.0...HEAD
+[1.17.0]: https://github.com/codegangsta/cli/compare/v1.16.0...v1.17.0
+[1.16.0]: https://github.com/codegangsta/cli/compare/v1.15.0...v1.16.0
+[1.15.0]: https://github.com/codegangsta/cli/compare/v1.14.0...v1.15.0
+[1.14.0]: https://github.com/codegangsta/cli/compare/v1.13.0...v1.14.0
+[1.13.0]: https://github.com/codegangsta/cli/compare/v1.12.0...v1.13.0
+[1.12.0]: https://github.com/codegangsta/cli/compare/v1.11.1...v1.12.0
+[1.11.1]: https://github.com/codegangsta/cli/compare/v1.11.0...v1.11.1
+[1.11.0]: https://github.com/codegangsta/cli/compare/v1.10.2...v1.11.0
+[1.10.2]: https://github.com/codegangsta/cli/compare/v1.10.1...v1.10.2
+[1.10.1]: https://github.com/codegangsta/cli/compare/v1.10.0...v1.10.1
+[1.10.0]: https://github.com/codegangsta/cli/compare/v1.9.0...v1.10.0
+[1.9.0]: https://github.com/codegangsta/cli/compare/v1.8.0...v1.9.0
+[1.8.0]: https://github.com/codegangsta/cli/compare/v1.7.1...v1.8.0
+[1.7.1]: https://github.com/codegangsta/cli/compare/v1.7.0...v1.7.1
+[1.7.0]: https://github.com/codegangsta/cli/compare/v1.6.0...v1.7.0
+[1.6.0]: https://github.com/codegangsta/cli/compare/v1.5.0...v1.6.0
+[1.5.0]: https://github.com/codegangsta/cli/compare/v1.4.1...v1.5.0
+[1.4.1]: https://github.com/codegangsta/cli/compare/v1.4.0...v1.4.1
+[1.4.0]: https://github.com/codegangsta/cli/compare/v1.3.1...v1.4.0
+[1.3.1]: https://github.com/codegangsta/cli/compare/v1.3.0...v1.3.1
+[1.3.0]: https://github.com/codegangsta/cli/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/codegangsta/cli/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/codegangsta/cli/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/codegangsta/cli/compare/v0.1.0...v1.0.0

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/README.md

@@ -1,22 +1,24 @@
 [![Coverage](http://gocover.io/_badge/github.com/codegangsta/cli?0)](http://gocover.io/github.com/codegangsta/cli)
 [![Build Status](https://travis-ci.org/codegangsta/cli.svg?branch=master)](https://travis-ci.org/codegangsta/cli)
 [![GoDoc](https://godoc.org/github.com/codegangsta/cli?status.svg)](https://godoc.org/github.com/codegangsta/cli)
+[![codebeat](https://codebeat.co/badges/0a8f30aa-f975-404b-b878-5fab3ae1cc5f)](https://codebeat.co/projects/github-com-codegangsta-cli)
+[![Go Report Card](https://goreportcard.com/badge/codegangsta/cli)](https://goreportcard.com/report/codegangsta/cli)
 
-# cli.go
+# cli
 
-`cli.go` is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
+cli is a simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
 
 ## Overview
 
 Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
 
-**This is where `cli.go` comes into play.** `cli.go` makes command line programming fun, organized, and expressive!
+**This is where cli comes into play.** cli makes command line programming fun, organized, and expressive!
 
 ## Installation
 
 Make sure you have a working Go environment (go 1.1+ is *required*). [See the install instructions](http://golang.org/doc/install.html).
 
-To install `cli.go`, simply run:
+To install cli, simply run:
 ```
 $ go get github.com/codegangsta/cli
 ```
@@ -28,7 +30,7 @@ export PATH=$PATH:$GOPATH/bin
 
 ## Getting Started
 
-One of the philosophies behind `cli.go` is that an API should be playful and full of discovery. So a `cli.go` app can be as little as one line of code in `main()`. 
+One of the philosophies behind cli is that an API should be playful and full of discovery. So a cli app can be as little as one line of code in `main()`.
 
 ``` go
 package main
@@ -45,11 +47,16 @@ func main() {
 
 This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
 
+<!-- {
+  "output": "boom! I say!"
+} -->
 ``` go
 package main
 
 import (
+  "fmt"
   "os"
+
   "github.com/codegangsta/cli"
 )
 
@@ -57,10 +64,11 @@ func main() {
   app := cli.NewApp()
   app.Name = "boom"
   app.Usage = "make an explosive entrance"
-  app.Action = func(c *cli.Context) {
+  app.Action = func(c *cli.Context) error {
-    println("boom! I say!")
+    fmt.Println("boom! I say!")
+    return nil
   }
-  
+
   app.Run(os.Args)
 }
 ```
@@ -73,11 +81,16 @@ Being a programmer can be a lonely job. Thankfully by the power of automation th
 
 Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
 
+<!-- {
+  "output": "Hello friend!"
+} -->
 ``` go
 package main
 
 import (
+  "fmt"
   "os"
+
   "github.com/codegangsta/cli"
 )
 
@@ -85,8 +98,9 @@ func main() {
   app := cli.NewApp()
   app.Name = "greet"
   app.Usage = "fight the loneliness!"
-  app.Action = func(c *cli.Context) {
+  app.Action = func(c *cli.Context) error {
-    println("Hello friend!")
+    fmt.Println("Hello friend!")
+    return nil
   }
 
   app.Run(os.Args)
@@ -106,7 +120,7 @@ $ greet
 Hello friend!
 ```
 
-`cli.go` also generates neat help text:
+cli also generates neat help text:
 
 ```
 $ greet help
@@ -132,8 +146,9 @@ You can lookup arguments by calling the `Args` function on `cli.Context`.
 
 ``` go
 ...
-app.Action = func(c *cli.Context) {
+app.Action = func(c *cli.Context) error {
-  println("Hello", c.Args()[0])
+  fmt.Println("Hello", c.Args()[0])
+  return nil
 }
 ...
 ```
@@ -151,16 +166,17 @@ app.Flags = []cli.Flag {
     Usage: "language for the greeting",
   },
 }
-app.Action = func(c *cli.Context) {
+app.Action = func(c *cli.Context) error {
   name := "someone"
-  if len(c.Args()) > 0 {
+  if c.NArg() > 0 {
     name = c.Args()[0]
   }
   if c.String("lang") == "spanish" {
-    println("Hola", name)
+    fmt.Println("Hola", name)
   } else {
-    println("Hello", name)
+    fmt.Println("Hello", name)
   }
+  return nil
 }
 ...
 ```
@@ -178,22 +194,45 @@ app.Flags = []cli.Flag {
     Destination: &language,
   },
 }
-app.Action = func(c *cli.Context) {
+app.Action = func(c *cli.Context) error {
   name := "someone"
-  if len(c.Args()) > 0 {
+  if c.NArg() > 0 {
     name = c.Args()[0]
   }
   if language == "spanish" {
-    println("Hola", name)
+    fmt.Println("Hola", name)
   } else {
-    println("Hello", name)
+    fmt.Println("Hello", name)
   }
+  return nil
 }
 ...
 ```
 
 See full list of flags at http://godoc.org/github.com/codegangsta/cli
 
+#### Placeholder Values
+
+Sometimes it's useful to specify a flag's value within the usage string itself. Such placeholders are
+indicated with back quotes.
+
+For example this:
+
+```go
+cli.StringFlag{
+  Name:  "config, c",
+  Usage: "Load configuration from `FILE`",
+}
+```
+
+Will result in help output like:
+
+```
+--config FILE, -c FILE   Load configuration from FILE
+```
+
+Note that only the first placeholder is used. Subsequent back-quoted words will be left as-is.
+
 #### Alternate Names
 
 You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
@@ -238,6 +277,49 @@ app.Flags = []cli.Flag {
 }
 ```
 
+#### Values from alternate input sources (YAML and others)
+
+There is a separate package altsrc that adds support for getting flag values from other input sources like YAML.
+
+In order to get values for a flag from an alternate input source the following code would be added to wrap an existing cli.Flag like below:
+
+``` go
+  altsrc.NewIntFlag(cli.IntFlag{Name: "test"})
+```
+
+Initialization must also occur for these flags. Below is an example initializing getting data from a yaml file below.
+
+``` go
+  command.Before = altsrc.InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
+```
+
+The code above will use the "load" string as a flag name to get the file name of a yaml file from the cli.Context.
+It will then use that file name to initialize the yaml input source for any flags that are defined on that command.
+As a note the "load" flag used would also have to be defined on the command flags in order for this code snipped to work.
+
+Currently only YAML files are supported but developers can add support for other input sources by implementing the
+altsrc.InputSourceContext for their given sources.
+
+Here is a more complete sample of a command using YAML support:
+
+``` go
+  command := &cli.Command{
+    Name:        "test-cmd",
+    Aliases:     []string{"tc"},
+    Usage:       "this is for testing",
+    Description: "testing",
+    Action: func(c *cli.Context) error {
+      // Action to run
+      return nil
+    },
+    Flags: []cli.Flag{
+      NewIntFlag(cli.IntFlag{Name: "test"}),
+      cli.StringFlag{Name: "load"}},
+  }
+  command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
+  err := command.Run(c)
+```
+
 ### Subcommands
 
 Subcommands can be defined for a more git-like command line app.
@@ -249,16 +331,18 @@ app.Commands = []cli.Command{
     Name:      "add",
     Aliases:     []string{"a"},
     Usage:     "add a task to the list",
-    Action: func(c *cli.Context) {
+    Action: func(c *cli.Context) error {
-      println("added task: ", c.Args().First())
+      fmt.Println("added task: ", c.Args().First())
+      return nil
     },
   },
   {
     Name:      "complete",
     Aliases:     []string{"c"},
     Usage:     "complete a task on the list",
-    Action: func(c *cli.Context) {
+    Action: func(c *cli.Context) error {
-      println("completed task: ", c.Args().First())
+      fmt.Println("completed task: ", c.Args().First())
+      return nil
     },
   },
   {
@@ -269,15 +353,17 @@ app.Commands = []cli.Command{
       {
         Name:  "add",
         Usage: "add a new template",
-        Action: func(c *cli.Context) {
+        Action: func(c *cli.Context) error {
-            println("new task template: ", c.Args().First())
+          fmt.Println("new task template: ", c.Args().First())
+          return nil
         },
       },
       {
         Name:  "remove",
         Usage: "remove an existing template",
-        Action: func(c *cli.Context) {
+        Action: func(c *cli.Context) error {
-          println("removed task template: ", c.Args().First())
+          fmt.Println("removed task template: ", c.Args().First())
+          return nil
         },
       },
     },
@@ -286,6 +372,80 @@ app.Commands = []cli.Command{
 ...
 ```
 
+### Subcommands categories
+
+For additional organization in apps that have many subcommands, you can
+associate a category for each command to group them together in the help
+output.
+
+E.g.
+
+```go
+...
+  app.Commands = []cli.Command{
+    {
+      Name: "noop",
+    },
+    {
+      Name:     "add",
+      Category: "template",
+    },
+    {
+      Name:     "remove",
+      Category: "template",
+    },
+  }
+...
+```
+
+Will include:
+
+```
+...
+COMMANDS:
+    noop
+
+  Template actions:
+    add
+    remove
+...
+```
+
+### Exit code
+
+Calling `App.Run` will not automatically call `os.Exit`, which means that by
+default the exit code will "fall through" to being `0`.  An explicit exit code
+may be set by returning a non-nil error that fulfills `cli.ExitCoder`, *or* a
+`cli.MultiError` that includes an error that fulfills `cli.ExitCoder`, e.g.:
+
+``` go
+package main
+
+import (
+  "os"
+
+  "github.com/codegangsta/cli"
+)
+
+func main() {
+  app := cli.NewApp()
+  app.Flags = []cli.Flag{
+    cli.BoolTFlag{
+      Name:  "ginger-crouton",
+      Usage: "is it in the soup?",
+    },
+  }
+  app.Action = func(ctx *cli.Context) error {
+    if !ctx.Bool("ginger-crouton") {
+      return cli.NewExitError("it is not in the soup", 86)
+    }
+    return nil
+  }
+
+  app.Run(os.Args)
+}
+```
+
 ### Bash Completion
 
 You can enable completion commands by setting the `EnableBashCompletion`
@@ -303,12 +463,13 @@ app.Commands = []cli.Command{
     Name:  "complete",
     Aliases: []string{"c"},
     Usage: "complete a task on the list",
-    Action: func(c *cli.Context) {
+    Action: func(c *cli.Context) error {
-       println("completed task: ", c.Args().First())
+       fmt.Println("completed task: ", c.Args().First())
+       return nil
     },
     BashComplete: func(c *cli.Context) {
       // This will complete if no args are passed
-      if len(c.Args()) > 0 {
+      if c.NArg() > 0 {
         return
       }
       for _, t := range tasks {
@@ -343,6 +504,72 @@ Alternatively, you can just document that users should source the generic
 `autocomplete/bash_autocomplete` in their bash configuration with `$PROG` set
 to the name of their program (as above).
 
+### Generated Help Text Customization
+
+All of the help text generation may be customized, and at multiple levels.  The
+templates are exposed as variables `AppHelpTemplate`, `CommandHelpTemplate`, and
+`SubcommandHelpTemplate` which may be reassigned or augmented, and full override
+is possible by assigning a compatible func to the `cli.HelpPrinter` variable,
+e.g.:
+
+<!-- {
+  "output": "Ha HA.  I pwnd the help!!1"
+} -->
+``` go
+package main
+
+import (
+  "fmt"
+  "io"
+  "os"
+
+  "github.com/codegangsta/cli"
+)
+
+func main() {
+  // EXAMPLE: Append to an existing template
+  cli.AppHelpTemplate = fmt.Sprintf(`%s
+
+WEBSITE: http://awesometown.example.com
+
+SUPPORT: support@awesometown.example.com
+
+`, cli.AppHelpTemplate)
+
+  // EXAMPLE: Override a template
+  cli.AppHelpTemplate = `NAME:
+   {{.Name}} - {{.Usage}}
+USAGE:
+   {{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command
+[command options]{{end}} {{if
+.ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
+   {{if len .Authors}}
+AUTHOR(S):
+   {{range .Authors}}{{ . }}{{end}}
+   {{end}}{{if .Commands}}
+COMMANDS:
+{{range .Commands}}{{if not .HideHelp}}   {{join .Names ", "}}{{ "\t"
+}}{{.Usage}}{{ "\n" }}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+GLOBAL OPTIONS:
+   {{range .VisibleFlags}}{{.}}
+   {{end}}{{end}}{{if .Copyright }}
+COPYRIGHT:
+   {{.Copyright}}
+   {{end}}{{if .Version}}
+VERSION:
+   {{.Version}}
+   {{end}}
+`
+
+  // EXAMPLE: Replace the `HelpPrinter` func
+  cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) {
+    fmt.Println("Ha HA.  I pwnd the help!!1")
+  }
+
+  cli.NewApp().Run(os.Args)
+}
+```
+
 ## Contribution Guidelines
 
 Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/app.go

@@ -5,10 +5,27 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
 	"time"
 )
 
+var (
+	changeLogURL                    = "https://github.com/codegangsta/cli/blob/master/CHANGELOG.md"
+	appActionDeprecationURL         = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
+	runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL)
+
+	contactSysadmin = "This is an error in the application.  Please contact the distributor of this application if this is not you."
+
+	errNonFuncAction = NewExitError("ERROR invalid Action type.  "+
+		fmt.Sprintf("Must be a func of type `cli.ActionFunc`.  %s", contactSysadmin)+
+		fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+	errInvalidActionSignature = NewExitError("ERROR invalid Action signature.  "+
+		fmt.Sprintf("Must be `cli.ActionFunc`.  %s", contactSysadmin)+
+		fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+)
+
 // App is the main structure of a cli application. It is recommended that
 // an app be created with the cli.NewApp() function
 type App struct {
@@ -32,24 +49,27 @@ type App struct {
 	EnableBashCompletion bool
 	// Boolean to hide built-in help command
 	HideHelp bool
-	// Boolean to hide built-in version flag
+	// Boolean to hide built-in version flag and the VERSION section of help
 	HideVersion bool
+	// Populate on app startup, only gettable through method Categories()
+	categories CommandCategories
 	// An action to execute when the bash-completion flag is set
-	BashComplete func(context *Context)
+	BashComplete BashCompleteFunc
 	// An action to execute before any subcommands are run, but after the context is ready
 	// If a non-nil error is returned, no subcommands are run
-	Before func(context *Context) error
+	Before BeforeFunc
 	// An action to execute after any subcommands are run, but after the subcommand has finished
 	// It is run even if Action() panics
-	After func(context *Context) error
+	After AfterFunc
 	// The action to execute when no subcommands are specified
-	Action func(context *Context)
+	Action interface{}
+	// TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
+	// of deprecation period has passed, maybe?
+
 	// Execute this function if the proper command cannot be found
-	CommandNotFound func(context *Context, command string)
+	CommandNotFound CommandNotFoundFunc
-	// Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
+	// Execute this function if an usage error occurs
-	// This function is able to replace the original error messages.
+	OnUsageError OnUsageErrorFunc
-	// If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
-	OnUsageError func(context *Context, err error, isSubcommand bool) error
 	// Compilation date
 	Compiled time.Time
 	// List of all authors who contributed
@@ -62,6 +82,12 @@ type App struct {
 	Email string
 	// Writer writer to write output to
 	Writer io.Writer
+	// ErrWriter writes error output
+	ErrWriter io.Writer
+	// Other custom info
+	Metadata map[string]interface{}
+
+	didSetup bool
 }
 
 // Tries to find out when this binary was compiled.
@@ -74,11 +100,12 @@ func compileTime() time.Time {
 	return info.ModTime()
 }
 
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
+// NewApp creates a new cli Application with some reasonable defaults for Name,
+// Usage, Version and Action.
 func NewApp() *App {
 	return &App{
-		Name:         path.Base(os.Args[0]),
+		Name:         filepath.Base(os.Args[0]),
-		HelpName:     path.Base(os.Args[0]),
+		HelpName:     filepath.Base(os.Args[0]),
 		Usage:        "A new cli application",
 		UsageText:    "",
 		Version:      "0.0.0",
@@ -89,8 +116,16 @@ func NewApp() *App {
 	}
 }
 
-// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
+// Setup runs initialization code to ensure all data structures are ready for
-func (a *App) Run(arguments []string) (err error) {
+// `Run` or inspection prior to `Run`.  It is internally called by `Run`, but
+// will return early if setup has already happened.
+func (a *App) Setup() {
+	if a.didSetup {
+		return
+	}
+
+	a.didSetup = true
+
 	if a.Author != "" || a.Email != "" {
 		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
 	}
@@ -104,6 +139,12 @@ func (a *App) Run(arguments []string) (err error) {
 	}
 	a.Commands = newCmds
 
+	a.categories = CommandCategories{}
+	for _, command := range a.Commands {
+		a.categories = a.categories.AddCommand(command.Category, command)
+	}
+	sort.Sort(a.categories)
+
 	// append help to commands
 	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
 		a.Commands = append(a.Commands, helpCommand)
@@ -120,6 +161,12 @@ func (a *App) Run(arguments []string) (err error) {
 	if !a.HideVersion {
 		a.appendFlag(VersionFlag)
 	}
+}
+
+// Run is the entry point to the cli app. Parses the arguments slice and routes
+// to the proper flag/args combination
+func (a *App) Run(arguments []string) (err error) {
+	a.Setup()
 
 	// parse flags
 	set := flagSet(a.Name, a.Flags)
@@ -140,12 +187,12 @@ func (a *App) Run(arguments []string) (err error) {
 	if err != nil {
 		if a.OnUsageError != nil {
 			err := a.OnUsageError(context, err, false)
-			return err
+			HandleExitCoder(err)
-		} else {
-			fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
-			ShowAppHelp(context)
 			return err
 		}
+		fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
+		ShowAppHelp(context)
+		return err
 	}
 
 	if !a.HideHelp && checkHelp(context) {
@@ -171,10 +218,12 @@ func (a *App) Run(arguments []string) (err error) {
 	}
 
 	if a.Before != nil {
-		err = a.Before(context)
+		beforeErr := a.Before(context)
-		if err != nil {
+		if beforeErr != nil {
-			fmt.Fprintf(a.Writer, "%v\n\n", err)
+			fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
 			ShowAppHelp(context)
+			HandleExitCoder(beforeErr)
+			err = beforeErr
 			return err
 		}
 	}
@@ -189,19 +238,25 @@ func (a *App) Run(arguments []string) (err error) {
 	}
 
 	// Run default Action
-	a.Action(context)
+	err = HandleAction(a.Action, context)
-	return nil
+
+	HandleExitCoder(err)
+	return err
 }
 
-// Another entry point to the cli app, takes care of passing arguments and error handling
+// DEPRECATED: Another entry point to the cli app, takes care of passing arguments and error handling
 func (a *App) RunAndExitOnError() {
+	fmt.Fprintf(a.errWriter(),
+		"DEPRECATED cli.App.RunAndExitOnError.  %s  See %s\n",
+		contactSysadmin, runAndExitOnErrorDeprecationURL)
 	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(a.errWriter(), err)
-		os.Exit(1)
+		OsExiter(1)
 	}
 }
 
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
+// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
+// generate command-specific flags
 func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	// append help to commands
 	if len(a.Commands) > 0 {
@@ -252,12 +307,12 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	if err != nil {
 		if a.OnUsageError != nil {
 			err = a.OnUsageError(context, err, true)
-			return err
+			HandleExitCoder(err)
-		} else {
-			fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
-			ShowSubcommandHelp(context)
 			return err
 		}
+		fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
+		ShowSubcommandHelp(context)
+		return err
 	}
 
 	if len(a.Commands) > 0 {
@@ -274,6 +329,7 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 		defer func() {
 			afterErr := a.After(context)
 			if afterErr != nil {
+				HandleExitCoder(err)
 				if err != nil {
 					err = NewMultiError(err, afterErr)
 				} else {
@@ -284,8 +340,10 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	if a.Before != nil {
-		err := a.Before(context)
+		beforeErr := a.Before(context)
-		if err != nil {
+		if beforeErr != nil {
+			HandleExitCoder(beforeErr)
+			err = beforeErr
 			return err
 		}
 	}
@@ -300,12 +358,13 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	// Run default Action
-	a.Action(context)
+	err = HandleAction(a.Action, context)
 
-	return nil
+	HandleExitCoder(err)
+	return err
 }
 
-// Returns the named command on App. Returns nil if the command does not exist
+// Command returns the named command on App. Returns nil if the command does not exist
 func (a *App) Command(name string) *Command {
 	for _, c := range a.Commands {
 		if c.HasName(name) {
@@ -316,6 +375,46 @@ func (a *App) Command(name string) *Command {
 	return nil
 }
 
+// Categories returns a slice containing all the categories with the commands they contain
+func (a *App) Categories() CommandCategories {
+	return a.categories
+}
+
+// VisibleCategories returns a slice of categories and commands that are
+// Hidden=false
+func (a *App) VisibleCategories() []*CommandCategory {
+	ret := []*CommandCategory{}
+	for _, category := range a.categories {
+		if visible := func() *CommandCategory {
+			for _, command := range category.Commands {
+				if !command.Hidden {
+					return category
+				}
+			}
+			return nil
+		}(); visible != nil {
+			ret = append(ret, visible)
+		}
+	}
+	return ret
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (a *App) VisibleCommands() []Command {
+	ret := []Command{}
+	for _, command := range a.Commands {
+		if !command.Hidden {
+			ret = append(ret, command)
+		}
+	}
+	return ret
+}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (a *App) VisibleFlags() []Flag {
+	return visibleFlags(a.Flags)
+}
+
 func (a *App) hasFlag(flag Flag) bool {
 	for _, f := range a.Flags {
 		if flag == f {
@@ -326,6 +425,16 @@ func (a *App) hasFlag(flag Flag) bool {
 	return false
 }
 
+func (a *App) errWriter() io.Writer {
+
+	// When the app ErrWriter is nil use the package level one.
+	if a.ErrWriter == nil {
+		return ErrWriter
+	}
+
+	return a.ErrWriter
+}
+
 func (a *App) appendFlag(flag Flag) {
 	if !a.hasFlag(flag) {
 		a.Flags = append(a.Flags, flag)
@@ -347,3 +456,43 @@ func (a Author) String() string {
 
 	return fmt.Sprintf("%v %v", a.Name, e)
 }
+
+// HandleAction uses ✧✧✧reflection✧✧✧ to figure out if the given Action is an
+// ActionFunc, a func with the legacy signature for Action, or some other
+// invalid thing.  If it's an ActionFunc or a func with the legacy signature for
+// Action, the func is run!
+func HandleAction(action interface{}, context *Context) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch r.(type) {
+			case error:
+				err = r.(error)
+			default:
+				err = NewExitError(fmt.Sprintf("ERROR unknown Action error: %v. See %s", r, appActionDeprecationURL), 2)
+			}
+		}
+	}()
+
+	if reflect.TypeOf(action).Kind() != reflect.Func {
+		return errNonFuncAction
+	}
+
+	vals := reflect.ValueOf(action).Call([]reflect.Value{reflect.ValueOf(context)})
+
+	if len(vals) == 0 {
+		fmt.Fprintf(ErrWriter,
+			"DEPRECATED Action signature.  Must be `cli.ActionFunc`.  %s  See %s\n",
+			contactSysadmin, appActionDeprecationURL)
+		return nil
+	}
+
+	if len(vals) > 1 {
+		return errInvalidActionSignature
+	}
+
+	if retErr, ok := vals[0].Interface().(error); vals[0].IsValid() && ok {
+		return retErr
+	}
+
+	return err
+}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/category.go

@@ -0,0 +1,44 @@
+package cli
+
+// CommandCategories is a slice of *CommandCategory.
+type CommandCategories []*CommandCategory
+
+// CommandCategory is a category containing commands.
+type CommandCategory struct {
+	Name     string
+	Commands Commands
+}
+
+func (c CommandCategories) Less(i, j int) bool {
+	return c[i].Name < c[j].Name
+}
+
+func (c CommandCategories) Len() int {
+	return len(c)
+}
+
+func (c CommandCategories) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}
+
+// AddCommand adds a command to a category.
+func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
+	for _, commandCategory := range c {
+		if commandCategory.Name == category {
+			commandCategory.Commands = append(commandCategory.Commands, command)
+			return c
+		}
+	}
+	return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (c *CommandCategory) VisibleCommands() []Command {
+	ret := []Command{}
+	for _, command := range c.Commands {
+		if !command.Hidden {
+			ret = append(ret, command)
+		}
+	}
+	return ret
+}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/cli.go

@@ -10,31 +10,10 @@
 //     app := cli.NewApp()
 //     app.Name = "greet"
 //     app.Usage = "say a greeting"
-//     app.Action = func(c *cli.Context) {
+//     app.Action = func(c *cli.Context) error {
 //       println("Greetings")
 //     }
 //
 //     app.Run(os.Args)
 //   }
 package cli
-
-import (
-	"strings"
-)
-
-type MultiError struct {
-	Errors []error
-}
-
-func NewMultiError(err ...error) MultiError {
-	return MultiError{Errors: err}
-}
-
-func (m MultiError) Error() string {
-	errs := make([]string, len(m.Errors))
-	for i, err := range m.Errors {
-		errs[i] = err.Error()
-	}
-
-	return strings.Join(errs, "\n")
-}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/command.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"fmt"
 	"io/ioutil"
+	"sort"
 	"strings"
 )
 
@@ -22,35 +23,40 @@ type Command struct {
 	Description string
 	// A short description of the arguments of this command
 	ArgsUsage string
+	// The category the command is part of
+	Category string
 	// The function to call when checking for bash command completions
-	BashComplete func(context *Context)
+	BashComplete BashCompleteFunc
 	// An action to execute before any sub-subcommands are run, but after the context is ready
 	// If a non-nil error is returned, no sub-subcommands are run
-	Before func(context *Context) error
+	Before BeforeFunc
 	// An action to execute after any subcommands are run, but after the subcommand has finished
 	// It is run even if Action() panics
-	After func(context *Context) error
+	After AfterFunc
 	// The function to call when this command is invoked
-	Action func(context *Context)
+	Action interface{}
-	// Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
+	// TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
-	// This function is able to replace the original error messages.
+	// of deprecation period has passed, maybe?
-	// If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
+
-	OnUsageError func(context *Context, err error) error
+	// Execute this function if a usage error occurs.
+	OnUsageError OnUsageErrorFunc
 	// List of child commands
-	Subcommands []Command
+	Subcommands Commands
 	// List of flags to parse
 	Flags []Flag
 	// Treat all flags as normal arguments if true
 	SkipFlagParsing bool
 	// Boolean to hide built-in help command
 	HideHelp bool
+	// Boolean to hide this command from help or completion
+	Hidden bool
 
 	// Full name of command for help, defaults to full command name, including parent commands.
 	HelpName        string
 	commandNamePath []string
 }
 
-// Returns the full name of the command.
+// FullName returns the full name of the command.
 // For subcommands this ensures that parent commands are part of the command path
 func (c Command) FullName() string {
 	if c.commandNamePath == nil {
@@ -59,7 +65,10 @@ func (c Command) FullName() string {
 	return strings.Join(c.commandNamePath, " ")
 }
 
-// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
+// Commands is a slice of Command
+type Commands []Command
+
+// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
 func (c Command) Run(ctx *Context) (err error) {
 	if len(c.Subcommands) > 0 {
 		return c.startApp(ctx)
@@ -120,14 +129,14 @@ func (c Command) Run(ctx *Context) (err error) {
 
 	if err != nil {
 		if c.OnUsageError != nil {
-			err := c.OnUsageError(ctx, err)
+			err := c.OnUsageError(ctx, err, false)
-			return err
+			HandleExitCoder(err)
-		} else {
-			fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
-			fmt.Fprintln(ctx.App.Writer)
-			ShowCommandHelp(ctx, c.Name)
 			return err
 		}
+		fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
+		fmt.Fprintln(ctx.App.Writer)
+		ShowCommandHelp(ctx, c.Name)
+		return err
 	}
 
 	nerr := normalizeFlags(c.Flags, set)
@@ -137,6 +146,7 @@ func (c Command) Run(ctx *Context) (err error) {
 		ShowCommandHelp(ctx, c.Name)
 		return nerr
 	}
+
 	context := NewContext(ctx.App, set, ctx)
 
 	if checkCommandCompletions(context, c.Name) {
@@ -151,6 +161,7 @@ func (c Command) Run(ctx *Context) (err error) {
 		defer func() {
 			afterErr := c.After(context)
 			if afterErr != nil {
+				HandleExitCoder(err)
 				if err != nil {
 					err = NewMultiError(err, afterErr)
 				} else {
@@ -161,20 +172,26 @@ func (c Command) Run(ctx *Context) (err error) {
 	}
 
 	if c.Before != nil {
-		err := c.Before(context)
+		err = c.Before(context)
 		if err != nil {
 			fmt.Fprintln(ctx.App.Writer, err)
 			fmt.Fprintln(ctx.App.Writer)
 			ShowCommandHelp(ctx, c.Name)
+			HandleExitCoder(err)
 			return err
 		}
 	}
 
 	context.Command = c
-	c.Action(context)
+	err = HandleAction(c.Action, context)
-	return nil
+
+	if err != nil {
+		HandleExitCoder(err)
+	}
+	return err
 }
 
+// Names returns the names including short names and aliases.
 func (c Command) Names() []string {
 	names := []string{c.Name}
 
@@ -185,7 +202,7 @@ func (c Command) Names() []string {
 	return append(names, c.Aliases...)
 }
 
-// Returns true if Command.Name or Command.ShortName matches given name
+// HasName returns true if Command.Name or Command.ShortName matches given name
 func (c Command) HasName(name string) bool {
 	for _, n := range c.Names() {
 		if n == name {
@@ -197,7 +214,7 @@ func (c Command) HasName(name string) bool {
 
 func (c Command) startApp(ctx *Context) error {
 	app := NewApp()
-
+	app.Metadata = ctx.App.Metadata
 	// set the name and usage
 	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
 	if c.HelpName == "" {
@@ -227,6 +244,13 @@ func (c Command) startApp(ctx *Context) error {
 	app.Email = ctx.App.Email
 	app.Writer = ctx.App.Writer
 
+	app.categories = CommandCategories{}
+	for _, command := range c.Subcommands {
+		app.categories = app.categories.AddCommand(command.Category, command)
+	}
+
+	sort.Sort(app.categories)
+
 	// bash completion
 	app.EnableBashCompletion = ctx.App.EnableBashCompletion
 	if c.BashComplete != nil {
@@ -248,3 +272,8 @@ func (c Command) startApp(ctx *Context) error {
 
 	return app.RunAsSubcommand(ctx)
 }
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (c Command) VisibleFlags() []Flag {
+	return visibleFlags(c.Flags)
+}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/context.go

@@ -21,57 +21,62 @@ type Context struct {
 	parentContext  *Context
 }
 
-// Creates a new context. For use in when invoking an App or Command action.
+// NewContext creates a new context. For use in when invoking an App or Command action.
 func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
 	return &Context{App: app, flagSet: set, parentContext: parentCtx}
 }
 
-// Looks up the value of a local int flag, returns 0 if no int flag exists
+// Int looks up the value of a local int flag, returns 0 if no int flag exists
 func (c *Context) Int(name string) int {
 	return lookupInt(name, c.flagSet)
 }
 
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
+// Duration looks up the value of a local time.Duration flag, returns 0 if no
+// time.Duration flag exists
 func (c *Context) Duration(name string) time.Duration {
 	return lookupDuration(name, c.flagSet)
 }
 
-// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
+// Float64 looks up the value of a local float64 flag, returns 0 if no float64
+// flag exists
 func (c *Context) Float64(name string) float64 {
 	return lookupFloat64(name, c.flagSet)
 }
 
-// Looks up the value of a local bool flag, returns false if no bool flag exists
+// Bool looks up the value of a local bool flag, returns false if no bool flag exists
 func (c *Context) Bool(name string) bool {
 	return lookupBool(name, c.flagSet)
 }
 
-// Looks up the value of a local boolT flag, returns false if no bool flag exists
+// BoolT looks up the value of a local boolT flag, returns false if no bool flag exists
 func (c *Context) BoolT(name string) bool {
 	return lookupBoolT(name, c.flagSet)
 }
 
-// Looks up the value of a local string flag, returns "" if no string flag exists
+// String looks up the value of a local string flag, returns "" if no string flag exists
 func (c *Context) String(name string) string {
 	return lookupString(name, c.flagSet)
 }
 
-// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
+// StringSlice looks up the value of a local string slice flag, returns nil if no
+// string slice flag exists
 func (c *Context) StringSlice(name string) []string {
 	return lookupStringSlice(name, c.flagSet)
 }
 
-// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
+// IntSlice looks up the value of a local int slice flag, returns nil if no int
+// slice flag exists
 func (c *Context) IntSlice(name string) []int {
 	return lookupIntSlice(name, c.flagSet)
 }
 
-// Looks up the value of a local generic flag, returns nil if no generic flag exists
+// Generic looks up the value of a local generic flag, returns nil if no generic
+// flag exists
 func (c *Context) Generic(name string) interface{} {
 	return lookupGeneric(name, c.flagSet)
 }
 
-// Looks up the value of a global int flag, returns 0 if no int flag exists
+// GlobalInt looks up the value of a global int flag, returns 0 if no int flag exists
 func (c *Context) GlobalInt(name string) int {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupInt(name, fs)
@@ -79,7 +84,17 @@ func (c *Context) GlobalInt(name string) int {
 	return 0
 }
 
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
+// GlobalFloat64 looks up the value of a global float64 flag, returns float64(0)
+// if no float64 flag exists
+func (c *Context) GlobalFloat64(name string) float64 {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupFloat64(name, fs)
+	}
+	return float64(0)
+}
+
+// GlobalDuration looks up the value of a global time.Duration flag, returns 0
+// if no time.Duration flag exists
 func (c *Context) GlobalDuration(name string) time.Duration {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupDuration(name, fs)
@@ -87,7 +102,8 @@ func (c *Context) GlobalDuration(name string) time.Duration {
 	return 0
 }
 
-// Looks up the value of a global bool flag, returns false if no bool flag exists
+// GlobalBool looks up the value of a global bool flag, returns false if no bool
+// flag exists
 func (c *Context) GlobalBool(name string) bool {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupBool(name, fs)
@@ -95,7 +111,17 @@ func (c *Context) GlobalBool(name string) bool {
 	return false
 }
 
-// Looks up the value of a global string flag, returns "" if no string flag exists
+// GlobalBoolT looks up the value of a global bool flag, returns true if no bool
+// flag exists
+func (c *Context) GlobalBoolT(name string) bool {
+	if fs := lookupGlobalFlagSet(name, c); fs != nil {
+		return lookupBoolT(name, fs)
+	}
+	return false
+}
+
+// GlobalString looks up the value of a global string flag, returns "" if no
+// string flag exists
 func (c *Context) GlobalString(name string) string {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupString(name, fs)
@@ -103,7 +129,8 @@ func (c *Context) GlobalString(name string) string {
 	return ""
 }
 
-// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
+// GlobalStringSlice looks up the value of a global string slice flag, returns
+// nil if no string slice flag exists
 func (c *Context) GlobalStringSlice(name string) []string {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupStringSlice(name, fs)
@@ -111,7 +138,8 @@ func (c *Context) GlobalStringSlice(name string) []string {
 	return nil
 }
 
-// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
+// GlobalIntSlice looks up the value of a global int slice flag, returns nil if
+// no int slice flag exists
 func (c *Context) GlobalIntSlice(name string) []int {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupIntSlice(name, fs)
@@ -119,7 +147,8 @@ func (c *Context) GlobalIntSlice(name string) []int {
 	return nil
 }
 
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
+// GlobalGeneric looks up the value of a global generic flag, returns nil if no
+// generic flag exists
 func (c *Context) GlobalGeneric(name string) interface{} {
 	if fs := lookupGlobalFlagSet(name, c); fs != nil {
 		return lookupGeneric(name, fs)
@@ -127,12 +156,22 @@ func (c *Context) GlobalGeneric(name string) interface{} {
 	return nil
 }
 
-// Returns the number of flags set
+// NumFlags returns the number of flags set
 func (c *Context) NumFlags() int {
 	return c.flagSet.NFlag()
 }
 
-// Determines if the flag was actually set
+// Set sets a context flag to a value.
+func (c *Context) Set(name, value string) error {
+	return c.flagSet.Set(name, value)
+}
+
+// GlobalSet sets a context flag to a value on the global flagset
+func (c *Context) GlobalSet(name, value string) error {
+	return globalContext(c).flagSet.Set(name, value)
+}
+
+// IsSet determines if the flag was actually set
 func (c *Context) IsSet(name string) bool {
 	if c.setFlags == nil {
 		c.setFlags = make(map[string]bool)
@@ -143,7 +182,7 @@ func (c *Context) IsSet(name string) bool {
 	return c.setFlags[name] == true
 }
 
-// Determines if the global flag was actually set
+// GlobalIsSet determines if the global flag was actually set
 func (c *Context) GlobalIsSet(name string) bool {
 	if c.globalSetFlags == nil {
 		c.globalSetFlags = make(map[string]bool)
@@ -160,7 +199,7 @@ func (c *Context) GlobalIsSet(name string) bool {
 	return c.globalSetFlags[name]
 }
 
-// Returns a slice of flag names used in this context.
+// FlagNames returns a slice of flag names used in this context.
 func (c *Context) FlagNames() (names []string) {
 	for _, flag := range c.Command.Flags {
 		name := strings.Split(flag.GetName(), ",")[0]
@@ -172,7 +211,7 @@ func (c *Context) FlagNames() (names []string) {
 	return
 }
 
-// Returns a slice of global flag names used by the app.
+// GlobalFlagNames returns a slice of global flag names used by the app.
 func (c *Context) GlobalFlagNames() (names []string) {
 	for _, flag := range c.App.Flags {
 		name := strings.Split(flag.GetName(), ",")[0]
@@ -184,20 +223,26 @@ func (c *Context) GlobalFlagNames() (names []string) {
 	return
 }
 
-// Returns the parent context, if any
+// Parent returns the parent context, if any
 func (c *Context) Parent() *Context {
 	return c.parentContext
 }
 
+// Args contains apps console arguments
 type Args []string
 
-// Returns the command line arguments associated with the context.
+// Args returns the command line arguments associated with the context.
 func (c *Context) Args() Args {
 	args := Args(c.flagSet.Args())
 	return args
 }
 
-// Returns the nth argument, or else a blank string
+// NArg returns the number of the command line arguments.
+func (c *Context) NArg() int {
+	return len(c.Args())
+}
+
+// Get returns the nth argument, or else a blank string
 func (a Args) Get(n int) string {
 	if len(a) > n {
 		return a[n]
@@ -205,12 +250,12 @@ func (a Args) Get(n int) string {
 	return ""
 }
 
-// Returns the first argument, or else a blank string
+// First returns the first argument, or else a blank string
 func (a Args) First() string {
 	return a.Get(0)
 }
 
-// Return the rest of the arguments (not the first one)
+// Tail returns the rest of the arguments (not the first one)
 // or else an empty string slice
 func (a Args) Tail() []string {
 	if len(a) >= 2 {
@@ -219,12 +264,12 @@ func (a Args) Tail() []string {
 	return []string{}
 }
 
-// Checks if there are any arguments present
+// Present checks if there are any arguments present
 func (a Args) Present() bool {
 	return len(a) != 0
 }
 
-// Swaps arguments at the given indexes
+// Swap swaps arguments at the given indexes
 func (a Args) Swap(from, to int) error {
 	if from >= len(a) || to >= len(a) {
 		return errors.New("index out of range")
@@ -233,6 +278,19 @@ func (a Args) Swap(from, to int) error {
 	return nil
 }
 
+func globalContext(ctx *Context) *Context {
+	if ctx == nil {
+		return nil
+	}
+
+	for {
+		if ctx.parentContext == nil {
+			return ctx
+		}
+		ctx = ctx.parentContext
+	}
+}
+
 func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
 	if ctx.parentContext != nil {
 		ctx = ctx.parentContext

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/errors.go

@@ -0,0 +1,92 @@
+package cli
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
+var OsExiter = os.Exit
+
+// ErrWriter is used to write errors to the user. This can be anything
+// implementing the io.Writer interface and defaults to os.Stderr.
+var ErrWriter io.Writer = os.Stderr
+
+// MultiError is an error that wraps multiple errors.
+type MultiError struct {
+	Errors []error
+}
+
+// NewMultiError creates a new MultiError. Pass in one or more errors.
+func NewMultiError(err ...error) MultiError {
+	return MultiError{Errors: err}
+}
+
+// Error implents the error interface.
+func (m MultiError) Error() string {
+	errs := make([]string, len(m.Errors))
+	for i, err := range m.Errors {
+		errs[i] = err.Error()
+	}
+
+	return strings.Join(errs, "\n")
+}
+
+// ExitCoder is the interface checked by `App` and `Command` for a custom exit
+// code
+type ExitCoder interface {
+	error
+	ExitCode() int
+}
+
+// ExitError fulfills both the builtin `error` interface and `ExitCoder`
+type ExitError struct {
+	exitCode int
+	message  string
+}
+
+// NewExitError makes a new *ExitError
+func NewExitError(message string, exitCode int) *ExitError {
+	return &ExitError{
+		exitCode: exitCode,
+		message:  message,
+	}
+}
+
+// Error returns the string message, fulfilling the interface required by
+// `error`
+func (ee *ExitError) Error() string {
+	return ee.message
+}
+
+// ExitCode returns the exit code, fulfilling the interface required by
+// `ExitCoder`
+func (ee *ExitError) ExitCode() int {
+	return ee.exitCode
+}
+
+// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
+// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
+// given exit code.  If the given error is a MultiError, then this func is
+// called on all members of the Errors slice.
+func HandleExitCoder(err error) {
+	if err == nil {
+		return
+	}
+
+	if exitErr, ok := err.(ExitCoder); ok {
+		if err.Error() != "" {
+			fmt.Fprintln(ErrWriter, err)
+		}
+		OsExiter(exitErr.ExitCode())
+		return
+	}
+
+	if multiErr, ok := err.(MultiError); ok {
+		for _, merr := range multiErr.Errors {
+			HandleExitCoder(merr)
+		}
+	}
+}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/flag.go

@@ -4,24 +4,28 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
 	"time"
 )
 
-// This flag enables bash-completion for all commands and subcommands
+const defaultPlaceholder = "value"
+
+// BashCompletionFlag enables bash-completion for all commands and subcommands
 var BashCompletionFlag = BoolFlag{
-	Name: "generate-bash-completion",
+	Name:   "generate-bash-completion",
+	Hidden: true,
 }
 
-// This flag prints the version for the application
+// VersionFlag prints the version for the application
 var VersionFlag = BoolFlag{
 	Name:  "version, v",
 	Usage: "print the version",
 }
 
-// This flag prints the help for all commands and subcommands
+// HelpFlag prints the help for all commands and subcommands
 // Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
 // unless HideHelp is set to true)
 var HelpFlag = BoolFlag{
@@ -29,6 +33,10 @@ var HelpFlag = BoolFlag{
 	Usage: "show help",
 }
 
+// FlagStringer converts a flag definition to a string. This is used by help
+// to display a flag.
+var FlagStringer FlagStringFunc = stringifyFlag
+
 // Flag is a common interface related to parsing flags in cli.
 // For more advanced flag parsing techniques, it is recommended that
 // this interface be implemented.
@@ -68,24 +76,14 @@ type GenericFlag struct {
 	Value  Generic
 	Usage  string
 	EnvVar string
+	Hidden bool
 }
 
 // String returns the string representation of the generic flag to display the
 // help text to the user (uses the String() method of the generic flag to show
 // the value)
 func (f GenericFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
+	return FlagStringer(f)
-}
-
-func (f GenericFlag) FormatValueHelp() string {
-	if f.Value == nil {
-		return ""
-	}
-	s := f.Value.String()
-	if len(s) == 0 {
-		return ""
-	}
-	return fmt.Sprintf("\"%s\"", s)
 }
 
 // Apply takes the flagset and calls Set on the generic flag with the value
@@ -107,6 +105,7 @@ func (f GenericFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of a flag.
 func (f GenericFlag) GetName() string {
 	return f.Name
 }
@@ -130,20 +129,19 @@ func (f *StringSlice) Value() []string {
 	return *f
 }
 
-// StringSlice is a string flag that can be specified multiple times on the
+// StringSliceFlag is a string flag that can be specified multiple times on the
 // command-line
 type StringSliceFlag struct {
 	Name   string
 	Value  *StringSlice
 	Usage  string
 	EnvVar string
+	Hidden bool
 }
 
 // String returns the usage
 func (f StringSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+	return FlagStringer(f)
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
 }
 
 // Apply populates the flag given the flag set and environment
@@ -171,11 +169,12 @@ func (f StringSliceFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of a flag.
 func (f StringSliceFlag) GetName() string {
 	return f.Name
 }
 
-// StringSlice is an opaque type for []int to satisfy flag.Value
+// IntSlice is an opaque type for []int to satisfy flag.Value
 type IntSlice []int
 
 // Set parses the value into an integer and appends it to the list of values
@@ -183,9 +182,8 @@ func (f *IntSlice) Set(value string) error {
 	tmp, err := strconv.Atoi(value)
 	if err != nil {
 		return err
-	} else {
-		*f = append(*f, tmp)
 	}
+	*f = append(*f, tmp)
 	return nil
 }
 
@@ -206,13 +204,12 @@ type IntSliceFlag struct {
 	Value  *IntSlice
 	Usage  string
 	EnvVar string
+	Hidden bool
 }
 
 // String returns the usage
 func (f IntSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+	return FlagStringer(f)
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
 }
 
 // Apply populates the flag given the flag set and environment
@@ -226,7 +223,7 @@ func (f IntSliceFlag) Apply(set *flag.FlagSet) {
 					s = strings.TrimSpace(s)
 					err := newVal.Set(s)
 					if err != nil {
-						fmt.Fprintf(os.Stderr, err.Error())
+						fmt.Fprintf(ErrWriter, err.Error())
 					}
 				}
 				f.Value = newVal
@@ -243,6 +240,7 @@ func (f IntSliceFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f IntSliceFlag) GetName() string {
 	return f.Name
 }
@@ -253,11 +251,12 @@ type BoolFlag struct {
 	Usage       string
 	EnvVar      string
 	Destination *bool
+	Hidden      bool
 }
 
 // String returns a readable representation of this value (for usage defaults)
 func (f BoolFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+	return FlagStringer(f)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -285,6 +284,7 @@ func (f BoolFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f BoolFlag) GetName() string {
 	return f.Name
 }
@@ -296,11 +296,12 @@ type BoolTFlag struct {
 	Usage       string
 	EnvVar      string
 	Destination *bool
+	Hidden      bool
 }
 
 // String returns a readable representation of this value (for usage defaults)
 func (f BoolTFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+	return FlagStringer(f)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -328,6 +329,7 @@ func (f BoolTFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f BoolTFlag) GetName() string {
 	return f.Name
 }
@@ -339,19 +341,12 @@ type StringFlag struct {
 	Usage       string
 	EnvVar      string
 	Destination *string
+	Hidden      bool
 }
 
 // String returns the usage
 func (f StringFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
+	return FlagStringer(f)
-}
-
-func (f StringFlag) FormatValueHelp() string {
-	s := f.Value
-	if len(s) == 0 {
-		return ""
-	}
-	return fmt.Sprintf("\"%s\"", s)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -375,6 +370,7 @@ func (f StringFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f StringFlag) GetName() string {
 	return f.Name
 }
@@ -387,11 +383,12 @@ type IntFlag struct {
 	Usage       string
 	EnvVar      string
 	Destination *int
+	Hidden      bool
 }
 
 // String returns the usage
 func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return FlagStringer(f)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -418,6 +415,7 @@ func (f IntFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f IntFlag) GetName() string {
 	return f.Name
 }
@@ -430,11 +428,12 @@ type DurationFlag struct {
 	Usage       string
 	EnvVar      string
 	Destination *time.Duration
+	Hidden      bool
 }
 
 // String returns a readable representation of this value (for usage defaults)
 func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return FlagStringer(f)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -461,6 +460,7 @@ func (f DurationFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f DurationFlag) GetName() string {
 	return f.Name
 }
@@ -473,11 +473,12 @@ type Float64Flag struct {
 	Usage       string
 	EnvVar      string
 	Destination *float64
+	Hidden      bool
 }
 
 // String returns the usage
 func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return FlagStringer(f)
 }
 
 // Apply populates the flag given the flag set and environment
@@ -503,10 +504,21 @@ func (f Float64Flag) Apply(set *flag.FlagSet) {
 	})
 }
 
+// GetName returns the name of the flag.
 func (f Float64Flag) GetName() string {
 	return f.Name
 }
 
+func visibleFlags(fl []Flag) []Flag {
+	visible := []Flag{}
+	for _, flag := range fl {
+		if !reflect.ValueOf(flag).FieldByName("Hidden").Bool() {
+			visible = append(visible, flag)
+		}
+	}
+	return visible
+}
+
 func prefixFor(name string) (prefix string) {
 	if len(name) == 1 {
 		prefix = "-"
@@ -517,16 +529,37 @@ func prefixFor(name string) (prefix string) {
 	return
 }
 
-func prefixedNames(fullName string) (prefixed string) {
+// Returns the placeholder, if any, and the unquoted usage string.
+func unquoteUsage(usage string) (string, string) {
+	for i := 0; i < len(usage); i++ {
+		if usage[i] == '`' {
+			for j := i + 1; j < len(usage); j++ {
+				if usage[j] == '`' {
+					name := usage[i+1 : j]
+					usage = usage[:i] + name + usage[j+1:]
+					return name, usage
+				}
+			}
+			break
+		}
+	}
+	return "", usage
+}
+
+func prefixedNames(fullName, placeholder string) string {
+	var prefixed string
 	parts := strings.Split(fullName, ",")
 	for i, name := range parts {
 		name = strings.Trim(name, " ")
 		prefixed += prefixFor(name) + name
+		if placeholder != "" {
+			prefixed += " " + placeholder
+		}
 		if i < len(parts)-1 {
 			prefixed += ", "
 		}
 	}
-	return
+	return prefixed
 }
 
 func withEnvHint(envVar, str string) string {
@@ -544,3 +577,83 @@ func withEnvHint(envVar, str string) string {
 	}
 	return str + envText
 }
+
+func stringifyFlag(f Flag) string {
+	fv := reflect.ValueOf(f)
+
+	switch f.(type) {
+	case IntSliceFlag:
+		return withEnvHint(fv.FieldByName("EnvVar").String(),
+			stringifyIntSliceFlag(f.(IntSliceFlag)))
+	case StringSliceFlag:
+		return withEnvHint(fv.FieldByName("EnvVar").String(),
+			stringifyStringSliceFlag(f.(StringSliceFlag)))
+	}
+
+	placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
+
+	needsPlaceholder := false
+	defaultValueString := ""
+	val := fv.FieldByName("Value")
+
+	if val.IsValid() {
+		needsPlaceholder = true
+		defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
+
+		if val.Kind() == reflect.String && val.String() != "" {
+			defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
+		}
+	}
+
+	if defaultValueString == " (default: )" {
+		defaultValueString = ""
+	}
+
+	if needsPlaceholder && placeholder == "" {
+		placeholder = defaultPlaceholder
+	}
+
+	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
+
+	return withEnvHint(fv.FieldByName("EnvVar").String(),
+		fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
+}
+
+func stringifyIntSliceFlag(f IntSliceFlag) string {
+	defaultVals := []string{}
+	if f.Value != nil && len(f.Value.Value()) > 0 {
+		for _, i := range f.Value.Value() {
+			defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
+		}
+	}
+
+	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifyStringSliceFlag(f StringSliceFlag) string {
+	defaultVals := []string{}
+	if f.Value != nil && len(f.Value.Value()) > 0 {
+		for _, s := range f.Value.Value() {
+			if len(s) > 0 {
+				defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
+			}
+		}
+	}
+
+	return stringifySliceFlag(f.Usage, f.Name, defaultVals)
+}
+
+func stringifySliceFlag(usage, name string, defaultVals []string) string {
+	placeholder, usage := unquoteUsage(usage)
+	if placeholder == "" {
+		placeholder = defaultPlaceholder
+	}
+
+	defaultVal := ""
+	if len(defaultVals) > 0 {
+		defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
+	}
+
+	usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
+	return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
+}

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/funcs.go

@@ -0,0 +1,28 @@
+package cli
+
+// BashCompleteFunc is an action to execute when the bash-completion flag is set
+type BashCompleteFunc func(*Context)
+
+// BeforeFunc is an action to execute before any subcommands are run, but after
+// the context is ready if a non-nil error is returned, no subcommands are run
+type BeforeFunc func(*Context) error
+
+// AfterFunc is an action to execute after any subcommands are run, but after the
+// subcommand has finished it is run even if Action() panics
+type AfterFunc func(*Context) error
+
+// ActionFunc is the action to execute when no subcommands are specified
+type ActionFunc func(*Context) error
+
+// CommandNotFoundFunc is executed if the proper command cannot be found
+type CommandNotFoundFunc func(*Context, string)
+
+// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
+// customized usage error messages.  This function is able to replace the
+// original error messages.  If this function is not set, the "Incorrect usage"
+// is displayed and the execution is interrupted.
+type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
+
+// FlagStringFunc is used by the help generation to display a flag, which is
+// expected to be a single line.
+type FlagStringFunc func(Flag) string

Godeps/_workspace/src/gopkg.in/urfave/cli.v1/help.go

@@ -3,68 +3,74 @@ package cli
 import (
 	"fmt"
 	"io"
+	"os"
 	"strings"
 	"text/tabwriter"
 	"text/template"
 )
 
-// The text template for the Default help topic.
+// AppHelpTemplate is the text template for the Default help topic.
 // cli.go uses text/template to render templates. You can
 // render custom help text by setting this variable.
 var AppHelpTemplate = `NAME:
    {{.Name}} - {{.Usage}}
 
 USAGE:
-   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
+   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
-   {{if .Version}}
+   {{if .Version}}{{if not .HideVersion}}
 VERSION:
    {{.Version}}
-   {{end}}{{if len .Authors}}
+   {{end}}{{end}}{{if len .Authors}}
 AUTHOR(S):
-   {{range .Authors}}{{ . }}{{end}}
+   {{range .Authors}}{{.}}{{end}}
-   {{end}}{{if .Commands}}
+   {{end}}{{if .VisibleCommands}}
-COMMANDS:
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+   {{.Name}}:{{end}}{{range .VisibleCommands}}
-   {{end}}{{end}}{{if .Flags}}
+     {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{"\t"}}{{.Usage}}{{end}}
+{{end}}{{end}}{{if .VisibleFlags}}
 GLOBAL OPTIONS:
-   {{range .Flags}}{{.}}
+   {{range .VisibleFlags}}{{.}}
-   {{end}}{{end}}{{if .Copyright }}
+   {{end}}{{end}}{{if .Copyright}}
 COPYRIGHT:
    {{.Copyright}}
    {{end}}
 `
 
-// The text template for the command help topic.
+// CommandHelpTemplate is the text template for the command help topic.
 // cli.go uses text/template to render templates. You can
 // render custom help text by setting this variable.
 var CommandHelpTemplate = `NAME:
    {{.HelpName}} - {{.Usage}}
 
 USAGE:
-   {{.HelpName}}{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Description}}
+   {{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Category}}
+
+CATEGORY:
+   {{.Category}}{{end}}{{if .Description}}
 
 DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
+   {{.Description}}{{end}}{{if .VisibleFlags}}
 
 OPTIONS:
-   {{range .Flags}}{{.}}
+   {{range .VisibleFlags}}{{.}}
-   {{end}}{{ end }}
+   {{end}}{{end}}
 `
 
-// The text template for the subcommand help topic.
+// SubcommandHelpTemplate is the text template for the subcommand help topic.
 // cli.go uses text/template to render templates. You can
 // render custom help text by setting this variable.
 var SubcommandHelpTemplate = `NAME:
    {{.HelpName}} - {{.Usage}}
 
 USAGE:
-   {{.HelpName}} command{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
+   {{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
 
-COMMANDS:
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+   {{.Name}}:{{end}}{{range .VisibleCommands}}
-   {{end}}{{if .Flags}}
+     {{.Name}}{{with .ShortName}}, {{.}}{{end}}{{"\t"}}{{.Usage}}{{end}}
+{{end}}{{if .VisibleFlags}}
 OPTIONS:
-   {{range .Flags}}{{.}}
+   {{range .VisibleFlags}}{{.}}
    {{end}}{{end}}
 `
 
@@ -73,13 +79,14 @@ var helpCommand = Command{
 	Aliases:   []string{"h"},
 	Usage:     "Shows a list of commands or help for one command",
 	ArgsUsage: "[command]",
-	Action: func(c *Context) {
+	Action: func(c *Context) error {
 		args := c.Args()
 		if args.Present() {
-			ShowCommandHelp(c, args.First())
+			return ShowCommandHelp(c, args.First())
-		} else {
-			ShowAppHelp(c)
 		}
+
+		ShowAppHelp(c)
+		return nil
 	},
 }
 
@@ -88,65 +95,73 @@ var helpSubcommand = Command{
 	Aliases:   []string{"h"},
 	Usage:     "Shows a list of commands or help for one command",
 	ArgsUsage: "[command]",
-	Action: func(c *Context) {
+	Action: func(c *Context) error {
 		args := c.Args()
 		if args.Present() {
-			ShowCommandHelp(c, args.First())
+			return ShowCommandHelp(c, args.First())
-		} else {
-			ShowSubcommandHelp(c)
 		}
+
+		return ShowSubcommandHelp(c)
 	},
 }
 
 // Prints help for the App or Command
 type helpPrinter func(w io.Writer, templ string, data interface{})
 
+// HelpPrinter is a function that writes the help output. If not set a default
+// is used. The function signature is:
+// func(w io.Writer, templ string, data interface{})
 var HelpPrinter helpPrinter = printHelp
 
-// Prints version for the App
+// VersionPrinter prints the version for the App
 var VersionPrinter = printVersion
 
+// ShowAppHelp is an action that displays the help.
 func ShowAppHelp(c *Context) {
 	HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
 }
 
-// Prints the list of subcommands as the default app completion method
+// DefaultAppComplete prints the list of subcommands as the default app completion method
 func DefaultAppComplete(c *Context) {
 	for _, command := range c.App.Commands {
+		if command.Hidden {
+			continue
+		}
 		for _, name := range command.Names() {
 			fmt.Fprintln(c.App.Writer, name)
 		}
 	}
 }
 
-// Prints help for the given command
+// ShowCommandHelp prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) {
+func ShowCommandHelp(ctx *Context, command string) error {
 	// show the subcommand help for a command with subcommands
 	if command == "" {
 		HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
-		return
+		return nil
 	}
 
 	for _, c := range ctx.App.Commands {
 		if c.HasName(command) {
 			HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
-			return
+			return nil
 		}
 	}
 
-	if ctx.App.CommandNotFound != nil {
+	if ctx.App.CommandNotFound == nil {
-		ctx.App.CommandNotFound(ctx, command)
+		return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3)
-	} else {
-		fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
 	}
+
+	ctx.App.CommandNotFound(ctx, command)
+	return nil
 }
 
-// Prints help for the given subcommand
+// ShowSubcommandHelp prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
+func ShowSubcommandHelp(c *Context) error {
-	ShowCommandHelp(c, c.Command.Name)
+	return ShowCommandHelp(c, c.Command.Name)
 }
 
-// Prints the version number of the App
+// ShowVersion prints the version number of the App
 func ShowVersion(c *Context) {
 	VersionPrinter(c)
 }
@@ -155,7 +170,7 @@ func printVersion(c *Context) {
 	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
 }
 
-// Prints the lists of commands within a given context
+// ShowCompletions prints the lists of commands within a given context
 func ShowCompletions(c *Context) {
 	a := c.App
 	if a != nil && a.BashComplete != nil {
@@ -163,7 +178,7 @@ func ShowCompletions(c *Context) {
 	}
 }
 
-// Prints the custom completions for a given command
+// ShowCommandCompletions prints the custom completions for a given command
 func ShowCommandCompletions(ctx *Context, command string) {
 	c := ctx.App.Command(command)
 	if c != nil && c.BashComplete != nil {
@@ -181,7 +196,10 @@ func printHelp(out io.Writer, templ string, data interface{}) {
 	err := t.Execute(w, data)
 	if err != nil {
 		// If the writer is closed, t.Execute will fail, and there's nothing
-		// we can do to recover. We could send this to os.Stderr if we need.
+		// we can do to recover.
+		if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
+			fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
+		}
 		return
 	}
 	w.Flush()

README.md

@@ -36,6 +36,10 @@ Once the dependencies are installed, run
 
     make geth
 
+or, to build the full suite of utilities:
+
+    make all
+
 ## Executables
 
 The go-ethereum project comes with several wrappers/executables found in the `cmd` directory.
@@ -58,14 +62,14 @@ anyone on the internet, and are grateful for even the smallest of fixes!
 If you'd like to contribute to go-ethereum, please fork, fix, commit and send a pull request
 for the maintainers to review and merge into the main code base. If you wish to submit more
 complex changes though, please check up with the core devs first on [our gitter channel](https://gitter.im/ethereum/go-ethereum)
-to ensure those changes are in line with the general philosopy of the project and/or get some
+to ensure those changes are in line with the general philosophy of the project and/or get some
 early feedback which can make both your efforts much lighter as well as our review and merge
 procedures quick and simple.
 
-Please make sure your contributions adhere to our coding guidlines:
+Please make sure your contributions adhere to our coding guidelines:
 
  * Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting) guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)).
- * Code must be documented adherign to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines.
+ * Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines.
  * Pull requests need to be based on and opened against the `develop` branch.
  * Commit messages should be prefixed with the package(s) they modify.
    * E.g. "eth, rpc: make trace configs optional"
@@ -82,3 +86,5 @@ included in our repository in the `COPYING.LESSER` file.
 The go-ethereum binaries (i.e. all code inside of the `cmd` directory) is licensed under the
 [GNU General Public License v3.0](http://www.gnu.org/licenses/gpl-3.0.en.html), also included
 in our repository in the `COPYING` file.
+
+

VERSION

@@ -1 +1 @@
-1.5.0
+1.4.8

accounts/abi/abi.go

@@ -238,8 +238,16 @@ func (abi ABI) Unpack(v interface{}, name string, output []byte) error {
 		return fmt.Errorf("abi: unmarshalling empty output")
 	}
 
-	value := reflect.ValueOf(v).Elem()
+	// make sure the passed value is a pointer
-	typ := value.Type()
+	valueOf := reflect.ValueOf(v)
+	if reflect.Ptr != valueOf.Kind() {
+		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
+	}
+
+	var (
+		value = valueOf.Elem()
+		typ   = value.Type()
+	)
 
 	if len(method.Outputs) > 1 {
 		switch value.Kind() {
@@ -268,6 +276,25 @@ func (abi ABI) Unpack(v interface{}, name string, output []byte) error {
 				return fmt.Errorf("abi: cannot marshal tuple in to slice %T (only []interface{} is supported)", v)
 			}
 
+			// if the slice already contains values, set those instead of the interface slice itself.
+			if value.Len() > 0 {
+				if len(method.Outputs) > value.Len() {
+					return fmt.Errorf("abi: cannot marshal in to slices of unequal size (require: %v, got: %v)", len(method.Outputs), value.Len())
+				}
+
+				for i := 0; i < len(method.Outputs); i++ {
+					marshalledValue, err := toGoType(i, method.Outputs[i], output)
+					if err != nil {
+						return err
+					}
+					reflectValue := reflect.ValueOf(marshalledValue)
+					if err := set(value.Index(i).Elem(), reflectValue, method.Outputs[i]); err != nil {
+						return err
+					}
+				}
+				return nil
+			}
+
 			// create a new slice and start appending the unmarshalled
 			// values to the new interface slice.
 			z := reflect.MakeSlice(typ, 0, len(method.Outputs))
@@ -296,34 +323,6 @@ func (abi ABI) Unpack(v interface{}, name string, output []byte) error {
 	return nil
 }
 
-// set attempts to assign src to dst by either setting, copying or otherwise.
-//
-// set is a bit more lenient when it comes to assignment and doesn't force an as
-// strict ruleset as bare `reflect` does.
-func set(dst, src reflect.Value, output Argument) error {
-	dstType := dst.Type()
-	srcType := src.Type()
-
-	switch {
-	case dstType.AssignableTo(src.Type()):
-		dst.Set(src)
-	case dstType.Kind() == reflect.Array && srcType.Kind() == reflect.Slice:
-		if !dstType.Elem().AssignableTo(r_byte) {
-			return fmt.Errorf("abi: cannot unmarshal %v in to array of elem %v", src.Type(), dstType.Elem())
-		}
-
-		if dst.Len() < output.Type.SliceSize {
-			return fmt.Errorf("abi: cannot unmarshal src (len=%d) in to dst (len=%d)", output.Type.SliceSize, dst.Len())
-		}
-		reflect.Copy(dst, src)
-	case dstType.Kind() == reflect.Interface:
-		dst.Set(src)
-	default:
-		return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
-	}
-	return nil
-}
-
 func (abi *ABI) UnmarshalJSON(data []byte) error {
 	var fields []struct {
 		Type     string

accounts/abi/abi_test.go

@@ -289,6 +289,37 @@ func TestSimpleMethodUnpack(t *testing.T) {
 	}
 }
 
+func TestUnpackSetInterfaceSlice(t *testing.T) {
+	var (
+		var1 = new(uint8)
+		var2 = new(uint8)
+	)
+	out := []interface{}{var1, var2}
+	abi, err := JSON(strings.NewReader(`[{"type":"function", "name":"ints", "outputs":[{"type":"uint8"}, {"type":"uint8"}]}]`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	marshalledReturn := append(pad([]byte{1}, 32, true), pad([]byte{2}, 32, true)...)
+	err = abi.Unpack(&out, "ints", marshalledReturn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if *var1 != 1 {
+		t.Error("expected var1 to be 1, got", *var1)
+	}
+	if *var2 != 2 {
+		t.Error("expected var2 to be 2, got", *var2)
+	}
+
+	out = []interface{}{var1}
+	err = abi.Unpack(&out, "ints", marshalledReturn)
+
+	expErr := "abi: cannot marshal in to slices of unequal size (require: 2, got: 1)"
+	if err == nil || err.Error() != expErr {
+		t.Error("expected err:", expErr, "Got:", err)
+	}
+}
+
 func TestPack(t *testing.T) {
 	for i, test := range []struct {
 		typ string

accounts/abi/bind/backend.go

@@ -27,15 +27,16 @@ import (
 // ErrNoCode is returned by call and transact operations for which the requested
 // recipient contract to operate on does not exist in the state db or does not
 // have any code associated with it (i.e. suicided).
-//
-// Please note, this error string is part of the RPC API and is expected by the
-// native contract bindings to signal this particular error. Do not change this
-// as it will break all dependent code!
 var ErrNoCode = errors.New("no contract code at given address")
 
 // ContractCaller defines the methods needed to allow operating with contract on a read
 // only basis.
 type ContractCaller interface {
+	// HasCode checks if the contract at the given address has any code associated
+	// with it or not. This is needed to differentiate between contract internal
+	// errors and the local chain being out of sync.
+	HasCode(contract common.Address, pending bool) (bool, error)
+
 	// ContractCall executes an Ethereum contract call with the specified data as
 	// the input. The pending flag requests execution against the pending block, not
 	// the stable head of the chain.
@@ -55,6 +56,11 @@ type ContractTransactor interface {
 	// execution of a transaction.
 	SuggestGasPrice() (*big.Int, error)
 
+	// HasCode checks if the contract at the given address has any code associated
+	// with it or not. This is needed to differentiate between contract internal
+	// errors and the local chain being out of sync.
+	HasCode(contract common.Address, pending bool) (bool, error)
+
 	// EstimateGasLimit tries to estimate the gas needed to execute a specific
 	// transaction based on the current pending state of the backend blockchain.
 	// There is no guarantee that this is the true gas limit requirement as other
@@ -68,7 +74,38 @@ type ContractTransactor interface {
 
 // ContractBackend defines the methods needed to allow operating with contract
 // on a read-write basis.
+//
+// This interface is essentially the union of ContractCaller and ContractTransactor
+// but due to a bug in the Go compiler (https://github.com/golang/go/issues/6977),
+// we cannot simply list it as the two interfaces. The other solution is to add a
+// third interface containing the common methods, but that convolutes the user API
+// as it introduces yet another parameter to require for initialization.
 type ContractBackend interface {
-	ContractCaller
+	// HasCode checks if the contract at the given address has any code associated
-	ContractTransactor
+	// with it or not. This is needed to differentiate between contract internal
+	// errors and the local chain being out of sync.
+	HasCode(contract common.Address, pending bool) (bool, error)
+
+	// ContractCall executes an Ethereum contract call with the specified data as
+	// the input. The pending flag requests execution against the pending block, not
+	// the stable head of the chain.
+	ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error)
+
+	// PendingAccountNonce retrieves the current pending nonce associated with an
+	// account.
+	PendingAccountNonce(account common.Address) (uint64, error)
+
+	// SuggestGasPrice retrieves the currently suggested gas price to allow a timely
+	// execution of a transaction.
+	SuggestGasPrice() (*big.Int, error)
+
+	// EstimateGasLimit tries to estimate the gas needed to execute a specific
+	// transaction based on the current pending state of the backend blockchain.
+	// There is no guarantee that this is the true gas limit requirement as other
+	// transactions may be added or removed by miners, but it should provide a basis
+	// for setting a reasonable default.
+	EstimateGasLimit(sender common.Address, contract *common.Address, value *big.Int, data []byte) (*big.Int, error)
+
+	// SendTransaction injects the transaction into the pending pool for execution.
+	SendTransaction(tx *types.Transaction) error
 }

accounts/abi/bind/backends/nil.go

@@ -38,6 +38,7 @@ func (*nilBackend) ContractCall(common.Address, []byte, bool) ([]byte, error) {
 func (*nilBackend) EstimateGasLimit(common.Address, *common.Address, *big.Int, []byte) (*big.Int, error) {
 	panic("not implemented")
 }
+func (*nilBackend) HasCode(common.Address, bool) (bool, error)         { panic("not implemented") }
 func (*nilBackend) SuggestGasPrice() (*big.Int, error)                 { panic("not implemented") }
 func (*nilBackend) PendingAccountNonce(common.Address) (uint64, error) { panic("not implemented") }
 func (*nilBackend) SendTransaction(*types.Transaction) error           { panic("not implemented") }

accounts/abi/bind/backends/remote.go

@@ -111,6 +111,26 @@ func (b *rpcBackend) request(method string, params []interface{}) (json.RawMessa
 	return res.Result, nil
 }
 
+// HasCode implements ContractVerifier.HasCode by retrieving any code associated
+// with the contract from the remote node, and checking its size.
+func (b *rpcBackend) HasCode(contract common.Address, pending bool) (bool, error) {
+	// Execute the RPC code retrieval
+	block := "latest"
+	if pending {
+		block = "pending"
+	}
+	res, err := b.request("eth_getCode", []interface{}{contract.Hex(), block})
+	if err != nil {
+		return false, err
+	}
+	var hex string
+	if err := json.Unmarshal(res, &hex); err != nil {
+		return false, err
+	}
+	// Convert the response back to a Go byte slice and return
+	return len(common.FromHex(hex)) > 0, nil
+}
+
 // ContractCall implements ContractCaller.ContractCall, delegating the execution of
 // a contract call to the remote node, returning the reply to for local processing.
 func (b *rpcBackend) ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) {

accounts/abi/bind/backends/simulated.go

@@ -78,6 +78,16 @@ func (b *SimulatedBackend) Rollback() {
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database)
 }
 
+// HasCode implements ContractVerifier.HasCode, checking whether there is any
+// code associated with a certain account in the blockchain.
+func (b *SimulatedBackend) HasCode(contract common.Address, pending bool) (bool, error) {
+	if pending {
+		return len(b.pendingState.GetCode(contract)) > 0, nil
+	}
+	statedb, _ := b.blockchain.State()
+	return len(statedb.GetCode(contract)) > 0, nil
+}
+
 // ContractCall implements ContractCaller.ContractCall, executing the specified
 // contract with the given input data.
 func (b *SimulatedBackend) ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) {

accounts/abi/bind/base.go

@@ -20,6 +20,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
@@ -56,6 +57,9 @@ type BoundContract struct {
 	abi        abi.ABI            // Reflect based ABI to access the correct Ethereum methods
 	caller     ContractCaller     // Read interface to interact with the blockchain
 	transactor ContractTransactor // Write interface to interact with the blockchain
+
+	latestHasCode  uint32 // Cached verification that the latest state contains code for this contract
+	pendingHasCode uint32 // Cached verification that the pending state contains code for this contract
 }
 
 // NewBoundContract creates a low level contract interface through which calls
@@ -96,6 +100,19 @@ func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string,
 	if opts == nil {
 		opts = new(CallOpts)
 	}
+	// Make sure we have a contract to operate on, and bail out otherwise
+	if (opts.Pending && atomic.LoadUint32(&c.pendingHasCode) == 0) || (!opts.Pending && atomic.LoadUint32(&c.latestHasCode) == 0) {
+		if code, err := c.caller.HasCode(c.address, opts.Pending); err != nil {
+			return err
+		} else if !code {
+			return ErrNoCode
+		}
+		if opts.Pending {
+			atomic.StoreUint32(&c.pendingHasCode, 1)
+		} else {
+			atomic.StoreUint32(&c.latestHasCode, 1)
+		}
+	}
 	// Pack the input, call and unpack the results
 	input, err := c.abi.Pack(method, params...)
 	if err != nil {
@@ -153,6 +170,16 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	}
 	gasLimit := opts.GasLimit
 	if gasLimit == nil {
+		// Gas estimation cannot succeed without code for method invocations
+		if contract != nil && atomic.LoadUint32(&c.pendingHasCode) == 0 {
+			if code, err := c.transactor.HasCode(c.address, true); err != nil {
+				return nil, err
+			} else if !code {
+				return nil, ErrNoCode
+			}
+			atomic.StoreUint32(&c.pendingHasCode, 1)
+		}
+		// If the contract surely has code (or code is not needed), estimate the transaction
 		gasLimit, err = c.transactor.EstimateGasLimit(opts.From, contract, value, input)
 		if err != nil {
 			return nil, fmt.Errorf("failed to exstimate gas needed: %v", err)

accounts/abi/bind/bind_test.go

@@ -194,12 +194,44 @@ var bindTests = []struct {
 			}
 		`,
 	},
+	// Tests that plain values can be properly returned and deserialized
+	{
+		`Getter`,
+		`
+			contract Getter {
+				function getter() constant returns (string, int, bytes32) {
+					return ("Hi", 1, sha3(""));
+				}
+			}
+		`,
+		`606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`,
+		`[{"constant":true,"inputs":[],"name":"getter","outputs":[{"name":"","type":"string"},{"name":"","type":"int256"},{"name":"","type":"bytes32"}],"type":"function"}]`,
+		`
+			// Generate a new random account and a funded simulator
+			key, _ := crypto.GenerateKey()
+			auth := bind.NewKeyedTransactor(key)
+			sim := backends.NewSimulatedBackend(core.GenesisAccount{Address: auth.From, Balance: big.NewInt(10000000000)})
+
+			// Deploy a tuple tester contract and execute a structured call on it
+			_, _, getter, err := DeployGetter(auth, sim)
+			if err != nil {
+				t.Fatalf("Failed to deploy getter contract: %v", err)
+			}
+			sim.Commit()
+
+			if str, num, _, err := getter.Getter(nil); err != nil {
+				t.Fatalf("Failed to call anonymous field retriever: %v", err)
+			} else if str != "Hi" || num.Cmp(big.NewInt(1)) != 0 {
+				t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", str, num, "Hi", 1)
+			}
+		`,
+	},
 	// Tests that tuples can be properly returned and deserialized
 	{
 		`Tupler`,
 		`
 			contract Tupler {
-				function tuple() returns (string a, int b, bytes32 c) {
+				function tuple() constant returns (string a, int b, bytes32 c) {
 					return ("Hi", 1, sha3(""));
 				}
 			}
@@ -219,8 +251,10 @@ var bindTests = []struct {
 			}
 			sim.Commit()
 
-			if _, err := tupler.Tuple(nil); err != nil {
+			if res, err := tupler.Tuple(nil); err != nil {
 				t.Fatalf("Failed to call structure retriever: %v", err)
+			} else if res.A != "Hi" || res.B.Cmp(big.NewInt(1)) != 0 {
+				t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", res.A, res.B, "Hi", 1)
 			}
 		`,
 	},

accounts/abi/bind/template.go

@@ -211,7 +211,7 @@ package {{.Package}}
 				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}} = new({{bindtype .Type}})
 				{{end}}
 			){{end}}
-			out := {{if .Structured}}ret{{else}}{{if eq (len .Normalized.Outputs) 1}}ret0{{else}}[]interface{}{
+			out := {{if .Structured}}ret{{else}}{{if eq (len .Normalized.Outputs) 1}}ret0{{else}}&[]interface{}{
 				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}},
 				{{end}}
 			}{{end}}{{end}}

accounts/abi/method.go

@@ -62,7 +62,7 @@ func (m Method) pack(method Method, args ...interface{}) ([]byte, error) {
 			// calculate the offset
 			offset := len(method.Inputs)*32 + len(variableInput)
 			// set the offset
-			ret = append(ret, packNum(reflect.ValueOf(offset), UintTy)...)
+			ret = append(ret, packNum(reflect.ValueOf(offset))...)
 			// Append the packed output to the variable input. The variable input
 			// will be appended at the end of the input.
 			variableInput = append(variableInput, packed...)

accounts/abi/numbers.go

@@ -56,61 +56,21 @@ var (
 	big_ts   = reflect.TypeOf([]*big.Int(nil))
 )
 
-// U256 will ensure unsigned 256bit on big nums
+// U256 converts a big Int into a 256bit EVM number.
 func U256(n *big.Int) []byte {
 	return common.LeftPadBytes(common.U256(n).Bytes(), 32)
 }
 
-func S256(n *big.Int) []byte {
-	sint := common.S256(n)
-	ret := common.LeftPadBytes(sint.Bytes(), 32)
-	if sint.Cmp(common.Big0) < 0 {
-		for i, b := range ret {
-			if b == 0 {
-				ret[i] = 1
-				continue
-			}
-			break
-		}
-	}
-
-	return ret
-}
-
-// S256 will ensure signed 256bit on big nums
-func U2U256(n uint64) []byte {
-	return U256(big.NewInt(int64(n)))
-}
-
-func S2S256(n int64) []byte {
-	return S256(big.NewInt(n))
-}
-
 // packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
-func packNum(value reflect.Value, to byte) []byte {
+func packNum(value reflect.Value) []byte {
 	switch kind := value.Kind(); kind {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		if to == UintTy {
+		return U256(new(big.Int).SetUint64(value.Uint()))
-			return U2U256(value.Uint())
-		} else {
-			return S2S256(int64(value.Uint()))
-		}
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		if to == UintTy {
+		return U256(big.NewInt(value.Int()))
-			return U2U256(uint64(value.Int()))
-		} else {
-			return S2S256(value.Int())
-		}
 	case reflect.Ptr:
-		// This only takes care of packing and casting. No type checking is done here. It should be done prior to using this function.
+		return U256(value.Interface().(*big.Int))
-		if to == UintTy {
-			return U256(value.Interface().(*big.Int))
-		} else {
-			return S256(value.Interface().(*big.Int))
-		}
-
 	}
-
 	return nil
 }
 

accounts/abi/numbers_test.go

@@ -18,6 +18,7 @@ package abi
 
 import (
 	"bytes"
+	"math"
 	"math/big"
 	"reflect"
 	"testing"
@@ -26,49 +27,46 @@ import (
 func TestNumberTypes(t *testing.T) {
 	ubytes := make([]byte, 32)
 	ubytes[31] = 1
-	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
 
 	unsigned := U256(big.NewInt(1))
 	if !bytes.Equal(unsigned, ubytes) {
 		t.Errorf("expected %x got %x", ubytes, unsigned)
 	}
-
-	signed := S256(big.NewInt(1))
-	if !bytes.Equal(signed, ubytes) {
-		t.Errorf("expected %x got %x", ubytes, unsigned)
-	}
-
-	signed = S256(big.NewInt(-1))
-	if !bytes.Equal(signed, sbytesmin) {
-		t.Errorf("expected %x got %x", ubytes, unsigned)
-	}
 }
 
 func TestPackNumber(t *testing.T) {
-	ubytes := make([]byte, 32)
+	tests := []struct {
-	ubytes[31] = 1
+		value  reflect.Value
-	sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+		packed []byte
-	maxunsigned := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
+	}{
+		// Protocol limits
+		{reflect.ValueOf(0), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+		{reflect.ValueOf(1), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
+		{reflect.ValueOf(-1), []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}},
 
-	packed := packNum(reflect.ValueOf(1), IntTy)
+		// Type corner cases
-	if !bytes.Equal(packed, ubytes) {
+		{reflect.ValueOf(uint8(math.MaxUint8)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255}},
-		t.Errorf("expected %x got %x", ubytes, packed)
+		{reflect.ValueOf(uint16(math.MaxUint16)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255}},
-	}
+		{reflect.ValueOf(uint32(math.MaxUint32)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255}},
-	packed = packNum(reflect.ValueOf(-1), IntTy)
+		{reflect.ValueOf(uint64(math.MaxUint64)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255}},
-	if !bytes.Equal(packed, sbytesmin) {
-		t.Errorf("expected %x got %x", ubytes, packed)
-	}
-	packed = packNum(reflect.ValueOf(1), UintTy)
-	if !bytes.Equal(packed, ubytes) {
-		t.Errorf("expected %x got %x", ubytes, packed)
-	}
-	packed = packNum(reflect.ValueOf(-1), UintTy)
-	if !bytes.Equal(packed, maxunsigned) {
-		t.Errorf("expected %x got %x", maxunsigned, packed)
-	}
 
-	packed = packNum(reflect.ValueOf("string"), UintTy)
+		{reflect.ValueOf(int8(math.MaxInt8)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127}},
-	if packed != nil {
+		{reflect.ValueOf(int16(math.MaxInt16)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 255}},
+		{reflect.ValueOf(int32(math.MaxInt32)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255}},
+		{reflect.ValueOf(int64(math.MaxInt64)), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255, 255, 255, 255}},
+
+		{reflect.ValueOf(int8(math.MinInt8)), []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 128}},
+		{reflect.ValueOf(int16(math.MinInt16)), []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 128, 0}},
+		{reflect.ValueOf(int32(math.MinInt32)), []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0}},
+		{reflect.ValueOf(int64(math.MinInt64)), []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0, 0}},
+	}
+	for i, tt := range tests {
+		packed := packNum(tt.value)
+		if !bytes.Equal(packed, tt.packed) {
+			t.Errorf("test %d: pack mismatch: have %x, want %x", i, packed, tt.packed)
+		}
+	}
+	if packed := packNum(reflect.ValueOf("string")); packed != nil {
 		t.Errorf("expected 'string' to pack to nil. got %x instead", packed)
 	}
 }

accounts/abi/packing.go

@@ -25,7 +25,7 @@ import (
 // packBytesSlice packs the given bytes as [L, V] as the canonical representation
 // bytes slice
 func packBytesSlice(bytes []byte, l int) []byte {
-	len := packNum(reflect.ValueOf(l), UintTy)
+	len := packNum(reflect.ValueOf(l))
 	return append(len, common.RightPadBytes(bytes, (l+31)/32*32)...)
 }
 
@@ -34,7 +34,7 @@ func packBytesSlice(bytes []byte, l int) []byte {
 func packElement(t Type, reflectValue reflect.Value) []byte {
 	switch t.T {
 	case IntTy, UintTy:
-		return packNum(reflectValue, t.T)
+		return packNum(reflectValue)
 	case StringTy:
 		return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len())
 	case AddressTy:

accounts/abi/reflect.go

@@ -16,7 +16,10 @@
 
 package abi
 
-import "reflect"
+import (
+	"fmt"
+	"reflect"
+)
 
 // indirect recursively dereferences the value until it either gets the value
 // or finds a big.Int
@@ -62,3 +65,33 @@ func mustArrayToByteSlice(value reflect.Value) reflect.Value {
 	reflect.Copy(slice, value)
 	return slice
 }
+
+// set attempts to assign src to dst by either setting, copying or otherwise.
+//
+// set is a bit more lenient when it comes to assignment and doesn't force an as
+// strict ruleset as bare `reflect` does.
+func set(dst, src reflect.Value, output Argument) error {
+	dstType := dst.Type()
+	srcType := src.Type()
+
+	switch {
+	case dstType.AssignableTo(src.Type()):
+		dst.Set(src)
+	case dstType.Kind() == reflect.Array && srcType.Kind() == reflect.Slice:
+		if !dstType.Elem().AssignableTo(r_byte) {
+			return fmt.Errorf("abi: cannot unmarshal %v in to array of elem %v", src.Type(), dstType.Elem())
+		}
+
+		if dst.Len() < output.Type.SliceSize {
+			return fmt.Errorf("abi: cannot unmarshal src (len=%d) in to dst (len=%d)", output.Type.SliceSize, dst.Len())
+		}
+		reflect.Copy(dst, src)
+	case dstType.Kind() == reflect.Interface:
+		dst.Set(src)
+	case dstType.Kind() == reflect.Ptr:
+		return set(dst.Elem(), src, output)
+	default:
+		return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
+	}
+	return nil
+}

accounts/account_manager.go

@@ -147,9 +147,21 @@ func (am *Manager) Sign(addr common.Address, hash []byte) (signature []byte, err
 	return crypto.Sign(hash, unlockedKey.PrivateKey)
 }
 
+// SignWithPassphrase signs hash if the private key matching the given address can be
+// decrypted with the given passphrase.
+func (am *Manager) SignWithPassphrase(addr common.Address, passphrase string, hash []byte) (signature []byte, err error) {
+	_, key, err := am.getDecryptedKey(Account{Address: addr}, passphrase)
+	if err != nil {
+		return nil, err
+	}
+
+	defer zeroKey(key.PrivateKey)
+	return crypto.Sign(hash, key.PrivateKey)
+}
+
 // Unlock unlocks the given account indefinitely.
-func (am *Manager) Unlock(a Account, keyAuth string) error {
+func (am *Manager) Unlock(a Account, passphrase string) error {
-	return am.TimedUnlock(a, keyAuth, 0)
+	return am.TimedUnlock(a, passphrase, 0)
 }
 
 // Lock removes the private key with the given address from memory.

accounts/accounts_test.go

@@ -81,6 +81,34 @@ func TestSign(t *testing.T) {
 	}
 }
 
+func TestSignWithPassphrase(t *testing.T) {
+	dir, am := tmpManager(t, true)
+	defer os.RemoveAll(dir)
+
+	pass := "passwd"
+	acc, err := am.NewAccount(pass)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if _, unlocked := am.unlocked[acc.Address]; unlocked {
+		t.Fatal("expected account to be locked")
+	}
+
+	_, err = am.SignWithPassphrase(acc.Address, pass, testSigData)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if _, unlocked := am.unlocked[acc.Address]; unlocked {
+		t.Fatal("expected account to be locked")
+	}
+
+	if _, err = am.SignWithPassphrase(acc.Address, "invalid passwd", testSigData); err == nil {
+		t.Fatal("expected SignHash to fail with invalid password")
+	}
+}
+
 func TestTimedUnlock(t *testing.T) {
 	dir, am := tmpManager(t, true)
 	defer os.RemoveAll(dir)

cmd/ethtest/main.go

@@ -25,10 +25,10 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/tests"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -183,7 +183,7 @@ func runSuite(test, file string) {
 	}
 }
 
-func setupApp(c *cli.Context) {
+func setupApp(c *cli.Context) error {
 	flagTest := c.GlobalString(TestFlag.Name)
 	flagFile := c.GlobalString(FileFlag.Name)
 	continueOnError = c.GlobalBool(ContinueOnErrorFlag.Name)
@@ -196,8 +196,8 @@ func setupApp(c *cli.Context) {
 		if err := runTestWithReader(flagTest, os.Stdin); err != nil {
 			glog.Fatalln(err)
 		}
-
 	}
+	return nil
 }
 
 func main() {

cmd/evm/main.go

@@ -24,7 +24,6 @@ import (
 	"runtime"
 	"time"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -33,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/logger/glog"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -84,11 +84,16 @@ var (
 		Name:  "verbosity",
 		Usage: "sets the verbosity level",
 	}
+	CreateFlag = cli.BoolFlag{
+		Name:  "create",
+		Usage: "indicates the action should be create rather than call",
+	}
 )
 
 func init() {
 	app = utils.NewApp("0.2", "the evm command line interface")
 	app.Flags = []cli.Flag{
+		CreateFlag,
 		DebugFlag,
 		VerbosityFlag,
 		ForceJitFlag,
@@ -104,15 +109,13 @@ func init() {
 	app.Action = run
 }
 
-func run(ctx *cli.Context) {
+func run(ctx *cli.Context) error {
 	glog.SetToStderr(true)
 	glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
 
 	db, _ := ethdb.NewMemDatabase()
 	statedb, _ := state.New(common.Hash{}, db)
 	sender := statedb.CreateAccount(common.StringToAddress("sender"))
-	receiver := statedb.CreateAccount(common.StringToAddress("receiver"))
-	receiver.SetCode(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name)))
 
 	vmenv := NewEnv(statedb, common.StringToAddress("evmuser"), common.Big(ctx.GlobalString(ValueFlag.Name)), vm.Config{
 		Debug:     ctx.GlobalBool(DebugFlag.Name),
@@ -121,17 +124,37 @@ func run(ctx *cli.Context) {
 	})
 
 	tstart := time.Now()
-	ret, e := vmenv.Call(
+
-		sender,
+	var (
-		receiver.Address(),
+		ret []byte
-		common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)),
+		err error
-		common.Big(ctx.GlobalString(GasFlag.Name)),
-		common.Big(ctx.GlobalString(PriceFlag.Name)),
-		common.Big(ctx.GlobalString(ValueFlag.Name)),
 	)
+
+	if ctx.GlobalBool(CreateFlag.Name) {
+		input := append(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name)), common.Hex2Bytes(ctx.GlobalString(InputFlag.Name))...)
+		ret, _, err = vmenv.Create(
+			sender,
+			input,
+			common.Big(ctx.GlobalString(GasFlag.Name)),
+			common.Big(ctx.GlobalString(PriceFlag.Name)),
+			common.Big(ctx.GlobalString(ValueFlag.Name)),
+		)
+	} else {
+		receiver := statedb.CreateAccount(common.StringToAddress("receiver"))
+		receiver.SetCode(common.Hex2Bytes(ctx.GlobalString(CodeFlag.Name)))
+		ret, err = vmenv.Call(
+			sender,
+			receiver.Address(),
+			common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)),
+			common.Big(ctx.GlobalString(GasFlag.Name)),
+			common.Big(ctx.GlobalString(PriceFlag.Name)),
+			common.Big(ctx.GlobalString(ValueFlag.Name)),
+		)
+	}
 	vmdone := time.Since(tstart)
 
 	if ctx.GlobalBool(DumpFlag.Name) {
+		statedb.Commit()
 		fmt.Println(string(statedb.Dump()))
 	}
 	vm.StdErrFormat(vmenv.StructLogs())
@@ -150,10 +173,11 @@ num gc:     %d
 	}
 
 	fmt.Printf("OUT: 0x%x", ret)
-	if e != nil {
+	if err != nil {
-		fmt.Printf(" error: %v", e)
+		fmt.Printf(" error: %v", err)
 	}
 	fmt.Println()
+	return nil
 }
 
 func main() {
@@ -196,6 +220,7 @@ type ruleSet struct{}
 
 func (ruleSet) IsHomestead(*big.Int) bool { return true }
 
+func (self *VMEnv) MarkCodeHash(common.Hash)   {}
 func (self *VMEnv) RuleSet() vm.RuleSet        { return ruleSet{} }
 func (self *VMEnv) Vm() vm.Vm                  { return self.evm }
 func (self *VMEnv) Db() vm.Database            { return self.state }

cmd/geth/accountcmd.go

@@ -20,12 +20,13 @@ import (
 	"fmt"
 	"io/ioutil"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/console"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -69,7 +70,7 @@ either new or import). Without it you are not able to unlock your account.
 
 Note that exporting your key in unencrypted format is NOT supported.
 
-Keys are stored under <DATADIR>/keys.
+Keys are stored under <DATADIR>/keystore.
 It is safe to transfer the entire directory or the individual keys therein
 between ethereum nodes by simply copying.
 Make sure you backup your keys regularly.
@@ -166,11 +167,12 @@ nodes.
 	}
 )
 
-func accountList(ctx *cli.Context) {
+func accountList(ctx *cli.Context) error {
 	accman := utils.MakeAccountManager(ctx)
 	for i, acct := range accman.Accounts() {
 		fmt.Printf("Account #%d: {%x} %s\n", i, acct.Address, acct.File)
 	}
+	return nil
 }
 
 // tries unlocking the specified account a few times.
@@ -215,12 +217,12 @@ func getPassPhrase(prompt string, confirmation bool, i int, passwords []string)
 	if prompt != "" {
 		fmt.Println(prompt)
 	}
-	password, err := utils.Stdin.PasswordPrompt("Passphrase: ")
+	password, err := console.Stdin.PromptPassword("Passphrase: ")
 	if err != nil {
 		utils.Fatalf("Failed to read passphrase: %v", err)
 	}
 	if confirmation {
-		confirm, err := utils.Stdin.PasswordPrompt("Repeat passphrase: ")
+		confirm, err := console.Stdin.PromptPassword("Repeat passphrase: ")
 		if err != nil {
 			utils.Fatalf("Failed to read passphrase confirmation: %v", err)
 		}
@@ -258,7 +260,7 @@ func ambiguousAddrRecovery(am *accounts.Manager, err *accounts.AmbiguousAddrErro
 }
 
 // accountCreate creates a new account into the keystore defined by the CLI flags.
-func accountCreate(ctx *cli.Context) {
+func accountCreate(ctx *cli.Context) error {
 	accman := utils.MakeAccountManager(ctx)
 	password := getPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx))
 
@@ -267,11 +269,12 @@ func accountCreate(ctx *cli.Context) {
 		utils.Fatalf("Failed to create account: %v", err)
 	}
 	fmt.Printf("Address: {%x}\n", account.Address)
+	return nil
 }
 
 // accountUpdate transitions an account from a previous format to the current
 // one, also providing the possibility to change the pass-phrase.
-func accountUpdate(ctx *cli.Context) {
+func accountUpdate(ctx *cli.Context) error {
 	if len(ctx.Args()) == 0 {
 		utils.Fatalf("No accounts specified to update")
 	}
@@ -282,9 +285,10 @@ func accountUpdate(ctx *cli.Context) {
 	if err := accman.Update(account, oldPassword, newPassword); err != nil {
 		utils.Fatalf("Could not update the account: %v", err)
 	}
+	return nil
 }
 
-func importWallet(ctx *cli.Context) {
+func importWallet(ctx *cli.Context) error {
 	keyfile := ctx.Args().First()
 	if len(keyfile) == 0 {
 		utils.Fatalf("keyfile must be given as argument")
@@ -302,9 +306,10 @@ func importWallet(ctx *cli.Context) {
 		utils.Fatalf("%v", err)
 	}
 	fmt.Printf("Address: {%x}\n", acct.Address)
+	return nil
 }
 
-func accountImport(ctx *cli.Context) {
+func accountImport(ctx *cli.Context) error {
 	keyfile := ctx.Args().First()
 	if len(keyfile) == 0 {
 		utils.Fatalf("keyfile must be given as argument")
@@ -320,4 +325,5 @@ func accountImport(ctx *cli.Context) {
 		utils.Fatalf("Could not create the account: %v", err)
 	}
 	fmt.Printf("Address: {%x}\n", acct.Address)
+	return nil
 }

cmd/geth/chaincmd.go

@@ -23,14 +23,15 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/console"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/logger/glog"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -71,7 +72,7 @@ Use "ethereum dump 0" to dump the genesis block.
 	}
 )
 
-func importChain(ctx *cli.Context) {
+func importChain(ctx *cli.Context) error {
 	if len(ctx.Args()) != 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
@@ -83,9 +84,10 @@ func importChain(ctx *cli.Context) {
 		utils.Fatalf("Import error: %v", err)
 	}
 	fmt.Printf("Import done in %v", time.Since(start))
+	return nil
 }
 
-func exportChain(ctx *cli.Context) {
+func exportChain(ctx *cli.Context) error {
 	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
@@ -113,10 +115,11 @@ func exportChain(ctx *cli.Context) {
 		utils.Fatalf("Export error: %v\n", err)
 	}
 	fmt.Printf("Export done in %v", time.Since(start))
+	return nil
 }
 
-func removeDB(ctx *cli.Context) {
+func removeDB(ctx *cli.Context) error {
-	confirm, err := utils.Stdin.ConfirmPrompt("Remove local database?")
+	confirm, err := console.Stdin.PromptConfirm("Remove local database?")
 	if err != nil {
 		utils.Fatalf("%v", err)
 	}
@@ -131,9 +134,10 @@ func removeDB(ctx *cli.Context) {
 	} else {
 		fmt.Println("Operation aborted")
 	}
+	return nil
 }
 
-func upgradeDB(ctx *cli.Context) {
+func upgradeDB(ctx *cli.Context) error {
 	glog.Infoln("Upgrading blockchain database")
 
 	chain, chainDb := utils.MakeChain(ctx)
@@ -162,9 +166,10 @@ func upgradeDB(ctx *cli.Context) {
 		os.Remove(exportFile)
 		glog.Infoln("Import finished")
 	}
+	return nil
 }
 
-func dump(ctx *cli.Context) {
+func dump(ctx *cli.Context) error {
 	chain, chainDb := utils.MakeChain(ctx)
 	for _, arg := range ctx.Args() {
 		var block *types.Block
@@ -181,12 +186,12 @@ func dump(ctx *cli.Context) {
 			state, err := state.New(block.Root(), chainDb)
 			if err != nil {
 				utils.Fatalf("could not create new state: %v", err)
-				return
 			}
 			fmt.Printf("%s\n", state.Dump())
 		}
 	}
 	chainDb.Close()
+	return nil
 }
 
 // hashish returns true for strings that look like hashes.

cmd/geth/consolecmd.go

@@ -0,0 +1,173 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"os"
+	"os/signal"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/console"
+	"gopkg.in/urfave/cli.v1"
+)
+
+var (
+	consoleCommand = cli.Command{
+		Action: localConsole,
+		Name:   "console",
+		Usage:  `Geth Console: interactive JavaScript environment`,
+		Description: `
+The Geth console is an interactive shell for the JavaScript runtime environment
+which exposes a node admin interface as well as the Ðapp JavaScript API.
+See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
+`,
+	}
+	attachCommand = cli.Command{
+		Action: remoteConsole,
+		Name:   "attach",
+		Usage:  `Geth Console: interactive JavaScript environment (connect to node)`,
+		Description: `
+The Geth console is an interactive shell for the JavaScript runtime environment
+which exposes a node admin interface as well as the Ðapp JavaScript API.
+See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.
+This command allows to open a console on a running geth node.
+	`,
+	}
+	javascriptCommand = cli.Command{
+		Action: ephemeralConsole,
+		Name:   "js",
+		Usage:  `executes the given JavaScript files in the Geth JavaScript VM`,
+		Description: `
+The JavaScript VM exposes a node admin interface as well as the Ðapp
+JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
+`,
+	}
+)
+
+// localConsole starts a new geth node, attaching a JavaScript console to it at the
+// same time.
+func localConsole(ctx *cli.Context) error {
+	// Create and start the node based on the CLI flags
+	node := utils.MakeSystemNode(clientIdentifier, verString, relConfig, makeDefaultExtra(), ctx)
+	startNode(ctx, node)
+	defer node.Stop()
+
+	// Attach to the newly started node and start the JavaScript console
+	client, err := node.Attach()
+	if err != nil {
+		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
+	}
+	config := console.Config{
+		DataDir: node.DataDir(),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
+		Client:  client,
+		Preload: utils.MakeConsolePreloads(ctx),
+	}
+	console, err := console.New(config)
+	if err != nil {
+		utils.Fatalf("Failed to start the JavaScript console: %v", err)
+	}
+	defer console.Stop(false)
+
+	// If only a short execution was requested, evaluate and return
+	if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
+		console.Evaluate(script)
+		return nil
+	}
+	// Otherwise print the welcome screen and enter interactive mode
+	console.Welcome()
+	console.Interactive()
+
+	return nil
+}
+
+// remoteConsole will connect to a remote geth instance, attaching a JavaScript
+// console to it.
+func remoteConsole(ctx *cli.Context) error {
+	// Attach to a remotely running geth instance and start the JavaScript console
+	client, err := utils.NewRemoteRPCClient(ctx)
+	if err != nil {
+		utils.Fatalf("Unable to attach to remote geth: %v", err)
+	}
+	config := console.Config{
+		DataDir: utils.MustMakeDataDir(ctx),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
+		Client:  client,
+		Preload: utils.MakeConsolePreloads(ctx),
+	}
+	console, err := console.New(config)
+	if err != nil {
+		utils.Fatalf("Failed to start the JavaScript console: %v", err)
+	}
+	defer console.Stop(false)
+
+	// If only a short execution was requested, evaluate and return
+	if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
+		console.Evaluate(script)
+		return nil
+	}
+	// Otherwise print the welcome screen and enter interactive mode
+	console.Welcome()
+	console.Interactive()
+
+	return nil
+}
+
+// ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript
+// console to it, and each of the files specified as arguments and tears the
+// everything down.
+func ephemeralConsole(ctx *cli.Context) error {
+	// Create and start the node based on the CLI flags
+	node := utils.MakeSystemNode(clientIdentifier, verString, relConfig, makeDefaultExtra(), ctx)
+	startNode(ctx, node)
+	defer node.Stop()
+
+	// Attach to the newly started node and start the JavaScript console
+	client, err := node.Attach()
+	if err != nil {
+		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
+	}
+	config := console.Config{
+		DataDir: node.DataDir(),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
+		Client:  client,
+		Preload: utils.MakeConsolePreloads(ctx),
+	}
+	console, err := console.New(config)
+	if err != nil {
+		utils.Fatalf("Failed to start the JavaScript console: %v", err)
+	}
+	defer console.Stop(false)
+
+	// Evaluate each of the specified JavaScript files
+	for _, file := range ctx.Args() {
+		if err = console.Execute(file); err != nil {
+			utils.Fatalf("Failed to execute %s: %v", file, err)
+		}
+	}
+	// Wait for pending callbacks, but stop for Ctrl-C.
+	abort := make(chan os.Signal, 1)
+	signal.Notify(abort, os.Interrupt)
+
+	go func() {
+		<-abort
+		os.Exit(0)
+	}()
+	console.Stop(true)
+
+	return nil
+}

cmd/geth/consolecmd_test.go

@@ -0,0 +1,170 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"crypto/rand"
+	"math/big"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// Tests that a node embedded within a console can be started up properly and
+// then terminated by closing the input stream.
+func TestConsoleWelcome(t *testing.T) {
+	coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+
+	// Start a geth console, make sure it's cleaned up and terminate the console
+	geth := runGeth(t,
+		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
+		"--etherbase", coinbase, "--shh",
+		"console")
+
+	// Gather all the infos the welcome message needs to contain
+	geth.setTemplateFunc("goos", func() string { return runtime.GOOS })
+	geth.setTemplateFunc("gover", runtime.Version)
+	geth.setTemplateFunc("gethver", func() string { return verString })
+	geth.setTemplateFunc("niltime", func() string { return time.Unix(0, 0).Format(time.RFC1123) })
+	geth.setTemplateFunc("apis", func() []string {
+		apis := append(strings.Split(rpc.DefaultIPCApis, ","), rpc.MetadataApi)
+		sort.Strings(apis)
+		return apis
+	})
+
+	// Verify the actual welcome message to the required template
+	geth.expect(`
+Welcome to the Geth JavaScript console!
+
+instance: Geth/v{{gethver}}/{{goos}}/{{gover}}
+coinbase: {{.Etherbase}}
+at block: 0 ({{niltime}})
+ datadir: {{.Datadir}}
+ modules:{{range apis}} {{.}}:1.0{{end}}
+
+> {{.InputLine "exit"}}
+`)
+	geth.expectExit()
+}
+
+// Tests that a console can be attached to a running node via various means.
+func TestIPCAttachWelcome(t *testing.T) {
+	// Configure the instance for IPC attachement
+	coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+	var ipc string
+	if runtime.GOOS == "windows" {
+		ipc = `\\.\pipe\geth` + strconv.Itoa(trulyRandInt(100000, 999999))
+	} else {
+		ws := tmpdir(t)
+		defer os.RemoveAll(ws)
+		ipc = filepath.Join(ws, "geth.ipc")
+	}
+	// Note: we need --shh because testAttachWelcome checks for default
+	// list of ipc modules and shh is included there.
+	geth := runGeth(t,
+		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
+		"--etherbase", coinbase, "--shh", "--ipcpath", ipc)
+
+	time.Sleep(2 * time.Second) // Simple way to wait for the RPC endpoint to open
+	testAttachWelcome(t, geth, "ipc:"+ipc)
+
+	geth.interrupt()
+	geth.expectExit()
+}
+
+func TestHTTPAttachWelcome(t *testing.T) {
+	coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+	port := strconv.Itoa(trulyRandInt(1024, 65536)) // Yeah, sometimes this will fail, sorry :P
+	geth := runGeth(t,
+		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
+		"--etherbase", coinbase, "--rpc", "--rpcport", port)
+
+	time.Sleep(2 * time.Second) // Simple way to wait for the RPC endpoint to open
+	testAttachWelcome(t, geth, "http://localhost:"+port)
+
+	geth.interrupt()
+	geth.expectExit()
+}
+
+func TestWSAttachWelcome(t *testing.T) {
+	coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+	port := strconv.Itoa(trulyRandInt(1024, 65536)) // Yeah, sometimes this will fail, sorry :P
+
+	geth := runGeth(t,
+		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
+		"--etherbase", coinbase, "--ws", "--wsport", port)
+
+	time.Sleep(2 * time.Second) // Simple way to wait for the RPC endpoint to open
+	testAttachWelcome(t, geth, "ws://localhost:"+port)
+
+	geth.interrupt()
+	geth.expectExit()
+}
+
+func testAttachWelcome(t *testing.T, geth *testgeth, endpoint string) {
+	// Attach to a running geth note and terminate immediately
+	attach := runGeth(t, "attach", endpoint)
+	defer attach.expectExit()
+	attach.stdin.Close()
+
+	// Gather all the infos the welcome message needs to contain
+	attach.setTemplateFunc("goos", func() string { return runtime.GOOS })
+	attach.setTemplateFunc("gover", runtime.Version)
+	attach.setTemplateFunc("gethver", func() string { return verString })
+	attach.setTemplateFunc("etherbase", func() string { return geth.Etherbase })
+	attach.setTemplateFunc("niltime", func() string { return time.Unix(0, 0).Format(time.RFC1123) })
+	attach.setTemplateFunc("ipc", func() bool { return strings.HasPrefix(endpoint, "ipc") })
+	attach.setTemplateFunc("datadir", func() string { return geth.Datadir })
+	attach.setTemplateFunc("apis", func() []string {
+		var apis []string
+		if strings.HasPrefix(endpoint, "ipc") {
+			apis = append(strings.Split(rpc.DefaultIPCApis, ","), rpc.MetadataApi)
+		} else {
+			apis = append(strings.Split(rpc.DefaultHTTPApis, ","), rpc.MetadataApi)
+		}
+		sort.Strings(apis)
+		return apis
+	})
+
+	// Verify the actual welcome message to the required template
+	attach.expect(`
+Welcome to the Geth JavaScript console!
+
+instance: Geth/v{{gethver}}/{{goos}}/{{gover}}
+coinbase: {{etherbase}}
+at block: 0 ({{niltime}}){{if ipc}}
+ datadir: {{datadir}}{{end}}
+ modules:{{range apis}} {{.}}:1.0{{end}}
+
+> {{.InputLine "exit" }}
+`)
+	attach.expectExit()
+}
+
+// trulyRandInt generates a crypto random integer used by the console tests to
+// not clash network ports with other tests running cocurrently.
+func trulyRandInt(lo, hi int) int {
+	num, _ := rand.Int(rand.Reader, big.NewInt(int64(hi-lo)))
+	return int(num.Int64()) + lo
+}

cmd/geth/js.go

@@ -1,427 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"math/big"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-
-	"github.com/codegangsta/cli"
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/registrar"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/internal/web3ext"
-	re "github.com/ethereum/go-ethereum/jsre"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/peterh/liner"
-	"github.com/robertkrimen/otto"
-)
-
-var (
-	passwordRegexp = regexp.MustCompile("personal.[nu]")
-	leadingSpace   = regexp.MustCompile("^ ")
-	onlyws         = regexp.MustCompile("^\\s*$")
-	exit           = regexp.MustCompile("^\\s*exit\\s*;*\\s*$")
-)
-
-type jsre struct {
-	re         *re.JSRE
-	stack      *node.Node
-	wait       chan *big.Int
-	ps1        string
-	atexit     func()
-	corsDomain string
-	client     rpc.Client
-}
-
-func makeCompleter(re *jsre) liner.WordCompleter {
-	return func(line string, pos int) (head string, completions []string, tail string) {
-		if len(line) == 0 || pos == 0 {
-			return "", nil, ""
-		}
-		// chuck data to relevant part for autocompletion, e.g. in case of nested lines eth.getBalance(eth.coinb<tab><tab>
-		i := 0
-		for i = pos - 1; i > 0; i-- {
-			if line[i] == '.' || (line[i] >= 'a' && line[i] <= 'z') || (line[i] >= 'A' && line[i] <= 'Z') {
-				continue
-			}
-			if i >= 3 && line[i] == '3' && line[i-3] == 'w' && line[i-2] == 'e' && line[i-1] == 'b' {
-				continue
-			}
-			i += 1
-			break
-		}
-		return line[:i], re.re.CompleteKeywords(line[i:pos]), line[pos:]
-	}
-}
-
-func newLightweightJSRE(docRoot string, client rpc.Client, datadir string, interactive bool) *jsre {
-	js := &jsre{ps1: "> "}
-	js.wait = make(chan *big.Int)
-	js.client = client
-	js.re = re.New(docRoot)
-	if err := js.apiBindings(); err != nil {
-		utils.Fatalf("Unable to initialize console - %v", err)
-	}
-	js.setupInput(datadir)
-	return js
-}
-
-func newJSRE(stack *node.Node, docRoot, corsDomain string, client rpc.Client, interactive bool) *jsre {
-	js := &jsre{stack: stack, ps1: "> "}
-	// set default cors domain used by startRpc from CLI flag
-	js.corsDomain = corsDomain
-	js.wait = make(chan *big.Int)
-	js.client = client
-	js.re = re.New(docRoot)
-	if err := js.apiBindings(); err != nil {
-		utils.Fatalf("Unable to connect - %v", err)
-	}
-	js.setupInput(stack.DataDir())
-	return js
-}
-
-func (self *jsre) setupInput(datadir string) {
-	self.withHistory(datadir, func(hist *os.File) { utils.Stdin.ReadHistory(hist) })
-	utils.Stdin.SetCtrlCAborts(true)
-	utils.Stdin.SetWordCompleter(makeCompleter(self))
-	utils.Stdin.SetTabCompletionStyle(liner.TabPrints)
-	self.atexit = func() {
-		self.withHistory(datadir, func(hist *os.File) {
-			hist.Truncate(0)
-			utils.Stdin.WriteHistory(hist)
-		})
-		utils.Stdin.Close()
-		close(self.wait)
-	}
-}
-
-func (self *jsre) batch(statement string) {
-	err := self.re.EvalAndPrettyPrint(statement)
-
-	if err != nil {
-		fmt.Printf("%v", jsErrorString(err))
-	}
-
-	if self.atexit != nil {
-		self.atexit()
-	}
-
-	self.re.Stop(false)
-}
-
-// show summary of current geth instance
-func (self *jsre) welcome() {
-	self.re.Run(`
-    (function () {
-      console.log('instance: ' + web3.version.node);
-      console.log("coinbase: " + eth.coinbase);
-      var ts = 1000 * eth.getBlock(eth.blockNumber).timestamp;
-      console.log("at block: " + eth.blockNumber + " (" + new Date(ts) + ")");
-      console.log(' datadir: ' + admin.datadir);
-    })();
-  `)
-	if modules, err := self.supportedApis(); err == nil {
-		loadedModules := make([]string, 0)
-		for api, version := range modules {
-			loadedModules = append(loadedModules, fmt.Sprintf("%s:%s", api, version))
-		}
-		sort.Strings(loadedModules)
-	}
-}
-
-func (self *jsre) supportedApis() (map[string]string, error) {
-	return self.client.SupportedModules()
-}
-
-func (js *jsre) apiBindings() error {
-	apis, err := js.supportedApis()
-	if err != nil {
-		return err
-	}
-
-	apiNames := make([]string, 0, len(apis))
-	for a, _ := range apis {
-		apiNames = append(apiNames, a)
-	}
-
-	jeth := utils.NewJeth(js.re, js.client)
-	js.re.Set("jeth", struct{}{})
-	t, _ := js.re.Get("jeth")
-	jethObj := t.Object()
-
-	jethObj.Set("send", jeth.Send)
-	jethObj.Set("sendAsync", jeth.Send)
-
-	err = js.re.Compile("bignumber.js", re.BigNumber_JS)
-	if err != nil {
-		utils.Fatalf("Error loading bignumber.js: %v", err)
-	}
-
-	err = js.re.Compile("web3.js", re.Web3_JS)
-	if err != nil {
-		utils.Fatalf("Error loading web3.js: %v", err)
-	}
-
-	_, err = js.re.Run("var Web3 = require('web3');")
-	if err != nil {
-		utils.Fatalf("Error requiring web3: %v", err)
-	}
-
-	_, err = js.re.Run("var web3 = new Web3(jeth);")
-	if err != nil {
-		utils.Fatalf("Error setting web3 provider: %v", err)
-	}
-
-	// load only supported API's in javascript runtime
-	shortcuts := "var eth = web3.eth; var personal = web3.personal; "
-	for _, apiName := range apiNames {
-		if apiName == "web3" || apiName == "rpc" {
-			continue // manually mapped or ignore
-		}
-
-		if jsFile, ok := web3ext.Modules[apiName]; ok {
-			if err = js.re.Compile(fmt.Sprintf("%s.js", apiName), jsFile); err == nil {
-				shortcuts += fmt.Sprintf("var %s = web3.%s; ", apiName, apiName)
-			} else {
-				utils.Fatalf("Error loading %s.js: %v", apiName, err)
-			}
-		}
-	}
-
-	_, err = js.re.Run(shortcuts)
-	if err != nil {
-		utils.Fatalf("Error setting namespaces: %v", err)
-	}
-
-	js.re.Run(`var GlobalRegistrar = eth.contract(` + registrar.GlobalRegistrarAbi + `);   registrar = GlobalRegistrar.at("` + registrar.GlobalRegistrarAddr + `");`)
-
-	// overrule some of the methods that require password as input and ask for it interactively
-	p, err := js.re.Get("personal")
-	if err != nil {
-		fmt.Println("Unable to overrule sensitive methods in personal module")
-		return nil
-	}
-
-	// Override the unlockAccount and newAccount methods on the personal object since these require user interaction.
-	// Assign the jeth.unlockAccount and jeth.newAccount in the jsre the original web3 callbacks. These will be called
-	// by the jeth.* methods after they got the password from the user and send the original web3 request to the backend.
-	if persObj := p.Object(); persObj != nil { // make sure the personal api is enabled over the interface
-		js.re.Run(`jeth.unlockAccount = personal.unlockAccount;`)
-		persObj.Set("unlockAccount", jeth.UnlockAccount)
-		js.re.Run(`jeth.newAccount = personal.newAccount;`)
-		persObj.Set("newAccount", jeth.NewAccount)
-	}
-
-	// The admin.sleep and admin.sleepBlocks are offered by the console and not by the RPC layer.
-	// Bind these if the admin module is available.
-	if a, err := js.re.Get("admin"); err == nil {
-		if adminObj := a.Object(); adminObj != nil {
-			adminObj.Set("sleepBlocks", jeth.SleepBlocks)
-			adminObj.Set("sleep", jeth.Sleep)
-		}
-	}
-
-	return nil
-}
-
-func (self *jsre) AskPassword() (string, bool) {
-	pass, err := utils.Stdin.PasswordPrompt("Passphrase: ")
-	if err != nil {
-		return "", false
-	}
-	return pass, true
-}
-
-func (self *jsre) ConfirmTransaction(tx string) bool {
-	// Retrieve the Ethereum instance from the node
-	var ethereum *eth.Ethereum
-	if err := self.stack.Service(&ethereum); err != nil {
-		return false
-	}
-	// If natspec is enabled, ask for permission
-	if ethereum.NatSpec && false /* disabled for now */ {
-		//		notice := natspec.GetNotice(self.xeth, tx, ethereum.HTTPClient())
-		//		fmt.Println(notice)
-		//		answer, _ := self.Prompt("Confirm Transaction [y/n]")
-		//		return strings.HasPrefix(strings.Trim(answer, " "), "y")
-	}
-	return true
-}
-
-func (self *jsre) UnlockAccount(addr []byte) bool {
-	fmt.Printf("Please unlock account %x.\n", addr)
-	pass, err := utils.Stdin.PasswordPrompt("Passphrase: ")
-	if err != nil {
-		return false
-	}
-	// TODO: allow retry
-	var ethereum *eth.Ethereum
-	if err := self.stack.Service(&ethereum); err != nil {
-		return false
-	}
-	a := accounts.Account{Address: common.BytesToAddress(addr)}
-	if err := ethereum.AccountManager().Unlock(a, pass); err != nil {
-		return false
-	} else {
-		fmt.Println("Account is now unlocked for this session.")
-		return true
-	}
-}
-
-// preloadJSFiles loads JS files that the user has specified with ctx.PreLoadJSFlag into
-// the JSRE. If not all files could be loaded it will return an error describing the error.
-func (self *jsre) preloadJSFiles(ctx *cli.Context) error {
-	if ctx.GlobalString(utils.PreLoadJSFlag.Name) != "" {
-		assetPath := ctx.GlobalString(utils.JSpathFlag.Name)
-		jsFiles := strings.Split(ctx.GlobalString(utils.PreLoadJSFlag.Name), ",")
-		for _, file := range jsFiles {
-			filename := common.AbsolutePath(assetPath, strings.TrimSpace(file))
-			if err := self.re.Exec(filename); err != nil {
-				return fmt.Errorf("%s: %v", file, jsErrorString(err))
-			}
-		}
-	}
-	return nil
-}
-
-// jsErrorString adds a backtrace to errors generated by otto.
-func jsErrorString(err error) string {
-	if ottoErr, ok := err.(*otto.Error); ok {
-		return ottoErr.String()
-	}
-	return err.Error()
-}
-
-func (self *jsre) interactive() {
-	// Read input lines.
-	prompt := make(chan string)
-	inputln := make(chan string)
-	go func() {
-		defer close(inputln)
-		for {
-			line, err := utils.Stdin.Prompt(<-prompt)
-			if err != nil {
-				if err == liner.ErrPromptAborted { // ctrl-C
-					self.resetPrompt()
-					inputln <- ""
-					continue
-				}
-				return
-			}
-			inputln <- line
-		}
-	}()
-	// Wait for Ctrl-C, too.
-	sig := make(chan os.Signal, 1)
-	signal.Notify(sig, os.Interrupt)
-
-	defer func() {
-		if self.atexit != nil {
-			self.atexit()
-		}
-		self.re.Stop(false)
-	}()
-	for {
-		prompt <- self.ps1
-		select {
-		case <-sig:
-			fmt.Println("caught interrupt, exiting")
-			return
-		case input, ok := <-inputln:
-			if !ok || indentCount <= 0 && exit.MatchString(input) {
-				return
-			}
-			if onlyws.MatchString(input) {
-				continue
-			}
-			str += input + "\n"
-			self.setIndent()
-			if indentCount <= 0 {
-				if mustLogInHistory(str) {
-					utils.Stdin.AppendHistory(str[:len(str)-1])
-				}
-				self.parseInput(str)
-				str = ""
-			}
-		}
-	}
-}
-
-func mustLogInHistory(input string) bool {
-	return len(input) == 0 ||
-		passwordRegexp.MatchString(input) ||
-		!leadingSpace.MatchString(input)
-}
-
-func (self *jsre) withHistory(datadir string, op func(*os.File)) {
-	hist, err := os.OpenFile(filepath.Join(datadir, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
-	if err != nil {
-		fmt.Printf("unable to open history file: %v\n", err)
-		return
-	}
-	op(hist)
-	hist.Close()
-}
-
-func (self *jsre) parseInput(code string) {
-	defer func() {
-		if r := recover(); r != nil {
-			fmt.Println("[native] error", r)
-		}
-	}()
-	if err := self.re.EvalAndPrettyPrint(code); err != nil {
-		if ottoErr, ok := err.(*otto.Error); ok {
-			fmt.Println(ottoErr.String())
-		} else {
-			fmt.Println(err)
-		}
-		return
-	}
-}
-
-var indentCount = 0
-var str = ""
-
-func (self *jsre) resetPrompt() {
-	indentCount = 0
-	str = ""
-	self.ps1 = "> "
-}
-
-func (self *jsre) setIndent() {
-	open := strings.Count(str, "{")
-	open += strings.Count(str, "(")
-	closed := strings.Count(str, "}")
-	closed += strings.Count(str, ")")
-	indentCount = open - closed
-	if indentCount <= 0 {
-		self.ps1 = "> "
-	} else {
-		self.ps1 = strings.Join(make([]string, indentCount*2), "..")
-		self.ps1 += " "
-	}
-}

cmd/geth/js_test.go

@@ -1,500 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"math/big"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/compiler"
-	"github.com/ethereum/go-ethereum/common/httpclient"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/node"
-)
-
-const (
-	testSolcPath = ""
-	solcVersion  = "0.9.23"
-	testAddress  = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
-	testBalance  = "10000000000000000000"
-	// of empty string
-	testHash = "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
-)
-
-var (
-	versionRE      = regexp.MustCompile(strconv.Quote(`"compilerVersion":"` + solcVersion + `"`))
-	testNodeKey, _ = crypto.HexToECDSA("4b50fa71f5c3eeb8fdc452224b2395af2fcc3d125e06c32c82e048c0559db03f")
-	testAccount, _ = crypto.HexToECDSA("e6fab74a43941f82d89cb7faa408e227cdad3153c4720e540e855c19b15e6674")
-	testGenesis    = `{"` + testAddress[2:] + `": {"balance": "` + testBalance + `"}}`
-)
-
-type testjethre struct {
-	*jsre
-	lastConfirm string
-	client      *httpclient.HTTPClient
-}
-
-// Temporary disabled while natspec hasn't been migrated
-//func (self *testjethre) ConfirmTransaction(tx string) bool {
-//	var ethereum *eth.Ethereum
-//	self.stack.Service(&ethereum)
-//
-//	if ethereum.NatSpec {
-//		self.lastConfirm = natspec.GetNotice(self.xeth, tx, self.client)
-//	}
-//	return true
-//}
-
-func testJEthRE(t *testing.T) (string, *testjethre, *node.Node) {
-	return testREPL(t, nil)
-}
-
-func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *node.Node) {
-	tmp, err := ioutil.TempDir("", "geth-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Create a networkless protocol stack
-	stack, err := node.New(&node.Config{DataDir: tmp, PrivateKey: testNodeKey, Name: "test", NoDiscovery: true})
-	if err != nil {
-		t.Fatalf("failed to create node: %v", err)
-	}
-	// Initialize and register the Ethereum protocol
-	accman := accounts.NewPlaintextManager(filepath.Join(tmp, "keystore"))
-	db, _ := ethdb.NewMemDatabase()
-	core.WriteGenesisBlockForTesting(db, core.GenesisAccount{
-		Address: common.HexToAddress(testAddress),
-		Balance: common.String2Big(testBalance),
-	})
-	ethConf := &eth.Config{
-		ChainConfig:      &core.ChainConfig{HomesteadBlock: new(big.Int)},
-		TestGenesisState: db,
-		AccountManager:   accman,
-		DocRoot:          "/",
-		SolcPath:         testSolcPath,
-		PowTest:          true,
-	}
-	if config != nil {
-		config(ethConf)
-	}
-	if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
-		return eth.New(ctx, ethConf)
-	}); err != nil {
-		t.Fatalf("failed to register ethereum protocol: %v", err)
-	}
-	// Initialize all the keys for testing
-	a, err := accman.ImportECDSA(testAccount, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := accman.Unlock(a, ""); err != nil {
-		t.Fatal(err)
-	}
-	// Start the node and assemble the REPL tester
-	if err := stack.Start(); err != nil {
-		t.Fatalf("failed to start test stack: %v", err)
-	}
-	var ethereum *eth.Ethereum
-	stack.Service(&ethereum)
-
-	assetPath := filepath.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext")
-	client, err := stack.Attach()
-	if err != nil {
-		t.Fatalf("failed to attach to node: %v", err)
-	}
-	tf := &testjethre{client: ethereum.HTTPClient()}
-	repl := newJSRE(stack, assetPath, "", client, false)
-	tf.jsre = repl
-	return tmp, tf, stack
-}
-
-func TestNodeInfo(t *testing.T) {
-	t.Skip("broken after p2p update")
-	tmp, repl, ethereum := testJEthRE(t)
-	defer ethereum.Stop()
-	defer os.RemoveAll(tmp)
-
-	want := `{"DiscPort":0,"IP":"0.0.0.0","ListenAddr":"","Name":"test","NodeID":"4cb2fc32924e94277bf94b5e4c983beedb2eabd5a0bc941db32202735c6625d020ca14a5963d1738af43b6ac0a711d61b1a06de931a499fe2aa0b1a132a902b5","NodeUrl":"enode://4cb2fc32924e94277bf94b5e4c983beedb2eabd5a0bc941db32202735c6625d020ca14a5963d1738af43b6ac0a711d61b1a06de931a499fe2aa0b1a132a902b5@0.0.0.0:0","TCPPort":0,"Td":"131072"}`
-	checkEvalJSON(t, repl, `admin.nodeInfo`, want)
-}
-
-func TestAccounts(t *testing.T) {
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-
-	checkEvalJSON(t, repl, `eth.accounts`, `["`+testAddress+`"]`)
-	checkEvalJSON(t, repl, `eth.coinbase`, `"`+testAddress+`"`)
-	val, err := repl.re.Run(`jeth.newAccount("password")`)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-	addr := val.String()
-	if !regexp.MustCompile(`0x[0-9a-f]{40}`).MatchString(addr) {
-		t.Errorf("address not hex: %q", addr)
-	}
-
-	checkEvalJSON(t, repl, `eth.accounts`, `["`+testAddress+`","`+addr+`"]`)
-
-}
-
-func TestBlockChain(t *testing.T) {
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-	// get current block dump before export/import.
-	val, err := repl.re.Run("JSON.stringify(debug.dumpBlock(eth.blockNumber))")
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-	beforeExport := val.String()
-
-	// do the export
-	extmp, err := ioutil.TempDir("", "geth-test-export")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(extmp)
-	tmpfile := filepath.Join(extmp, "export.chain")
-	tmpfileq := strconv.Quote(tmpfile)
-
-	var ethereum *eth.Ethereum
-	node.Service(&ethereum)
-	ethereum.BlockChain().Reset()
-
-	checkEvalJSON(t, repl, `admin.exportChain(`+tmpfileq+`)`, `true`)
-	if _, err := os.Stat(tmpfile); err != nil {
-		t.Fatal(err)
-	}
-
-	// check import, verify that dumpBlock gives the same result.
-	checkEvalJSON(t, repl, `admin.importChain(`+tmpfileq+`)`, `true`)
-	checkEvalJSON(t, repl, `debug.dumpBlock(eth.blockNumber)`, beforeExport)
-}
-
-func TestMining(t *testing.T) {
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-	checkEvalJSON(t, repl, `eth.mining`, `false`)
-}
-
-func TestRPC(t *testing.T) {
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-
-	checkEvalJSON(t, repl, `admin.startRPC("127.0.0.1", 5004, "*", "web3,eth,net")`, `true`)
-}
-
-func TestCheckTestAccountBalance(t *testing.T) {
-	t.Skip() // i don't think it tests the correct behaviour here. it's actually testing
-	// internals which shouldn't be tested. This now fails because of a change in the core
-	// and i have no means to fix this, sorry - @obscuren
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-
-	repl.re.Run(`primary = "` + testAddress + `"`)
-	checkEvalJSON(t, repl, `eth.getBalance(primary)`, `"`+testBalance+`"`)
-}
-
-func TestSignature(t *testing.T) {
-	tmp, repl, node := testJEthRE(t)
-	defer node.Stop()
-	defer os.RemoveAll(tmp)
-
-	val, err := repl.re.Run(`eth.sign("` + testAddress + `", "` + testHash + `")`)
-
-	// This is a very preliminary test, lacking actual signature verification
-	if err != nil {
-		t.Errorf("Error running js: %v", err)
-		return
-	}
-	output := val.String()
-	t.Logf("Output: %v", output)
-
-	regex := regexp.MustCompile(`^0x[0-9a-f]{130}$`)
-	if !regex.MatchString(output) {
-		t.Errorf("Signature is not 65 bytes represented in hexadecimal.")
-		return
-	}
-}
-
-func TestContract(t *testing.T) {
-	t.Skip("contract testing is implemented with mining in ethash test mode. This takes about 7seconds to run. Unskip and run on demand")
-	coinbase := common.HexToAddress(testAddress)
-	tmp, repl, ethereum := testREPL(t, func(conf *eth.Config) {
-		conf.Etherbase = coinbase
-		conf.PowTest = true
-	})
-	if err := ethereum.Start(); err != nil {
-		t.Errorf("error starting ethereum: %v", err)
-		return
-	}
-	defer ethereum.Stop()
-	defer os.RemoveAll(tmp)
-
-	// Temporary disabled while registrar isn't migrated
-	//reg := registrar.New(repl.xeth)
-	//_, err := reg.SetGlobalRegistrar("", coinbase)
-	//if err != nil {
-	//	t.Errorf("error setting HashReg: %v", err)
-	//}
-	//_, err = reg.SetHashReg("", coinbase)
-	//if err != nil {
-	//	t.Errorf("error setting HashReg: %v", err)
-	//}
-	//_, err = reg.SetUrlHint("", coinbase)
-	//if err != nil {
-	//	t.Errorf("error setting HashReg: %v", err)
-	//}
-	/* TODO:
-	* lookup receipt and contract addresses by tx hash
-	* name registration for HashReg and UrlHint addresses
-	* mine those transactions
-	* then set once more SetHashReg SetUrlHint
-	 */
-
-	source := `contract test {\n` +
-		"   /// @notice Will multiply `a` by 7." + `\n` +
-		`   function multiply(uint a) returns(uint d) {\n` +
-		`       return a * 7;\n` +
-		`   }\n` +
-		`}\n`
-
-	if checkEvalJSON(t, repl, `admin.stopNatSpec()`, `true`) != nil {
-		return
-	}
-
-	contractInfo, err := ioutil.ReadFile("info_test.json")
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if checkEvalJSON(t, repl, `primary = eth.accounts[0]`, `"`+testAddress+`"`) != nil {
-		return
-	}
-	if checkEvalJSON(t, repl, `source = "`+source+`"`, `"`+source+`"`) != nil {
-		return
-	}
-
-	// if solc is found with right version, test it, otherwise read from file
-	sol, err := compiler.New("")
-	if err != nil {
-		t.Logf("solc not found: mocking contract compilation step")
-	} else if sol.Version() != solcVersion {
-		t.Logf("WARNING: solc different version found (%v, test written for %v, may need to update)", sol.Version(), solcVersion)
-	}
-
-	if err != nil {
-		info, err := ioutil.ReadFile("info_test.json")
-		if err != nil {
-			t.Fatalf("%v", err)
-		}
-		_, err = repl.re.Run(`contract = JSON.parse(` + strconv.Quote(string(info)) + `)`)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-	} else {
-		if checkEvalJSON(t, repl, `contract = eth.compile.solidity(source).test`, string(contractInfo)) != nil {
-			return
-		}
-	}
-
-	if checkEvalJSON(t, repl, `contract.code`, `"0x605880600c6000396000f3006000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa114602e57005b603d6004803590602001506047565b8060005260206000f35b60006007820290506053565b91905056"`) != nil {
-		return
-	}
-
-	if checkEvalJSON(
-		t, repl,
-		`contractaddress = eth.sendTransaction({from: primary, data: contract.code})`,
-		`"0x46d69d55c3c4b86a924a92c9fc4720bb7bce1d74"`,
-	) != nil {
-		return
-	}
-
-	if !processTxs(repl, t, 8) {
-		return
-	}
-
-	callSetup := `abiDef = JSON.parse('[{"constant":false,"inputs":[{"name":"a","type":"uint256"}],"name":"multiply","outputs":[{"name":"d","type":"uint256"}],"type":"function"}]');
-Multiply7 = eth.contract(abiDef);
-multiply7 = Multiply7.at(contractaddress);
-`
-	_, err = repl.re.Run(callSetup)
-	if err != nil {
-		t.Errorf("unexpected error setting up contract, got %v", err)
-		return
-	}
-
-	expNotice := ""
-	if repl.lastConfirm != expNotice {
-		t.Errorf("incorrect confirmation message: expected %v, got %v", expNotice, repl.lastConfirm)
-		return
-	}
-
-	if checkEvalJSON(t, repl, `admin.startNatSpec()`, `true`) != nil {
-		return
-	}
-	if checkEvalJSON(t, repl, `multiply7.multiply.sendTransaction(6, { from: primary })`, `"0x4ef9088431a8033e4580d00e4eb2487275e031ff4163c7529df0ef45af17857b"`) != nil {
-		return
-	}
-
-	if !processTxs(repl, t, 1) {
-		return
-	}
-
-	expNotice = `About to submit transaction (no NatSpec info found for contract: content hash not found for '0x87e2802265838c7f14bb69eecd2112911af6767907a702eeaa445239fb20711b'): {"params":[{"to":"0x46d69d55c3c4b86a924a92c9fc4720bb7bce1d74","data": "0xc6888fa10000000000000000000000000000000000000000000000000000000000000006"}]}`
-	if repl.lastConfirm != expNotice {
-		t.Errorf("incorrect confirmation message: expected\n%v, got\n%v", expNotice, repl.lastConfirm)
-		return
-	}
-
-	var contentHash = `"0x86d2b7cf1e72e9a7a3f8d96601f0151742a2f780f1526414304fbe413dc7f9bd"`
-	if sol != nil && solcVersion != sol.Version() {
-		modContractInfo := versionRE.ReplaceAll(contractInfo, []byte(`"compilerVersion":"`+sol.Version()+`"`))
-		fmt.Printf("modified contractinfo:\n%s\n", modContractInfo)
-		contentHash = `"` + common.ToHex(crypto.Keccak256([]byte(modContractInfo))) + `"`
-	}
-	if checkEvalJSON(t, repl, `filename = "/tmp/info.json"`, `"/tmp/info.json"`) != nil {
-		return
-	}
-	if checkEvalJSON(t, repl, `contentHash = admin.saveInfo(contract.info, filename)`, contentHash) != nil {
-		return
-	}
-	if checkEvalJSON(t, repl, `admin.register(primary, contractaddress, contentHash)`, `true`) != nil {
-		return
-	}
-	if checkEvalJSON(t, repl, `admin.registerUrl(primary, contentHash, "file://"+filename)`, `true`) != nil {
-		return
-	}
-
-	if checkEvalJSON(t, repl, `admin.startNatSpec()`, `true`) != nil {
-		return
-	}
-
-	if !processTxs(repl, t, 3) {
-		return
-	}
-
-	if checkEvalJSON(t, repl, `multiply7.multiply.sendTransaction(6, { from: primary })`, `"0x66d7635c12ad0b231e66da2f987ca3dfdca58ffe49c6442aa55960858103fd0c"`) != nil {
-		return
-	}
-
-	if !processTxs(repl, t, 1) {
-		return
-	}
-
-	expNotice = "Will multiply 6 by 7."
-	if repl.lastConfirm != expNotice {
-		t.Errorf("incorrect confirmation message: expected\n%v, got\n%v", expNotice, repl.lastConfirm)
-		return
-	}
-}
-
-func pendingTransactions(repl *testjethre, t *testing.T) (txc int64, err error) {
-	var ethereum *eth.Ethereum
-	repl.stack.Service(&ethereum)
-
-	txs := ethereum.TxPool().GetTransactions()
-	return int64(len(txs)), nil
-}
-
-func processTxs(repl *testjethre, t *testing.T, expTxc int) bool {
-	var txc int64
-	var err error
-	for i := 0; i < 50; i++ {
-		txc, err = pendingTransactions(repl, t)
-		if err != nil {
-			t.Errorf("unexpected error checking pending transactions: %v", err)
-			return false
-		}
-		if expTxc < int(txc) {
-			t.Errorf("too many pending transactions: expected %v, got %v", expTxc, txc)
-			return false
-		} else if expTxc == int(txc) {
-			break
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-	if int(txc) != expTxc {
-		t.Errorf("incorrect number of pending transactions, expected %v, got %v", expTxc, txc)
-		return false
-	}
-	var ethereum *eth.Ethereum
-	repl.stack.Service(&ethereum)
-
-	err = ethereum.StartMining(runtime.NumCPU(), "")
-	if err != nil {
-		t.Errorf("unexpected error mining: %v", err)
-		return false
-	}
-	defer ethereum.StopMining()
-
-	timer := time.NewTimer(100 * time.Second)
-	blockNr := ethereum.BlockChain().CurrentBlock().Number()
-	height := new(big.Int).Add(blockNr, big.NewInt(1))
-	repl.wait <- height
-	select {
-	case <-timer.C:
-		// if times out make sure the xeth loop does not block
-		go func() {
-			select {
-			case repl.wait <- nil:
-			case <-repl.wait:
-			}
-		}()
-	case <-repl.wait:
-	}
-	txc, err = pendingTransactions(repl, t)
-	if err != nil {
-		t.Errorf("unexpected error checking pending transactions: %v", err)
-		return false
-	}
-	if txc != 0 {
-		t.Errorf("%d trasactions were not mined", txc)
-		return false
-	}
-	return true
-}
-
-func checkEvalJSON(t *testing.T, re *testjethre, expr, want string) error {
-	val, err := re.re.Run("JSON.stringify(" + expr + ")")
-	if err == nil && val.String() != want {
-		err = fmt.Errorf("Output mismatch for `%s`:\ngot:  %s\nwant: %s", expr, val.String(), want)
-	}
-	if err != nil {
-		_, file, line, _ := runtime.Caller(1)
-		file = filepath.Base(file)
-		fmt.Printf("\t%s:%d: %v\n", file, line, err)
-		t.Fail()
-	}
-	return err
-}

cmd/geth/main.go

@@ -22,17 +22,16 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"os/signal"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/ethash"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/console"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -44,14 +43,15 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/release"
 	"github.com/ethereum/go-ethereum/rlp"
+	"gopkg.in/urfave/cli.v1"
 )
 
 const (
-	clientIdentifier = "Geth"     // Client identifier to advertise over the network
+	clientIdentifier = "Geth"   // Client identifier to advertise over the network
-	versionMajor     = 1          // Major version component of the current release
+	versionMajor     = 1        // Major version component of the current release
-	versionMinor     = 5          // Minor version component of the current release
+	versionMinor     = 4        // Minor version component of the current release
-	versionPatch     = 0          // Patch version component of the current release
+	versionPatch     = 8        // Patch version component of the current release
-	versionMeta      = "unstable" // Version metadata to append to the version string
+	versionMeta      = "stable" // Version metadata to append to the version string
 
 	versionOracle = "0xfa7b9770ca4cb04296cac84f37736d4041251cdf" // Ethereum address of the Geth release oracle
 )
@@ -95,6 +95,9 @@ func init() {
 		monitorCommand,
 		accountCommand,
 		walletCommand,
+		consoleCommand,
+		attachCommand,
+		javascriptCommand,
 		{
 			Action: makedag,
 			Name:   "makedag",
@@ -138,36 +141,6 @@ The output of this command is supposed to be machine-readable.
 The init command initialises a new genesis block and definition for the network.
 This is a destructive action and changes the network in which you will be
 participating.
-`,
-		},
-		{
-			Action: console,
-			Name:   "console",
-			Usage:  `Geth Console: interactive JavaScript environment`,
-			Description: `
-The Geth console is an interactive shell for the JavaScript runtime environment
-which exposes a node admin interface as well as the Ðapp JavaScript API.
-See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
-`,
-		},
-		{
-			Action: attach,
-			Name:   "attach",
-			Usage:  `Geth Console: interactive JavaScript environment (connect to node)`,
-			Description: `
-		The Geth console is an interactive shell for the JavaScript runtime environment
-		which exposes a node admin interface as well as the Ðapp JavaScript API.
-		See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.
-		This command allows to open a console on a running geth node.
-		`,
-		},
-		{
-			Action: execScripts,
-			Name:   "js",
-			Usage:  `executes the given JavaScript files in the Geth JavaScript VM`,
-			Description: `
-The JavaScript VM exposes a node admin interface as well as the Ðapp
-JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
 `,
 		},
 	}
@@ -196,6 +169,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 		utils.MiningGPUFlag,
 		utils.AutoDAGFlag,
 		utils.TargetGasLimitFlag,
+		utils.DAOSoftForkFlag,
 		utils.NATFlag,
 		utils.NatspecEnabledFlag,
 		utils.NoDiscoverFlag,
@@ -214,7 +188,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 		utils.IPCApiFlag,
 		utils.IPCPathFlag,
 		utils.ExecFlag,
-		utils.PreLoadJSFlag,
+		utils.PreloadJSFlag,
 		utils.WhisperEnabledFlag,
 		utils.DevModeFlag,
 		utils.TestNetFlag,
@@ -244,6 +218,12 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 		// Start system runtime metrics collection
 		go metrics.CollectProcessMetrics(3 * time.Second)
 
+		// This should be the only place where reporting is enabled
+		// because it is not intended to run while testing.
+		// In addition to this check, bad block reports are sent only
+		// for chains with the main network genesis block and network id 1.
+		eth.EnableBadBlockReporting = true
+
 		utils.SetupNetwork(ctx)
 
 		// Deprecation warning.
@@ -257,7 +237,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 	app.After = func(ctx *cli.Context) error {
 		logger.Flush()
 		debug.Exit()
-		utils.Stdin.Close() // Resets terminal mode.
+		console.Stdin.Close() // Resets terminal mode.
 		return nil
 	}
 }
@@ -292,45 +272,17 @@ func makeDefaultExtra() []byte {
 // geth is the main entry point into the system if no special subcommand is ran.
 // It creates a default node based on the command line arguments and runs it in
 // blocking mode, waiting for it to be shut down.
-func geth(ctx *cli.Context) {
+func geth(ctx *cli.Context) error {
 	node := utils.MakeSystemNode(clientIdentifier, verString, relConfig, makeDefaultExtra(), ctx)
 	startNode(ctx, node)
 	node.Wait()
-}
 
-// attach will connect to a running geth instance attaching a JavaScript console and to it.
+	return nil
-func attach(ctx *cli.Context) {
-	// attach to a running geth instance
-	client, err := utils.NewRemoteRPCClient(ctx)
-	if err != nil {
-		utils.Fatalf("Unable to attach to geth: %v", err)
-	}
-
-	repl := newLightweightJSRE(
-		ctx.GlobalString(utils.JSpathFlag.Name),
-		client,
-		ctx.GlobalString(utils.DataDirFlag.Name),
-		true,
-	)
-
-	// preload user defined JS files into the console
-	err = repl.preloadJSFiles(ctx)
-	if err != nil {
-		utils.Fatalf("unable to preload JS file %v", err)
-	}
-
-	// in case the exec flag holds a JS statement execute it and return
-	if ctx.GlobalString(utils.ExecFlag.Name) != "" {
-		repl.batch(ctx.GlobalString(utils.ExecFlag.Name))
-	} else {
-		repl.welcome()
-		repl.interactive()
-	}
 }
 
 // initGenesis will initialise the given JSON format genesis file and writes it as
 // the zero'd block (i.e. genesis) or will fail hard if it can't succeed.
-func initGenesis(ctx *cli.Context) {
+func initGenesis(ctx *cli.Context) error {
 	genesisPath := ctx.Args().First()
 	if len(genesisPath) == 0 {
 		utils.Fatalf("must supply path to genesis JSON file")
@@ -351,77 +303,7 @@ func initGenesis(ctx *cli.Context) {
 		utils.Fatalf("failed to write genesis block: %v", err)
 	}
 	glog.V(logger.Info).Infof("successfully wrote genesis block and/or chain rule set: %x", block.Hash())
-}
+	return nil
-
-// console starts a new geth node, attaching a JavaScript console to it at the
-// same time.
-func console(ctx *cli.Context) {
-	// Create and start the node based on the CLI flags
-	node := utils.MakeSystemNode(clientIdentifier, verString, relConfig, makeDefaultExtra(), ctx)
-	startNode(ctx, node)
-
-	// Attach to the newly started node, and either execute script or become interactive
-	client, err := node.Attach()
-	if err != nil {
-		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
-	}
-	repl := newJSRE(node,
-		ctx.GlobalString(utils.JSpathFlag.Name),
-		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
-		client, true)
-
-	// preload user defined JS files into the console
-	err = repl.preloadJSFiles(ctx)
-	if err != nil {
-		utils.Fatalf("%v", err)
-	}
-
-	// in case the exec flag holds a JS statement execute it and return
-	if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
-		repl.batch(script)
-	} else {
-		repl.welcome()
-		repl.interactive()
-	}
-	node.Stop()
-}
-
-// execScripts starts a new geth node based on the CLI flags, and executes each
-// of the JavaScript files specified as command arguments.
-func execScripts(ctx *cli.Context) {
-	// Create and start the node based on the CLI flags
-	node := utils.MakeSystemNode(clientIdentifier, verString, relConfig, makeDefaultExtra(), ctx)
-	startNode(ctx, node)
-	defer node.Stop()
-
-	// Attach to the newly started node and execute the given scripts
-	client, err := node.Attach()
-	if err != nil {
-		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
-	}
-	repl := newJSRE(node,
-		ctx.GlobalString(utils.JSpathFlag.Name),
-		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
-		client, false)
-
-	// Run all given files.
-	for _, file := range ctx.Args() {
-		if err = repl.re.Exec(file); err != nil {
-			break
-		}
-	}
-	if err != nil {
-		utils.Fatalf("JavaScript Error: %v", jsErrorString(err))
-	}
-	// JS files loaded successfully.
-	// Wait for pending callbacks, but stop for Ctrl-C.
-	abort := make(chan os.Signal, 1)
-	signal.Notify(abort, os.Interrupt)
-	go func() {
-		<-abort
-		repl.re.Stop(false)
-	}()
-	repl.re.Stop(true)
 }
 
 // startNode boots up the system node and all registered protocols, after which
@@ -453,7 +335,7 @@ func startNode(ctx *cli.Context, stack *node.Node) {
 	}
 }
 
-func makedag(ctx *cli.Context) {
+func makedag(ctx *cli.Context) error {
 	args := ctx.Args()
 	wrongArgs := func() {
 		utils.Fatalf(`Usage: geth makedag <block number> <outputdir>`)
@@ -480,13 +362,15 @@ func makedag(ctx *cli.Context) {
 	default:
 		wrongArgs()
 	}
+	return nil
 }
 
-func gpuinfo(ctx *cli.Context) {
+func gpuinfo(ctx *cli.Context) error {
 	eth.PrintOpenCLDevices()
+	return nil
 }
 
-func gpubench(ctx *cli.Context) {
+func gpubench(ctx *cli.Context) error {
 	args := ctx.Args()
 	wrongArgs := func() {
 		utils.Fatalf(`Usage: geth gpubench <gpu number>`)
@@ -503,9 +387,10 @@ func gpubench(ctx *cli.Context) {
 	default:
 		wrongArgs()
 	}
+	return nil
 }
 
-func version(c *cli.Context) {
+func version(c *cli.Context) error {
 	fmt.Println(clientIdentifier)
 	fmt.Println("Version:", verString)
 	fmt.Println("Protocol Versions:", eth.ProtocolVersions)
@@ -514,4 +399,6 @@ func version(c *cli.Context) {
 	fmt.Println("OS:", runtime.GOOS)
 	fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
 	fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
+
+	return nil
 }

cmd/geth/monitorcmd.go

@@ -26,11 +26,11 @@ import (
 
 	"sort"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/gizak/termui"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -67,7 +67,7 @@ to display multiple metrics simultaneously.
 )
 
 // monitor starts a terminal UI based monitoring tool for the requested metrics.
-func monitor(ctx *cli.Context) {
+func monitor(ctx *cli.Context) error {
 	var (
 		client rpc.Client
 		err    error
@@ -154,6 +154,7 @@ func monitor(ctx *cli.Context) {
 		}
 	}()
 	termui.Loop()
+	return nil
 }
 
 // retrieveMetrics contacts the attached geth node and retrieves the entire set

cmd/geth/run_test.go

@@ -20,7 +20,6 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"html/template"
 	"io"
 	"io/ioutil"
 	"os"
@@ -28,6 +27,7 @@ import (
 	"regexp"
 	"sync"
 	"testing"
+	"text/template"
 	"time"
 )
 
@@ -45,6 +45,7 @@ type testgeth struct {
 	// template variables for expect
 	Datadir    string
 	Executable string
+	Etherbase  string
 	Func       template.FuncMap
 
 	removeDatadir bool
@@ -57,7 +58,10 @@ type testgeth struct {
 func init() {
 	// Run the app if we're the child process for runGeth.
 	if os.Getenv("GETH_TEST_CHILD") != "" {
-		app.RunAndExitOnError()
+		if err := app.Run(os.Args); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
 		os.Exit(0)
 	}
 }
@@ -67,11 +71,15 @@ func init() {
 func runGeth(t *testing.T, args ...string) *testgeth {
 	tt := &testgeth{T: t, Executable: os.Args[0]}
 	for i, arg := range args {
-		if arg == "-datadir" || arg == "--datadir" {
+		switch {
+		case arg == "-datadir" || arg == "--datadir":
 			if i < len(args)-1 {
 				tt.Datadir = args[i+1]
 			}
-			break
+		case arg == "-etherbase" || arg == "--etherbase":
+			if i < len(args)-1 {
+				tt.Etherbase = args[i+1]
+			}
 		}
 	}
 	if tt.Datadir == "" {

cmd/geth/usage.go

@@ -21,9 +21,9 @@ package main
 import (
 	"io"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/internal/debug"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // AppHelpTemplate is the test template for the default, global app help topic.
@@ -101,7 +101,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.RPCCORSDomainFlag,
 			utils.JSpathFlag,
 			utils.ExecFlag,
-			utils.PreLoadJSFlag,
+			utils.PreloadJSFlag,
 		},
 	},
 	{
@@ -128,6 +128,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.TargetGasLimitFlag,
 			utils.GasPriceFlag,
 			utils.ExtraDataFlag,
+			utils.DAOSoftForkFlag,
 		},
 	},
 	{

cmd/utils/client.go

@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // NewRemoteRPCClient returns a RPC client which connects to a running geth instance.

cmd/utils/cmd.go

@@ -120,7 +120,7 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 		}
 	}
 
-	glog.Infoln("Importing blockchain", fn)
+	glog.Infoln("Importing blockchain ", fn)
 	fh, err := os.Open(fn)
 	if err != nil {
 		return err
@@ -182,7 +182,7 @@ func hasAllBlocks(chain *core.BlockChain, bs []*types.Block) bool {
 }
 
 func ExportChain(blockchain *core.BlockChain, fn string) error {
-	glog.Infoln("Exporting blockchain to", fn)
+	glog.Infoln("Exporting blockchain to ", fn)
 	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
 	if err != nil {
 		return err
@@ -191,12 +191,12 @@ func ExportChain(blockchain *core.BlockChain, fn string) error {
 	if err := blockchain.Export(fh); err != nil {
 		return err
 	}
-	glog.Infoln("Exported blockchain to", fn)
+	glog.Infoln("Exported blockchain to ", fn)
 	return nil
 }
 
 func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, last uint64) error {
-	glog.Infoln("Exporting blockchain to", fn)
+	glog.Infoln("Exporting blockchain to ", fn)
 	// TODO verify mode perms
 	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModePerm)
 	if err != nil {
@@ -206,6 +206,6 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las
 	if err := blockchain.ExportN(fh, first, last); err != nil {
 		return err
 	}
-	glog.Infoln("Exported blockchain to", fn)
+	glog.Infoln("Exported blockchain to ", fn)
 	return nil
 }

cmd/utils/customflags.go

@@ -24,7 +24,7 @@ import (
 	"path"
 	"strings"
 
-	"github.com/codegangsta/cli"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // Custom type which is registered in the flags library which cli uses for

cmd/utils/flags.go

@@ -30,7 +30,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/ethash"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
@@ -51,6 +50,7 @@ import (
 	"github.com/ethereum/go-ethereum/release"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/whisper"
+	"gopkg.in/urfave/cli.v1"
 )
 
 func init() {
@@ -181,6 +181,10 @@ var (
 		Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine",
 		Value: params.GenesisGasLimit.String(),
 	}
+	DAOSoftForkFlag = cli.BoolFlag{
+		Name:  "dao-soft-fork",
+		Usage: "Vote for the DAO soft-fork, temporarilly decreasing the gas limits",
+	}
 	AutoDAGFlag = cli.BoolFlag{
 		Name:  "autodag",
 		Usage: "Enable automatic DAG pregeneration",
@@ -302,7 +306,7 @@ var (
 		Name:  "exec",
 		Usage: "Execute JavaScript statement (only in combination with console/attach)",
 	}
-	PreLoadJSFlag = cli.StringFlag{
+	PreloadJSFlag = cli.StringFlag{
 		Name:  "preload",
 		Usage: "Comma separated list of JavaScript files to preload into the console",
 	}
@@ -677,6 +681,9 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
 	// Configure the Ethereum service
 	accman := MakeAccountManager(ctx)
 
+	// Handle some miner strategies arrising from the DAO fiasco
+	core.DAOSoftFork = ctx.GlobalBool(DAOSoftForkFlag.Name)
+
 	// initialise new random number generator
 	rand := rand.New(rand.NewSource(time.Now().UnixNano()))
 	// get enabled jit flag
@@ -864,3 +871,20 @@ func MakeChain(ctx *cli.Context) (chain *core.BlockChain, chainDb ethdb.Database
 	}
 	return chain, chainDb
 }
+
+// MakeConsolePreloads retrieves the absolute paths for the console JavaScript
+// scripts to preload before starting.
+func MakeConsolePreloads(ctx *cli.Context) []string {
+	// Skip preloading if there's nothing to preload
+	if ctx.GlobalString(PreloadJSFlag.Name) == "" {
+		return nil
+	}
+	// Otherwise resolve absolute paths and return them
+	preloads := []string{}
+
+	assets := ctx.GlobalString(JSpathFlag.Name)
+	for _, file := range strings.Split(ctx.GlobalString(PreloadJSFlag.Name), ",") {
+		preloads = append(preloads, common.AbsolutePath(assets, strings.TrimSpace(file)))
+	}
+	return preloads
+}

cmd/utils/input.go

@@ -1,98 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package utils
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/peterh/liner"
-)
-
-// Holds the stdin line reader.
-// Only this reader may be used for input because it keeps
-// an internal buffer.
-var Stdin = newUserInputReader()
-
-type userInputReader struct {
-	*liner.State
-	warned     bool
-	supported  bool
-	normalMode liner.ModeApplier
-	rawMode    liner.ModeApplier
-}
-
-func newUserInputReader() *userInputReader {
-	r := new(userInputReader)
-	// Get the original mode before calling NewLiner.
-	// This is usually regular "cooked" mode where characters echo.
-	normalMode, _ := liner.TerminalMode()
-	// Turn on liner. It switches to raw mode.
-	r.State = liner.NewLiner()
-	rawMode, err := liner.TerminalMode()
-	if err != nil || !liner.TerminalSupported() {
-		r.supported = false
-	} else {
-		r.supported = true
-		r.normalMode = normalMode
-		r.rawMode = rawMode
-		// Switch back to normal mode while we're not prompting.
-		normalMode.ApplyMode()
-	}
-	return r
-}
-
-func (r *userInputReader) Prompt(prompt string) (string, error) {
-	if r.supported {
-		r.rawMode.ApplyMode()
-		defer r.normalMode.ApplyMode()
-	} else {
-		// liner tries to be smart about printing the prompt
-		// and doesn't print anything if input is redirected.
-		// Un-smart it by printing the prompt always.
-		fmt.Print(prompt)
-		prompt = ""
-		defer fmt.Println()
-	}
-	return r.State.Prompt(prompt)
-}
-
-func (r *userInputReader) PasswordPrompt(prompt string) (passwd string, err error) {
-	if r.supported {
-		r.rawMode.ApplyMode()
-		defer r.normalMode.ApplyMode()
-		return r.State.PasswordPrompt(prompt)
-	}
-	if !r.warned {
-		fmt.Println("!! Unsupported terminal, password will be echoed.")
-		r.warned = true
-	}
-	// Just as in Prompt, handle printing the prompt here instead of relying on liner.
-	fmt.Print(prompt)
-	passwd, err = r.State.Prompt("")
-	fmt.Println()
-	return passwd, err
-}
-
-func (r *userInputReader) ConfirmPrompt(prompt string) (bool, error) {
-	prompt = prompt + " [y/N] "
-	input, err := r.Prompt(prompt)
-	if len(input) > 0 && strings.ToUpper(input[:1]) == "Y" {
-		return true, nil
-	}
-	return false, err
-}

cmd/utils/jeth.go

@@ -1,301 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package utils
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"github.com/ethereum/go-ethereum/jsre"
-	"github.com/ethereum/go-ethereum/rpc"
-
-	"github.com/robertkrimen/otto"
-)
-
-type Jeth struct {
-	re     *jsre.JSRE
-	client rpc.Client
-}
-
-// NewJeth create a new backend for the JSRE console
-func NewJeth(re *jsre.JSRE, client rpc.Client) *Jeth {
-	return &Jeth{re, client}
-}
-
-// err returns an error object for the given error code and message.
-func (self *Jeth) err(call otto.FunctionCall, code int, msg string, id interface{}) (response otto.Value) {
-	m := rpc.JSONErrResponse{
-		Version: "2.0",
-		Id:      id,
-		Error: rpc.JSONError{
-			Code:    code,
-			Message: msg,
-		},
-	}
-
-	errObj, _ := json.Marshal(m.Error)
-	errRes, _ := json.Marshal(m)
-
-	call.Otto.Run("ret_error = " + string(errObj))
-	res, _ := call.Otto.Run("ret_response = " + string(errRes))
-
-	return res
-}
-
-// UnlockAccount asks the user for the password and than executes the jeth.UnlockAccount callback in the jsre.
-// It will need the public address for the account to unlock as first argument.
-// The second argument is an optional string with the password. If not given the user is prompted for the password.
-// The third argument is an optional integer which specifies for how long the account will be unlocked (in seconds).
-func (self *Jeth) UnlockAccount(call otto.FunctionCall) (response otto.Value) {
-	var account, passwd otto.Value
-	duration := otto.NullValue()
-
-	if !call.Argument(0).IsString() {
-		fmt.Println("first argument must be the account to unlock")
-		return otto.FalseValue()
-	}
-
-	account = call.Argument(0)
-
-	// if password is not given or as null value -> ask user for password
-	if call.Argument(1).IsUndefined() || call.Argument(1).IsNull() {
-		fmt.Printf("Unlock account %s\n", account)
-		if input, err := Stdin.PasswordPrompt("Passphrase: "); err != nil {
-			throwJSExeception(err.Error())
-		} else {
-			passwd, _ = otto.ToValue(input)
-		}
-	} else {
-		if !call.Argument(1).IsString() {
-			throwJSExeception("password must be a string")
-		}
-		passwd = call.Argument(1)
-	}
-
-	// third argument is the duration how long the account must be unlocked.
-	// verify that its a number.
-	if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() {
-		if !call.Argument(2).IsNumber() {
-			throwJSExeception("unlock duration must be a number")
-		}
-		duration = call.Argument(2)
-	}
-
-	// jeth.unlockAccount will send the request to the backend.
-	if val, err := call.Otto.Call("jeth.unlockAccount", nil, account, passwd, duration); err == nil {
-		return val
-	} else {
-		throwJSExeception(err.Error())
-	}
-
-	return otto.FalseValue()
-}
-
-// NewAccount asks the user for the password and than executes the jeth.newAccount callback in the jsre
-func (self *Jeth) NewAccount(call otto.FunctionCall) (response otto.Value) {
-	var passwd string
-	if len(call.ArgumentList) == 0 {
-		var err error
-		passwd, err = Stdin.PasswordPrompt("Passphrase: ")
-		if err != nil {
-			return otto.FalseValue()
-		}
-		passwd2, err := Stdin.PasswordPrompt("Repeat passphrase: ")
-		if err != nil {
-			return otto.FalseValue()
-		}
-
-		if passwd != passwd2 {
-			fmt.Println("Passphrases don't match")
-			return otto.FalseValue()
-		}
-	} else if len(call.ArgumentList) == 1 && call.Argument(0).IsString() {
-		passwd, _ = call.Argument(0).ToString()
-	} else {
-		fmt.Println("expected 0 or 1 string argument")
-		return otto.FalseValue()
-	}
-
-	ret, err := call.Otto.Call("jeth.newAccount", nil, passwd)
-	if err == nil {
-		return ret
-	}
-	fmt.Println(err)
-	return otto.FalseValue()
-}
-
-// Send will serialize the first argument, send it to the node and returns the response.
-func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
-	// verify we got a batch request (array) or a single request (object)
-	ro := call.Argument(0).Object()
-	if ro == nil || (ro.Class() != "Array" && ro.Class() != "Object") {
-		throwJSExeception("Internal Error: request must be an object or array")
-	}
-
-	// convert otto vm arguments to go values by JSON serialising and parsing.
-	data, err := call.Otto.Call("JSON.stringify", nil, ro)
-	if err != nil {
-		throwJSExeception(err.Error())
-	}
-
-	jsonreq, _ := data.ToString()
-
-	// parse arguments to JSON rpc requests, either to an array (batch) or to a single request.
-	var reqs []rpc.JSONRequest
-	batch := true
-	if err = json.Unmarshal([]byte(jsonreq), &reqs); err != nil {
-		// single request?
-		reqs = make([]rpc.JSONRequest, 1)
-		if err = json.Unmarshal([]byte(jsonreq), &reqs[0]); err != nil {
-			throwJSExeception("invalid request")
-		}
-		batch = false
-	}
-
-	call.Otto.Set("response_len", len(reqs))
-	call.Otto.Run("var ret_response = new Array(response_len);")
-
-	for i, req := range reqs {
-		if err := self.client.Send(&req); err != nil {
-			return self.err(call, -32603, err.Error(), req.Id)
-		}
-
-		result := make(map[string]interface{})
-		if err = self.client.Recv(&result); err != nil {
-			return self.err(call, -32603, err.Error(), req.Id)
-		}
-
-		id, _ := result["id"]
-		jsonver, _ := result["jsonrpc"]
-
-		call.Otto.Set("ret_id", id)
-		call.Otto.Set("ret_jsonrpc", jsonver)
-		call.Otto.Set("response_idx", i)
-
-		// call was successful
-		if res, ok := result["result"]; ok {
-			payload, _ := json.Marshal(res)
-			call.Otto.Set("ret_result", string(payload))
-			response, err = call.Otto.Run(`
-				ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, result: JSON.parse(ret_result) };
-			`)
-			continue
-		}
-
-		// request returned an error
-		if res, ok := result["error"]; ok {
-			payload, _ := json.Marshal(res)
-			call.Otto.Set("ret_result", string(payload))
-			response, err = call.Otto.Run(`
-				ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, error: JSON.parse(ret_result) };
-			`)
-			continue
-		}
-
-		return self.err(call, -32603, fmt.Sprintf("Invalid response"), new(int64))
-	}
-
-	if !batch {
-		call.Otto.Run("ret_response = ret_response[0];")
-	}
-
-	// if a callback was given execute it.
-	if call.Argument(1).IsObject() {
-		call.Otto.Set("callback", call.Argument(1))
-		call.Otto.Run(`
-		if (Object.prototype.toString.call(callback) == '[object Function]') {
-			callback(null, ret_response);
-		}
-		`)
-	}
-
-	return
-}
-
-// throwJSExeception panics on an otto value, the Otto VM will then throw msg as a javascript error.
-func throwJSExeception(msg interface{}) otto.Value {
-	p, _ := otto.ToValue(msg)
-	panic(p)
-}
-
-// Sleep will halt the console for arg[0] seconds.
-func (self *Jeth) Sleep(call otto.FunctionCall) (response otto.Value) {
-	if len(call.ArgumentList) >= 1 {
-		if call.Argument(0).IsNumber() {
-			sleep, _ := call.Argument(0).ToInteger()
-			time.Sleep(time.Duration(sleep) * time.Second)
-			return otto.TrueValue()
-		}
-	}
-	return throwJSExeception("usage: sleep(<sleep in seconds>)")
-}
-
-// SleepBlocks will wait for a specified number of new blocks or max for a
-// given of seconds. sleepBlocks(nBlocks[, maxSleep]).
-func (self *Jeth) SleepBlocks(call otto.FunctionCall) (response otto.Value) {
-	nBlocks := int64(0)
-	maxSleep := int64(9999999999999999) // indefinitely
-
-	nArgs := len(call.ArgumentList)
-
-	if nArgs == 0 {
-		throwJSExeception("usage: sleepBlocks(<n blocks>[, max sleep in seconds])")
-	}
-
-	if nArgs >= 1 {
-		if call.Argument(0).IsNumber() {
-			nBlocks, _ = call.Argument(0).ToInteger()
-		} else {
-			throwJSExeception("expected number as first argument")
-		}
-	}
-
-	if nArgs >= 2 {
-		if call.Argument(1).IsNumber() {
-			maxSleep, _ = call.Argument(1).ToInteger()
-		} else {
-			throwJSExeception("expected number as second argument")
-		}
-	}
-
-	// go through the console, this will allow web3 to call the appropriate
-	// callbacks if a delayed response or notification is received.
-	currentBlockNr := func() int64 {
-		result, err := call.Otto.Run("eth.blockNumber")
-		if err != nil {
-			throwJSExeception(err.Error())
-		}
-		blockNr, err := result.ToInteger()
-		if err != nil {
-			throwJSExeception(err.Error())
-		}
-		return blockNr
-	}
-
-	targetBlockNr := currentBlockNr() + nBlocks
-	deadline := time.Now().Add(time.Duration(maxSleep) * time.Second)
-
-	for time.Now().Before(deadline) {
-		if currentBlockNr() >= targetBlockNr {
-			return otto.TrueValue()
-		}
-		time.Sleep(time.Second)
-	}
-
-	return otto.FalseValue()
-}

common/compiler/solidity.go

@@ -149,7 +149,6 @@ func (sol *Solidity) Compile(source string) (map[string]*Contract, error) {
 	compilerOptions := strings.Join(params, " ")
 
 	cmd := exec.Command(sol.solcPath, params...)
-	cmd.Dir = wd
 	cmd.Stdin = strings.NewReader(source)
 	cmd.Stderr = stderr
 

console/bridge.go

@@ -0,0 +1,317 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package console
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/robertkrimen/otto"
+)
+
+// bridge is a collection of JavaScript utility methods to bride the .js runtime
+// environment and the Go RPC connection backing the remote method calls.
+type bridge struct {
+	client   rpc.Client   // RPC client to execute Ethereum requests through
+	prompter UserPrompter // Input prompter to allow interactive user feedback
+	printer  io.Writer    // Output writer to serialize any display strings to
+}
+
+// newBridge creates a new JavaScript wrapper around an RPC client.
+func newBridge(client rpc.Client, prompter UserPrompter, printer io.Writer) *bridge {
+	return &bridge{
+		client:   client,
+		prompter: prompter,
+		printer:  printer,
+	}
+}
+
+// NewAccount is a wrapper around the personal.newAccount RPC method that uses a
+// non-echoing password prompt to aquire the passphrase and executes the original
+// RPC method (saved in jeth.newAccount) with it to actually execute the RPC call.
+func (b *bridge) NewAccount(call otto.FunctionCall) (response otto.Value) {
+	var (
+		password string
+		confirm  string
+		err      error
+	)
+	switch {
+	// No password was specified, prompt the user for it
+	case len(call.ArgumentList) == 0:
+		if password, err = b.prompter.PromptPassword("Passphrase: "); err != nil {
+			throwJSException(err.Error())
+		}
+		if confirm, err = b.prompter.PromptPassword("Repeat passphrase: "); err != nil {
+			throwJSException(err.Error())
+		}
+		if password != confirm {
+			throwJSException("passphrases don't match!")
+		}
+
+	// A single string password was specified, use that
+	case len(call.ArgumentList) == 1 && call.Argument(0).IsString():
+		password, _ = call.Argument(0).ToString()
+
+	// Otherwise fail with some error
+	default:
+		throwJSException("expected 0 or 1 string argument")
+	}
+	// Password aquired, execute the call and return
+	ret, err := call.Otto.Call("jeth.newAccount", nil, password)
+	if err != nil {
+		throwJSException(err.Error())
+	}
+	return ret
+}
+
+// UnlockAccount is a wrapper around the personal.unlockAccount RPC method that
+// uses a non-echoing password prompt to aquire the passphrase and executes the
+// original RPC method (saved in jeth.unlockAccount) with it to actually execute
+// the RPC call.
+func (b *bridge) UnlockAccount(call otto.FunctionCall) (response otto.Value) {
+	// Make sure we have an account specified to unlock
+	if !call.Argument(0).IsString() {
+		throwJSException("first argument must be the account to unlock")
+	}
+	account := call.Argument(0)
+
+	// If password is not given or is the null value, prompt the user for it
+	var passwd otto.Value
+
+	if call.Argument(1).IsUndefined() || call.Argument(1).IsNull() {
+		fmt.Fprintf(b.printer, "Unlock account %s\n", account)
+		if input, err := b.prompter.PromptPassword("Passphrase: "); err != nil {
+			throwJSException(err.Error())
+		} else {
+			passwd, _ = otto.ToValue(input)
+		}
+	} else {
+		if !call.Argument(1).IsString() {
+			throwJSException("password must be a string")
+		}
+		passwd = call.Argument(1)
+	}
+	// Third argument is the duration how long the account must be unlocked.
+	duration := otto.NullValue()
+	if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() {
+		if !call.Argument(2).IsNumber() {
+			throwJSException("unlock duration must be a number")
+		}
+		duration = call.Argument(2)
+	}
+	// Send the request to the backend and return
+	val, err := call.Otto.Call("jeth.unlockAccount", nil, account, passwd, duration)
+	if err != nil {
+		throwJSException(err.Error())
+	}
+	return val
+}
+
+// Sleep will block the console for the specified number of seconds.
+func (b *bridge) Sleep(call otto.FunctionCall) (response otto.Value) {
+	if call.Argument(0).IsNumber() {
+		sleep, _ := call.Argument(0).ToInteger()
+		time.Sleep(time.Duration(sleep) * time.Second)
+		return otto.TrueValue()
+	}
+	return throwJSException("usage: sleep(<number of seconds>)")
+}
+
+// SleepBlocks will block the console for a specified number of new blocks optionally
+// until the given timeout is reached.
+func (b *bridge) SleepBlocks(call otto.FunctionCall) (response otto.Value) {
+	var (
+		blocks = int64(0)
+		sleep  = int64(9999999999999999) // indefinitely
+	)
+	// Parse the input parameters for the sleep
+	nArgs := len(call.ArgumentList)
+	if nArgs == 0 {
+		throwJSException("usage: sleepBlocks(<n blocks>[, max sleep in seconds])")
+	}
+	if nArgs >= 1 {
+		if call.Argument(0).IsNumber() {
+			blocks, _ = call.Argument(0).ToInteger()
+		} else {
+			throwJSException("expected number as first argument")
+		}
+	}
+	if nArgs >= 2 {
+		if call.Argument(1).IsNumber() {
+			sleep, _ = call.Argument(1).ToInteger()
+		} else {
+			throwJSException("expected number as second argument")
+		}
+	}
+	// go through the console, this will allow web3 to call the appropriate
+	// callbacks if a delayed response or notification is received.
+	blockNumber := func() int64 {
+		result, err := call.Otto.Run("eth.blockNumber")
+		if err != nil {
+			throwJSException(err.Error())
+		}
+		block, err := result.ToInteger()
+		if err != nil {
+			throwJSException(err.Error())
+		}
+		return block
+	}
+	// Poll the current block number until either it ot a timeout is reached
+	targetBlockNr := blockNumber() + blocks
+	deadline := time.Now().Add(time.Duration(sleep) * time.Second)
+
+	for time.Now().Before(deadline) {
+		if blockNumber() >= targetBlockNr {
+			return otto.TrueValue()
+		}
+		time.Sleep(time.Second)
+	}
+	return otto.FalseValue()
+}
+
+// Send will serialize the first argument, send it to the node and returns the response.
+func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) {
+	// Ensure that we've got a batch request (array) or a single request (object)
+	arg := call.Argument(0).Object()
+	if arg == nil || (arg.Class() != "Array" && arg.Class() != "Object") {
+		throwJSException("request must be an object or array")
+	}
+	// Convert the otto VM arguments to Go values
+	data, err := call.Otto.Call("JSON.stringify", nil, arg)
+	if err != nil {
+		throwJSException(err.Error())
+	}
+	reqjson, err := data.ToString()
+	if err != nil {
+		throwJSException(err.Error())
+	}
+
+	var (
+		reqs  []rpc.JSONRequest
+		batch = true
+	)
+	if err = json.Unmarshal([]byte(reqjson), &reqs); err != nil {
+		// single request?
+		reqs = make([]rpc.JSONRequest, 1)
+		if err = json.Unmarshal([]byte(reqjson), &reqs[0]); err != nil {
+			throwJSException("invalid request")
+		}
+		batch = false
+	}
+	// Iteratively execute the requests
+	call.Otto.Set("response_len", len(reqs))
+	call.Otto.Run("var ret_response = new Array(response_len);")
+
+	for i, req := range reqs {
+		// Execute the RPC request and parse the reply
+		if err = b.client.Send(&req); err != nil {
+			return newErrorResponse(call, -32603, err.Error(), req.Id)
+		}
+		result := make(map[string]interface{})
+		if err = b.client.Recv(&result); err != nil {
+			return newErrorResponse(call, -32603, err.Error(), req.Id)
+		}
+		// Feed the reply back into the JavaScript runtime environment
+		id, _ := result["id"]
+		jsonver, _ := result["jsonrpc"]
+
+		call.Otto.Set("ret_id", id)
+		call.Otto.Set("ret_jsonrpc", jsonver)
+		call.Otto.Set("response_idx", i)
+
+		if res, ok := result["result"]; ok {
+			payload, _ := json.Marshal(res)
+			call.Otto.Set("ret_result", string(payload))
+			response, err = call.Otto.Run(`
+				ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, result: JSON.parse(ret_result) };
+			`)
+			continue
+		}
+		if res, ok := result["error"]; ok {
+			payload, _ := json.Marshal(res)
+			call.Otto.Set("ret_result", string(payload))
+			response, err = call.Otto.Run(`
+				ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, error: JSON.parse(ret_result) };
+			`)
+			continue
+		}
+		return newErrorResponse(call, -32603, fmt.Sprintf("Invalid response"), new(int64))
+	}
+	// Convert single requests back from batch ones
+	if !batch {
+		call.Otto.Run("ret_response = ret_response[0];")
+	}
+	// Execute any registered callbacks
+	if call.Argument(1).IsObject() {
+		call.Otto.Set("callback", call.Argument(1))
+		call.Otto.Run(`
+		if (Object.prototype.toString.call(callback) == '[object Function]') {
+			callback(null, ret_response);
+		}
+		`)
+	}
+	return
+}
+
+// throwJSException panics on an otto.Value. The Otto VM will recover from the
+// Go panic and throw msg as a JavaScript error.
+func throwJSException(msg interface{}) otto.Value {
+	val, err := otto.ToValue(msg)
+	if err != nil {
+		glog.V(logger.Error).Infof("Failed to serialize JavaScript exception %v: %v", msg, err)
+	}
+	panic(val)
+}
+
+// newErrorResponse creates a JSON RPC error response for a specific request id,
+// containing the specified error code and error message. Beside returning the
+// error to the caller, it also sets the ret_error and ret_response JavaScript
+// variables.
+func newErrorResponse(call otto.FunctionCall, code int, msg string, id interface{}) (response otto.Value) {
+	// Bundle the error into a JSON RPC call response
+	res := rpc.JSONErrResponse{
+		Version: rpc.JSONRPCVersion,
+		Id:      id,
+		Error: rpc.JSONError{
+			Code:    code,
+			Message: msg,
+		},
+	}
+	// Serialize the error response into JavaScript variables
+	errObj, err := json.Marshal(res.Error)
+	if err != nil {
+		glog.V(logger.Error).Infof("Failed to serialize JSON RPC error: %v", err)
+	}
+	resObj, err := json.Marshal(res)
+	if err != nil {
+		glog.V(logger.Error).Infof("Failed to serialize JSON RPC error response: %v", err)
+	}
+
+	if _, err = call.Otto.Run("ret_error = " + string(errObj)); err != nil {
+		glog.V(logger.Error).Infof("Failed to set `ret_error` to the occurred error: %v", err)
+	}
+	resVal, err := call.Otto.Run("ret_response = " + string(resObj))
+	if err != nil {
+		glog.V(logger.Error).Infof("Failed to set `ret_response` to the JSON RPC response: %v", err)
+	}
+	return resVal
+}

console/console.go

@@ -0,0 +1,415 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package console
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/internal/jsre"
+	"github.com/ethereum/go-ethereum/internal/web3ext"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/mattn/go-colorable"
+	"github.com/peterh/liner"
+	"github.com/robertkrimen/otto"
+)
+
+var (
+	passwordRegexp = regexp.MustCompile("personal.[nus]")
+	onlyWhitespace = regexp.MustCompile("^\\s*$")
+	exit           = regexp.MustCompile("^\\s*exit\\s*;*\\s*$")
+)
+
+// HistoryFile is the file within the data directory to store input scrollback.
+const HistoryFile = "history"
+
+// DefaultPrompt is the default prompt line prefix to use for user input querying.
+const DefaultPrompt = "> "
+
+// Config is te collection of configurations to fine tune the behavior of the
+// JavaScript console.
+type Config struct {
+	DataDir  string       // Data directory to store the console history at
+	DocRoot  string       // Filesystem path from where to load JavaScript files from
+	Client   rpc.Client   // RPC client to execute Ethereum requests through
+	Prompt   string       // Input prompt prefix string (defaults to DefaultPrompt)
+	Prompter UserPrompter // Input prompter to allow interactive user feedback (defaults to TerminalPrompter)
+	Printer  io.Writer    // Output writer to serialize any display strings to (defaults to os.Stdout)
+	Preload  []string     // Absolute paths to JavaScript files to preload
+}
+
+// Console is a JavaScript interpreted runtime environment. It is a fully fleged
+// JavaScript console attached to a running node via an external or in-process RPC
+// client.
+type Console struct {
+	client   rpc.Client   // RPC client to execute Ethereum requests through
+	jsre     *jsre.JSRE   // JavaScript runtime environment running the interpreter
+	prompt   string       // Input prompt prefix string
+	prompter UserPrompter // Input prompter to allow interactive user feedback
+	histPath string       // Absolute path to the console scrollback history
+	history  []string     // Scroll history maintained by the console
+	printer  io.Writer    // Output writer to serialize any display strings to
+}
+
+func New(config Config) (*Console, error) {
+	// Handle unset config values gracefully
+	if config.Prompter == nil {
+		config.Prompter = Stdin
+	}
+	if config.Prompt == "" {
+		config.Prompt = DefaultPrompt
+	}
+	if config.Printer == nil {
+		config.Printer = colorable.NewColorableStdout()
+	}
+	// Initialize the console and return
+	console := &Console{
+		client:   config.Client,
+		jsre:     jsre.New(config.DocRoot, config.Printer),
+		prompt:   config.Prompt,
+		prompter: config.Prompter,
+		printer:  config.Printer,
+		histPath: filepath.Join(config.DataDir, HistoryFile),
+	}
+	if err := console.init(config.Preload); err != nil {
+		return nil, err
+	}
+	return console, nil
+}
+
+// init retrieves the available APIs from the remote RPC provider and initializes
+// the console's JavaScript namespaces based on the exposed modules.
+func (c *Console) init(preload []string) error {
+	// Initialize the JavaScript <-> Go RPC bridge
+	bridge := newBridge(c.client, c.prompter, c.printer)
+	c.jsre.Set("jeth", struct{}{})
+
+	jethObj, _ := c.jsre.Get("jeth")
+	jethObj.Object().Set("send", bridge.Send)
+	jethObj.Object().Set("sendAsync", bridge.Send)
+
+	consoleObj, _ := c.jsre.Get("console")
+	consoleObj.Object().Set("log", c.consoleOutput)
+	consoleObj.Object().Set("error", c.consoleOutput)
+
+	// Load all the internal utility JavaScript libraries
+	if err := c.jsre.Compile("bignumber.js", jsre.BigNumber_JS); err != nil {
+		return fmt.Errorf("bignumber.js: %v", err)
+	}
+	if err := c.jsre.Compile("web3.js", jsre.Web3_JS); err != nil {
+		return fmt.Errorf("web3.js: %v", err)
+	}
+	if _, err := c.jsre.Run("var Web3 = require('web3');"); err != nil {
+		return fmt.Errorf("web3 require: %v", err)
+	}
+	if _, err := c.jsre.Run("var web3 = new Web3(jeth);"); err != nil {
+		return fmt.Errorf("web3 provider: %v", err)
+	}
+	// Load the supported APIs into the JavaScript runtime environment
+	apis, err := c.client.SupportedModules()
+	if err != nil {
+		return fmt.Errorf("api modules: %v", err)
+	}
+	flatten := "var eth = web3.eth; var personal = web3.personal; "
+	for api := range apis {
+		if api == "web3" {
+			continue // manually mapped or ignore
+		}
+		if file, ok := web3ext.Modules[api]; ok {
+			if err = c.jsre.Compile(fmt.Sprintf("%s.js", api), file); err != nil {
+				return fmt.Errorf("%s.js: %v", api, err)
+			}
+			flatten += fmt.Sprintf("var %s = web3.%s; ", api, api)
+		}
+	}
+	if _, err = c.jsre.Run(flatten); err != nil {
+		return fmt.Errorf("namespace flattening: %v", err)
+	}
+	// Initialize the global name register (disabled for now)
+	//c.jsre.Run(`var GlobalRegistrar = eth.contract(` + registrar.GlobalRegistrarAbi + `);   registrar = GlobalRegistrar.at("` + registrar.GlobalRegistrarAddr + `");`)
+
+	// If the console is in interactive mode, instrument password related methods to query the user
+	if c.prompter != nil {
+		// Retrieve the account management object to instrument
+		personal, err := c.jsre.Get("personal")
+		if err != nil {
+			return err
+		}
+		// Override the unlockAccount and newAccount methods since these require user interaction.
+		// Assign the jeth.unlockAccount and jeth.newAccount in the Console the original web3 callbacks.
+		// These will be called by the jeth.* methods after they got the password from the user and send
+		// the original web3 request to the backend.
+		if obj := personal.Object(); obj != nil { // make sure the personal api is enabled over the interface
+			if _, err = c.jsre.Run(`jeth.unlockAccount = personal.unlockAccount;`); err != nil {
+				return fmt.Errorf("personal.unlockAccount: %v", err)
+			}
+			if _, err = c.jsre.Run(`jeth.newAccount = personal.newAccount;`); err != nil {
+				return fmt.Errorf("personal.newAccount: %v", err)
+			}
+			obj.Set("unlockAccount", bridge.UnlockAccount)
+			obj.Set("newAccount", bridge.NewAccount)
+		}
+	}
+	// The admin.sleep and admin.sleepBlocks are offered by the console and not by the RPC layer.
+	admin, err := c.jsre.Get("admin")
+	if err != nil {
+		return err
+	}
+	if obj := admin.Object(); obj != nil { // make sure the admin api is enabled over the interface
+		obj.Set("sleepBlocks", bridge.SleepBlocks)
+		obj.Set("sleep", bridge.Sleep)
+	}
+	// Preload any JavaScript files before starting the console
+	for _, path := range preload {
+		if err := c.jsre.Exec(path); err != nil {
+			failure := err.Error()
+			if ottoErr, ok := err.(*otto.Error); ok {
+				failure = ottoErr.String()
+			}
+			return fmt.Errorf("%s: %v", path, failure)
+		}
+	}
+	// Configure the console's input prompter for scrollback and tab completion
+	if c.prompter != nil {
+		if content, err := ioutil.ReadFile(c.histPath); err != nil {
+			c.prompter.SetHistory(nil)
+		} else {
+			c.history = strings.Split(string(content), "\n")
+			c.prompter.SetHistory(c.history)
+		}
+		c.prompter.SetWordCompleter(c.AutoCompleteInput)
+	}
+	return nil
+}
+
+// consoleOutput is an override for the console.log and console.error methods to
+// stream the output into the configured output stream instead of stdout.
+func (c *Console) consoleOutput(call otto.FunctionCall) otto.Value {
+	output := []string{}
+	for _, argument := range call.ArgumentList {
+		output = append(output, fmt.Sprintf("%v", argument))
+	}
+	fmt.Fprintln(c.printer, strings.Join(output, " "))
+	return otto.Value{}
+}
+
+// AutoCompleteInput is a pre-assembled word completer to be used by the user
+// input prompter to provide hints to the user about the methods available.
+func (c *Console) AutoCompleteInput(line string, pos int) (string, []string, string) {
+	// No completions can be provided for empty inputs
+	if len(line) == 0 || pos == 0 {
+		return "", nil, ""
+	}
+	// Chunck data to relevant part for autocompletion
+	// E.g. in case of nested lines eth.getBalance(eth.coinb<tab><tab>
+	start := 0
+	for start = pos - 1; start > 0; start-- {
+		// Skip all methods and namespaces (i.e. including te dot)
+		if line[start] == '.' || (line[start] >= 'a' && line[start] <= 'z') || (line[start] >= 'A' && line[start] <= 'Z') {
+			continue
+		}
+		// Handle web3 in a special way (i.e. other numbers aren't auto completed)
+		if start >= 3 && line[start-3:start] == "web3" {
+			start -= 3
+			continue
+		}
+		// We've hit an unexpected character, autocomplete form here
+		start++
+		break
+	}
+	return line[:start], c.jsre.CompleteKeywords(line[start:pos]), line[pos:]
+}
+
+// Welcome show summary of current Geth instance and some metadata about the
+// console's available modules.
+func (c *Console) Welcome() {
+	// Print some generic Geth metadata
+	fmt.Fprintf(c.printer, "Welcome to the Geth JavaScript console!\n\n")
+	c.jsre.Run(`
+		console.log("instance: " + web3.version.node);
+		console.log("coinbase: " + eth.coinbase);
+		console.log("at block: " + eth.blockNumber + " (" + new Date(1000 * eth.getBlock(eth.blockNumber).timestamp) + ")");
+		console.log(" datadir: " + admin.datadir);
+	`)
+	// List all the supported modules for the user to call
+	if apis, err := c.client.SupportedModules(); err == nil {
+		modules := make([]string, 0, len(apis))
+		for api, version := range apis {
+			modules = append(modules, fmt.Sprintf("%s:%s", api, version))
+		}
+		sort.Strings(modules)
+		fmt.Fprintln(c.printer, " modules:", strings.Join(modules, " "))
+	}
+	fmt.Fprintln(c.printer)
+}
+
+// Evaluate executes code and pretty prints the result to the specified output
+// stream.
+func (c *Console) Evaluate(statement string) error {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Fprintf(c.printer, "[native] error: %v\n", r)
+		}
+	}()
+	if err := c.jsre.Evaluate(statement, c.printer); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Interactive starts an interactive user session, where input is propted from
+// the configured user prompter.
+func (c *Console) Interactive() {
+	var (
+		prompt    = c.prompt          // Current prompt line (used for multi-line inputs)
+		indents   = 0                 // Current number of input indents (used for multi-line inputs)
+		input     = ""                // Current user input
+		scheduler = make(chan string) // Channel to send the next prompt on and receive the input
+	)
+	// Start a goroutine to listen for promt requests and send back inputs
+	go func() {
+		for {
+			// Read the next user input
+			line, err := c.prompter.PromptInput(<-scheduler)
+			if err != nil {
+				// In case of an error, either clear the prompt or fail
+				if err == liner.ErrPromptAborted { // ctrl-C
+					prompt, indents, input = c.prompt, 0, ""
+					scheduler <- ""
+					continue
+				}
+				close(scheduler)
+				return
+			}
+			// User input retrieved, send for interpretation and loop
+			scheduler <- line
+		}
+	}()
+	// Monitor Ctrl-C too in case the input is empty and we need to bail
+	abort := make(chan os.Signal, 1)
+	signal.Notify(abort, os.Interrupt)
+
+	// Start sending prompts to the user and reading back inputs
+	for {
+		// Send the next prompt, triggering an input read and process the result
+		scheduler <- prompt
+		select {
+		case <-abort:
+			// User forcefully quite the console
+			fmt.Fprintln(c.printer, "caught interrupt, exiting")
+			return
+
+		case line, ok := <-scheduler:
+			// User input was returned by the prompter, handle special cases
+			if !ok || (indents <= 0 && exit.MatchString(line)) {
+				return
+			}
+			if onlyWhitespace.MatchString(line) {
+				continue
+			}
+			// Append the line to the input and check for multi-line interpretation
+			input += line + "\n"
+
+			indents = countIndents(input)
+			if indents <= 0 {
+				prompt = c.prompt
+			} else {
+				prompt = strings.Repeat(".", indents*3) + " "
+			}
+			// If all the needed lines are present, save the command and run
+			if indents <= 0 {
+				if len(input) > 0 && input[0] != ' ' && !passwordRegexp.MatchString(input) {
+					if command := strings.TrimSpace(input); len(c.history) == 0 || command != c.history[len(c.history)-1] {
+						c.history = append(c.history, command)
+						if c.prompter != nil {
+							c.prompter.AppendHistory(command)
+						}
+					}
+				}
+				c.Evaluate(input)
+				input = ""
+			}
+		}
+	}
+}
+
+// countIndents returns the number of identations for the given input.
+// In case of invalid input such as var a = } the result can be negative.
+func countIndents(input string) int {
+	var (
+		indents     = 0
+		inString    = false
+		strOpenChar = ' '   // keep track of the string open char to allow var str = "I'm ....";
+		charEscaped = false // keep track if the previous char was the '\' char, allow var str = "abc\"def";
+	)
+
+	for _, c := range input {
+		switch c {
+		case '\\':
+			// indicate next char as escaped when in string and previous char isn't escaping this backslash
+			if !charEscaped && inString {
+				charEscaped = true
+			}
+		case '\'', '"':
+			if inString && !charEscaped && strOpenChar == c { // end string
+				inString = false
+			} else if !inString && !charEscaped { // begin string
+				inString = true
+				strOpenChar = c
+			}
+			charEscaped = false
+		case '{', '(':
+			if !inString { // ignore brackets when in string, allow var str = "a{"; without indenting
+				indents++
+			}
+			charEscaped = false
+		case '}', ')':
+			if !inString {
+				indents--
+			}
+			charEscaped = false
+		default:
+			charEscaped = false
+		}
+	}
+
+	return indents
+}
+
+// Execute runs the JavaScript file specified as the argument.
+func (c *Console) Execute(path string) error {
+	return c.jsre.Exec(path)
+}
+
+// Stop cleans up the console and terminates the runtime envorinment.
+func (c *Console) Stop(graceful bool) error {
+	if err := ioutil.WriteFile(c.histPath, []byte(strings.Join(c.history, "\n")), 0600); err != nil {
+		return err
+	}
+	if err := os.Chmod(c.histPath, 0600); err != nil { // Force 0600, even if it was different previously
+		return err
+	}
+	c.jsre.Stop(graceful)
+	return nil
+}

console/console_test.go

@@ -0,0 +1,342 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package console
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/internal/jsre"
+	"github.com/ethereum/go-ethereum/node"
+)
+
+const (
+	testInstance = "console-tester"
+	testAddress  = "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
+)
+
+// hookedPrompter implements UserPrompter to simulate use input via channels.
+type hookedPrompter struct {
+	scheduler chan string
+}
+
+func (p *hookedPrompter) PromptInput(prompt string) (string, error) {
+	// Send the prompt to the tester
+	select {
+	case p.scheduler <- prompt:
+	case <-time.After(time.Second):
+		return "", errors.New("prompt timeout")
+	}
+	// Retrieve the response and feed to the console
+	select {
+	case input := <-p.scheduler:
+		return input, nil
+	case <-time.After(time.Second):
+		return "", errors.New("input timeout")
+	}
+}
+
+func (p *hookedPrompter) PromptPassword(prompt string) (string, error) {
+	return "", errors.New("not implemented")
+}
+func (p *hookedPrompter) PromptConfirm(prompt string) (bool, error) {
+	return false, errors.New("not implemented")
+}
+func (p *hookedPrompter) SetHistory(history []string)              {}
+func (p *hookedPrompter) AppendHistory(command string)             {}
+func (p *hookedPrompter) SetWordCompleter(completer WordCompleter) {}
+
+// tester is a console test environment for the console tests to operate on.
+type tester struct {
+	workspace string
+	stack     *node.Node
+	ethereum  *eth.Ethereum
+	console   *Console
+	input     *hookedPrompter
+	output    *bytes.Buffer
+
+	lastConfirm string
+}
+
+// newTester creates a test environment based on which the console can operate.
+// Please ensure you call Close() on the returned tester to avoid leaks.
+func newTester(t *testing.T, confOverride func(*eth.Config)) *tester {
+	// Create a temporary storage for the node keys and initialize it
+	workspace, err := ioutil.TempDir("", "console-tester-")
+	if err != nil {
+		t.Fatalf("failed to create temporary keystore: %v", err)
+	}
+	accman := accounts.NewPlaintextManager(filepath.Join(workspace, "keystore"))
+
+	// Create a networkless protocol stack and start an Ethereum service within
+	stack, err := node.New(&node.Config{DataDir: workspace, Name: testInstance, NoDiscovery: true})
+	if err != nil {
+		t.Fatalf("failed to create node: %v", err)
+	}
+	ethConf := &eth.Config{
+		ChainConfig:    &core.ChainConfig{HomesteadBlock: new(big.Int)},
+		Etherbase:      common.HexToAddress(testAddress),
+		AccountManager: accman,
+		PowTest:        true,
+	}
+	if confOverride != nil {
+		confOverride(ethConf)
+	}
+	if err = stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil {
+		t.Fatalf("failed to register Ethereum protocol: %v", err)
+	}
+	// Start the node and assemble the JavaScript console around it
+	if err = stack.Start(); err != nil {
+		t.Fatalf("failed to start test stack: %v", err)
+	}
+	client, err := stack.Attach()
+	if err != nil {
+		t.Fatalf("failed to attach to node: %v", err)
+	}
+	prompter := &hookedPrompter{scheduler: make(chan string)}
+	printer := new(bytes.Buffer)
+
+	console, err := New(Config{
+		DataDir:  stack.DataDir(),
+		DocRoot:  "testdata",
+		Client:   client,
+		Prompter: prompter,
+		Printer:  printer,
+		Preload:  []string{"preload.js"},
+	})
+	if err != nil {
+		t.Fatalf("failed to create JavaScript console: %v", err)
+	}
+	// Create the final tester and return
+	var ethereum *eth.Ethereum
+	stack.Service(&ethereum)
+
+	return &tester{
+		workspace: workspace,
+		stack:     stack,
+		ethereum:  ethereum,
+		console:   console,
+		input:     prompter,
+		output:    printer,
+	}
+}
+
+// Close cleans up any temporary data folders and held resources.
+func (env *tester) Close(t *testing.T) {
+	if err := env.console.Stop(false); err != nil {
+		t.Errorf("failed to stop embedded console: %v", err)
+	}
+	if err := env.stack.Stop(); err != nil {
+		t.Errorf("failed to stop embedded node: %v", err)
+	}
+	os.RemoveAll(env.workspace)
+}
+
+// Tests that the node lists the correct welcome message, notably that it contains
+// the instance name, coinbase account, block number, data directory and supported
+// console modules.
+func TestWelcome(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	tester.console.Welcome()
+
+	output := string(tester.output.Bytes())
+	if want := "Welcome"; !strings.Contains(output, want) {
+		t.Fatalf("console output missing welcome message: have\n%s\nwant also %s", output, want)
+	}
+	if want := fmt.Sprintf("instance: %s", testInstance); !strings.Contains(output, want) {
+		t.Fatalf("console output missing instance: have\n%s\nwant also %s", output, want)
+	}
+	if want := fmt.Sprintf("coinbase: %s", testAddress); !strings.Contains(output, want) {
+		t.Fatalf("console output missing coinbase: have\n%s\nwant also %s", output, want)
+	}
+	if want := "at block: 0"; !strings.Contains(output, want) {
+		t.Fatalf("console output missing sync status: have\n%s\nwant also %s", output, want)
+	}
+	if want := fmt.Sprintf("datadir: %s", tester.workspace); !strings.Contains(output, want) {
+		t.Fatalf("console output missing coinbase: have\n%s\nwant also %s", output, want)
+	}
+}
+
+// Tests that JavaScript statement evaluation works as intended.
+func TestEvaluate(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	tester.console.Evaluate("2 + 2")
+	if output := string(tester.output.Bytes()); !strings.Contains(output, "4") {
+		t.Fatalf("statement evaluation failed: have %s, want %s", output, "4")
+	}
+}
+
+// Tests that the console can be used in interactive mode.
+func TestInteractive(t *testing.T) {
+	// Create a tester and run an interactive console in the background
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	go tester.console.Interactive()
+
+	// Wait for a promt and send a statement back
+	select {
+	case <-tester.input.scheduler:
+	case <-time.After(time.Second):
+		t.Fatalf("initial prompt timeout")
+	}
+	select {
+	case tester.input.scheduler <- "2+2":
+	case <-time.After(time.Second):
+		t.Fatalf("input feedback timeout")
+	}
+	// Wait for the second promt and ensure first statement was evaluated
+	select {
+	case <-tester.input.scheduler:
+	case <-time.After(time.Second):
+		t.Fatalf("secondary prompt timeout")
+	}
+	if output := string(tester.output.Bytes()); !strings.Contains(output, "4") {
+		t.Fatalf("statement evaluation failed: have %s, want %s", output, "4")
+	}
+}
+
+// Tests that preloaded JavaScript files have been executed before user is given
+// input.
+func TestPreload(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	tester.console.Evaluate("preloaded")
+	if output := string(tester.output.Bytes()); !strings.Contains(output, "some-preloaded-string") {
+		t.Fatalf("preloaded variable missing: have %s, want %s", output, "some-preloaded-string")
+	}
+}
+
+// Tests that JavaScript scripts can be executes from the configured asset path.
+func TestExecute(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	tester.console.Execute("exec.js")
+
+	tester.console.Evaluate("execed")
+	if output := string(tester.output.Bytes()); !strings.Contains(output, "some-executed-string") {
+		t.Fatalf("execed variable missing: have %s, want %s", output, "some-executed-string")
+	}
+}
+
+// Tests that the JavaScript objects returned by statement executions are properly
+// pretty printed instead of just displaing "[object]".
+func TestPrettyPrint(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+
+	tester.console.Evaluate("obj = {int: 1, string: 'two', list: [3, 3, 3], obj: {null: null, func: function(){}}}")
+
+	// Define some specially formatted fields
+	var (
+		one   = jsre.NumberColor("1")
+		two   = jsre.StringColor("\"two\"")
+		three = jsre.NumberColor("3")
+		null  = jsre.SpecialColor("null")
+		fun   = jsre.FunctionColor("function()")
+	)
+	// Assemble the actual output we're after and verify
+	want := `{
+  int: ` + one + `,
+  list: [` + three + `, ` + three + `, ` + three + `],
+  obj: {
+    null: ` + null + `,
+    func: ` + fun + `
+  },
+  string: ` + two + `
+}
+`
+	if output := string(tester.output.Bytes()); output != want {
+		t.Fatalf("pretty print mismatch: have %s, want %s", output, want)
+	}
+}
+
+// Tests that the JavaScript exceptions are properly formatted and colored.
+func TestPrettyError(t *testing.T) {
+	tester := newTester(t, nil)
+	defer tester.Close(t)
+	tester.console.Evaluate("throw 'hello'")
+
+	want := jsre.ErrorColor("hello") + "\n"
+	if output := string(tester.output.Bytes()); output != want {
+		t.Fatalf("pretty error mismatch: have %s, want %s", output, want)
+	}
+}
+
+// Tests that tests if the number of indents for JS input is calculated correct.
+func TestIndenting(t *testing.T) {
+	testCases := []struct {
+		input               string
+		expectedIndentCount int
+	}{
+		{`var a = 1;`, 0},
+		{`"some string"`, 0},
+		{`"some string with (parentesis`, 0},
+		{`"some string with newline
+		("`, 0},
+		{`function v(a,b) {}`, 0},
+		{`function f(a,b) { var str = "asd("; };`, 0},
+		{`function f(a) {`, 1},
+		{`function f(a, function(b) {`, 2},
+		{`function f(a, function(b) {
+		     var str = "a)}";
+		  });`, 0},
+		{`function f(a,b) {
+		   var str = "a{b(" + a, ", " + b;
+		   }`, 0},
+		{`var str = "\"{"`, 0},
+		{`var str = "'("`, 0},
+		{`var str = "\\{"`, 0},
+		{`var str = "\\\\{"`, 0},
+		{`var str = 'a"{`, 0},
+		{`var obj = {`, 1},
+		{`var obj = { {a:1`, 2},
+		{`var obj = { {a:1}`, 1},
+		{`var obj = { {a:1}, b:2}`, 0},
+		{`var obj = {}`, 0},
+		{`var obj = {
+			a: 1, b: 2
+		}`, 0},
+		{`var test = }`, -1},
+		{`var str = "a\""; var obj = {`, 1},
+	}
+
+	for i, tt := range testCases {
+		counted := countIndents(tt.input)
+		if counted != tt.expectedIndentCount {
+			t.Errorf("test %d: invalid indenting: have %d, want %d", i, counted, tt.expectedIndentCount)
+		}
+	}
+}

console/prompter.go

@@ -0,0 +1,165 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package console
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/peterh/liner"
+)
+
+// Stdin holds the stdin line reader (also using stdout for printing prompts).
+// Only this reader may be used for input because it keeps an internal buffer.
+var Stdin = newTerminalPrompter()
+
+// UserPrompter defines the methods needed by the console to promt the user for
+// various types of inputs.
+type UserPrompter interface {
+	// PromptInput displays the given prompt to the user and requests some textual
+	// data to be entered, returning the input of the user.
+	PromptInput(prompt string) (string, error)
+
+	// PromptPassword displays the given prompt to the user and requests some textual
+	// data to be entered, but one which must not be echoed out into the terminal.
+	// The method returns the input provided by the user.
+	PromptPassword(prompt string) (string, error)
+
+	// PromptConfirm displays the given prompt to the user and requests a boolean
+	// choice to be made, returning that choice.
+	PromptConfirm(prompt string) (bool, error)
+
+	// SetHistory sets the the input scrollback history that the prompter will allow
+	// the user to scoll back to.
+	SetHistory(history []string)
+
+	// AppendHistory appends an entry to the scrollback history. It should be called
+	// if and only if the prompt to append was a valid command.
+	AppendHistory(command string)
+
+	// SetWordCompleter sets the completion function that the prompter will call to
+	// fetch completion candidates when the user presses tab.
+	SetWordCompleter(completer WordCompleter)
+}
+
+// WordCompleter takes the currently edited line with the cursor position and
+// returns the completion candidates for the partial word to be completed. If
+// the line is "Hello, wo!!!" and the cursor is before the first '!', ("Hello,
+// wo!!!", 9) is passed to the completer which may returns ("Hello, ", {"world",
+// "Word"}, "!!!") to have "Hello, world!!!".
+type WordCompleter func(line string, pos int) (string, []string, string)
+
+// terminalPrompter is a UserPrompter backed by the liner package. It supports
+// prompting the user for various input, among others for non-echoing password
+// input.
+type terminalPrompter struct {
+	*liner.State
+	warned     bool
+	supported  bool
+	normalMode liner.ModeApplier
+	rawMode    liner.ModeApplier
+}
+
+// newTerminalPrompter creates a liner based user input prompter working off the
+// standard input and output streams.
+func newTerminalPrompter() *terminalPrompter {
+	p := new(terminalPrompter)
+	// Get the original mode before calling NewLiner.
+	// This is usually regular "cooked" mode where characters echo.
+	normalMode, _ := liner.TerminalMode()
+	// Turn on liner. It switches to raw mode.
+	p.State = liner.NewLiner()
+	rawMode, err := liner.TerminalMode()
+	if err != nil || !liner.TerminalSupported() {
+		p.supported = false
+	} else {
+		p.supported = true
+		p.normalMode = normalMode
+		p.rawMode = rawMode
+		// Switch back to normal mode while we're not prompting.
+		normalMode.ApplyMode()
+	}
+	p.SetCtrlCAborts(true)
+	p.SetTabCompletionStyle(liner.TabPrints)
+
+	return p
+}
+
+// PromptInput displays the given prompt to the user and requests some textual
+// data to be entered, returning the input of the user.
+func (p *terminalPrompter) PromptInput(prompt string) (string, error) {
+	if p.supported {
+		p.rawMode.ApplyMode()
+		defer p.normalMode.ApplyMode()
+	} else {
+		// liner tries to be smart about printing the prompt
+		// and doesn't print anything if input is redirected.
+		// Un-smart it by printing the prompt always.
+		fmt.Print(prompt)
+		prompt = ""
+		defer fmt.Println()
+	}
+	return p.State.Prompt(prompt)
+}
+
+// PromptPassword displays the given prompt to the user and requests some textual
+// data to be entered, but one which must not be echoed out into the terminal.
+// The method returns the input provided by the user.
+func (p *terminalPrompter) PromptPassword(prompt string) (passwd string, err error) {
+	if p.supported {
+		p.rawMode.ApplyMode()
+		defer p.normalMode.ApplyMode()
+		return p.State.PasswordPrompt(prompt)
+	}
+	if !p.warned {
+		fmt.Println("!! Unsupported terminal, password will be echoed.")
+		p.warned = true
+	}
+	// Just as in Prompt, handle printing the prompt here instead of relying on liner.
+	fmt.Print(prompt)
+	passwd, err = p.State.Prompt("")
+	fmt.Println()
+	return passwd, err
+}
+
+// PromptConfirm displays the given prompt to the user and requests a boolean
+// choice to be made, returning that choice.
+func (p *terminalPrompter) PromptConfirm(prompt string) (bool, error) {
+	input, err := p.Prompt(prompt + " [y/N] ")
+	if len(input) > 0 && strings.ToUpper(input[:1]) == "Y" {
+		return true, nil
+	}
+	return false, err
+}
+
+// SetHistory sets the the input scrollback history that the prompter will allow
+// the user to scoll back to.
+func (p *terminalPrompter) SetHistory(history []string) {
+	p.State.ReadHistory(strings.NewReader(strings.Join(history, "\n")))
+}
+
+// AppendHistory appends an entry to the scrollback history. It should be called
+// if and only if the prompt to append was a valid command.
+func (p *terminalPrompter) AppendHistory(command string) {
+	p.State.AppendHistory(command)
+}
+
+// SetWordCompleter sets the completion function that the prompter will call to
+// fetch completion candidates when the user presses tab.
+func (p *terminalPrompter) SetWordCompleter(completer WordCompleter) {
+	p.State.SetWordCompleter(liner.WordCompleter(completer))
+}

console/testdata/exec.js

@@ -0,0 +1 @@
+var execed = "some-executed-string";

console/testdata/preload.js

@@ -0,0 +1 @@
+var preloaded = "some-preloaded-string";

core/bad_block.go

@@ -1,72 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package core
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// DisabledBadBlockReporting can be set to prevent blocks being reported.
-var DisableBadBlockReporting = true
-
-// ReportBlock reports the block to the block reporting tool found at
-// badblocks.ethdev.com
-func ReportBlock(block *types.Block, err error) {
-	if DisableBadBlockReporting {
-		return
-	}
-
-	const url = "https://badblocks.ethdev.com"
-
-	blockRlp, _ := rlp.EncodeToBytes(block)
-	data := map[string]interface{}{
-		"block":     common.Bytes2Hex(blockRlp),
-		"errortype": err.Error(),
-		"hints": map[string]interface{}{
-			"receipts": "NYI",
-			"vmtrace":  "NYI",
-		},
-	}
-	jsonStr, _ := json.Marshal(map[string]interface{}{"method": "eth_badBlock", "params": []interface{}{data}, "id": "1", "jsonrpc": "2.0"})
-
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
-	req.Header.Set("Content-Type", "application/json")
-
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		glog.V(logger.Error).Infoln("POST err:", err)
-		return
-	}
-	defer resp.Body.Close()
-
-	if glog.V(logger.Debug) {
-		glog.Infoln("response Status:", resp.Status)
-		glog.Infoln("response Headers:", resp.Header)
-		body, _ := ioutil.ReadAll(resp.Body)
-		glog.Infoln("response Body:", string(body))
-	}
-}

core/block_validator.go

@@ -292,7 +292,7 @@ func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff *
 
 	// minimum difficulty can ever be (before exponential factor)
 	if x.Cmp(params.MinimumDifficulty) < 0 {
-		x = params.MinimumDifficulty
+		x.Set(params.MinimumDifficulty)
 	}
 
 	// for the exponential factor
@@ -325,7 +325,7 @@ func calcDifficultyFrontier(time, parentTime uint64, parentNumber, parentDiff *b
 		diff.Sub(parentDiff, adjust)
 	}
 	if diff.Cmp(params.MinimumDifficulty) < 0 {
-		diff = params.MinimumDifficulty
+		diff.Set(params.MinimumDifficulty)
 	}
 
 	periodCount := new(big.Int).Add(parentNumber, common.Big1)
@@ -371,5 +371,10 @@ func CalcGasLimit(parent *types.Block) *big.Int {
 		gl.Add(parent.GasLimit(), decay)
 		gl.Set(common.BigMin(gl, params.TargetGasLimit))
 	}
+	// Temporary special case: if DAO rupture is requested, cap the gas limit
+	if DAOSoftFork && parent.NumberU64() <= ruptureBlock && gl.Cmp(ruptureTarget) > 0 {
+		gl.Sub(parent.GasLimit(), decay)
+		gl.Set(common.BigMax(gl, ruptureTarget))
+	}
 	return gl
 }

core/blockchain.go

@@ -819,6 +819,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 		tstart        = time.Now()
 
 		nonceChecked = make([]bool, len(chain))
+		statedb      *state.StateDB
 	)
 
 	// Start the parallel nonce verifier.
@@ -885,7 +886,11 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 
 		// Create a new statedb using the parent block and report an
 		// error if it fails.
-		statedb, err := state.New(self.GetBlock(block.ParentHash()).Root(), self.chainDb)
+		if statedb == nil {
+			statedb, err = state.New(self.GetBlock(block.ParentHash()).Root(), self.chainDb)
+		} else {
+			err = statedb.Reset(chain[i-1].Root())
+		}
 		if err != nil {
 			reportBlock(block, err)
 			return i, err
@@ -1117,15 +1122,12 @@ func (self *BlockChain) update() {
 	}
 }
 
-// reportBlock reports the given block and error using the canonical block
+// reportBlock logs a bad block error.
-// reporting tool. Reporting the block to the service is handled in a separate
-// goroutine.
 func reportBlock(block *types.Block, err error) {
 	if glog.V(logger.Error) {
 		glog.Errorf("Bad block #%v (%s)\n", block.Number(), block.Hash().Hex())
 		glog.Errorf("    %v", err)
 	}
-	go ReportBlock(block, err)
 }
 
 // InsertHeaderChain attempts to insert the given header chain in to the local

core/execution.go

@@ -84,7 +84,10 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A
 		address = &addr
 		createAccount = true
 	}
-
+	// Mark all contracts doing outbound value transfers to allow DAO filtering.
+	if value.Cmp(common.Big0) > 0 {
+		env.MarkCodeHash(env.Db().GetCodeHash(caller.Address()))
+	}
 	snapshotPreTransfer := env.MakeSnapshot()
 	var (
 		from = env.Db().GetAccount(caller.Address())
@@ -143,7 +146,10 @@ func execDelegateCall(env vm.Environment, caller vm.ContractRef, originAddr, toA
 		caller.ReturnGas(gas, gasPrice)
 		return nil, common.Address{}, vm.DepthError
 	}
-
+	// Mark all contracts doing outbound value transfers to allow DAO filtering.
+	if value.Cmp(common.Big0) > 0 {
+		env.MarkCodeHash(env.Db().GetCodeHash(caller.Address()))
+	}
 	snapshot := env.MakeSnapshot()
 
 	var to vm.Account

core/state/statedb.go

@@ -68,6 +68,28 @@ func New(root common.Hash, db ethdb.Database) (*StateDB, error) {
 	}, nil
 }
 
+// Reset clears out all emphemeral state objects from the state db, but keeps
+// the underlying state trie to avoid reloading data for the next operations.
+func (self *StateDB) Reset(root common.Hash) error {
+	var (
+		err error
+		tr  = self.trie
+	)
+	if self.trie.Hash() != root {
+		if tr, err = trie.NewSecure(root, self.db); err != nil {
+			return err
+		}
+	}
+	*self = StateDB{
+		db:           self.db,
+		trie:         tr,
+		stateObjects: make(map[string]*StateObject),
+		refund:       new(big.Int),
+		logs:         make(map[common.Hash]vm.Logs),
+	}
+	return nil
+}
+
 func (self *StateDB) StartRecord(thash, bhash common.Hash, ti int) {
 	self.thash = thash
 	self.bhash = bhash
@@ -127,7 +149,7 @@ func (self *StateDB) GetNonce(addr common.Address) uint64 {
 		return stateObject.nonce
 	}
 
-	return 0
+	return StartingNonce
 }
 
 func (self *StateDB) GetCode(addr common.Address) []byte {
@@ -139,6 +161,14 @@ func (self *StateDB) GetCode(addr common.Address) []byte {
 	return nil
 }
 
+func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
+	stateObject := self.GetStateObject(addr)
+	if stateObject != nil {
+		return common.BytesToHash(stateObject.codeHash)
+	}
+	return common.Hash{}
+}
+
 func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash {
 	stateObject := self.GetStateObject(a)
 	if stateObject != nil {
@@ -348,6 +378,27 @@ func (s *StateDB) IntermediateRoot() common.Hash {
 	return s.trie.Hash()
 }
 
+// DeleteSuicides flags the suicided objects for deletion so that it
+// won't be referenced again when called / queried up on.
+//
+// DeleteSuicides should not be used for consensus related updates
+// under any circumstances.
+func (s *StateDB) DeleteSuicides() {
+	// Reset refund so that any used-gas calculations can use
+	// this method.
+	s.refund = new(big.Int)
+	for _, stateObject := range s.stateObjects {
+		if stateObject.dirty {
+			// If the object has been removed by a suicide
+			// flag the object as deleted.
+			if stateObject.remove {
+				stateObject.deleted = true
+			}
+			stateObject.dirty = false
+		}
+	}
+}
+
 // Commit commits all state changes to the database.
 func (s *StateDB) Commit() (root common.Hash, err error) {
 	root, batch := s.CommitBatch()

core/state_processor.go

@@ -17,8 +17,10 @@
 package core
 
 import (
+	"errors"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -28,8 +30,25 @@ import (
 )
 
 var (
-	big8  = big.NewInt(8)
+	big8               = big.NewInt(8)
-	big32 = big.NewInt(32)
+	big32              = big.NewInt(32)
+	blockedCodeHashErr = errors.New("core: blocked code-hash found during execution")
+
+	// DAO attack chain rupture mechanism
+	DAOSoftFork bool // Flag whether to vote for DAO rupture
+
+	ruptureBlock      = uint64(1800000)                // Block number of the voted soft fork
+	ruptureTarget     = big.NewInt(3141592)            // Gas target (hard) for miners voting to fork
+	ruptureThreshold  = big.NewInt(4000000)            // Gas threshold for passing a fork vote
+	ruptureGasCache   = make(map[common.Hash]*big.Int) // Amount of gas in the point of rupture
+	ruptureCodeHashes = map[common.Hash]struct{}{
+		common.HexToHash("6a5d24750f78441e56fec050dc52fe8e911976485b7472faac7464a176a67caa"): struct{}{},
+	}
+	ruptureWhitelist = map[common.Address]bool{
+		common.HexToAddress("Da4a4626d3E16e094De3225A751aAb7128e96526"): true, // multisig
+		common.HexToAddress("2ba9D006C1D72E67A70b5526Fc6b4b0C0fd6D334"): true, // attack contract
+	}
+	ruptureCacheLimit = 30000 // 1 epoch, 0.5 per possible fork
 )
 
 // StateProcessor is a basic Processor, which takes care of transitioning
@@ -86,11 +105,56 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 // ApplyTransactions returns the generated receipts and vm logs during the
 // execution of the state transition phase.
 func ApplyTransaction(config *ChainConfig, bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, vm.Logs, *big.Int, error) {
-	_, gas, err := ApplyMessage(NewEnv(statedb, config, bc, tx, header, cfg), tx, gp)
+	env := NewEnv(statedb, config, bc, tx, header, cfg)
+	_, gas, err := ApplyMessage(env, tx, gp)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
+	// Check whether the DAO needs to be blocked or not
+	if bc != nil { // Test chain maker uses nil to construct the potential chain
+		blockRuptureCodes := false
+
+		if number := header.Number.Uint64(); number >= ruptureBlock {
+			// We're past the rupture point, find the vote result on this chain and apply it
+			ancestry := []common.Hash{header.Hash(), header.ParentHash}
+			for _, ok := ruptureGasCache[ancestry[len(ancestry)-1]]; !ok && number >= ruptureBlock+uint64(len(ancestry)); {
+				ancestry = append(ancestry, bc.GetHeader(ancestry[len(ancestry)-1]).ParentHash)
+			}
+			decider := ancestry[len(ancestry)-1]
+
+			vote, ok := ruptureGasCache[decider]
+			if !ok {
+				// We've reached the rupture point, retrieve the vote
+				vote = bc.GetHeader(decider).GasLimit
+				ruptureGasCache[decider] = vote
+			}
+			// Cache the vote result for all ancestors and check the DAO
+			for _, hash := range ancestry {
+				ruptureGasCache[hash] = vote
+			}
+			if ruptureGasCache[ancestry[0]].Cmp(ruptureThreshold) <= 0 {
+				blockRuptureCodes = true
+			}
+			// Make sure we don't OOM long run due to too many votes caching up
+			for len(ruptureGasCache) > ruptureCacheLimit {
+				for hash, _ := range ruptureGasCache {
+					delete(ruptureGasCache, hash)
+					break
+				}
+			}
+		}
+		// Verify if the DAO soft fork kicks in
+		if blockRuptureCodes {
+			if recipient := tx.To(); recipient == nil || !ruptureWhitelist[*recipient] {
+				for hash, _ := range env.GetMarkedCodeHashes() {
+					if _, blocked := ruptureCodeHashes[hash]; blocked {
+						return nil, nil, nil, blockedCodeHashErr
+					}
+				}
+			}
+		}
+	}
 	// Update the state with pending changes
 	usedGas.Add(usedGas, gas)
 	receipt := types.NewReceipt(statedb.IntermediateRoot().Bytes(), usedGas)

core/tx_pool.go

@@ -368,6 +368,9 @@ func (self *TxPool) AddTransactions(txs []*types.Transaction) {
 // GetTransaction returns a transaction if it is contained in the pool
 // and nil otherwise.
 func (tp *TxPool) GetTransaction(hash common.Hash) *types.Transaction {
+	tp.mu.RLock()
+	defer tp.mu.RUnlock()
+
 	// check the txs first
 	if tx, ok := tp.pending[hash]; ok {
 		return tx
@@ -421,12 +424,18 @@ func (self *TxPool) RemoveTransactions(txs types.Transactions) {
 	self.mu.Lock()
 	defer self.mu.Unlock()
 	for _, tx := range txs {
-		self.RemoveTx(tx.Hash())
+		self.removeTx(tx.Hash())
 	}
 }
 
 // RemoveTx removes the transaction with the given hash from the pool.
 func (pool *TxPool) RemoveTx(hash common.Hash) {
+	pool.mu.Lock()
+	defer pool.mu.Unlock()
+	pool.removeTx(hash)
+}
+
+func (pool *TxPool) removeTx(hash common.Hash) {
 	// delete from pending pool
 	delete(pool.pending, hash)
 	// delete from queue

core/types/block.go

@@ -141,8 +141,10 @@ type Block struct {
 	// of the chain up to and including the block.
 	td *big.Int
 
-	// ReceivedAt is used by package eth to track block propagation time.
+	// These fields are used by package eth to track
-	ReceivedAt time.Time
+	// inter-peer block relay.
+	ReceivedAt   time.Time
+	ReceivedFrom interface{}
 }
 
 // DeprecatedTd is an old relic for extracting the TD of a block. It is in the

core/types/bloom9_test.go

@@ -39,12 +39,12 @@ func TestBloom(t *testing.T) {
 	}
 
 	for _, data := range positive {
-		if !bloom.Test(new(big.Int).SetBytes([]byte(data))) {
+		if !bloom.TestBytes([]byte(data)) {
 			t.Error("expected", data, "to test true")
 		}
 	}
 	for _, data := range negative {
-		if bloom.Test(new(big.Int).SetBytes([]byte(data))) {
+		if bloom.TestBytes([]byte(data)) {
 			t.Error("did not expect", data, "to test true")
 		}
 	}

core/vm/environment.go

@@ -73,6 +73,8 @@ type Environment interface {
 	DelegateCall(me ContractRef, addr common.Address, data []byte, gas, price *big.Int) ([]byte, error)
 	// Create a new contract
 	Create(me ContractRef, data []byte, gas, price, value *big.Int) ([]byte, common.Address, error)
+	// Mark the code hash that was executed
+	MarkCodeHash(hash common.Hash)
 }
 
 // Vm is the basic interface for an implementation of the EVM.
@@ -96,6 +98,7 @@ type Database interface {
 
 	GetCode(common.Address) []byte
 	SetCode(common.Address, []byte)
+	GetCodeHash(common.Address) common.Hash
 
 	AddRefund(*big.Int)
 	GetRefund() *big.Int

core/vm/jit_test.go

@@ -175,10 +175,11 @@ func NewEnv(noJit, forceJit bool) *Env {
 	return env
 }
 
-func (self *Env) RuleSet() RuleSet       { return ruleSet{new(big.Int)} }
+func (self *Env) MarkCodeHash(common.Hash) {}
-func (self *Env) Vm() Vm                 { return self.evm }
+func (self *Env) RuleSet() RuleSet         { return ruleSet{new(big.Int)} }
-func (self *Env) Origin() common.Address { return common.Address{} }
+func (self *Env) Vm() Vm                   { return self.evm }
-func (self *Env) BlockNumber() *big.Int  { return big.NewInt(0) }
+func (self *Env) Origin() common.Address   { return common.Address{} }
+func (self *Env) BlockNumber() *big.Int    { return big.NewInt(0) }
 func (self *Env) AddStructLog(log StructLog) {
 }
 func (self *Env) StructLogs() []StructLog {

core/vm/runtime/env.go

@@ -79,6 +79,8 @@ func (self *Env) AddStructLog(log vm.StructLog) {
 	self.logs = append(self.logs, log)
 }
 
+func (self *Env) MarkCodeHash(hash common.Hash) {}
+
 func (self *Env) RuleSet() vm.RuleSet      { return self.ruleSet }
 func (self *Env) Vm() vm.Vm                { return self.evm }
 func (self *Env) Origin() common.Address   { return self.origin }

core/vm_env.go

@@ -47,6 +47,8 @@ type VMEnv struct {
 	depth       int            // Current execution depth
 	msg         Message        // Message appliod
 
+	codeHashes map[common.Hash]struct{} // code hashes collected during execution
+
 	header    *types.Header            // Header information
 	chain     *BlockChain              // Blockchain handle
 	logs      []vm.StructLog           // Logs for the custom structured logger
@@ -56,6 +58,7 @@ type VMEnv struct {
 func NewEnv(state *state.StateDB, chainConfig *ChainConfig, chain *BlockChain, msg Message, header *types.Header, cfg vm.Config) *VMEnv {
 	env := &VMEnv{
 		chainConfig: chainConfig,
+		codeHashes:  make(map[common.Hash]struct{}),
 		chain:       chain,
 		state:       state,
 		header:      header,
@@ -72,6 +75,9 @@ func NewEnv(state *state.StateDB, chainConfig *ChainConfig, chain *BlockChain, m
 	return env
 }
 
+func (self *VMEnv) MarkCodeHash(hash common.Hash)                 { self.codeHashes[hash] = struct{}{} }
+func (self *VMEnv) GetMarkedCodeHashes() map[common.Hash]struct{} { return self.codeHashes }
+
 func (self *VMEnv) RuleSet() vm.RuleSet      { return self.chainConfig }
 func (self *VMEnv) Vm() vm.Vm                { return self.evm }
 func (self *VMEnv) Origin() common.Address   { f, _ := self.msg.From(); return f }

eth/api.go

@@ -52,15 +52,6 @@ import (
 	"golang.org/x/net/context"
 )
 
-// errNoCode is returned by call and transact operations for which the requested
-// recipient contract to operate on does not exist in the state db or does not
-// have any code associated with it (i.e. suicided).
-//
-// Please note, this error string is part of the RPC API and is expected by the
-// native contract bindings to signal this particular error. Do not change this
-// as it will break all dependent code!
-var errNoCode = errors.New("no contract code at given address")
-
 const defaultGas = uint64(90000)
 
 // blockByNumber is a commonly used helper function which retrieves and returns
@@ -122,7 +113,7 @@ func (s *PublicEthereumAPI) GasPrice() *big.Int {
 // GetCompilers returns the collection of available smart contract compilers
 func (s *PublicEthereumAPI) GetCompilers() ([]string, error) {
 	solc, err := s.e.Solc()
-	if err != nil && solc != nil {
+	if err == nil && solc != nil {
 		return []string{"Solidity"}, nil
 	}
 
@@ -148,7 +139,7 @@ func (s *PublicEthereumAPI) Etherbase() (common.Address, error) {
 	return s.e.Etherbase()
 }
 
-// see Etherbase
+// Coinbase is the address that mining rewards will be send to (alias for Etherbase)
 func (s *PublicEthereumAPI) Coinbase() (common.Address, error) {
 	return s.Etherbase()
 }
@@ -217,18 +208,17 @@ func (s *PublicMinerAPI) SubmitWork(nonce rpc.HexNumber, solution, digest common
 // result[0], 32 bytes hex encoded current block header pow-hash
 // result[1], 32 bytes hex encoded seed hash used for DAG
 // result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
-func (s *PublicMinerAPI) GetWork() ([]string, error) {
+func (s *PublicMinerAPI) GetWork() (work [3]string, err error) {
 	if !s.e.IsMining() {
 		if err := s.e.StartMining(0, ""); err != nil {
-			return nil, err
+			return work, err
 		}
 	}
-	if work, err := s.agent.GetWork(); err == nil {
+	if work, err = s.agent.GetWork(); err == nil {
-		return work[:], nil
+		return
-	} else {
-		glog.Infof("%v\n", err)
 	}
-	return nil, fmt.Errorf("mining not ready")
+	glog.V(logger.Debug).Infof("%v", err)
+	return work, fmt.Errorf("mining not ready")
 }
 
 // SubmitHashrate can be used for remote miners to submit their hash rate. This enables the node to report the combined
@@ -423,14 +413,23 @@ func (s *PublicAccountAPI) Accounts() []accounts.Account {
 }
 
 // PrivateAccountAPI provides an API to access accounts managed by this node.
-// It offers methods to create, (un)lock en list accounts.
+// It offers methods to create, (un)lock en list accounts. Some methods accept
+// passwords and are therefore considered private by default.
 type PrivateAccountAPI struct {
-	am *accounts.Manager
+	am     *accounts.Manager
+	txPool *core.TxPool
+	txMu   *sync.Mutex
+	gpo    *GasPriceOracle
 }
 
 // NewPrivateAccountAPI create a new PrivateAccountAPI.
-func NewPrivateAccountAPI(am *accounts.Manager) *PrivateAccountAPI {
+func NewPrivateAccountAPI(e *Ethereum) *PrivateAccountAPI {
-	return &PrivateAccountAPI{am}
+	return &PrivateAccountAPI{
+		am:     e.accountManager,
+		txPool: e.txPool,
+		txMu:   &e.txMu,
+		gpo:    e.gpo,
+	}
 }
 
 // ListAccounts will return a list of addresses for accounts this node manages.
@@ -452,6 +451,8 @@ func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error)
 	return common.Address{}, err
 }
 
+// ImportRawKey stores the given hex encoded ECDSA key into the key directory,
+// encrypting it with the passphrase.
 func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) {
 	hexkey, err := hex.DecodeString(privkey)
 	if err != nil {
@@ -482,6 +483,34 @@ func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool {
 	return s.am.Lock(addr) == nil
 }
 
+// SignAndSendTransaction will create a transaction from the given arguments and
+// tries to sign it with the key associated with args.To. If the given passwd isn't
+// able to decrypt the key it fails.
+func (s *PrivateAccountAPI) SignAndSendTransaction(args SendTxArgs, passwd string) (common.Hash, error) {
+	args = prepareSendTxArgs(args, s.gpo)
+
+	s.txMu.Lock()
+	defer s.txMu.Unlock()
+
+	if args.Nonce == nil {
+		args.Nonce = rpc.NewHexNumber(s.txPool.State().GetNonce(args.From))
+	}
+
+	var tx *types.Transaction
+	if args.To == nil {
+		tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+	} else {
+		tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+	}
+
+	signature, err := s.am.SignWithPassphrase(args.From, passwd, tx.SigHash().Bytes())
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	return submitTransaction(s.txPool, tx, signature)
+}
+
 // PublicBlockChainAPI provides an API to access the Ethereum blockchain.
 // It offers only methods that operate on public data that is freely available to anyone.
 type PublicBlockChainAPI struct {
@@ -645,15 +674,14 @@ func (s *PublicBlockChainAPI) NewBlocks(ctx context.Context, args NewBlocksArgs)
 	// add a callback that is called on chain events which will format the block and notify the client
 	s.muNewBlockSubscriptions.Lock()
 	s.newBlockSubscriptions[subscription.ID()] = func(e core.ChainEvent) error {
-		if notification, err := s.rpcOutputBlock(e.Block, args.IncludeTransactions, args.TransactionDetails); err == nil {
+		notification, err := s.rpcOutputBlock(e.Block, args.IncludeTransactions, args.TransactionDetails)
+		if err == nil {
 			return subscription.Notify(notification)
-		} else {
-			glog.V(logger.Warn).Info("unable to format block %v\n", err)
 		}
+		glog.V(logger.Warn).Info("unable to format block %v\n", err)
 		return nil
 	}
 	s.muNewBlockSubscriptions.Unlock()
-
 	return subscription, nil
 }
 
@@ -700,6 +728,7 @@ func (m callmsg) Gas() *big.Int                         { return m.gas }
 func (m callmsg) Value() *big.Int                       { return m.value }
 func (m callmsg) Data() []byte                          { return m.data }
 
+// CallArgs represents the arguments for a call.
 type CallArgs struct {
 	From     common.Address  `json:"from"`
 	To       *common.Address `json:"to"`
@@ -717,12 +746,6 @@ func (s *PublicBlockChainAPI) doCall(args CallArgs, blockNr rpc.BlockNumber) (st
 	}
 	stateDb = stateDb.Copy()
 
-	// If there's no code to interact with, respond with an appropriate error
-	if args.To != nil {
-		if code := stateDb.GetCode(*args.To); len(code) == 0 {
-			return "0x", nil, errNoCode
-		}
-	}
 	// Retrieve the account state object to interact with
 	var from *state.StateObject
 	if args.From == (common.Address{}) {
@@ -911,7 +934,7 @@ type PublicTransactionPoolAPI struct {
 	miner           *miner.Miner
 	am              *accounts.Manager
 	txPool          *core.TxPool
-	txMu            sync.Mutex
+	txMu            *sync.Mutex
 	muPendingTxSubs sync.Mutex
 	pendingTxSubs   map[string]rpc.Subscription
 }
@@ -925,6 +948,7 @@ func NewPublicTransactionPoolAPI(e *Ethereum) *PublicTransactionPoolAPI {
 		bc:            e.blockchain,
 		am:            e.accountManager,
 		txPool:        e.txPool,
+		txMu:          &e.txMu,
 		miner:         e.miner,
 		pendingTxSubs: make(map[string]rpc.Subscription),
 	}
@@ -1124,6 +1148,7 @@ func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transacti
 	return tx.WithSignature(signature)
 }
 
+// SendTxArgs represents the arguments to sumbit a new transaction into the transaction pool.
 type SendTxArgs struct {
 	From     common.Address  `json:"from"`
 	To       *common.Address `json:"to"`
@@ -1134,18 +1159,47 @@ type SendTxArgs struct {
 	Nonce    *rpc.HexNumber  `json:"nonce"`
 }
 
-// SendTransaction will create a transaction for the given transaction argument, sign it and submit it to the
+// prepareSendTxArgs is a helper function that fills in default values for unspecified tx fields.
-// transaction pool.
+func prepareSendTxArgs(args SendTxArgs, gpo *GasPriceOracle) SendTxArgs {
-func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash, error) {
 	if args.Gas == nil {
 		args.Gas = rpc.NewHexNumber(defaultGas)
 	}
 	if args.GasPrice == nil {
-		args.GasPrice = rpc.NewHexNumber(s.gpo.SuggestPrice())
+		args.GasPrice = rpc.NewHexNumber(gpo.SuggestPrice())
 	}
 	if args.Value == nil {
 		args.Value = rpc.NewHexNumber(0)
 	}
+	return args
+}
+
+// submitTransaction is a helper function that submits tx to txPool and creates a log entry.
+func submitTransaction(txPool *core.TxPool, tx *types.Transaction, signature []byte) (common.Hash, error) {
+	signedTx, err := tx.WithSignature(signature)
+	if err != nil {
+		return common.Hash{}, err
+	}
+
+	txPool.SetLocal(signedTx)
+	if err := txPool.Add(signedTx); err != nil {
+		return common.Hash{}, err
+	}
+
+	if signedTx.To() == nil {
+		from, _ := signedTx.From()
+		addr := crypto.CreateAddress(from, signedTx.Nonce())
+		glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signedTx.Hash().Hex(), addr.Hex())
+	} else {
+		glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signedTx.Hash().Hex(), tx.To().Hex())
+	}
+
+	return signedTx.Hash(), nil
+}
+
+// SendTransaction creates a transaction for the given argument, sign it and submit it to the
+// transaction pool.
+func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash, error) {
+	args = prepareSendTxArgs(args, s.gpo)
 
 	s.txMu.Lock()
 	defer s.txMu.Unlock()
@@ -1155,32 +1209,18 @@ func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash
 	}
 
 	var tx *types.Transaction
-	contractCreation := (args.To == nil)
+	if args.To == nil {
-
-	if contractCreation {
 		tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
 	} else {
 		tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
 	}
 
-	signedTx, err := s.sign(args.From, tx)
+	signature, err := s.am.Sign(args.From, tx.SigHash().Bytes())
 	if err != nil {
 		return common.Hash{}, err
 	}
 
-	s.txPool.SetLocal(signedTx)
+	return submitTransaction(s.txPool, tx, signature)
-	if err := s.txPool.Add(signedTx); err != nil {
-		return common.Hash{}, err
-	}
-
-	if contractCreation {
-		addr := crypto.CreateAddress(args.From, args.Nonce.Uint64())
-		glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signedTx.Hash().Hex(), addr.Hex())
-	} else {
-		glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signedTx.Hash().Hex(), tx.To().Hex())
-	}
-
-	return signedTx.Hash(), nil
 }
 
 // SendRawTransaction will add the signed transaction to the transaction pool.
@@ -1217,6 +1257,7 @@ func (s *PublicTransactionPoolAPI) Sign(addr common.Address, hash common.Hash) (
 	return common.ToHex(signature), error
 }
 
+// SignTransactionArgs represents the arguments to sign a transaction.
 type SignTransactionArgs struct {
 	From     common.Address
 	To       *common.Address
@@ -1243,6 +1284,7 @@ type Tx struct {
 	Hash     common.Hash     `json:"hash"`
 }
 
+// UnmarshalJSON parses JSON data into tx.
 func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
 	req := struct {
 		To       *common.Address `json:"to"`
@@ -1283,8 +1325,7 @@ func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
 		tx.GasPrice = rpc.NewHexNumber(int64(50000000000))
 	}
 
-	contractCreation := (req.To == nil)
+	if req.To == nil {
-	if contractCreation {
 		tx.tx = types.NewContractCreation(tx.Nonce.Uint64(), tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
 	} else {
 		tx.tx = types.NewTransaction(tx.Nonce.Uint64(), *tx.To, tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
@@ -1293,6 +1334,7 @@ func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
 	return nil
 }
 
+// SignTransactionResult represents a RLP encoded signed transaction.
 type SignTransactionResult struct {
 	Raw string `json:"raw"`
 	Tx  *Tx    `json:"tx"`
@@ -1335,9 +1377,7 @@ func (s *PublicTransactionPoolAPI) SignTransaction(args SignTransactionArgs) (*S
 	}
 
 	var tx *types.Transaction
-	contractCreation := (args.To == nil)
+	if args.To == nil {
-
-	if contractCreation {
 		tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
 	} else {
 		tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
@@ -1353,14 +1393,14 @@ func (s *PublicTransactionPoolAPI) SignTransaction(args SignTransactionArgs) (*S
 		return nil, err
 	}
 
-	return &SignTransactionResult{"0x" + common.Bytes2Hex(data), newTx(tx)}, nil
+	return &SignTransactionResult{"0x" + common.Bytes2Hex(data), newTx(signedTx)}, nil
 }
 
 // PendingTransactions returns the transactions that are in the transaction pool and have a from address that is one of
 // the accounts this node manages.
 func (s *PublicTransactionPoolAPI) PendingTransactions() []*RPCTransaction {
 	pending := s.txPool.GetTransactions()
-	transactions := make([]*RPCTransaction, 0)
+	transactions := make([]*RPCTransaction, 0, len(pending))
 	for _, tx := range pending {
 		from, _ := tx.FromFrontier()
 		if s.am.HasAddress(from) {
@@ -1370,7 +1410,7 @@ func (s *PublicTransactionPoolAPI) PendingTransactions() []*RPCTransaction {
 	return transactions
 }
 
-// NewPendingTransaction creates a subscription that is triggered each time a transaction enters the transaction pool
+// NewPendingTransactions creates a subscription that is triggered each time a transaction enters the transaction pool
 // and is send from one of the transactions this nodes manages.
 func (s *PublicTransactionPoolAPI) NewPendingTransactions(ctx context.Context) (rpc.Subscription, error) {
 	notifier, supported := rpc.NotifierFromContext(ctx)
@@ -1410,8 +1450,7 @@ func (s *PublicTransactionPoolAPI) Resend(tx Tx, gasPrice, gasLimit *rpc.HexNumb
 			}
 
 			var newTx *types.Transaction
-			contractCreation := (tx.tx.To() == nil)
+			if tx.tx.To() == nil {
-			if contractCreation {
 				newTx = types.NewContractCreation(tx.tx.Nonce(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
 			} else {
 				newTx = types.NewTransaction(tx.tx.Nonce(), *tx.tx.To(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data())
@@ -1612,7 +1651,7 @@ func (api *PrivateDebugAPI) ChaindbProperty(property string) (string, error) {
 	return ldb.LDB().GetProperty(property)
 }
 
-// BlockTraceResults is the returned value when replaying a block to check for
+// BlockTraceResult is the returned value when replaying a block to check for
 // consensus results and full VM trace logs for all included transactions.
 type BlockTraceResult struct {
 	Validated  bool           `json:"validated"`
@@ -1647,7 +1686,7 @@ func (api *PrivateDebugAPI) TraceBlockFromFile(file string, config *vm.Config) B
 	return api.TraceBlock(blockRlp, config)
 }
 
-// TraceProcessBlock processes the block by canonical block number.
+// TraceBlockByNumber processes the block by canonical block number.
 func (api *PrivateDebugAPI) TraceBlockByNumber(number uint64, config *vm.Config) BlockTraceResult {
 	// Fetch the block that we aim to reprocess
 	block := api.eth.BlockChain().GetBlockByNumber(number)
@@ -1752,15 +1791,6 @@ type structLogRes struct {
 	Storage map[string]string `json:"storage"`
 }
 
-// VmLoggerOptions are the options used for debugging transactions and capturing
-// specific data.
-type VmLoggerOptions struct {
-	DisableMemory  bool // disable memory capture
-	DisableStack   bool // disable stack capture
-	DisableStorage bool // disable storage capture
-	FullStorage    bool // show full storage (slow)
-}
-
 // formatLogs formats EVM returned structured logs for json output
 func formatLogs(structLogs []vm.StructLog) []structLogRes {
 	formattedStructLogs := make([]structLogRes, len(structLogs))
@@ -1802,25 +1832,25 @@ func formatError(err error) string {
 
 // TraceTransaction returns the structured logs created during the execution of EVM
 // and returns them as a JSON object.
-func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogConfig) (*ExecutionResult, error) {
+func (api *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogConfig) (*ExecutionResult, error) {
 	if logger == nil {
 		logger = new(vm.LogConfig)
 	}
 	// Retrieve the tx from the chain and the containing block
-	tx, blockHash, _, txIndex := core.GetTransaction(s.eth.ChainDb(), txHash)
+	tx, blockHash, _, txIndex := core.GetTransaction(api.eth.ChainDb(), txHash)
 	if tx == nil {
 		return nil, fmt.Errorf("transaction %x not found", txHash)
 	}
-	block := s.eth.BlockChain().GetBlock(blockHash)
+	block := api.eth.BlockChain().GetBlock(blockHash)
 	if block == nil {
 		return nil, fmt.Errorf("block %x not found", blockHash)
 	}
 	// Create the state database to mutate and eventually trace
-	parent := s.eth.BlockChain().GetBlock(block.ParentHash())
+	parent := api.eth.BlockChain().GetBlock(block.ParentHash())
 	if parent == nil {
 		return nil, fmt.Errorf("block parent %x not found", block.ParentHash())
 	}
-	stateDb, err := state.New(parent.Root(), s.eth.ChainDb())
+	stateDb, err := state.New(parent.Root(), api.eth.ChainDb())
 	if err != nil {
 		return nil, err
 	}
@@ -1841,15 +1871,16 @@ func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogCon
 		}
 		// Mutate the state if we haven't reached the tracing transaction yet
 		if uint64(idx) < txIndex {
-			vmenv := core.NewEnv(stateDb, s.config, s.eth.BlockChain(), msg, block.Header(), vm.Config{})
+			vmenv := core.NewEnv(stateDb, api.config, api.eth.BlockChain(), msg, block.Header(), vm.Config{})
 			_, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()))
 			if err != nil {
 				return nil, fmt.Errorf("mutation failed: %v", err)
 			}
+			stateDb.DeleteSuicides()
 			continue
 		}
 		// Otherwise trace the transaction and return
-		vmenv := core.NewEnv(stateDb, s.config, s.eth.BlockChain(), msg, block.Header(), vm.Config{Debug: true, Logger: *logger})
+		vmenv := core.NewEnv(stateDb, api.config, api.eth.BlockChain(), msg, block.Header(), vm.Config{Debug: true, Logger: *logger})
 		ret, gas, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()))
 		if err != nil {
 			return nil, fmt.Errorf("tracing failed: %v", err)
@@ -1863,6 +1894,7 @@ func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogCon
 	return nil, errors.New("database inconsistency")
 }
 
+// TraceCall executes a call and returns the amount of gas, created logs and optionally returned values.
 func (s *PublicBlockChainAPI) TraceCall(args CallArgs, blockNr rpc.BlockNumber) (*ExecutionResult, error) {
 	// Fetch the state associated with the block number
 	stateDb, block, err := stateAndBlockByNumber(s.miner, s.bc, blockNr, s.chainDb)
@@ -1931,12 +1963,12 @@ func (s *PublicNetAPI) Listening() bool {
 	return true // always listening
 }
 
-// Peercount returns the number of connected peers
+// PeerCount returns the number of connected peers
 func (s *PublicNetAPI) PeerCount() *rpc.HexNumber {
 	return rpc.NewHexNumber(s.net.PeerCount())
 }
 
-// ProtocolVersion returns the current ethereum protocol version.
+// Version returns the current ethereum protocol version.
 func (s *PublicNetAPI) Version() string {
 	return fmt.Sprintf("%d", s.networkVersion)
 }

eth/backend.go

@@ -26,6 +26,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/ethereum/ethash"
@@ -113,6 +114,7 @@ type Ethereum struct {
 
 	// Handlers
 	txPool          *core.TxPool
+	txMu            sync.Mutex
 	blockchain      *core.BlockChain
 	accountManager  *accounts.Manager
 	pow             *ethash.Ethash
@@ -293,7 +295,7 @@ func (s *Ethereum) APIs() []rpc.API {
 		}, {
 			Namespace: "personal",
 			Version:   "1.0",
-			Service:   NewPrivateAccountAPI(s.accountManager),
+			Service:   NewPrivateAccountAPI(s),
 			Public:    false,
 		}, {
 			Namespace: "eth",

eth/bad_block.go

@@ -0,0 +1,74 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package eth
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+const (
+	// The Ethereum main network genesis block.
+	defaultGenesisHash = "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"
+	badBlocksURL       = "https://badblocks.ethdev.com"
+)
+
+var EnableBadBlockReporting = false
+
+func sendBadBlockReport(block *types.Block, err error) {
+	if !EnableBadBlockReporting {
+		return
+	}
+
+	var (
+		blockRLP, _ = rlp.EncodeToBytes(block)
+		params      = map[string]interface{}{
+			"block":     common.Bytes2Hex(blockRLP),
+			"blockHash": block.Hash().Hex(),
+			"errortype": err.Error(),
+			"client":    "go",
+		}
+	)
+	if !block.ReceivedAt.IsZero() {
+		params["receivedAt"] = block.ReceivedAt.UTC().String()
+	}
+	if p, ok := block.ReceivedFrom.(*peer); ok {
+		params["receivedFrom"] = map[string]interface{}{
+			"enode":           fmt.Sprintf("enode://%x@%v", p.ID(), p.RemoteAddr()),
+			"name":            p.Name(),
+			"protocolVersion": p.version,
+		}
+	}
+	jsonStr, _ := json.Marshal(map[string]interface{}{"method": "eth_badBlock", "id": "1", "jsonrpc": "2.0", "params": []interface{}{params}})
+	client := http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Post(badBlocksURL, "application/json", bytes.NewReader(jsonStr))
+	if err != nil {
+		glog.V(logger.Debug).Infoln(err)
+		return
+	}
+	glog.V(logger.Debug).Infof("Bad Block Report posted (%d)", resp.StatusCode)
+	resp.Body.Close()
+}

eth/bind.go

@@ -19,7 +19,6 @@ package eth
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rlp"
@@ -49,6 +48,17 @@ func NewContractBackend(eth *Ethereum) *ContractBackend {
 	}
 }
 
+// HasCode implements bind.ContractVerifier.HasCode by retrieving any code associated
+// with the contract from the local API, and checking its size.
+func (b *ContractBackend) HasCode(contract common.Address, pending bool) (bool, error) {
+	block := rpc.LatestBlockNumber
+	if pending {
+		block = rpc.PendingBlockNumber
+	}
+	out, err := b.bcapi.GetCode(contract, block)
+	return len(common.FromHex(out)) > 0, err
+}
+
 // ContractCall implements bind.ContractCaller executing an Ethereum contract
 // call with the specified data as the input. The pending flag requests execution
 // against the pending block, not the stable head of the chain.
@@ -64,9 +74,6 @@ func (b *ContractBackend) ContractCall(contract common.Address, data []byte, pen
 	}
 	// Execute the call and convert the output back to Go types
 	out, err := b.bcapi.Call(args, block)
-	if err == errNoCode {
-		err = bind.ErrNoCode
-	}
 	return common.FromHex(out), err
 }
 
@@ -95,9 +102,6 @@ func (b *ContractBackend) EstimateGasLimit(sender common.Address, contract *comm
 		Value: *rpc.NewHexNumber(value),
 		Data:  common.ToHex(data),
 	})
-	if err == errNoCode {
-		err = bind.ErrNoCode
-	}
 	return out.BigInt(), err
 }
 

eth/downloader/downloader_test.go

@@ -43,8 +43,9 @@ var (
 	genesis     = core.GenesisBlockForTesting(testdb, testAddress, big.NewInt(1000000000))
 )
 
-// Reduce the block cache limit, otherwise the tests will be very heavy.
+// Reduce some of the parameters to make the tester faster.
 func init() {
+	MaxForkAncestry = uint64(10000)
 	blockCacheLimit = 1024
 }
 
@@ -52,11 +53,15 @@ func init() {
 // the returned hash chain is ordered head->parent. In addition, every 3rd block
 // contains a transaction and every 5th an uncle to allow testing correct block
 // reassembly.
-func makeChain(n int, seed byte, parent *types.Block, parentReceipts types.Receipts) ([]common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]types.Receipts) {
+func makeChain(n int, seed byte, parent *types.Block, parentReceipts types.Receipts, heavy bool) ([]common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]types.Receipts) {
 	// Generate the block chain
 	blocks, receipts := core.GenerateChain(parent, testdb, n, func(i int, block *core.BlockGen) {
 		block.SetCoinbase(common.Address{seed})
 
+		// If a heavy chain is requested, delay blocks to raise difficulty
+		if heavy {
+			block.OffsetTime(-1)
+		}
 		// If the block number is multiple of 3, send a bonus transaction to the miner
 		if parent == genesis && i%3 == 0 {
 			tx, err := types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(testKey)
@@ -97,15 +102,19 @@ func makeChain(n int, seed byte, parent *types.Block, parentReceipts types.Recei
 
 // makeChainFork creates two chains of length n, such that h1[:f] and
 // h2[:f] are different but have a common suffix of length n-f.
-func makeChainFork(n, f int, parent *types.Block, parentReceipts types.Receipts) ([]common.Hash, []common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]*types.Block, map[common.Hash]types.Receipts, map[common.Hash]types.Receipts) {
+func makeChainFork(n, f int, parent *types.Block, parentReceipts types.Receipts, balanced bool) ([]common.Hash, []common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]*types.Block, map[common.Hash]types.Receipts, map[common.Hash]types.Receipts) {
 	// Create the common suffix
-	hashes, headers, blocks, receipts := makeChain(n-f, 0, parent, parentReceipts)
+	hashes, headers, blocks, receipts := makeChain(n-f, 0, parent, parentReceipts, false)
 
-	// Create the forks
+	// Create the forks, making the second heavyer if non balanced forks were requested
-	hashes1, headers1, blocks1, receipts1 := makeChain(f, 1, blocks[hashes[0]], receipts[hashes[0]])
+	hashes1, headers1, blocks1, receipts1 := makeChain(f, 1, blocks[hashes[0]], receipts[hashes[0]], false)
 	hashes1 = append(hashes1, hashes[1:]...)
 
-	hashes2, headers2, blocks2, receipts2 := makeChain(f, 2, blocks[hashes[0]], receipts[hashes[0]])
+	heavy := false
+	if !balanced {
+		heavy = true
+	}
+	hashes2, headers2, blocks2, receipts2 := makeChain(f, 2, blocks[hashes[0]], receipts[hashes[0]], heavy)
 	hashes2 = append(hashes2, hashes[1:]...)
 
 	for hash, header := range headers {
@@ -140,22 +149,25 @@ type downloadTester struct {
 	peerReceipts map[string]map[common.Hash]types.Receipts // Receipts belonging to different test peers
 	peerChainTds map[string]map[common.Hash]*big.Int       // Total difficulties of the blocks in the peer chains
 
+	peerMissingStates map[string]map[common.Hash]bool // State entries that fast sync should not return
+
 	lock sync.RWMutex
 }
 
 // newTester creates a new downloader test mocker.
 func newTester() *downloadTester {
 	tester := &downloadTester{
-		ownHashes:    []common.Hash{genesis.Hash()},
+		ownHashes:         []common.Hash{genesis.Hash()},
-		ownHeaders:   map[common.Hash]*types.Header{genesis.Hash(): genesis.Header()},
+		ownHeaders:        map[common.Hash]*types.Header{genesis.Hash(): genesis.Header()},
-		ownBlocks:    map[common.Hash]*types.Block{genesis.Hash(): genesis},
+		ownBlocks:         map[common.Hash]*types.Block{genesis.Hash(): genesis},
-		ownReceipts:  map[common.Hash]types.Receipts{genesis.Hash(): nil},
+		ownReceipts:       map[common.Hash]types.Receipts{genesis.Hash(): nil},
-		ownChainTd:   map[common.Hash]*big.Int{genesis.Hash(): genesis.Difficulty()},
+		ownChainTd:        map[common.Hash]*big.Int{genesis.Hash(): genesis.Difficulty()},
-		peerHashes:   make(map[string][]common.Hash),
+		peerHashes:        make(map[string][]common.Hash),
-		peerHeaders:  make(map[string]map[common.Hash]*types.Header),
+		peerHeaders:       make(map[string]map[common.Hash]*types.Header),
-		peerBlocks:   make(map[string]map[common.Hash]*types.Block),
+		peerBlocks:        make(map[string]map[common.Hash]*types.Block),
-		peerReceipts: make(map[string]map[common.Hash]types.Receipts),
+		peerReceipts:      make(map[string]map[common.Hash]types.Receipts),
-		peerChainTds: make(map[string]map[common.Hash]*big.Int),
+		peerChainTds:      make(map[string]map[common.Hash]*big.Int),
+		peerMissingStates: make(map[string]map[common.Hash]bool),
 	}
 	tester.stateDb, _ = ethdb.NewMemDatabase()
 	tester.stateDb.Put(genesis.Root().Bytes(), []byte{0x00})
@@ -167,6 +179,12 @@ func newTester() *downloadTester {
 	return tester
 }
 
+// terminate aborts any operations on the embedded downloader and releases all
+// held resources.
+func (dl *downloadTester) terminate() {
+	dl.downloader.Terminate()
+}
+
 // sync starts synchronizing with a remote peer, blocking until it completes.
 func (dl *downloadTester) sync(id string, td *big.Int, mode SyncMode) error {
 	dl.lock.RLock()
@@ -179,7 +197,17 @@ func (dl *downloadTester) sync(id string, td *big.Int, mode SyncMode) error {
 		}
 	}
 	dl.lock.RUnlock()
-	return dl.downloader.synchronise(id, hash, td, mode)
+
+	// Synchronise with the chosen peer and ensure proper cleanup afterwards
+	err := dl.downloader.synchronise(id, hash, td, mode)
+	select {
+	case <-dl.downloader.cancelCh:
+		// Ok, downloader fully cancelled after sync cycle
+	default:
+		// Downloader is still accepting packets, can block a peer up
+		panic("downloader active post sync cycle") // panic will be caught by tester
+	}
+	return err
 }
 
 // hasHeader checks if a header is present in the testers canonical chain.
@@ -389,6 +417,7 @@ func (dl *downloadTester) newSlowPeer(id string, version int, hashes []common.Ha
 		dl.peerBlocks[id] = make(map[common.Hash]*types.Block)
 		dl.peerReceipts[id] = make(map[common.Hash]types.Receipts)
 		dl.peerChainTds[id] = make(map[common.Hash]*big.Int)
+		dl.peerMissingStates[id] = make(map[common.Hash]bool)
 
 		genesis := hashes[len(hashes)-1]
 		if header := headers[genesis]; header != nil {
@@ -551,8 +580,8 @@ func (dl *downloadTester) peerGetAbsHeadersFn(id string, delay time.Duration) fu
 		hashes := dl.peerHashes[id]
 		headers := dl.peerHeaders[id]
 		result := make([]*types.Header, 0, amount)
-		for i := 0; i < amount && len(hashes)-int(origin)-1-i >= 0; i++ {
+		for i := 0; i < amount && len(hashes)-int(origin)-1-i*(skip+1) >= 0; i++ {
-			if header, ok := headers[hashes[len(hashes)-int(origin)-1-i]]; ok {
+			if header, ok := headers[hashes[len(hashes)-int(origin)-1-i*(skip+1)]]; ok {
 				result = append(result, header)
 			}
 		}
@@ -629,7 +658,9 @@ func (dl *downloadTester) peerGetNodeDataFn(id string, delay time.Duration) func
 		results := make([][]byte, 0, len(hashes))
 		for _, hash := range hashes {
 			if data, err := testdb.Get(hash.Bytes()); err == nil {
-				results = append(results, data)
+				if !dl.peerMissingStates[id][hash] {
+					results = append(results, data)
+				}
 			}
 		}
 		go dl.downloader.DeliverNodeData(id, results)
@@ -712,9 +743,11 @@ func testCanonicalSynchronisation(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
 
 	// Synchronise with the peer and make sure all relevant data was retrieved
@@ -736,9 +769,11 @@ func TestThrottling64Fast(t *testing.T) { testThrottling(t, 64, FastSync) }
 func testThrottling(t *testing.T, protocol int, mode SyncMode) {
 	// Create a long block chain to download and the tester
 	targetBlocks := 8 * blockCacheLimit
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
 
 	// Wrap the importer to allow stepping
@@ -810,22 +845,24 @@ func testThrottling(t *testing.T, protocol int, mode SyncMode) {
 // Tests that simple synchronization against a forked chain works correctly. In
 // this test common ancestor lookup should *not* be short circuited, and a full
 // binary search should be executed.
-func TestForkedSynchronisation61(t *testing.T)      { testForkedSynchronisation(t, 61, FullSync) }
+func TestForkedSync61(t *testing.T)      { testForkedSync(t, 61, FullSync) }
-func TestForkedSynchronisation62(t *testing.T)      { testForkedSynchronisation(t, 62, FullSync) }
+func TestForkedSync62(t *testing.T)      { testForkedSync(t, 62, FullSync) }
-func TestForkedSynchronisation63Full(t *testing.T)  { testForkedSynchronisation(t, 63, FullSync) }
+func TestForkedSync63Full(t *testing.T)  { testForkedSync(t, 63, FullSync) }
-func TestForkedSynchronisation63Fast(t *testing.T)  { testForkedSynchronisation(t, 63, FastSync) }
+func TestForkedSync63Fast(t *testing.T)  { testForkedSync(t, 63, FastSync) }
-func TestForkedSynchronisation64Full(t *testing.T)  { testForkedSynchronisation(t, 64, FullSync) }
+func TestForkedSync64Full(t *testing.T)  { testForkedSync(t, 64, FullSync) }
-func TestForkedSynchronisation64Fast(t *testing.T)  { testForkedSynchronisation(t, 64, FastSync) }
+func TestForkedSync64Fast(t *testing.T)  { testForkedSync(t, 64, FastSync) }
-func TestForkedSynchronisation64Light(t *testing.T) { testForkedSynchronisation(t, 64, LightSync) }
+func TestForkedSync64Light(t *testing.T) { testForkedSync(t, 64, LightSync) }
 
-func testForkedSynchronisation(t *testing.T, protocol int, mode SyncMode) {
+func testForkedSync(t *testing.T, protocol int, mode SyncMode) {
 	t.Parallel()
 
 	// Create a long enough forked chain
 	common, fork := MaxHashFetch, 2*MaxHashFetch
-	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil)
+	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil, true)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("fork A", protocol, hashesA, headersA, blocksA, receiptsA)
 	tester.newPeer("fork B", protocol, hashesB, headersB, blocksB, receiptsB)
 
@@ -842,6 +879,42 @@ func testForkedSynchronisation(t *testing.T, protocol int, mode SyncMode) {
 	assertOwnForkedChain(t, tester, common+1, []int{common + fork + 1, common + fork + 1})
 }
 
+// Tests that synchronising against a much shorter but much heavyer fork works
+// corrently and is not dropped.
+func TestHeavyForkedSync61(t *testing.T)      { testHeavyForkedSync(t, 61, FullSync) }
+func TestHeavyForkedSync62(t *testing.T)      { testHeavyForkedSync(t, 62, FullSync) }
+func TestHeavyForkedSync63Full(t *testing.T)  { testHeavyForkedSync(t, 63, FullSync) }
+func TestHeavyForkedSync63Fast(t *testing.T)  { testHeavyForkedSync(t, 63, FastSync) }
+func TestHeavyForkedSync64Full(t *testing.T)  { testHeavyForkedSync(t, 64, FullSync) }
+func TestHeavyForkedSync64Fast(t *testing.T)  { testHeavyForkedSync(t, 64, FastSync) }
+func TestHeavyForkedSync64Light(t *testing.T) { testHeavyForkedSync(t, 64, LightSync) }
+
+func testHeavyForkedSync(t *testing.T, protocol int, mode SyncMode) {
+	t.Parallel()
+
+	// Create a long enough forked chain
+	common, fork := MaxHashFetch, 4*MaxHashFetch
+	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil, false)
+
+	tester := newTester()
+	defer tester.terminate()
+
+	tester.newPeer("light", protocol, hashesA, headersA, blocksA, receiptsA)
+	tester.newPeer("heavy", protocol, hashesB[fork/2:], headersB, blocksB, receiptsB)
+
+	// Synchronise with the peer and make sure all blocks were retrieved
+	if err := tester.sync("light", nil, mode); err != nil {
+		t.Fatalf("failed to synchronise blocks: %v", err)
+	}
+	assertOwnChain(t, tester, common+fork+1)
+
+	// Synchronise with the second peer and make sure that fork is pulled too
+	if err := tester.sync("heavy", nil, mode); err != nil {
+		t.Fatalf("failed to synchronise blocks: %v", err)
+	}
+	assertOwnForkedChain(t, tester, common+1, []int{common + fork + 1, common + fork/2 + 1})
+}
+
 // Tests that an inactive downloader will not accept incoming hashes and blocks.
 func TestInactiveDownloader61(t *testing.T) {
 	t.Parallel()
@@ -856,11 +929,85 @@ func TestInactiveDownloader61(t *testing.T) {
 	}
 }
 
+// Tests that chain forks are contained within a certain interval of the current
+// chain head, ensuring that malicious peers cannot waste resources by feeding
+// long dead chains.
+func TestBoundedForkedSync61(t *testing.T)      { testBoundedForkedSync(t, 61, FullSync) }
+func TestBoundedForkedSync62(t *testing.T)      { testBoundedForkedSync(t, 62, FullSync) }
+func TestBoundedForkedSync63Full(t *testing.T)  { testBoundedForkedSync(t, 63, FullSync) }
+func TestBoundedForkedSync63Fast(t *testing.T)  { testBoundedForkedSync(t, 63, FastSync) }
+func TestBoundedForkedSync64Full(t *testing.T)  { testBoundedForkedSync(t, 64, FullSync) }
+func TestBoundedForkedSync64Fast(t *testing.T)  { testBoundedForkedSync(t, 64, FastSync) }
+func TestBoundedForkedSync64Light(t *testing.T) { testBoundedForkedSync(t, 64, LightSync) }
+
+func testBoundedForkedSync(t *testing.T, protocol int, mode SyncMode) {
+	t.Parallel()
+
+	// Create a long enough forked chain
+	common, fork := 13, int(MaxForkAncestry+17)
+	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil, true)
+
+	tester := newTester()
+	defer tester.terminate()
+
+	tester.newPeer("original", protocol, hashesA, headersA, blocksA, receiptsA)
+	tester.newPeer("rewriter", protocol, hashesB, headersB, blocksB, receiptsB)
+
+	// Synchronise with the peer and make sure all blocks were retrieved
+	if err := tester.sync("original", nil, mode); err != nil {
+		t.Fatalf("failed to synchronise blocks: %v", err)
+	}
+	assertOwnChain(t, tester, common+fork+1)
+
+	// Synchronise with the second peer and ensure that the fork is rejected to being too old
+	if err := tester.sync("rewriter", nil, mode); err != errInvalidAncestor {
+		t.Fatalf("sync failure mismatch: have %v, want %v", err, errInvalidAncestor)
+	}
+}
+
+// Tests that chain forks are contained within a certain interval of the current
+// chain head for short but heavy forks too. These are a bit special because they
+// take different ancestor lookup paths.
+func TestBoundedHeavyForkedSync61(t *testing.T)      { testBoundedHeavyForkedSync(t, 61, FullSync) }
+func TestBoundedHeavyForkedSync62(t *testing.T)      { testBoundedHeavyForkedSync(t, 62, FullSync) }
+func TestBoundedHeavyForkedSync63Full(t *testing.T)  { testBoundedHeavyForkedSync(t, 63, FullSync) }
+func TestBoundedHeavyForkedSync63Fast(t *testing.T)  { testBoundedHeavyForkedSync(t, 63, FastSync) }
+func TestBoundedHeavyForkedSync64Full(t *testing.T)  { testBoundedHeavyForkedSync(t, 64, FullSync) }
+func TestBoundedHeavyForkedSync64Fast(t *testing.T)  { testBoundedHeavyForkedSync(t, 64, FastSync) }
+func TestBoundedHeavyForkedSync64Light(t *testing.T) { testBoundedHeavyForkedSync(t, 64, LightSync) }
+
+func testBoundedHeavyForkedSync(t *testing.T, protocol int, mode SyncMode) {
+	t.Parallel()
+
+	// Create a long enough forked chain
+	common, fork := 13, int(MaxForkAncestry+17)
+	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil, false)
+
+	tester := newTester()
+	defer tester.terminate()
+
+	tester.newPeer("original", protocol, hashesA, headersA, blocksA, receiptsA)
+	tester.newPeer("heavy-rewriter", protocol, hashesB[MaxForkAncestry-17:], headersB, blocksB, receiptsB) // Root the fork below the ancestor limit
+
+	// Synchronise with the peer and make sure all blocks were retrieved
+	if err := tester.sync("original", nil, mode); err != nil {
+		t.Fatalf("failed to synchronise blocks: %v", err)
+	}
+	assertOwnChain(t, tester, common+fork+1)
+
+	// Synchronise with the second peer and ensure that the fork is rejected to being too old
+	if err := tester.sync("heavy-rewriter", nil, mode); err != errInvalidAncestor {
+		t.Fatalf("sync failure mismatch: have %v, want %v", err, errInvalidAncestor)
+	}
+}
+
 // Tests that an inactive downloader will not accept incoming block headers and
 // bodies.
 func TestInactiveDownloader62(t *testing.T) {
 	t.Parallel()
+
 	tester := newTester()
+	defer tester.terminate()
 
 	// Check that neither block headers nor bodies are accepted
 	if err := tester.downloader.DeliverHeaders("bad peer", []*types.Header{}); err != errNoSyncActive {
@@ -875,7 +1022,9 @@ func TestInactiveDownloader62(t *testing.T) {
 // bodies and receipts.
 func TestInactiveDownloader63(t *testing.T) {
 	t.Parallel()
+
 	tester := newTester()
+	defer tester.terminate()
 
 	// Check that neither block headers nor bodies are accepted
 	if err := tester.downloader.DeliverHeaders("bad peer", []*types.Header{}); err != errNoSyncActive {
@@ -909,9 +1058,11 @@ func testCancel(t *testing.T, protocol int, mode SyncMode) {
 	if targetBlocks >= MaxHeaderFetch {
 		targetBlocks = MaxHeaderFetch - 15
 	}
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
 
 	// Make sure canceling works with a pristine downloader
@@ -944,9 +1095,11 @@ func testMultiSynchronisation(t *testing.T, protocol int, mode SyncMode) {
 	// Create various peers with various parts of the chain
 	targetPeers := 8
 	targetBlocks := targetPeers*blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	for i := 0; i < targetPeers; i++ {
 		id := fmt.Sprintf("peer #%d", i)
 		tester.newPeer(id, protocol, hashes[i*blockCacheLimit:], headers, blocks, receipts)
@@ -972,10 +1125,12 @@ func testMultiProtoSync(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	// Create peers of every type
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("peer 61", 61, hashes, nil, blocks, nil)
 	tester.newPeer("peer 62", 62, hashes, headers, blocks, nil)
 	tester.newPeer("peer 63", 63, hashes, headers, blocks, receipts)
@@ -1010,9 +1165,11 @@ func testEmptyShortCircuit(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a block chain to download
 	targetBlocks := 2*blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
 
 	// Instrument the downloader to signal body requests
@@ -1063,9 +1220,10 @@ func testMissingHeaderAttack(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
 
 	// Attempt a full sync with an attacker feeding gapped headers
 	tester.newPeer("attack", protocol, hashes, headers, blocks, receipts)
@@ -1095,9 +1253,10 @@ func TestShiftedHeaderAttack64Light(t *testing.T) { testShiftedHeaderAttack(t, 6
 func testShiftedHeaderAttack(t *testing.T, protocol int, mode SyncMode) {
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
 
 	// Attempt a full sync with an attacker feeding shifted headers
 	tester.newPeer("attack", protocol, hashes, headers, blocks, receipts)
@@ -1126,9 +1285,10 @@ func TestInvalidHeaderRollback64Light(t *testing.T) { testInvalidHeaderRollback(
 func testInvalidHeaderRollback(t *testing.T, protocol int, mode SyncMode) {
 	// Create a small enough block chain to download
 	targetBlocks := 3*fsHeaderSafetyNet + fsMinFullBlocks
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	tester := newTester()
+	defer tester.terminate()
 
 	// Attempt to sync with an attacker that feeds junk during the fast sync phase.
 	// This should result in the last fsHeaderSafetyNet headers being rolled back.
@@ -1147,6 +1307,7 @@ func testInvalidHeaderRollback(t *testing.T, protocol int, mode SyncMode) {
 	// rolled back, and also the pivot point being reverted to a non-block status.
 	tester.newPeer("block-attack", protocol, hashes, headers, blocks, receipts)
 	missing = 3*fsHeaderSafetyNet + MaxHeaderFetch + 1
+	delete(tester.peerHeaders["fast-attack"], hashes[len(hashes)-missing]) // Make sure the fast-attacker doesn't fill in
 	delete(tester.peerHeaders["block-attack"], hashes[len(hashes)-missing])
 
 	if err := tester.sync("block-attack", nil, mode); err == nil {
@@ -1166,7 +1327,7 @@ func testInvalidHeaderRollback(t *testing.T, protocol int, mode SyncMode) {
 	tester.newPeer("withhold-attack", protocol, hashes, headers, blocks, receipts)
 	missing = 3*fsHeaderSafetyNet + MaxHeaderFetch + 1
 
-	tester.downloader.noFast = false
+	tester.downloader.fsPivotFails = 0
 	tester.downloader.syncInitHook = func(uint64, uint64) {
 		for i := missing; i <= len(hashes); i++ {
 			delete(tester.peerHeaders["withhold-attack"], hashes[len(hashes)-i])
@@ -1185,6 +1346,8 @@ func testInvalidHeaderRollback(t *testing.T, protocol int, mode SyncMode) {
 			t.Errorf("fast sync pivot block #%d not rolled back", head)
 		}
 	}
+	tester.downloader.fsPivotFails = fsCriticalTrials
+
 	// Synchronise with the valid peer and make sure sync succeeds. Since the last
 	// rollback should also disable fast syncing for this process, verify that we
 	// did a fresh full sync. Note, we can't assert anything about the receipts
@@ -1217,9 +1380,11 @@ func testHighTDStarvationAttack(t *testing.T, protocol int, mode SyncMode) {
 	t.Parallel()
 
 	tester := newTester()
-	hashes, headers, blocks, receipts := makeChain(0, 0, genesis, nil)
+	defer tester.terminate()
 
+	hashes, headers, blocks, receipts := makeChain(0, 0, genesis, nil, false)
 	tester.newPeer("attack", protocol, []common.Hash{hashes[0]}, headers, blocks, receipts)
+
 	if err := tester.sync("attack", big.NewInt(1000000), mode); err != errStallingPeer {
 		t.Fatalf("synchronisation error mismatch: have %v, want %v", err, errStallingPeer)
 	}
@@ -1237,29 +1402,33 @@ func testBlockHeaderAttackerDropping(t *testing.T, protocol int) {
 		result error
 		drop   bool
 	}{
-		{nil, false},                   // Sync succeeded, all is well
+		{nil, false},                        // Sync succeeded, all is well
-		{errBusy, false},               // Sync is already in progress, no problem
+		{errBusy, false},                    // Sync is already in progress, no problem
-		{errUnknownPeer, false},        // Peer is unknown, was already dropped, don't double drop
+		{errUnknownPeer, false},             // Peer is unknown, was already dropped, don't double drop
-		{errBadPeer, true},             // Peer was deemed bad for some reason, drop it
+		{errBadPeer, true},                  // Peer was deemed bad for some reason, drop it
-		{errStallingPeer, true},        // Peer was detected to be stalling, drop it
+		{errStallingPeer, true},             // Peer was detected to be stalling, drop it
-		{errNoPeers, false},            // No peers to download from, soft race, no issue
+		{errNoPeers, false},                 // No peers to download from, soft race, no issue
-		{errTimeout, true},             // No hashes received in due time, drop the peer
+		{errTimeout, true},                  // No hashes received in due time, drop the peer
-		{errEmptyHashSet, true},        // No hashes were returned as a response, drop as it's a dead end
+		{errEmptyHashSet, true},             // No hashes were returned as a response, drop as it's a dead end
-		{errEmptyHeaderSet, true},      // No headers were returned as a response, drop as it's a dead end
+		{errEmptyHeaderSet, true},           // No headers were returned as a response, drop as it's a dead end
-		{errPeersUnavailable, true},    // Nobody had the advertised blocks, drop the advertiser
+		{errPeersUnavailable, true},         // Nobody had the advertised blocks, drop the advertiser
-		{errInvalidChain, true},        // Hash chain was detected as invalid, definitely drop
+		{errInvalidAncestor, true},          // Agreed upon ancestor is not acceptable, drop the chain rewriter
-		{errInvalidBlock, false},       // A bad peer was detected, but not the sync origin
+		{errInvalidChain, true},             // Hash chain was detected as invalid, definitely drop
-		{errInvalidBody, false},        // A bad peer was detected, but not the sync origin
+		{errInvalidBlock, false},            // A bad peer was detected, but not the sync origin
-		{errInvalidReceipt, false},     // A bad peer was detected, but not the sync origin
+		{errInvalidBody, false},             // A bad peer was detected, but not the sync origin
-		{errCancelHashFetch, false},    // Synchronisation was canceled, origin may be innocent, don't drop
+		{errInvalidReceipt, false},          // A bad peer was detected, but not the sync origin
-		{errCancelBlockFetch, false},   // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelHashFetch, false},         // Synchronisation was canceled, origin may be innocent, don't drop
-		{errCancelHeaderFetch, false},  // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelBlockFetch, false},        // Synchronisation was canceled, origin may be innocent, don't drop
-		{errCancelBodyFetch, false},    // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelHeaderFetch, false},       // Synchronisation was canceled, origin may be innocent, don't drop
-		{errCancelReceiptFetch, false}, // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelBodyFetch, false},         // Synchronisation was canceled, origin may be innocent, don't drop
-		{errCancelProcessing, false},   // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelReceiptFetch, false},      // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelHeaderProcessing, false},  // Synchronisation was canceled, origin may be innocent, don't drop
+		{errCancelContentProcessing, false}, // Synchronisation was canceled, origin may be innocent, don't drop
 	}
 	// Run the tests and check disconnection status
 	tester := newTester()
+	defer tester.terminate()
+
 	for i, tt := range tests {
 		// Register a new peer and ensure it's presence
 		id := fmt.Sprintf("test %d", i)
@@ -1294,13 +1463,15 @@ func testSyncProgress(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	// Set a sync init hook to catch progress changes
 	starting := make(chan struct{})
 	progress := make(chan struct{})
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.downloader.syncInitHook = func(origin, latest uint64) {
 		starting <- struct{}{}
 		<-progress
@@ -1366,13 +1537,15 @@ func testForkedSyncProgress(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a forked chain to simulate origin revertal
 	common, fork := MaxHashFetch, 2*MaxHashFetch
-	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil)
+	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil, true)
 
 	// Set a sync init hook to catch progress changes
 	starting := make(chan struct{})
 	progress := make(chan struct{})
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.downloader.syncInitHook = func(origin, latest uint64) {
 		starting <- struct{}{}
 		<-progress
@@ -1441,13 +1614,15 @@ func testFailedSyncProgress(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small enough block chain to download
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
 
 	// Set a sync init hook to catch progress changes
 	starting := make(chan struct{})
 	progress := make(chan struct{})
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.downloader.syncInitHook = func(origin, latest uint64) {
 		starting <- struct{}{}
 		<-progress
@@ -1517,13 +1692,15 @@ func testFakedSyncProgress(t *testing.T, protocol int, mode SyncMode) {
 
 	// Create a small block chain
 	targetBlocks := blockCacheLimit - 15
-	hashes, headers, blocks, receipts := makeChain(targetBlocks+3, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(targetBlocks+3, 0, genesis, nil, false)
 
 	// Set a sync init hook to catch progress changes
 	starting := make(chan struct{})
 	progress := make(chan struct{})
 
 	tester := newTester()
+	defer tester.terminate()
+
 	tester.downloader.syncInitHook = func(origin, latest uint64) {
 		starting <- struct{}{}
 		<-progress
@@ -1590,7 +1767,7 @@ func TestDeliverHeadersHang64Light(t *testing.T) { testDeliverHeadersHang(t, 64,
 
 func testDeliverHeadersHang(t *testing.T, protocol int, mode SyncMode) {
 	t.Parallel()
-	hashes, headers, blocks, receipts := makeChain(5, 0, genesis, nil)
+	hashes, headers, blocks, receipts := makeChain(5, 0, genesis, nil, false)
 	fakeHeads := []*types.Header{{}, {}, {}, {}}
 	for i := 0; i < 200; i++ {
 		tester := newTester()
@@ -1610,7 +1787,7 @@ func testDeliverHeadersHang(t *testing.T, protocol int, mode SyncMode) {
 			impl := tester.peerGetAbsHeadersFn("peer", 0)
 			go impl(from, count, skip, reverse)
 			// None of the extra deliveries should block.
-			timeout := time.After(5 * time.Second)
+			timeout := time.After(15 * time.Second)
 			for i := 0; i < cap(deliveriesDone); i++ {
 				select {
 				case <-deliveriesDone:
@@ -1623,5 +1800,50 @@ func testDeliverHeadersHang(t *testing.T, protocol int, mode SyncMode) {
 		if err := tester.sync("peer", nil, mode); err != nil {
 			t.Errorf("sync failed: %v", err)
 		}
+		tester.terminate()
 	}
 }
+
+// Tests that if fast sync aborts in the critical section, it can restart a few
+// times before giving up.
+func TestFastCriticalRestarts63(t *testing.T) { testFastCriticalRestarts(t, 63) }
+func TestFastCriticalRestarts64(t *testing.T) { testFastCriticalRestarts(t, 64) }
+
+func testFastCriticalRestarts(t *testing.T, protocol int) {
+	t.Parallel()
+
+	// Create a large enough blockchin to actually fast sync on
+	targetBlocks := fsMinFullBlocks + 2*fsPivotInterval - 15
+	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil, false)
+
+	// Create a tester peer with the critical section state roots missing (force failures)
+	tester := newTester()
+	defer tester.terminate()
+
+	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
+	for i := 0; i < fsPivotInterval; i++ {
+		tester.peerMissingStates["peer"][headers[hashes[fsMinFullBlocks+i]].Root] = true
+	}
+	tester.downloader.dropPeer = func(id string) {} // We reuse the same "faulty" peer throughout the test
+
+	// Synchronise with the peer a few times and make sure they fail until the retry limit
+	for i := 0; i < fsCriticalTrials; i++ {
+		// Attempt a sync and ensure it fails properly
+		if err := tester.sync("peer", nil, FastSync); err == nil {
+			t.Fatalf("failing fast sync succeeded: %v", err)
+		}
+		time.Sleep(100 * time.Millisecond) // Make sure no in-flight requests remain
+
+		// If it's the first failure, pivot should be locked => reenable all others to detect pivot changes
+		if i == 0 {
+			tester.lock.Lock()
+			tester.peerMissingStates["peer"] = map[common.Hash]bool{tester.downloader.fsPivotLock.Root: true}
+			tester.lock.Unlock()
+		}
+	}
+	// Retry limit exhausted, downloader will switch to full sync, should succeed
+	if err := tester.sync("peer", nil, FastSync); err != nil {
+		t.Fatalf("failed to synchronise blocks in slow sync: %v", err)
+	}
+	assertOwnChain(t, tester, targetBlocks+1)
+}

eth/downloader/peer.go

@@ -23,6 +23,8 @@ import (
 	"errors"
 	"fmt"
 	"math"
+	"sort"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -31,8 +33,8 @@ import (
 )
 
 const (
-	maxLackingHashes = 4096 // Maximum number of entries allowed on the list or lacking items
+	maxLackingHashes  = 4096 // Maximum number of entries allowed on the list or lacking items
-	throughputImpact = 0.1  // The impact a single measurement has on a peer's final throughput value.
+	measurementImpact = 0.1  // The impact a single measurement has on a peer's final throughput value.
 )
 
 // Hash and block fetchers belonging to eth/61 and below
@@ -58,15 +60,20 @@ type peer struct {
 	id   string      // Unique identifier of the peer
 	head common.Hash // Hash of the peers latest known block
 
+	headerIdle  int32 // Current header activity state of the peer (idle = 0, active = 1)
 	blockIdle   int32 // Current block activity state of the peer (idle = 0, active = 1)
 	receiptIdle int32 // Current receipt activity state of the peer (idle = 0, active = 1)
 	stateIdle   int32 // Current node data activity state of the peer (idle = 0, active = 1)
 
+	headerThroughput  float64 // Number of headers measured to be retrievable per second
 	blockThroughput   float64 // Number of blocks (bodies) measured to be retrievable per second
 	receiptThroughput float64 // Number of receipts measured to be retrievable per second
 	stateThroughput   float64 // Number of node data pieces measured to be retrievable per second
 
-	blockStarted   time.Time // Time instance when the last block (body)fetch was started
+	rtt time.Duration // Request round trip time to track responsiveness (QoS)
+
+	headerStarted  time.Time // Time instance when the last header fetch was started
+	blockStarted   time.Time // Time instance when the last block (body) fetch was started
 	receiptStarted time.Time // Time instance when the last receipt fetch was started
 	stateStarted   time.Time // Time instance when the last node data fetch was started
 
@@ -118,10 +125,12 @@ func (p *peer) Reset() {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 
+	atomic.StoreInt32(&p.headerIdle, 0)
 	atomic.StoreInt32(&p.blockIdle, 0)
 	atomic.StoreInt32(&p.receiptIdle, 0)
 	atomic.StoreInt32(&p.stateIdle, 0)
 
+	p.headerThroughput = 0
 	p.blockThroughput = 0
 	p.receiptThroughput = 0
 	p.stateThroughput = 0
@@ -151,6 +160,24 @@ func (p *peer) Fetch61(request *fetchRequest) error {
 	return nil
 }
 
+// FetchHeaders sends a header retrieval request to the remote peer.
+func (p *peer) FetchHeaders(from uint64, count int) error {
+	// Sanity check the protocol version
+	if p.version < 62 {
+		panic(fmt.Sprintf("header fetch [eth/62+] requested on eth/%d", p.version))
+	}
+	// Short circuit if the peer is already fetching
+	if !atomic.CompareAndSwapInt32(&p.headerIdle, 0, 1) {
+		return errAlreadyFetching
+	}
+	p.headerStarted = time.Now()
+
+	// Issue the header retrieval request (absolut upwards without gaps)
+	go p.getAbsHeaders(from, count, 0, false)
+
+	return nil
+}
+
 // FetchBodies sends a block body retrieval request to the remote peer.
 func (p *peer) FetchBodies(request *fetchRequest) error {
 	// Sanity check the protocol version
@@ -217,6 +244,13 @@ func (p *peer) FetchNodeData(request *fetchRequest) error {
 	return nil
 }
 
+// SetHeadersIdle sets the peer to idle, allowing it to execute new header retrieval
+// requests. Its estimated header retrieval throughput is updated with that measured
+// just now.
+func (p *peer) SetHeadersIdle(delivered int) {
+	p.setIdle(p.headerStarted, delivered, &p.headerThroughput, &p.headerIdle)
+}
+
 // SetBlocksIdle sets the peer to idle, allowing it to execute new block retrieval
 // requests. Its estimated block retrieval throughput is updated with that measured
 // just now.
@@ -260,35 +294,47 @@ func (p *peer) setIdle(started time.Time, delivered int, throughput *float64, id
 		return
 	}
 	// Otherwise update the throughput with a new measurement
-	measured := float64(delivered) / (float64(time.Since(started)+1) / float64(time.Second)) // +1 (ns) to ensure non-zero divisor
+	elapsed := time.Since(started) + 1 // +1 (ns) to ensure non-zero divisor
-	*throughput = (1-throughputImpact)*(*throughput) + throughputImpact*measured
+	measured := float64(delivered) / (float64(elapsed) / float64(time.Second))
+
+	*throughput = (1-measurementImpact)*(*throughput) + measurementImpact*measured
+	p.rtt = time.Duration((1-measurementImpact)*float64(p.rtt) + measurementImpact*float64(elapsed))
+}
+
+// HeaderCapacity retrieves the peers header download allowance based on its
+// previously discovered throughput.
+func (p *peer) HeaderCapacity(targetRTT time.Duration) int {
+	p.lock.RLock()
+	defer p.lock.RUnlock()
+
+	return int(math.Min(1+math.Max(1, p.headerThroughput*float64(targetRTT)/float64(time.Second)), float64(MaxHeaderFetch)))
 }
 
 // BlockCapacity retrieves the peers block download allowance based on its
 // previously discovered throughput.
-func (p *peer) BlockCapacity() int {
+func (p *peer) BlockCapacity(targetRTT time.Duration) int {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
-	return int(math.Max(1, math.Min(p.blockThroughput*float64(blockTargetRTT)/float64(time.Second), float64(MaxBlockFetch))))
+	return int(math.Min(1+math.Max(1, p.blockThroughput*float64(targetRTT)/float64(time.Second)), float64(MaxBlockFetch)))
 }
 
 // ReceiptCapacity retrieves the peers receipt download allowance based on its
 // previously discovered throughput.
-func (p *peer) ReceiptCapacity() int {
+func (p *peer) ReceiptCapacity(targetRTT time.Duration) int {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
-	return int(math.Max(1, math.Min(p.receiptThroughput*float64(receiptTargetRTT)/float64(time.Second), float64(MaxReceiptFetch))))
+	return int(math.Min(1+math.Max(1, p.receiptThroughput*float64(targetRTT)/float64(time.Second)), float64(MaxReceiptFetch)))
 }
 
 // NodeDataCapacity retrieves the peers state download allowance based on its
 // previously discovered throughput.
-func (p *peer) NodeDataCapacity() int {
+func (p *peer) NodeDataCapacity(targetRTT time.Duration) int {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
-	return int(math.Max(1, math.Min(p.stateThroughput*float64(stateTargetRTT)/float64(time.Second), float64(MaxStateFetch))))
+	return int(math.Min(1+math.Max(1, p.stateThroughput*float64(targetRTT)/float64(time.Second)), float64(MaxStateFetch)))
 }
 
 // MarkLacking appends a new entity to the set of items (blocks, receipts, states)
@@ -322,15 +368,17 @@ func (p *peer) String() string {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
-	return fmt.Sprintf("Peer %s [%s]", p.id,
+	return fmt.Sprintf("Peer %s [%s]", p.id, strings.Join([]string{
-		fmt.Sprintf("blocks %3.2f/s, ", p.blockThroughput)+
+		fmt.Sprintf("hs %3.2f/s", p.headerThroughput),
-			fmt.Sprintf("receipts %3.2f/s, ", p.receiptThroughput)+
+		fmt.Sprintf("bs %3.2f/s", p.blockThroughput),
-			fmt.Sprintf("states %3.2f/s, ", p.stateThroughput)+
+		fmt.Sprintf("rs %3.2f/s", p.receiptThroughput),
-			fmt.Sprintf("lacking %4d", len(p.lacking)),
+		fmt.Sprintf("ss %3.2f/s", p.stateThroughput),
-	)
+		fmt.Sprintf("miss %4d", len(p.lacking)),
+		fmt.Sprintf("rtt %v", p.rtt),
+	}, ", "))
 }
 
-// peerSet represents the collection of active peer participating in the block
+// peerSet represents the collection of active peer participating in the chain
 // download procedure.
 type peerSet struct {
 	peers map[string]*peer
@@ -359,9 +407,13 @@ func (ps *peerSet) Reset() {
 // peer is already known.
 //
 // The method also sets the starting throughput values of the new peer to the
-// average of all existing peers, to give it a realistic change of being used
+// average of all existing peers, to give it a realistic chance of being used
 // for data retrievals.
 func (ps *peerSet) Register(p *peer) error {
+	// Retrieve the current median RTT as a sane default
+	p.rtt = ps.medianRTT()
+
+	// Register the new peer with some meaningful defaults
 	ps.lock.Lock()
 	defer ps.lock.Unlock()
 
@@ -369,15 +421,17 @@ func (ps *peerSet) Register(p *peer) error {
 		return errAlreadyRegistered
 	}
 	if len(ps.peers) > 0 {
-		p.blockThroughput, p.receiptThroughput, p.stateThroughput = 0, 0, 0
+		p.headerThroughput, p.blockThroughput, p.receiptThroughput, p.stateThroughput = 0, 0, 0, 0
 
 		for _, peer := range ps.peers {
 			peer.lock.RLock()
+			p.headerThroughput += peer.headerThroughput
 			p.blockThroughput += peer.blockThroughput
 			p.receiptThroughput += peer.receiptThroughput
 			p.stateThroughput += peer.stateThroughput
 			peer.lock.RUnlock()
 		}
+		p.headerThroughput /= float64(len(ps.peers))
 		p.blockThroughput /= float64(len(ps.peers))
 		p.receiptThroughput /= float64(len(ps.peers))
 		p.stateThroughput /= float64(len(ps.peers))
@@ -441,6 +495,20 @@ func (ps *peerSet) BlockIdlePeers() ([]*peer, int) {
 	return ps.idlePeers(61, 61, idle, throughput)
 }
 
+// HeaderIdlePeers retrieves a flat list of all the currently header-idle peers
+// within the active peer set, ordered by their reputation.
+func (ps *peerSet) HeaderIdlePeers() ([]*peer, int) {
+	idle := func(p *peer) bool {
+		return atomic.LoadInt32(&p.headerIdle) == 0
+	}
+	throughput := func(p *peer) float64 {
+		p.lock.RLock()
+		defer p.lock.RUnlock()
+		return p.headerThroughput
+	}
+	return ps.idlePeers(62, 64, idle, throughput)
+}
+
 // BodyIdlePeers retrieves a flat list of all the currently body-idle peers within
 // the active peer set, ordered by their reputation.
 func (ps *peerSet) BodyIdlePeers() ([]*peer, int) {
@@ -508,3 +576,34 @@ func (ps *peerSet) idlePeers(minProtocol, maxProtocol int, idleCheck func(*peer)
 	}
 	return idle, total
 }
+
+// medianRTT returns the median RTT of te peerset, considering only the tuning
+// peers if there are more peers available.
+func (ps *peerSet) medianRTT() time.Duration {
+	// Gather all the currnetly measured round trip times
+	ps.lock.RLock()
+	defer ps.lock.RUnlock()
+
+	rtts := make([]float64, 0, len(ps.peers))
+	for _, p := range ps.peers {
+		p.lock.RLock()
+		rtts = append(rtts, float64(p.rtt))
+		p.lock.RUnlock()
+	}
+	sort.Float64s(rtts)
+
+	median := rttMaxEstimate
+	if qosTuningPeers <= len(rtts) {
+		median = time.Duration(rtts[qosTuningPeers/2]) // Median of our tuning peers
+	} else if len(rtts) > 0 {
+		median = time.Duration(rtts[len(rtts)/2]) // Median of our connected peers (maintain even like this some baseline qos)
+	}
+	// Restrict the RTT into some QoS defaults, irrelevant of true RTT
+	if median < rttMinEstimate {
+		median = rttMinEstimate
+	}
+	if median > rttMaxEstimate {
+		median = rttMaxEstimate
+	}
+	return median
+}

eth/downloader/queue.go

@@ -40,7 +40,7 @@ import (
 
 var (
 	blockCacheLimit   = 8192 // Maximum number of blocks to cache before throttling the download
-	maxInFlightStates = 4096 // Maximum number of state downloads to allow concurrently
+	maxInFlightStates = 8192 // Maximum number of state downloads to allow concurrently
 )
 
 var (
@@ -52,6 +52,7 @@ var (
 // fetchRequest is a currently running data retrieval operation.
 type fetchRequest struct {
 	Peer    *peer               // Peer to which the request was sent
+	From    uint64              // [eth/62] Requested chain element index (used for skeleton fills only)
 	Hashes  map[common.Hash]int // [eth/61] Requested hashes with their insertion index (priority)
 	Headers []*types.Header     // [eth/62] Requested headers, sorted by request order
 	Time    time.Time           // Time when the request was made
@@ -79,6 +80,18 @@ type queue struct {
 
 	headerHead common.Hash // [eth/62] Hash of the last queued header to verify order
 
+	// Headers are "special", they download in batches, supported by a skeleton chain
+	headerTaskPool  map[uint64]*types.Header       // [eth/62] Pending header retrieval tasks, mapping starting indexes to skeleton headers
+	headerTaskQueue *prque.Prque                   // [eth/62] Priority queue of the skeleton indexes to fetch the filling headers for
+	headerPeerMiss  map[string]map[uint64]struct{} // [eth/62] Set of per-peer header batches known to be unavailable
+	headerPendPool  map[string]*fetchRequest       // [eth/62] Currently pending header retrieval operations
+	headerDonePool  map[uint64]struct{}            // [eth/62] Set of the completed header fetches
+	headerResults   []*types.Header                // [eth/62] Result cache accumulating the completed headers
+	headerProced    int                            // [eth/62] Number of headers already processed from the results
+	headerOffset    uint64                         // [eth/62] Number of the first header in the result cache
+	headerContCh    chan bool                      // [eth/62] Channel to notify when header download finishes
+
+	// All data retrievals below are based on an already assembles header chain
 	blockTaskPool  map[common.Hash]*types.Header // [eth/62] Pending block (body) retrieval tasks, mapping hashes to headers
 	blockTaskQueue *prque.Prque                  // [eth/62] Priority queue of the headers to fetch the blocks (bodies) for
 	blockPendPool  map[string]*fetchRequest      // [eth/62] Currently pending block (body) retrieval operations
@@ -113,6 +126,8 @@ func newQueue(stateDb ethdb.Database) *queue {
 	return &queue{
 		hashPool:         make(map[common.Hash]int),
 		hashQueue:        prque.New(),
+		headerPendPool:   make(map[string]*fetchRequest),
+		headerContCh:     make(chan bool),
 		blockTaskPool:    make(map[common.Hash]*types.Header),
 		blockTaskQueue:   prque.New(),
 		blockPendPool:    make(map[string]*fetchRequest),
@@ -149,6 +164,8 @@ func (q *queue) Reset() {
 
 	q.headerHead = common.Hash{}
 
+	q.headerPendPool = make(map[string]*fetchRequest)
+
 	q.blockTaskPool = make(map[common.Hash]*types.Header)
 	q.blockTaskQueue.Reset()
 	q.blockPendPool = make(map[string]*fetchRequest)
@@ -178,6 +195,14 @@ func (q *queue) Close() {
 	q.active.Broadcast()
 }
 
+// PendingHeaders retrieves the number of header requests pending for retrieval.
+func (q *queue) PendingHeaders() int {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	return q.headerTaskQueue.Size()
+}
+
 // PendingBlocks retrieves the number of block (body) requests pending for retrieval.
 func (q *queue) PendingBlocks() int {
 	q.lock.Lock()
@@ -205,6 +230,15 @@ func (q *queue) PendingNodeData() int {
 	return 0
 }
 
+// InFlightHeaders retrieves whether there are header fetch requests currently
+// in flight.
+func (q *queue) InFlightHeaders() bool {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	return len(q.headerPendPool) > 0
+}
+
 // InFlightBlocks retrieves whether there are block fetch requests currently in
 // flight.
 func (q *queue) InFlightBlocks() bool {
@@ -317,6 +351,45 @@ func (q *queue) Schedule61(hashes []common.Hash, fifo bool) []common.Hash {
 	return inserts
 }
 
+// ScheduleSkeleton adds a batch of header retrieval tasks to the queue to fill
+// up an already retrieved header skeleton.
+func (q *queue) ScheduleSkeleton(from uint64, skeleton []*types.Header) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	// No skeleton retrieval can be in progress, fail hard if so (huge implementation bug)
+	if q.headerResults != nil {
+		panic("skeleton assembly already in progress")
+	}
+	// Shedule all the header retrieval tasks for the skeleton assembly
+	q.headerTaskPool = make(map[uint64]*types.Header)
+	q.headerTaskQueue = prque.New()
+	q.headerPeerMiss = make(map[string]map[uint64]struct{}) // Reset availability to correct invalid chains
+	q.headerResults = make([]*types.Header, len(skeleton)*MaxHeaderFetch)
+	q.headerProced = 0
+	q.headerOffset = from
+	q.headerContCh = make(chan bool, 1)
+
+	for i, header := range skeleton {
+		index := from + uint64(i*MaxHeaderFetch)
+
+		q.headerTaskPool[index] = header
+		q.headerTaskQueue.Push(index, -float32(index))
+	}
+}
+
+// RetrieveHeaders retrieves the header chain assemble based on the scheduled
+// skeleton.
+func (q *queue) RetrieveHeaders() ([]*types.Header, int) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	headers, proced := q.headerResults, q.headerProced
+	q.headerResults, q.headerProced = nil, 0
+
+	return headers, proced
+}
+
 // Schedule adds a set of headers for the download queue for scheduling, returning
 // the new headers encountered.
 func (q *queue) Schedule(headers []*types.Header, from uint64) []*types.Header {
@@ -437,6 +510,46 @@ func (q *queue) countProcessableItems() int {
 	return len(q.resultCache)
 }
 
+// ReserveHeaders reserves a set of headers for the given peer, skipping any
+// previously failed batches.
+func (q *queue) ReserveHeaders(p *peer, count int) *fetchRequest {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	// Short circuit if the peer's already downloading something (sanity check to
+	// not corrupt state)
+	if _, ok := q.headerPendPool[p.id]; ok {
+		return nil
+	}
+	// Retrieve a batch of hashes, skipping previously failed ones
+	send, skip := uint64(0), []uint64{}
+	for send == 0 && !q.headerTaskQueue.Empty() {
+		from, _ := q.headerTaskQueue.Pop()
+		if q.headerPeerMiss[p.id] != nil {
+			if _, ok := q.headerPeerMiss[p.id][from.(uint64)]; ok {
+				skip = append(skip, from.(uint64))
+				continue
+			}
+		}
+		send = from.(uint64)
+	}
+	// Merge all the skipped batches back
+	for _, from := range skip {
+		q.headerTaskQueue.Push(from, -float32(from))
+	}
+	// Assemble and return the block download request
+	if send == 0 {
+		return nil
+	}
+	request := &fetchRequest{
+		Peer: p,
+		From: send,
+		Time: time.Now(),
+	}
+	q.headerPendPool[p.id] = request
+	return request
+}
+
 // ReserveBlocks reserves a set of block hashes for the given peer, skipping any
 // previously failed download.
 func (q *queue) ReserveBlocks(p *peer, count int) *fetchRequest {
@@ -635,6 +748,11 @@ func (q *queue) reserveHeaders(p *peer, count int, taskPool map[common.Hash]*typ
 	return request, progress, nil
 }
 
+// CancelHeaders aborts a fetch request, returning all pending skeleton indexes to the queue.
+func (q *queue) CancelHeaders(request *fetchRequest) {
+	q.cancel(request, q.headerTaskQueue, q.headerPendPool)
+}
+
 // CancelBlocks aborts a fetch request, returning all pending hashes to the queue.
 func (q *queue) CancelBlocks(request *fetchRequest) {
 	q.cancel(request, q.hashQueue, q.blockPendPool)
@@ -663,6 +781,9 @@ func (q *queue) cancel(request *fetchRequest, taskQueue *prque.Prque, pendPool m
 	q.lock.Lock()
 	defer q.lock.Unlock()
 
+	if request.From > 0 {
+		taskQueue.Push(request.From, -float32(request.From))
+	}
 	for hash, index := range request.Hashes {
 		taskQueue.Push(hash, float32(index))
 	}
@@ -702,6 +823,15 @@ func (q *queue) Revoke(peerId string) {
 	}
 }
 
+// ExpireHeaders checks for in flight requests that exceeded a timeout allowance,
+// canceling them and returning the responsible peers for penalisation.
+func (q *queue) ExpireHeaders(timeout time.Duration) map[string]int {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	return q.expire(timeout, q.headerPendPool, q.headerTaskQueue, headerTimeoutMeter)
+}
+
 // ExpireBlocks checks for in flight requests that exceeded a timeout allowance,
 // canceling them and returning the responsible peers for penalisation.
 func (q *queue) ExpireBlocks(timeout time.Duration) map[string]int {
@@ -753,6 +883,9 @@ func (q *queue) expire(timeout time.Duration, pendPool map[string]*fetchRequest,
 			timeoutMeter.Mark(1)
 
 			// Return any non satisfied requests to the pool
+			if request.From > 0 {
+				taskQueue.Push(request.From, -float32(request.From))
+			}
 			for hash, index := range request.Hashes {
 				taskQueue.Push(hash, float32(index))
 			}
@@ -842,6 +975,94 @@ func (q *queue) DeliverBlocks(id string, blocks []*types.Block) (int, error) {
 	}
 }
 
+// DeliverHeaders injects a header retrieval response into the header results
+// cache. This method either accepts all headers it received, or none of them
+// if they do not map correctly to the skeleton.
+//
+// If the headers are accepted, the method makes an attempt to deliver the set
+// of ready headers to the processor to keep the pipeline full. However it will
+// not block to prevent stalling other pending deliveries.
+func (q *queue) DeliverHeaders(id string, headers []*types.Header, headerProcCh chan []*types.Header) (int, error) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+
+	// Short circuit if the data was never requested
+	request := q.headerPendPool[id]
+	if request == nil {
+		return 0, errNoFetchesPending
+	}
+	headerReqTimer.UpdateSince(request.Time)
+	delete(q.headerPendPool, id)
+
+	// Ensure headers can be mapped onto the skeleton chain
+	target := q.headerTaskPool[request.From].Hash()
+
+	accepted := len(headers) == MaxHeaderFetch
+	if accepted {
+		if headers[0].Number.Uint64() != request.From {
+			glog.V(logger.Detail).Infof("Peer %s: first header #%v [%x] broke chain ordering, expected %d", id, headers[0].Number, headers[0].Hash().Bytes()[:4], request.From)
+			accepted = false
+		} else if headers[len(headers)-1].Hash() != target {
+			glog.V(logger.Detail).Infof("Peer %s: last header #%v [%x] broke skeleton structure, expected %x", id, headers[len(headers)-1].Number, headers[len(headers)-1].Hash().Bytes()[:4], target[:4])
+			accepted = false
+		}
+	}
+	if accepted {
+		for i, header := range headers[1:] {
+			hash := header.Hash()
+			if want := request.From + 1 + uint64(i); header.Number.Uint64() != want {
+				glog.V(logger.Warn).Infof("Peer %s: header #%v [%x] broke chain ordering, expected %d", id, header.Number, hash[:4], want)
+				accepted = false
+				break
+			}
+			if headers[i].Hash() != header.ParentHash {
+				glog.V(logger.Warn).Infof("Peer %s: header #%v [%x] broke chain ancestry", id, header.Number, hash[:4])
+				accepted = false
+				break
+			}
+		}
+	}
+	// If the batch of headers wasn't accepted, mark as unavailable
+	if !accepted {
+		glog.V(logger.Detail).Infof("Peer %s: skeleton filling from header #%d not accepted", id, request.From)
+
+		miss := q.headerPeerMiss[id]
+		if miss == nil {
+			q.headerPeerMiss[id] = make(map[uint64]struct{})
+			miss = q.headerPeerMiss[id]
+		}
+		miss[request.From] = struct{}{}
+
+		q.headerTaskQueue.Push(request.From, -float32(request.From))
+		return 0, errors.New("delivery not accepted")
+	}
+	// Clean up a successful fetch and try to deliver any sub-results
+	copy(q.headerResults[request.From-q.headerOffset:], headers)
+	delete(q.headerTaskPool, request.From)
+
+	ready := 0
+	for q.headerProced+ready < len(q.headerResults) && q.headerResults[q.headerProced+ready] != nil {
+		ready += MaxHeaderFetch
+	}
+	if ready > 0 {
+		// Headers are ready for delivery, gather them and push forward (non blocking)
+		process := make([]*types.Header, ready)
+		copy(process, q.headerResults[q.headerProced:q.headerProced+ready])
+
+		select {
+		case headerProcCh <- process:
+			glog.V(logger.Detail).Infof("%s: pre-scheduled %d headers from #%v", id, len(process), process[0].Number)
+			q.headerProced += len(process)
+		default:
+		}
+	}
+	// Check for termination and return
+	if len(q.headerTaskPool) == 0 {
+		q.headerContCh <- false
+	}
+	return len(headers), nil
+}
+
 // DeliverBodies injects a block body retrieval response into the results queue.
 // The method returns the number of blocks bodies accepted from the delivery and
 // also wakes any threads waiting for data delivery.
@@ -1041,13 +1262,19 @@ func (q *queue) deliverNodeData(results []trie.SyncResult, callback func(error,
 
 // Prepare configures the result cache to allow accepting and caching inbound
 // fetch results.
-func (q *queue) Prepare(offset uint64, mode SyncMode, pivot uint64) {
+func (q *queue) Prepare(offset uint64, mode SyncMode, pivot uint64, head *types.Header) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
 
+	// Prepare the queue for sync results
 	if q.resultOffset < offset {
 		q.resultOffset = offset
 	}
 	q.fastSyncPivot = pivot
 	q.mode = mode
+
+	// If long running fast sync, also start up a head stateretrieval immediately
+	if mode == FastSync && pivot > 0 {
+		q.stateScheduler = state.NewStateSync(head.Root, q.stateDatabase)
+	}
 }

eth/filters/api.go

@@ -233,6 +233,7 @@ func (s *PublicFilterAPI) newLogFilter(earliest, latest int64, addresses []commo
 	return id, nil
 }
 
+// Logs creates a subscription that fires for all new log that match the given filter criteria.
 func (s *PublicFilterAPI) Logs(ctx context.Context, args NewFilterArgs) (rpc.Subscription, error) {
 	notifier, supported := rpc.NotifierFromContext(ctx)
 	if !supported {
@@ -291,12 +292,13 @@ type NewFilterArgs struct {
 	Topics    [][]common.Hash
 }
 
+// UnmarshalJSON sets *args fields with given data.
 func (args *NewFilterArgs) UnmarshalJSON(data []byte) error {
 	type input struct {
 		From      *rpc.BlockNumber `json:"fromBlock"`
 		ToBlock   *rpc.BlockNumber `json:"toBlock"`
 		Addresses interface{}      `json:"address"`
-		Topics    interface{}      `json:"topics"`
+		Topics    []interface{}    `json:"topics"`
 	}
 
 	var raw input
@@ -321,7 +323,6 @@ func (args *NewFilterArgs) UnmarshalJSON(data []byte) error {
 	if raw.Addresses != nil {
 		// raw.Address can contain a single address or an array of addresses
 		var addresses []common.Address
-
 		if strAddrs, ok := raw.Addresses.([]interface{}); ok {
 			for i, addr := range strAddrs {
 				if strAddr, ok := addr.(string); ok {
@@ -352,56 +353,53 @@ func (args *NewFilterArgs) UnmarshalJSON(data []byte) error {
 		args.Addresses = addresses
 	}
 
+	// helper function which parses a string to a topic hash
 	topicConverter := func(raw string) (common.Hash, error) {
 		if len(raw) == 0 {
 			return common.Hash{}, nil
 		}
-
 		if len(raw) >= 2 && raw[0] == '0' && (raw[1] == 'x' || raw[1] == 'X') {
 			raw = raw[2:]
 		}
-
+		if len(raw) != 2 * common.HashLength {
+			return common.Hash{}, errors.New("invalid topic(s)")
+		}
 		if decAddr, err := hex.DecodeString(raw); err == nil {
 			return common.BytesToHash(decAddr), nil
 		}
-
+		return common.Hash{}, errors.New("invalid topic(s)")
-		return common.Hash{}, errors.New("invalid topic given")
 	}
 
-	// topics is an array consisting of strings or arrays of strings
+	// topics is an array consisting of strings and/or arrays of strings.
-	if raw.Topics != nil {
+	// JSON null values are converted to common.Hash{} and ignored by the filter manager.
-		topics, ok := raw.Topics.([]interface{})
+	if len(raw.Topics) > 0 {
-		if ok {
+		args.Topics = make([][]common.Hash, len(raw.Topics))
-			parsedTopics := make([][]common.Hash, len(topics))
+		for i, t := range raw.Topics {
-			for i, topic := range topics {
+			if t == nil { // ignore topic when matching logs
-				if topic == nil {
+				args.Topics[i] = []common.Hash{common.Hash{}}
-					parsedTopics[i] = []common.Hash{common.StringToHash("")}
+			} else if topic, ok := t.(string); ok { // match specific topic
-				} else if strTopic, ok := topic.(string); ok {
+				top, err := topicConverter(topic)
-					if t, err := topicConverter(strTopic); err != nil {
+				if err != nil {
-						return fmt.Errorf("invalid topic on index %d", i)
+					return err
-					} else {
-						parsedTopics[i] = []common.Hash{t}
-					}
-				} else if arrTopic, ok := topic.([]interface{}); ok {
-					parsedTopics[i] = make([]common.Hash, len(arrTopic))
-					for j := 0; j < len(parsedTopics[i]); i++ {
-						if arrTopic[j] == nil {
-							parsedTopics[i][j] = common.StringToHash("")
-						} else if str, ok := arrTopic[j].(string); ok {
-							if t, err := topicConverter(str); err != nil {
-								return fmt.Errorf("invalid topic on index %d", i)
-							} else {
-								parsedTopics[i] = []common.Hash{t}
-							}
-						} else {
-							return fmt.Errorf("topic[%d][%d] not a string", i, j)
-						}
-					}
-				} else {
-					return fmt.Errorf("topic[%d] invalid", i)
 				}
+				args.Topics[i] = []common.Hash{top}
+			} else if topics, ok := t.([]interface{}); ok { // or case e.g. [null, "topic0", "topic1"]
+				for _, rawTopic := range topics {
+					if rawTopic == nil {
+						args.Topics[i] = append(args.Topics[i], common.Hash{})
+					} else if topic, ok := rawTopic.(string); ok {
+						parsed, err := topicConverter(topic)
+						if err != nil {
+							return err
+						}
+						args.Topics[i] = append(args.Topics[i], parsed)
+					} else {
+						return fmt.Errorf("invalid topic(s)")
+					}
+				}
+			} else {
+				return fmt.Errorf("invalid topic(s)")
 			}
-			args.Topics = parsedTopics
 		}
 	}
 

eth/filters/api_test.go

@@ -0,0 +1,198 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package filters_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/eth/filters"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+func TestUnmarshalJSONNewFilterArgs(t *testing.T) {
+	var (
+		fromBlock rpc.BlockNumber = 0x123435
+		toBlock   rpc.BlockNumber = 0xabcdef
+		address0                  = common.StringToAddress("70c87d191324e6712a591f304b4eedef6ad9bb9d")
+		address1                  = common.StringToAddress("9b2055d370f73ec7d8a03e965129118dc8f5bf83")
+		topic0                    = common.HexToHash("3ac225168df54212a25c1c01fd35bebfea408fdac2e31ddd6f80a4bbf9a5f1ca")
+		topic1                    = common.HexToHash("9084a792d2f8b16a62b882fd56f7860c07bf5fa91dd8a2ae7e809e5180fef0b3")
+		topic2                    = common.HexToHash("6ccae1c4af4152f460ff510e573399795dfab5dcf1fa60d1f33ac8fdc1e480ce")
+		nullTopic                 = common.Hash{}
+	)
+
+	// default values
+	var test0 filters.NewFilterArgs
+	if err := json.Unmarshal([]byte("{}"), &test0); err != nil {
+		t.Fatal(err)
+	}
+	if test0.FromBlock != rpc.LatestBlockNumber {
+		t.Fatalf("expected %d, got %d", rpc.LatestBlockNumber, test0.FromBlock)
+	}
+	if test0.ToBlock != rpc.LatestBlockNumber {
+		t.Fatalf("expected %d, got %d", rpc.LatestBlockNumber, test0.ToBlock)
+	}
+	if len(test0.Addresses) != 0 {
+		t.Fatalf("expected 0 addresses, got %d", len(test0.Addresses))
+	}
+	if len(test0.Topics) != 0 {
+		t.Fatalf("expected 0 topics, got %d topics", len(test0.Topics))
+	}
+
+	// from, to block number
+	var test1 filters.NewFilterArgs
+	vector := fmt.Sprintf(`{"fromBlock":"0x%x","toBlock":"0x%x"}`, fromBlock, toBlock)
+	if err := json.Unmarshal([]byte(vector), &test1); err != nil {
+		t.Fatal(err)
+	}
+	if test1.FromBlock != fromBlock {
+		t.Fatalf("expected FromBlock %d, got %d", fromBlock, test1.FromBlock)
+	}
+	if test1.ToBlock != toBlock {
+		t.Fatalf("expected ToBlock %d, got %d", toBlock, test1.ToBlock)
+	}
+
+	// single address
+	var test2 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"address": "%s"}`, address0.Hex())
+	if err := json.Unmarshal([]byte(vector), &test2); err != nil {
+		t.Fatal(err)
+	}
+	if len(test2.Addresses) != 1 {
+		t.Fatalf("expected 1 address, got %d address(es)", len(test2.Addresses))
+	}
+	if test2.Addresses[0] != address0 {
+		t.Fatalf("expected address %x, got %x", address0, test2.Addresses[0])
+	}
+
+	// multiple address
+	var test3 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"address": ["%s", "%s"]}`, address0.Hex(), address1.Hex())
+	if err := json.Unmarshal([]byte(vector), &test3); err != nil {
+		t.Fatal(err)
+	}
+	if len(test3.Addresses) != 2 {
+		t.Fatalf("expected 2 addresses, got %d address(es)", len(test3.Addresses))
+	}
+	if test3.Addresses[0] != address0 {
+		t.Fatalf("expected address %x, got %x", address0, test3.Addresses[0])
+	}
+	if test3.Addresses[1] != address1 {
+		t.Fatalf("expected address %x, got %x", address1, test3.Addresses[1])
+	}
+
+	// single topic
+	var test4 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"topics": ["%s"]}`, topic0.Hex())
+	if err := json.Unmarshal([]byte(vector), &test4); err != nil {
+		t.Fatal(err)
+	}
+	if len(test4.Topics) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test4.Topics))
+	}
+	if len(test4.Topics[0]) != 1 {
+		t.Fatalf("expected len(topics[0]) to be 1, got %d", len(test4.Topics[0]))
+	}
+	if test4.Topics[0][0] != topic0 {
+		t.Fatalf("got %x, expected %x", test4.Topics[0][0], topic0)
+	}
+
+	// test multiple "AND" topics
+	var test5 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"topics": ["%s", "%s"]}`, topic0.Hex(), topic1.Hex())
+	if err := json.Unmarshal([]byte(vector), &test5); err != nil {
+		t.Fatal(err)
+	}
+	if len(test5.Topics) != 2 {
+		t.Fatalf("expected 2 topics, got %d", len(test5.Topics))
+	}
+	if len(test5.Topics[0]) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test5.Topics[0]))
+	}
+	if test5.Topics[0][0] != topic0 {
+		t.Fatalf("got %x, expected %x", test5.Topics[0][0], topic0)
+	}
+	if len(test5.Topics[1]) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test5.Topics[1]))
+	}
+	if test5.Topics[1][0] != topic1 {
+		t.Fatalf("got %x, expected %x", test5.Topics[1][0], topic1)
+	}
+
+	// test optional topic
+	var test6 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"topics": ["%s", null, "%s"]}`, topic0.Hex(), topic2.Hex())
+	if err := json.Unmarshal([]byte(vector), &test6); err != nil {
+		t.Fatal(err)
+	}
+	if len(test6.Topics) != 3 {
+		t.Fatalf("expected 3 topics, got %d", len(test6.Topics))
+	}
+	if len(test6.Topics[0]) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test6.Topics[0]))
+	}
+	if test6.Topics[0][0] != topic0 {
+		t.Fatalf("got %x, expected %x", test6.Topics[0][0], topic0)
+	}
+	if len(test6.Topics[1]) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test6.Topics[1]))
+	}
+	if test6.Topics[1][0] != nullTopic {
+		t.Fatalf("got %x, expected empty hash", test6.Topics[1][0])
+	}
+	if len(test6.Topics[2]) != 1 {
+		t.Fatalf("expected 1 topic, got %d", len(test6.Topics[2]))
+	}
+	if test6.Topics[2][0] != topic2 {
+		t.Fatalf("got %x, expected %x", test6.Topics[2][0], topic2)
+	}
+
+	// test OR topics
+	var test7 filters.NewFilterArgs
+	vector = fmt.Sprintf(`{"topics": [["%s", "%s"], null, ["%s", null]]}`, topic0.Hex(), topic1.Hex(), topic2.Hex())
+	if err := json.Unmarshal([]byte(vector), &test7); err != nil {
+		t.Fatal(err)
+	}
+	if len(test7.Topics) != 3 {
+		t.Fatalf("expected 3 topics, got %d topics", len(test7.Topics))
+	}
+	if len(test7.Topics[0]) != 2 {
+		t.Fatalf("expected 2 topics, got %d topics", len(test7.Topics[0]))
+	}
+	if test7.Topics[0][0] != topic0 || test7.Topics[0][1] != topic1 {
+		t.Fatalf("invalid topics expected [%x,%x], got [%x,%x]",
+			topic0, topic1, test7.Topics[0][0], test7.Topics[0][1],
+		)
+	}
+	if len(test7.Topics[1]) != 1 {
+		t.Fatalf("expected 1 topic, got %d topics", len(test7.Topics[1]))
+	}
+	if test7.Topics[1][0] != nullTopic {
+		t.Fatalf("expected empty hash, got %x", test7.Topics[1][0])
+	}
+	if len(test7.Topics[2]) != 2 {
+		t.Fatalf("expected 2 topics, got %d topics", len(test7.Topics[2]))
+	}
+	if test7.Topics[2][0] != topic2 || test7.Topics[2][1] != nullTopic {
+		t.Fatalf("invalid topics expected [%x,%x], got [%x,%x]",
+			topic2, nullTopic, test7.Topics[2][0], test7.Topics[2][1],
+		)
+	}
+}

eth/handler.go

@@ -22,6 +22,7 @@ import (
 	"math"
 	"math/big"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -58,7 +59,9 @@ type blockFetcherFn func([]common.Hash) error
 type ProtocolManager struct {
 	networkId int
 
-	fastSync   bool
+	fastSync uint32 // Flag whether fast sync is enabled (gets disabled if we already have blocks)
+	synced   uint32 // Flag whether we're considered synchronised (enables transaction processing)
+
 	txpool     txPool
 	blockchain *core.BlockChain
 	chaindb    ethdb.Database
@@ -82,20 +85,16 @@ type ProtocolManager struct {
 	// wait group is used for graceful shutdowns during downloading
 	// and processing
 	wg sync.WaitGroup
+
+	badBlockReportingEnabled bool
 }
 
 // NewProtocolManager returns a new ethereum sub protocol manager. The Ethereum sub protocol manages peers capable
 // with the ethereum network.
 func NewProtocolManager(config *core.ChainConfig, fastSync bool, networkId int, mux *event.TypeMux, txpool txPool, pow pow.PoW, blockchain *core.BlockChain, chaindb ethdb.Database) (*ProtocolManager, error) {
-	// Figure out whether to allow fast sync or not
-	if fastSync && blockchain.CurrentBlock().NumberU64() > 0 {
-		glog.V(logger.Info).Infof("blockchain not empty, fast sync disabled")
-		fastSync = false
-	}
 	// Create the protocol manager with the base fields
 	manager := &ProtocolManager{
 		networkId:   networkId,
-		fastSync:    fastSync,
 		eventMux:    mux,
 		txpool:      txpool,
 		blockchain:  blockchain,
@@ -106,6 +105,14 @@ func NewProtocolManager(config *core.ChainConfig, fastSync bool, networkId int,
 		txsyncCh:    make(chan *txsync),
 		quitSync:    make(chan struct{}),
 	}
+	// Figure out whether to allow fast sync or not
+	if fastSync && blockchain.CurrentBlock().NumberU64() > 0 {
+		glog.V(logger.Info).Infof("blockchain not empty, fast sync disabled")
+		fastSync = false
+	}
+	if fastSync {
+		manager.fastSync = uint32(1)
+	}
 	// Initiate a sub-protocol for every implemented version we can handle
 	manager.SubProtocols = make([]p2p.Protocol, 0, len(ProtocolVersions))
 	for i, version := range ProtocolVersions {
@@ -147,7 +154,7 @@ func NewProtocolManager(config *core.ChainConfig, fastSync bool, networkId int,
 	// Construct the different synchronisation mechanisms
 	manager.downloader = downloader.New(chaindb, manager.eventMux, blockchain.HasHeader, blockchain.HasBlockAndState, blockchain.GetHeader,
 		blockchain.GetBlock, blockchain.CurrentHeader, blockchain.CurrentBlock, blockchain.CurrentFastBlock, blockchain.FastSyncCommitHead,
-		blockchain.GetTd, blockchain.InsertHeaderChain, blockchain.InsertChain, blockchain.InsertReceiptChain, blockchain.Rollback,
+		blockchain.GetTd, blockchain.InsertHeaderChain, manager.insertChain, blockchain.InsertReceiptChain, blockchain.Rollback,
 		manager.removePeer)
 
 	validator := func(block *types.Block, parent *types.Block) error {
@@ -156,11 +163,28 @@ func NewProtocolManager(config *core.ChainConfig, fastSync bool, networkId int,
 	heighter := func() uint64 {
 		return blockchain.CurrentBlock().NumberU64()
 	}
-	manager.fetcher = fetcher.New(blockchain.GetBlock, validator, manager.BroadcastBlock, heighter, blockchain.InsertChain, manager.removePeer)
+	inserter := func(blocks types.Blocks) (int, error) {
+		atomic.StoreUint32(&manager.synced, 1) // Mark initial sync done on any fetcher import
+		return manager.insertChain(blocks)
+	}
+	manager.fetcher = fetcher.New(blockchain.GetBlock, validator, manager.BroadcastBlock, heighter, inserter, manager.removePeer)
+
+	if blockchain.Genesis().Hash().Hex() == defaultGenesisHash && networkId == 1 {
+		glog.V(logger.Debug).Infoln("Bad Block Reporting is enabled")
+		manager.badBlockReportingEnabled = true
+	}
 
 	return manager, nil
 }
 
+func (pm *ProtocolManager) insertChain(blocks types.Blocks) (i int, err error) {
+	i, err = pm.blockchain.InsertChain(blocks)
+	if pm.badBlockReportingEnabled && core.IsValidationErr(err) && i < len(blocks) {
+		go sendBadBlockReport(blocks[i], err)
+	}
+	return i, err
+}
+
 func (pm *ProtocolManager) removePeer(id string) {
 	// Short circuit if the peer was already removed
 	peer := pm.peers.Peer(id)
@@ -375,6 +399,7 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
 		// Update the receive timestamp of each block
 		for _, block := range blocks {
 			block.ReceivedAt = msg.ReceivedAt
+			block.ReceivedFrom = p
 		}
 		// Filter out any explicitly requested blocks, deliver the rest to the downloader
 		if blocks := pm.fetcher.FilterBlocks(blocks); len(blocks) > 0 {
@@ -661,6 +686,7 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
 			return errResp(ErrDecode, "block validation %v: %v", msg, err)
 		}
 		request.Block.ReceivedAt = msg.ReceivedAt
+		request.Block.ReceivedFrom = p
 
 		// Mark the peer as owning the block and schedule it for import
 		p.MarkBlock(request.Block.Hash())
@@ -678,7 +704,11 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
 		}
 
 	case msg.Code == TxMsg:
-		// Transactions arrived, parse all of them and deliver to the pool
+		// Transactions arrived, make sure we have a valid and fresh chain to handle them
+		if atomic.LoadUint32(&pm.synced) == 0 {
+			break
+		}
+		// Transactions can be processed, parse all of them and deliver to the pool
 		var txs []*types.Transaction
 		if err := msg.Decode(&txs); err != nil {
 			return errResp(ErrDecode, "msg %v: %v", msg, err)

eth/protocol_test.go

@@ -97,6 +97,7 @@ func TestRecvTransactions63(t *testing.T) { testRecvTransactions(t, 63) }
 func testRecvTransactions(t *testing.T, protocol int) {
 	txAdded := make(chan []*types.Transaction)
 	pm := newTestProtocolManagerMust(t, false, 0, nil, txAdded)
+	pm.synced = 1 // mark synced to accept transactions
 	p, _ := newTestPeer("peer", protocol, pm, true)
 	defer pm.Stop()
 	defer p.close()

eth/sync.go

@@ -18,6 +18,7 @@ package eth
 
 import (
 	"math/rand"
+	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -167,18 +168,20 @@ func (pm *ProtocolManager) synchronise(peer *peer) {
 	}
 	// Otherwise try to sync with the downloader
 	mode := downloader.FullSync
-	if pm.fastSync {
+	if atomic.LoadUint32(&pm.fastSync) == 1 {
 		mode = downloader.FastSync
 	}
 	if err := pm.downloader.Synchronise(peer.id, peer.Head(), peer.Td(), mode); err != nil {
 		return
 	}
+	atomic.StoreUint32(&pm.synced, 1) // Mark initial sync done
+
 	// If fast sync was enabled, and we synced up, disable it
-	if pm.fastSync {
+	if atomic.LoadUint32(&pm.fastSync) == 1 {
 		// Disable fast sync if we indeed have something in our chain
 		if pm.blockchain.CurrentBlock().NumberU64() > 0 {
 			glog.V(logger.Info).Infof("fast sync complete, auto disabling")
-			pm.fastSync = false
+			atomic.StoreUint32(&pm.fastSync, 0)
 		}
 	}
 }

eth/sync_test.go

@@ -17,6 +17,7 @@
 package eth
 
 import (
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -29,12 +30,12 @@ import (
 func TestFastSyncDisabling(t *testing.T) {
 	// Create a pristine protocol manager, check that fast sync is left enabled
 	pmEmpty := newTestProtocolManagerMust(t, true, 0, nil, nil)
-	if !pmEmpty.fastSync {
+	if atomic.LoadUint32(&pmEmpty.fastSync) == 0 {
 		t.Fatalf("fast sync disabled on pristine blockchain")
 	}
 	// Create a full protocol manager, check that fast sync gets disabled
 	pmFull := newTestProtocolManagerMust(t, true, 1024, nil, nil)
-	if pmFull.fastSync {
+	if atomic.LoadUint32(&pmFull.fastSync) == 1 {
 		t.Fatalf("fast sync not disabled on non-empty blockchain")
 	}
 	// Sync up the two peers
@@ -47,7 +48,7 @@ func TestFastSyncDisabling(t *testing.T) {
 	pmEmpty.synchronise(pmEmpty.peers.BestPeer())
 
 	// Check that fast sync was disabled
-	if pmEmpty.fastSync {
+	if atomic.LoadUint32(&pmEmpty.fastSync) == 1 {
 		t.Fatalf("fast sync not disabled after successful synchronisation")
 	}
 }

event/event.go

@@ -66,6 +66,9 @@ func (mux *TypeMux) Subscribe(types ...interface{}) Subscription {
 	mux.mutex.Lock()
 	defer mux.mutex.Unlock()
 	if mux.stopped {
+		// set the status to closed so that calling Unsubscribe after this
+		// call will short curuit
+		sub.closed = true
 		close(sub.postC)
 	} else {
 		if mux.subm == nil {

event/event_test.go

@@ -25,6 +25,14 @@ import (
 
 type testEvent int
 
+func TestSubCloseUnsub(t *testing.T) {
+	// the point of this test is **not** to panic
+	var mux TypeMux
+	mux.Stop()
+	sub := mux.Subscribe(int(0))
+	sub.Unsubscribe()
+}
+
 func TestSub(t *testing.T) {
 	mux := new(TypeMux)
 	defer mux.Stop()

internal/debug/flags.go

@@ -22,9 +22,9 @@ import (
 	_ "net/http/pprof"
 	"runtime"
 
-	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (