2026-03-06 13:28:40 +01:00
615 changed files with 15817 additions and 37159 deletions
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@ -9,7 +9,9 @@ and help.

 If you'd like to contribute to go-ethereum please fork, fix, commit and
 send a pull request. Commits which do not comply with the coding standards
-are ignored (use gofmt!).
+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.

 See [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
 for more details on configuring your environment, testing, and
--- a/.travis.yml
+++ b/.travis.yml
@ -13,15 +13,15 @@ matrix:
      go: 1.6.2
    - os: linux
      dist: trusty
-      go: 1.7.4
+      go: 1.7
    - os: osx
-      go: 1.7.4
+      go: 1.7

    # This builder does the Ubuntu PPA and Linux Azure uploads
    - os: linux
      dist: trusty
      sudo: required
-      go: 1.7.4
+      go: 1.7
      env:
        - ubuntu-ppa
        - azure-linux
@ -55,10 +55,14 @@ matrix:

    # This builder does the OSX Azure, Android Maven and Azure and iOS CocoaPods and Azure uploads
    - os: osx
-      go: 1.7.4
+      go: 1.7
      env:
        - azure-osx
        - mobile
+      cache:
+        directories:
+          - $HOME/.android.platforms
+          - $HOME/.cocoapods
      script:
        - go run build/ci.go install
        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds
@ -67,30 +71,27 @@ matrix:
        - brew update
        - brew install android-sdk maven gpg
        - alias gpg="gpg2"
-
        - export ANDROID_HOME=/usr/local/opt/android-sdk
+
+        - mkdir -p $ANDROID_HOME/platforms
+        - mv -f $HOME/.android.platforms $ANDROID_HOME/platforms
        - echo "y" | android update sdk --no-ui --filter `android list sdk | grep "SDK Platform Android" | grep -E 'API 15|API 19|API 24' | awk '{print $1}' | cut -d '-' -f 1 | tr '\n' ','`

        - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/builds
+        - mv -f $ANDROID_HOME/platforms $HOME/.android.platforms

        # Build the iOS framework and upload it to CocoaPods and Azure
        - gem uninstall cocoapods -a
        - gem install cocoapods --pre
-
-        - mv ~/.cocoapods/repos/master ~/.cocoapods/repos/master.bak
-        - sed -i '.bak' 's/repo.join/!repo.join/g' $(dirname `gem which cocoapods`)/cocoapods/sources_manager.rb
-        - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then git clone --depth=1 https://github.com/CocoaPods/Specs.git ~/.cocoapods/repos/master && pod setup --verbose; fi
-
        - xctool -version
        - xcrun simctl list
-
-        - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds
+        - travis_wait 30 go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds

 install:
  - go get golang.org/x/tools/cmd/cover
 script:
  - go run build/ci.go install
-  - go run build/ci.go test -coverage -vet -misspell
+  - go run build/ci.go test -coverage -vet

 notifications:
  webhooks:
--- a/4
+++ b/4
@ -2,10 +2,10 @@ FROM alpine:3.3

 ADD . /go-ethereum
 RUN \
-  apk add --update git go make gcc musl-dev         && \
+  apk add --update go make gcc musl-dev             && \
  (cd go-ethereum && make geth)                     && \
  cp go-ethereum/build/bin/geth /geth               && \
-  apk del git go make gcc musl-dev                  && \
+  apk del go make gcc musl-dev                      && \
  rm -rf /go-ethereum && rm -rf /var/cache/apk/*

 EXPOSE 8545
--- a/25
+++ b/25
@ -2,11 +2,12 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.

-.PHONY: geth android ios geth-cross evm all test clean
+.PHONY: geth geth-cross evm all test clean
 .PHONY: geth-linux geth-linux-386 geth-linux-amd64 geth-linux-mips64 geth-linux-mips64le
 .PHONY: geth-linux-arm geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64
 .PHONY: geth-darwin geth-darwin-386 geth-darwin-amd64
 .PHONY: geth-windows geth-windows-386 geth-windows-amd64
+.PHONY: geth-android geth-ios

 GOBIN = build/bin
 GO ?= latest
@ -19,21 +20,11 @@ geth:
 evm:
 	build/env.sh go run build/ci.go install ./cmd/evm
 	@echo "Done building."
-	@echo "Run \"$(GOBIN)/evm\" to start the evm."
+	@echo "Run \"$(GOBIN)/evm to start the evm."

 all:
 	build/env.sh go run build/ci.go install

-android:
-	build/env.sh go run build/ci.go aar --local
-	@echo "Done building."
-	@echo "Import \"$(GOBIN)/geth.aar\" to use the library."
-
-ios:
-	build/env.sh go run build/ci.go xcode --local
-	@echo "Done building."
-	@echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
-
 test: all
 	build/env.sh go run build/ci.go test

@ -121,3 +112,13 @@ geth-windows-amd64:
 	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=windows/amd64 -v ./cmd/geth
 	@echo "Windows amd64 cross compilation done:"
 	@ls -ld $(GOBIN)/geth-windows-* | grep amd64
+
+geth-android:
+	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=android-21/aar -v ./cmd/geth
+	@echo "Android cross compilation done:"
+	@ls -ld $(GOBIN)/geth-android-*
+
+geth-ios:
+	build/env.sh go run build/ci.go xgo -- --go=$(GO) --dest=$(GOBIN) --targets=ios-7.0/framework -v ./cmd/geth
+	@echo "iOS framework cross compilation done:"
+	@ls -ld $(GOBIN)/geth-ios-*
--- a/README.md
+++ b/README.md
@ -32,14 +32,13 @@ The go-ethereum project comes with several wrappers/executables found in the `cm

 | Command    | Description |
 |:----------:|-------------|
-| **`geth`** | Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default) archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as a gateway into the Ethereum network via JSON RPC endpoints exposed on top of HTTP, WebSocket and/or IPC transports. `geth --help` and the [CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options) for command line options |
+| **`geth`** | Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default) archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as a gateway into the Ethereum network via JSON RPC endpoints exposed on top of HTTP, WebSocket and/or IPC transports. Please see our [Command Line Options](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options) wiki page for details. |
 | `abigen` | Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages. It operates on plain [Ethereum contract ABIs](https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI) with expanded functionality if the contract bytecode is also available. However it also accepts Solidity source files, making development much more streamlined. Please see our [Native DApps](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts) wiki page for details. |
 | `bootnode` | Stripped down version of our Ethereum client implementation that only takes part in the network node discovery protocol, but does not run any of the higher level application protocols. It can be used as a lightweight bootstrap node to aid in finding peers in private networks. |
 | `disasm` | Bytecode disassembler to convert EVM (Ethereum Virtual Machine) bytecode into more user friendly assembly-like opcodes (e.g. `echo "6001" | disasm`). For details on the individual opcodes, please see pages 22-30 of the [Ethereum Yellow Paper](http://gavwood.com/paper.pdf). |
 | `evm` | Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow insolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug`). |
 | `gethrpctest` | Developer utility tool to support our [ethereum/rpc-test](https://github.com/ethereum/rpc-tests) test suite which validates baseline conformity to the [Ethereum JSON RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC) specs. Please see the [test suite's readme](https://github.com/ethereum/rpc-tests/blob/master/README.md) for details. |
 | `rlpdump` | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://github.com/ethereum/wiki/wiki/RLP)) dumps (data encoding used by the Ethereum protocol both network as well as consensus wise) to user friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`). |
-| `swarm`    | swarm daemon and tools. This is the entrypoint for the swarm network. `swarm --help` for command line options and subcommands. See https://swarm-guide.readthedocs.io for swarm documentation. |

 ## Running geth

--- a/2
+++ b/2
@ -1 +1 @@
-1.5.7
+1.5.1
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -91,30 +91,8 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) {
 	// first we need to create a slice of the type
 	var refSlice reflect.Value
 	switch elem.T {
-	case IntTy, UintTy, BoolTy:
-		// create a new reference slice matching the element type
-		switch t.Type.Kind {
-		case reflect.Bool:
-			refSlice = reflect.ValueOf([]bool(nil))
-		case reflect.Uint8:
-			refSlice = reflect.ValueOf([]uint8(nil))
-		case reflect.Uint16:
-			refSlice = reflect.ValueOf([]uint16(nil))
-		case reflect.Uint32:
-			refSlice = reflect.ValueOf([]uint32(nil))
-		case reflect.Uint64:
-			refSlice = reflect.ValueOf([]uint64(nil))
-		case reflect.Int8:
-			refSlice = reflect.ValueOf([]int8(nil))
-		case reflect.Int16:
-			refSlice = reflect.ValueOf([]int16(nil))
-		case reflect.Int32:
-			refSlice = reflect.ValueOf([]int32(nil))
-		case reflect.Int64:
-			refSlice = reflect.ValueOf([]int64(nil))
-		default:
-			refSlice = reflect.ValueOf([]*big.Int(nil))
-		}
+	case IntTy, UintTy, BoolTy: // int, uint, bool can all be of type big int.
+		refSlice = reflect.ValueOf([]*big.Int(nil))
 	case AddressTy: // address must be of slice Address
 		refSlice = reflect.ValueOf([]common.Address(nil))
 	case HashTy: // hash must be of slice hash
@ -169,27 +147,7 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) {
 		// set inter to the correct type (cast)
 		switch elem.T {
 		case IntTy, UintTy:
-			bigNum := common.BytesToBig(returnOutput)
-			switch t.Type.Kind {
-			case reflect.Uint8:
-				inter = uint8(bigNum.Uint64())
-			case reflect.Uint16:
-				inter = uint16(bigNum.Uint64())
-			case reflect.Uint32:
-				inter = uint32(bigNum.Uint64())
-			case reflect.Uint64:
-				inter = bigNum.Uint64()
-			case reflect.Int8:
-				inter = int8(bigNum.Int64())
-			case reflect.Int16:
-				inter = int16(bigNum.Int64())
-			case reflect.Int32:
-				inter = int32(bigNum.Int64())
-			case reflect.Int64:
-				inter = bigNum.Int64()
-			default:
-				inter = common.BytesToBig(returnOutput)
-			}
+			inter = common.BytesToBig(returnOutput)
 		case BoolTy:
 			inter = common.BytesToBig(returnOutput).Uint64() > 0
 		case AddressTy:
@ -211,7 +169,7 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) {
 // argument in T.
 func toGoType(i int, t Argument, output []byte) (interface{}, error) {
 	// we need to treat slices differently
-	if (t.Type.IsSlice || t.Type.IsArray) && t.Type.T != BytesTy && t.Type.T != StringTy && t.Type.T != FixedBytesTy && t.Type.T != FunctionTy {
+	if (t.Type.IsSlice || t.Type.IsArray) && t.Type.T != BytesTy && t.Type.T != StringTy && t.Type.T != FixedBytesTy {
 		return toGoSlice(i, t, output)
 	}

@ -275,7 +233,7 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) {
 		return common.BytesToAddress(returnOutput), nil
 	case HashTy:
 		return common.BytesToHash(returnOutput), nil
-	case BytesTy, FixedBytesTy, FunctionTy:
+	case BytesTy, FixedBytesTy:
 		return returnOutput, nil
 	case StringTy:
 		return string(returnOutput), nil
@ -387,13 +345,12 @@ func (abi ABI) Unpack(v interface{}, name string, output []byte) error {

 func (abi *ABI) UnmarshalJSON(data []byte) error {
 	var fields []struct {
-		Type      string
-		Name      string
-		Constant  bool
-		Indexed   bool
-		Anonymous bool
-		Inputs    []Argument
-		Outputs   []Argument
+		Type     string
+		Name     string
+		Constant bool
+		Indexed  bool
+		Inputs   []Argument
+		Outputs  []Argument
 	}

 	if err := json.Unmarshal(data, &fields); err != nil {
@ -418,9 +375,8 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 			}
 		case "event":
 			abi.Events[field.Name] = Event{
-				Name:      field.Name,
-				Anonymous: field.Anonymous,
-				Inputs:    field.Inputs,
+				Name:   field.Name,
+				Inputs: field.Inputs,
 			}
 		}
 	}
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@ -67,10 +67,10 @@ func TestTypeCheck(t *testing.T) {
 		{"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
 		{"uint16[3]", []uint16{1, 2, 3}, ""},
 		{"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
-		{"address[]", []common.Address{{1}}, ""},
-		{"address[1]", []common.Address{{1}}, ""},
-		{"address[1]", [1]common.Address{{1}}, ""},
-		{"address[2]", [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
+		{"address[]", []common.Address{common.Address{1}}, ""},
+		{"address[1]", []common.Address{common.Address{1}}, ""},
+		{"address[1]", [1]common.Address{common.Address{1}}, ""},
+		{"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"},
 		{"bytes32", [32]byte{}, ""},
 		{"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
 		{"bytes32", common.Hash{1}, ""},
@ -80,8 +80,7 @@ func TestTypeCheck(t *testing.T) {
 		{"bytes", [2]byte{0, 1}, ""},
 		{"bytes", common.Hash{1}, ""},
 		{"string", "hello world", ""},
-		{"bytes32[]", [][32]byte{{}}, ""},
-		{"function", [24]byte{}, ""},
+		{"bytes32[]", [][32]byte{[32]byte{}}, ""},
 	} {
 		typ, err := NewType(test.typ)
 		if err != nil {
@ -198,13 +197,6 @@ func TestSimpleMethodUnpack(t *testing.T) {
 			"interface",
 			"",
 		},
-		{
-			`[ { "type": "function" } ]`,
-			pad([]byte{1}, 32, false),
-			[24]byte{1},
-			"function",
-			"",
-		},
 	} {
 		abiDefinition := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def)
 		abi, err := JSON(strings.NewReader(abiDefinition))
@ -263,10 +255,6 @@ func TestSimpleMethodUnpack(t *testing.T) {
 			var v common.Hash
 			err = abi.Unpack(&v, "method", test.marshalledOutput)
 			outvar = v
-		case "function":
-			var v [24]byte
-			err = abi.Unpack(&v, "method", test.marshalledOutput)
-			outvar = v
 		case "interface":
 			err = abi.Unpack(&outvar, "method", test.marshalledOutput)
 		default:
@ -332,30 +320,6 @@ func TestUnpackSetInterfaceSlice(t *testing.T) {
 	}
 }

-func TestUnpackSetInterfaceArrayOutput(t *testing.T) {
-	var (
-		var1 = new([1]uint32)
-		var2 = new([1]uint32)
-	)
-	out := []interface{}{var1, var2}
-	abi, err := JSON(strings.NewReader(`[{"type":"function", "name":"ints", "outputs":[{"type":"uint32[1]"}, {"type":"uint32[1]"}]}]`))
-	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]uint32{1} {
-		t.Error("expected var1 to be [1], got", *var1)
-	}
-	if *var2 != [1]uint32{2} {
-		t.Error("expected var2 to be [2], got", *var2)
-	}
-}
-
 func TestPack(t *testing.T) {
 	for i, test := range []struct {
 		typ string
@ -367,9 +331,8 @@ func TestPack(t *testing.T) {
 		{"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})},
 		{"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)},
 		{"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})},
-		{"address[]", []common.Address{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
-		{"bytes32[]", []common.Hash{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
-		{"function", [24]byte{1}, pad([]byte{1}, 32, false)},
+		{"address[]", []common.Address{common.Address{1}, common.Address{2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
+		{"bytes32[]", []common.Hash{common.Hash{1}, common.Hash{2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
 	} {
 		typ, err := NewType(test.typ)
 		if err != nil {
@ -482,12 +445,12 @@ func TestReader(t *testing.T) {
 	Uint256, _ := NewType("uint256")
 	exp := ABI{
 		Methods: map[string]Method{
-			"balance": {
+			"balance": Method{
 				"balance", true, nil, nil,
 			},
-			"send": {
+			"send": Method{
 				"send", false, []Argument{
-					{"amount", Uint256, false},
+					Argument{"amount", Uint256, false},
 				}, nil,
 			},
 		},
@ -586,7 +549,7 @@ func TestTestSlice(t *testing.T) {

 func TestMethodSignature(t *testing.T) {
 	String, _ := NewType("string")
-	m := Method{"foo", false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil}
+	m := Method{"foo", false, []Argument{Argument{"bar", String, false}, Argument{"baz", String, false}}, nil}
 	exp := "foo(string,string)"
 	if m.Sig() != exp {
 		t.Error("signature mismatch", exp, "!=", m.Sig())
@ -598,7 +561,7 @@ func TestMethodSignature(t *testing.T) {
 	}

 	uintt, _ := NewType("uint")
-	m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil}
+	m = Method{"foo", false, []Argument{Argument{"bar", uintt, false}}, nil}
 	exp = "foo(uint256)"
 	if m.Sig() != exp {
 		t.Error("signature mismatch", exp, "!=", m.Sig())
@ -789,58 +752,23 @@ func TestDefaultFunctionParsing(t *testing.T) {
 func TestBareEvents(t *testing.T) {
 	const definition = `[
 	{ "type" : "event", "name" : "balance" },
-	{ "type" : "event", "name" : "anon", "anonymous" : true},
-	{ "type" : "event", "name" : "args", "inputs" : [{ "indexed":false, "name":"arg0", "type":"uint256" }, { "indexed":true, "name":"arg1", "type":"address" }] }
-	]`
-
-	arg0, _ := NewType("uint256")
-	arg1, _ := NewType("address")
-
-	expectedEvents := map[string]struct {
-		Anonymous bool
-		Args      []Argument
-	}{
-		"balance": {false, nil},
-		"anon":    {true, nil},
-		"args": {false, []Argument{
-			{Name: "arg0", Type: arg0, Indexed: false},
-			{Name: "arg1", Type: arg1, Indexed: true},
-		}},
-	}
+	{ "type" : "event", "name" : "name" }]`

 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Fatal(err)
 	}

-	if len(abi.Events) != len(expectedEvents) {
-		t.Fatalf("invalid number of events after parsing, want %d, got %d", len(expectedEvents), len(abi.Events))
+	if len(abi.Events) != 2 {
+		t.Error("expected 2 events")
 	}

-	for name, exp := range expectedEvents {
-		got, ok := abi.Events[name]
-		if !ok {
-			t.Errorf("could not found event %s", name)
-			continue
-		}
-		if got.Anonymous != exp.Anonymous {
-			t.Errorf("invalid anonymous indication for event %s, want %v, got %v", name, exp.Anonymous, got.Anonymous)
-		}
-		if len(got.Inputs) != len(exp.Args) {
-			t.Errorf("invalid number of args, want %d, got %d", len(exp.Args), len(got.Inputs))
-			continue
-		}
-		for i, arg := range exp.Args {
-			if arg.Name != got.Inputs[i].Name {
-				t.Errorf("events[%s].Input[%d] has an invalid name, want %s, got %s", name, i, arg.Name, got.Inputs[i].Name)
-			}
-			if arg.Indexed != got.Inputs[i].Indexed {
-				t.Errorf("events[%s].Input[%d] has an invalid indexed indication, want %v, got %v", name, i, arg.Indexed, got.Inputs[i].Indexed)
-			}
-			if arg.Type.T != got.Inputs[i].Type.T {
-				t.Errorf("events[%s].Input[%d] has an invalid type, want %x, got %x", name, i, arg.Type.T, got.Inputs[i].Type.T)
-			}
-		}
+	if _, ok := abi.Events["balance"]; !ok {
+		t.Error("expected 'balance' event to be present")
+	}
+
+	if _, ok := abi.Events["name"]; !ok {
+		t.Error("expected 'name' event to be present")
 	}
 }

--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@ -31,9 +31,8 @@ type Argument struct {

 func (a *Argument) UnmarshalJSON(data []byte) error {
 	var extarg struct {
-		Name    string
-		Type    string
-		Indexed bool
+		Name string
+		Type string
 	}
 	err := json.Unmarshal(data, &extarg)
 	if err != nil {
@ -45,7 +44,6 @@ func (a *Argument) UnmarshalJSON(data []byte) error {
 		return err
 	}
 	a.Name = extarg.Name
-	a.Indexed = extarg.Indexed

 	return nil
 }
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@ -52,7 +52,7 @@ func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
 			if address != keyAddr {
 				return nil, errors.New("not authorized to sign this account")
 			}
-			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
+			signature, err := crypto.SignEthereum(signer.Hash(tx).Bytes(), key)
 			if err != nil {
 				return nil, err
 			}
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@ -225,11 +225,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	from.SetBalance(common.MaxBig)
 	// Execute the call.
 	msg := callmsg{call}
-
-	evmContext := core.NewEVMContext(msg, block.Header(), b.blockchain)
-	// Create a new environment which holds all relevant information
-	// about the transaction and calling mechanisms.
-	vmenv := vm.NewEVM(evmContext, statedb, chainConfig, vm.Config{})
+	vmenv := core.NewEnv(statedb, chainConfig, b.blockchain, msg, block.Header(), vm.Config{})
 	gaspool := new(core.GasPool).AddGas(common.MaxBig)
 	ret, gasUsed, _, err := core.NewStateTransition(vmenv, msg, gaspool).TransitionDb()
 	return ret, gasUsed, err
--- a/accounts/abi/bind/base.go
+++ b/accounts/abi/bind/base.go
@ -170,7 +170,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	if value == nil {
 		value = new(big.Int)
 	}
-	var nonce uint64
+	nonce := uint64(0)
 	if opts.Nonce == nil {
 		nonce, err = c.transactor.PendingNonceAt(ensureContext(opts.Context), opts.From)
 		if err != nil {
--- a/accounts/abi/bind/bind.go
+++ b/accounts/abi/bind/bind.go
@ -147,21 +147,21 @@ func bindTypeGo(kind abi.Type) string {

 	switch {
 	case strings.HasPrefix(stringKind, "address"):
-		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("address(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
 		return fmt.Sprintf("%scommon.Address", parts[1])

 	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("bytes([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
 		return fmt.Sprintf("%s[%s]byte", parts[2], parts[1])

 	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
-		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 4 {
 			return stringKind
 		}
@ -172,7 +172,7 @@ func bindTypeGo(kind abi.Type) string {
 		return fmt.Sprintf("%s*big.Int", parts[3])

 	case strings.HasPrefix(stringKind, "bool") || strings.HasPrefix(stringKind, "string"):
-		parts := regexp.MustCompile(`([a-z]+)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("([a-z]+)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
@ -191,7 +191,7 @@ func bindTypeJava(kind abi.Type) string {

 	switch {
 	case strings.HasPrefix(stringKind, "address"):
-		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("address(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@ -201,7 +201,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("Addresses")

 	case strings.HasPrefix(stringKind, "bytes"):
-		parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("bytes([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 3 {
 			return stringKind
 		}
@ -211,7 +211,7 @@ func bindTypeJava(kind abi.Type) string {
 		return "byte[]"

 	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
-		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 4 {
 			return stringKind
 		}
@ -230,7 +230,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("BigInts")

 	case strings.HasPrefix(stringKind, "bool"):
-		parts := regexp.MustCompile(`bool(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("bool(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@ -240,7 +240,7 @@ func bindTypeJava(kind abi.Type) string {
 		return fmt.Sprintf("bool[]")

 	case strings.HasPrefix(stringKind, "string"):
-		parts := regexp.MustCompile(`string(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		parts := regexp.MustCompile("string(\\[[0-9]*\\])?").FindStringSubmatch(stringKind)
 		if len(parts) != 2 {
 			return stringKind
 		}
@ -278,7 +278,7 @@ func namedTypeJava(javaKind string, solKind abi.Type) string {
 	case "bool[]":
 		return "Bools"
 	case "BigInt":
-		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
+		parts := regexp.MustCompile("(u)?int([0-9]*)(\\[[0-9]*\\])?").FindStringSubmatch(solKind.String())
 		if len(parts) != 4 {
 			return javaKind
 		}
--- a/accounts/abi/bind/util_test.go
+++ b/accounts/abi/bind/util_test.go
@ -60,7 +60,7 @@ func TestWaitDeployed(t *testing.T) {

 		// Create the transaction.
 		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, big.NewInt(1), common.FromHex(test.code))
-		tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
+		tx, _ = tx.SignECDSA(types.HomesteadSigner{}, testKey)

 		// Wait for it to get mined in the background.
 		var (
--- a/accounts/abi/event.go
+++ b/accounts/abi/event.go
@ -25,12 +25,10 @@ import (
 )

 // Event is an event potentially triggered by the EVM's LOG mechanism. The Event
-// holds type information (inputs) about the yielded output. Anonymous events
-// don't get the signature canonical representation as the first LOG topic.
+// holds type information (inputs) about the yielded output
 type Event struct {
-	Name      string
-	Anonymous bool
-	Inputs    []Argument
+	Name   string
+	Inputs []Argument
 }

 // Id returns the canonical representation of the event's signature used by the
--- a/accounts/abi/packing.go
+++ b/accounts/abi/packing.go
@ -54,7 +54,7 @@ func packElement(t Type, reflectValue reflect.Value) []byte {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
 		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len())
-	case FixedBytesTy, FunctionTy:
+	case FixedBytesTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -33,8 +33,7 @@ const (
 	FixedBytesTy
 	BytesTy
 	HashTy
-	FixedpointTy
-	FunctionTy
+	RealTy
 )

 // Type is the reflection of the supported argument type
@ -58,16 +57,16 @@ var (
 	// Types can be in the format of:
 	//
 	// 	Input  = Type [ "[" [ Number ] "]" ] Name .
-	// 	Type   = [ "u" ] "int" [ Number ] [ x ] [ Number ].
+	// 	Type   = [ "u" ] "int" [ Number ] .
 	//
 	// Examples:
 	//
-	//      string     int       uint       fixed
+	//      string     int       uint       real
 	//      string32   int8      uint8      uint[]
-	//      address    int256    uint256    fixed128x128[2]
-	fullTypeRegex = regexp.MustCompile(`([a-zA-Z0-9]+)(\[([0-9]*)\])?`)
+	//      address    int256    uint256    real[2]
+	fullTypeRegex = regexp.MustCompile("([a-zA-Z0-9]+)(\\[([0-9]*)?\\])?")
 	// typeRegex parses the abi sub types
-	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
+	typeRegex = regexp.MustCompile("([a-zA-Z]+)([0-9]*)?")
 )

 // NewType creates a new reflection type of abi type given in t.
@ -91,19 +90,14 @@ func NewType(t string) (typ Type, err error) {
 		}
 		typ.Elem = &sliceType
 		typ.stringKind = sliceType.stringKind + t[len(res[1]):]
-		// Although we know that this is an array, we cannot return
-		// as we don't know the type of the element, however, if it
-		// is still an array, then don't determine the type.
-		if typ.Elem.IsArray || typ.Elem.IsSlice {
-			return typ, nil
-		}
+		return typ, nil
 	}

 	// parse the type and size of the abi-type.
 	parsedType := typeRegex.FindAllStringSubmatch(res[1], -1)[0]
 	// varSize is the size of the variable
 	var varSize int
-	if len(parsedType[3]) > 0 {
+	if len(parsedType[2]) > 0 {
 		var err error
 		varSize, err = strconv.Atoi(parsedType[2])
 		if err != nil {
@ -117,12 +111,7 @@ func NewType(t string) (typ Type, err error) {
 		varSize = 256
 		t += "256"
 	}
-
-	// only set stringKind if not array or slice, as for those,
-	// the correct string type has been set
-	if !(typ.IsArray || typ.IsSlice) {
-		typ.stringKind = t
-	}
+	typ.stringKind = t

 	switch varType {
 	case "int":
@ -159,12 +148,6 @@ func NewType(t string) (typ Type, err error) {
 			typ.T = FixedBytesTy
 			typ.SliceSize = varSize
 		}
-	case "function":
-		sliceType, _ := NewType("uint8")
-		typ.Elem = &sliceType
-		typ.IsArray = true
-		typ.T = FunctionTy
-		typ.SliceSize = 24
 	default:
 		return Type{}, fmt.Errorf("unsupported arg type: %s", t)
 	}
@ -185,7 +168,7 @@ func (t Type) pack(v reflect.Value) ([]byte, error) {
 		return nil, err
 	}

-	if (t.IsSlice || t.IsArray) && t.T != BytesTy && t.T != FixedBytesTy && t.T != FunctionTy {
+	if (t.IsSlice || t.IsArray) && t.T != BytesTy && t.T != FixedBytesTy {
 		var packed []byte

 		for i := 0; i < v.Len(); i++ {
--- a/accounts/abi/type_test.go
+++ b/accounts/abi/type_test.go
@ -1,78 +0,0 @@
-// 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 abi
-
-import (
-	"reflect"
-	"testing"
-)
-
-// typeWithoutStringer is a alias for the Type type which simply doesn't implement
-// the stringer interface to allow printing type details in the tests below.
-type typeWithoutStringer Type
-
-// Tests that all allowed types get recognized by the type parser.
-func TestTypeRegexp(t *testing.T) {
-	tests := []struct {
-		blob string
-		kind Type
-	}{
-		{"int", Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}},
-		{"int8", Type{Kind: reflect.Int8, Type: big_t, Size: 8, T: IntTy, stringKind: "int8"}},
-		{"int256", Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}},
-		{"int[]", Type{IsSlice: true, SliceSize: -1, Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}},
-		{"int[2]", Type{IsArray: true, SliceSize: 2, Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}},
-		{"int32[]", Type{IsSlice: true, SliceSize: -1, Kind: reflect.Int32, Type: big_t, Size: 32, T: IntTy, Elem: &Type{Kind: reflect.Int32, Type: big_t, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}},
-		{"int32[2]", Type{IsArray: true, SliceSize: 2, Kind: reflect.Int32, Type: big_t, Size: 32, T: IntTy, Elem: &Type{Kind: reflect.Int32, Type: big_t, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}},
-		{"uint", Type{Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, stringKind: "uint256"}},
-		{"uint8", Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}},
-		{"uint256", Type{Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, stringKind: "uint256"}},
-		{"uint[]", Type{IsSlice: true, SliceSize: -1, Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, Elem: &Type{Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}},
-		{"uint[2]", Type{IsArray: true, SliceSize: 2, Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, Elem: &Type{Kind: reflect.Ptr, Type: ubig_t, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}},
-		{"uint32[]", Type{IsSlice: true, SliceSize: -1, Kind: reflect.Uint32, Type: ubig_t, Size: 32, T: UintTy, Elem: &Type{Kind: reflect.Uint32, Type: big_t, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}},
-		{"uint32[2]", Type{IsArray: true, SliceSize: 2, Kind: reflect.Uint32, Type: ubig_t, Size: 32, T: UintTy, Elem: &Type{Kind: reflect.Uint32, Type: big_t, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}},
-		{"bytes", Type{IsSlice: true, SliceSize: -1, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: BytesTy, stringKind: "bytes"}},
-		{"bytes32", Type{IsArray: true, SliceSize: 32, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: FixedBytesTy, stringKind: "bytes32"}},
-		{"bytes[]", Type{IsSlice: true, SliceSize: -1, Elem: &Type{IsSlice: true, SliceSize: -1, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}},
-		{"bytes[2]", Type{IsArray: true, SliceSize: 2, Elem: &Type{IsSlice: true, SliceSize: -1, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[2]"}},
-		{"bytes32[]", Type{IsSlice: true, SliceSize: -1, Elem: &Type{IsArray: true, SliceSize: 32, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: FixedBytesTy, stringKind: "bytes32"}, stringKind: "bytes32[]"}},
-		{"bytes32[2]", Type{IsArray: true, SliceSize: 2, Elem: &Type{IsArray: true, SliceSize: 32, Elem: &Type{Kind: reflect.Uint8, Type: ubig_t, Size: 8, T: UintTy, stringKind: "uint8"}, T: FixedBytesTy, stringKind: "bytes32"}, stringKind: "bytes32[2]"}},
-		{"string", Type{Kind: reflect.String, Size: -1, T: StringTy, stringKind: "string"}},
-		{"string[]", Type{IsSlice: true, SliceSize: -1, Kind: reflect.String, T: StringTy, Size: -1, Elem: &Type{Kind: reflect.String, T: StringTy, Size: -1, stringKind: "string"}, stringKind: "string[]"}},
-		{"string[2]", Type{IsArray: true, SliceSize: 2, Kind: reflect.String, T: StringTy, Size: -1, Elem: &Type{Kind: reflect.String, T: StringTy, Size: -1, stringKind: "string"}, stringKind: "string[2]"}},
-		{"address", Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}},
-		{"address[]", Type{IsSlice: true, SliceSize: -1,Kind: reflect.Array, Type:address_t, T: AddressTy, Size:20, Elem: &Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}},
-		{"address[2]", Type{IsArray: true, SliceSize: 2,Kind: reflect.Array, Type:address_t, T: AddressTy, Size:20, Elem: &Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}},
-
-		// TODO when fixed types are implemented properly
-		// {"fixed", Type{}},
-		// {"fixed128x128", Type{}},
-		// {"fixed[]", Type{}},
-		// {"fixed[2]", Type{}},
-		// {"fixed128x128[]", Type{}},
-		// {"fixed128x128[2]", Type{}},
-	}
-	for i, tt := range tests {
-		typ, err := NewType(tt.blob)
-		if err != nil {
-			t.Errorf("type %d: failed to parse type string: %v", i, err)
-		}
-		if !reflect.DeepEqual(typ, tt.kind) {
-			t.Errorf("type %d: parsed type mismatch:\n  have %+v\n  want %+v", i, typeWithoutStringer(typ), typeWithoutStringer(tt.kind))
-		}
-	}
-}
--- a/accounts/account_manager.go
+++ b/accounts/account_manager.go
@ -136,12 +136,13 @@ func (am *Manager) DeleteAccount(a Account, passphrase string) error {
 	return err
 }

-// Sign calculates a ECDSA signature for the given hash. The produced signature
-// is in the [R || S || V] format where V is 0 or 1.
+// Sign calculates a ECDSA signature for the given hash.
+// Note, Ethereum signatures have a particular format as described in the
+// yellow paper. Use the SignEthereum function to calculate a signature
+// in Ethereum format.
 func (am *Manager) Sign(addr common.Address, hash []byte) ([]byte, error) {
 	am.mu.RLock()
 	defer am.mu.RUnlock()
-
 	unlockedKey, found := am.unlocked[addr]
 	if !found {
 		return nil, ErrLocked
@ -149,16 +150,28 @@ func (am *Manager) Sign(addr common.Address, hash []byte) ([]byte, error) {
 	return crypto.Sign(hash, unlockedKey.PrivateKey)
 }

-// SignWithPassphrase signs hash if the private key matching the given address
-// can be decrypted with the given passphrase. The produced signature is in the
-// [R || S || V] format where V is 0 or 1.
-func (am *Manager) SignWithPassphrase(a Account, passphrase string, hash []byte) (signature []byte, err error) {
-	_, key, err := am.getDecryptedKey(a, passphrase)
+// SignEthereum calculates a ECDSA signature for the given hash.
+// The signature has the format as described in the Ethereum yellow paper.
+func (am *Manager) SignEthereum(addr common.Address, hash []byte) ([]byte, error) {
+	am.mu.RLock()
+	defer am.mu.RUnlock()
+	unlockedKey, found := am.unlocked[addr]
+	if !found {
+		return nil, ErrLocked
+	}
+	return crypto.SignEthereum(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)
+	return crypto.SignEthereum(hash, key.PrivateKey)
 }

 // Unlock unlocks the given account indefinitely.
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@ -95,7 +95,7 @@ func TestSignWithPassphrase(t *testing.T) {
 		t.Fatal("expected account to be locked")
 	}

-	_, err = am.SignWithPassphrase(acc, pass, testSigData)
+	_, err = am.SignWithPassphrase(acc.Address, pass, testSigData)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -104,7 +104,7 @@ func TestSignWithPassphrase(t *testing.T) {
 		t.Fatal("expected account to be locked")
 	}

-	if _, err = am.SignWithPassphrase(acc, "invalid passwd", testSigData); err == nil {
+	if _, err = am.SignWithPassphrase(acc.Address, "invalid passwd", testSigData); err == nil {
 		t.Fatal("expected SignHash to fail with invalid password")
 	}
 }
@ -115,9 +115,6 @@ func TestTimedUnlock(t *testing.T) {

 	pass := "foo"
 	a1, err := am.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}

 	// Signing without passphrase fails because account is locked
 	_, err = am.Sign(a1.Address, testSigData)
@ -150,9 +147,6 @@ func TestOverrideUnlock(t *testing.T) {

 	pass := "foo"
 	a1, err := am.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}

 	// Unlock indefinitely.
 	if err = am.TimedUnlock(a1, pass, 5*time.Minute); err != nil {
--- a/accounts/addrcache.go
+++ b/accounts/addrcache.go
@ -225,7 +225,7 @@ func (ac *addrCache) scan() ([]Account, error) {
 		buf     = new(bufio.Reader)
 		addrs   []Account
 		keyJSON struct {
-			Address string `json:"address"`
+			Address common.Address `json:"address"`
 		}
 	)
 	for _, fi := range files {
@ -241,16 +241,15 @@ func (ac *addrCache) scan() ([]Account, error) {
 		}
 		buf.Reset(fd)
 		// Parse the address.
-		keyJSON.Address = ""
+		keyJSON.Address = common.Address{}
 		err = json.NewDecoder(buf).Decode(&keyJSON)
-		addr := common.HexToAddress(keyJSON.Address)
 		switch {
 		case err != nil:
 			glog.V(logger.Debug).Infof("can't decode key %s: %v", path, err)
-		case (addr == common.Address{}):
+		case (keyJSON.Address == common.Address{}):
 			glog.V(logger.Debug).Infof("can't decode key %s: missing or zero address", path)
 		default:
-			addrs = append(addrs, Account{Address: addr, File: path})
+			addrs = append(addrs, Account{Address: keyJSON.Address, File: path})
 		}
 		fd.Close()
 	}
--- a/accounts/presale.go
+++ b/accounts/presale.go
@ -22,7 +22,6 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
-	"errors"
 	"fmt"

 	"github.com/ethereum/go-ethereum/crypto"
@ -54,9 +53,6 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error
 		return nil, err
 	}
 	encSeedBytes, err := hex.DecodeString(preSaleKeyStruct.EncSeed)
-	if err != nil {
-		return nil, errors.New("invalid hex in encSeed")
-	}
 	iv := encSeedBytes[:16]
 	cipherText := encSeedBytes[16:]
 	/*
--- a/accounts/watch.go
+++ b/accounts/watch.go
@ -14,7 +14,7 @@
 // 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/>.

-// +build darwin,!ios freebsd linux,!arm64 netbsd solaris
+// +build darwin,!ios freebsd linux,!arm64 netbsd solaris windows

 package accounts

--- a/accounts/watch_fallback.go
+++ b/accounts/watch_fallback.go
@ -14,7 +14,7 @@
 // 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/>.

-// +build ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris
+// +build ios linux,arm64 !darwin,!freebsd,!linux,!netbsd,!solaris,!windows

 // This is the fallback implementation of directory watching.
 // It is used on unsupported platforms.
--- a/appveyor.yml
+++ b/appveyor.yml
@ -22,18 +22,19 @@ environment:

 install:
  - rmdir C:\go /s /q
-  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.7.4.windows-%GETH_ARCH%.zip
-  - 7z x go1.7.4.windows-%GETH_ARCH%.zip -y -oC:\ > NUL
+  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.7.3.windows-amd64.zip
+  - 7z x go1.7.3.windows-amd64.zip -y -oC:\ > NUL
  - go version
  - gcc --version

 build_script:
-  - go run build\ci.go install
+  - go run build\ci.go install -arch %GETH_ARCH%

 after_build:
-  - go run build\ci.go archive -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
-  - go run build\ci.go nsis -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
+  - go run build\ci.go archive -arch %GETH_ARCH% -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
+  - go run build\ci.go nsis -arch %GETH_ARCH% -signer WINDOWS_SIGNING_KEY -upload gethstore/builds

 test_script:
+  - set GOARCH=%GETH_ARCH%
  - set CGO_ENABLED=1
  - go run build\ci.go test -vet -coverage
--- a/build/ci.go
+++ b/build/ci.go
@ -24,13 +24,13 @@ Usage: go run ci.go <command> <command flags/arguments>
 Available commands are:

   install    [-arch architecture] [ packages... ]                                           -- builds packages and executables
-   test       [ -coverage ] [ -vet ] [ -misspell ] [ packages... ]                           -- runs the tests
+   test       [ -coverage ] [ -vet ] [ packages... ]                                         -- runs the tests
   archive    [-arch architecture] [ -type zip|tar ] [ -signer key-envvar ] [ -upload dest ] -- archives build artefacts
   importkeys                                                                                -- imports signing keys from env
   debsrc     [ -signer key-id ] [ -upload dest ]                                            -- creates a debian source package
   nsis                                                                                      -- creates a Windows NSIS installer
-   aar        [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ]                    -- creates an Android archive
-   xcode      [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ]                    -- creates an iOS XCode framework
+   aar        [ -sign key-id ] [-deploy repo] [ -upload dest ]                               -- creates an Android archive
+   xcode      [ -sign key-id ] [-deploy repo] [ -upload dest ]                               -- creates an iOS XCode framework
   xgo        [ options ]                                                                    -- cross builds according to options

 For all commands, -n prevents execution of external programs (dry run mode).
@ -72,7 +72,6 @@ var (
 		executablePath("abigen"),
 		executablePath("evm"),
 		executablePath("geth"),
-		executablePath("swarm"),
 		executablePath("rlpdump"),
 	}

@ -90,10 +89,6 @@ var (
 			Name:        "evm",
 			Description: "Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode.",
 		},
-		{
-			Name:        "swarm",
-			Description: "Ethereum Swarm daemon and tools",
-		},
 		{
 			Name:        "abigen",
 			Description: "Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages.",
@ -102,8 +97,7 @@ var (

 	// Distros for which packages are created.
 	// Note: vivid is unsupported because there is no golang-1.6 package for it.
-	// Note: wily is unsupported because it was officially deprecated on lanchpad.
-	debDistros = []string{"trusty", "xenial", "yakkety"}
+	debDistros = []string{"trusty", "wily", "xenial", "yakkety"}
 )

 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@ -195,7 +189,7 @@ func doInstall(cmdline []string) {
 			if err != nil {
 				log.Fatal(err)
 			}
-			for name := range pkgs {
+			for name, _ := range pkgs {
 				if name == "main" {
 					gobuild := goToolArch(*arch, "build", buildFlags(env)...)
 					gobuild.Args = append(gobuild.Args, "-v")
@ -262,7 +256,6 @@ func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd {
 func doTest(cmdline []string) {
 	var (
 		vet      = flag.Bool("vet", false, "Whether to run go vet")
-		misspell = flag.Bool("misspell", false, "Whether to run the spell checker")
 		coverage = flag.Bool("coverage", false, "Whether to record code coverage")
 	)
 	flag.CommandLine.Parse(cmdline)
@ -288,9 +281,7 @@ func doTest(cmdline []string) {
 	if *vet {
 		build.MustRun(goTool("vet", packages...))
 	}
-	if *misspell {
-		spellcheck(packages)
-	}
+
 	// Run the actual tests.
 	gotest := goTool("test")
 	// Test a single package at a time. CI builders are slow
@ -303,34 +294,6 @@ func doTest(cmdline []string) {
 	build.MustRun(gotest)
 }

-// spellcheck runs the client9/misspell spellchecker package on all Go, Cgo and
-// test files in the requested packages.
-func spellcheck(packages []string) {
-	// Ensure the spellchecker is available
-	build.MustRun(goTool("get", "github.com/client9/misspell/cmd/misspell"))
-
-	// Windows chokes on long argument lists, check packages individualy
-	for _, pkg := range packages {
-		// The spell checker doesn't work on packages, gather all .go files for it
-		out, err := goTool("list", "-f", "{{.Dir}}{{range .GoFiles}}\n{{.}}{{end}}{{range .CgoFiles}}\n{{.}}{{end}}{{range .TestGoFiles}}\n{{.}}{{end}}", pkg).CombinedOutput()
-		if err != nil {
-			log.Fatalf("source file listing failed: %v\n%s", err, string(out))
-		}
-		// Retrieve the folder and assemble the source list
-		lines := strings.Split(string(out), "\n")
-		root := lines[0]
-
-		sources := make([]string, 0, len(lines)-1)
-		for _, line := range lines[1:] {
-			if line = strings.TrimSpace(line); line != "" {
-				sources = append(sources, filepath.Join(root, line))
-			}
-		}
-		// Run the spell checker for this particular package
-		build.MustRunCommand(filepath.Join(GOBIN, "misspell"), append([]string{"-error"}, sources...)...)
-	}
-}
-
 // Release Packaging

 func doArchive(cmdline []string) {
@ -496,7 +459,7 @@ func makeWorkdir(wdflag string) string {
 }

 func isUnstableBuild(env build.Environment) bool {
-	if env.Tag != "" {
+	if env.Branch != "master" && env.Tag != "" {
 		return false
 	}
 	return true
@ -660,7 +623,6 @@ func doWindowsInstaller(cmdline []string) {
 	build.Render("build/nsis.geth.nsi", filepath.Join(*workdir, "geth.nsi"), 0644, nil)
 	build.Render("build/nsis.install.nsh", filepath.Join(*workdir, "install.nsh"), 0644, templateData)
 	build.Render("build/nsis.uninstall.nsh", filepath.Join(*workdir, "uninstall.nsh"), 0644, allTools)
-	build.Render("build/nsis.pathupdate.nsh", filepath.Join(*workdir, "PathUpdate.nsh"), 0644, nil)
 	build.Render("build/nsis.envvarupdate.nsh", filepath.Join(*workdir, "EnvVarUpdate.nsh"), 0644, nil)
 	build.CopyFile(filepath.Join(*workdir, "SimpleFC.dll"), "build/nsis.simplefc.dll", 0755)
 	build.CopyFile(filepath.Join(*workdir, "COPYING"), "COPYING", 0755)
@ -692,7 +654,6 @@ func doWindowsInstaller(cmdline []string) {

 func doAndroidArchive(cmdline []string) {
 	var (
-		local  = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`)
 		signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. ANDROID_SIGNING_KEY)`)
 		deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "https://oss.sonatype.org")`)
 		upload = flag.String("upload", "", `Destination to upload the archive (usually "gethstore/builds")`)
@ -705,11 +666,6 @@ func doAndroidArchive(cmdline []string) {
 	build.MustRun(gomobileTool("init"))
 	build.MustRun(gomobileTool("bind", "--target", "android", "--javapkg", "org.ethereum", "-v", "github.com/ethereum/go-ethereum/mobile"))

-	if *local {
-		// If we're building locally, copy bundle to build dir and skip Maven
-		os.Rename("geth.aar", filepath.Join(GOBIN, "geth.aar"))
-		return
-	}
 	meta := newMavenMetadata(env)
 	build.Render("build/mvn.pom", meta.Package+".pom", 0755, meta)

@ -788,7 +744,7 @@ func newMavenMetadata(env build.Environment) mavenMetadata {
 				continue
 			}
 			// Split the author and insert as a contributor
-			re := regexp.MustCompile("([^<]+) <(.+)>")
+			re := regexp.MustCompile("([^<]+) <(.+>)")
 			parts := re.FindStringSubmatch(line)
 			if len(parts) == 3 {
 				contribs = append(contribs, mavenContributor{Name: parts[1], Email: parts[2]})
@ -812,7 +768,6 @@ func newMavenMetadata(env build.Environment) mavenMetadata {

 func doXCodeFramework(cmdline []string) {
 	var (
-		local  = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`)
 		signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. IOS_SIGNING_KEY)`)
 		deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "trunk")`)
 		upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`)
@ -823,18 +778,12 @@ func doXCodeFramework(cmdline []string) {
 	// Build the iOS XCode framework
 	build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile"))
 	build.MustRun(gomobileTool("init"))
-	bind := gomobileTool("bind", "--target", "ios", "--tags", "ios", "-v", "github.com/ethereum/go-ethereum/mobile")

-	if *local {
-		// If we're building locally, use the build folder and stop afterwards
-		bind.Dir, _ = filepath.Abs(GOBIN)
-		build.MustRun(bind)
-		return
-	}
 	archive := "geth-" + archiveBasename("ios", env)
 	if err := os.Mkdir(archive, os.ModePerm); err != nil {
 		log.Fatal(err)
 	}
+	bind := gomobileTool("bind", "--target", "ios", "--tags", "ios", "--prefix", "GE", "-v", "github.com/ethereum/go-ethereum/mobile")
 	bind.Dir, _ = filepath.Abs(archive)
 	build.MustRun(bind)
 	build.MustRunCommand("tar", "-zcvf", archive+".tar.gz", archive)
@ -848,16 +797,16 @@ func doXCodeFramework(cmdline []string) {
 	}
 	// Prepare and upload a PodSpec to CocoaPods
 	if *deploy != "" {
-		meta := newPodMetadata(env, archive)
-		build.Render("build/pod.podspec", "Geth.podspec", 0755, meta)
-		build.MustRunCommand("pod", *deploy, "push", "Geth.podspec", "--allow-warnings", "--verbose")
+		meta := newPodMetadata(env)
+		build.Render("build/pod.podspec", meta.Name+".podspec", 0755, meta)
+		build.MustRunCommand("pod", *deploy, "push", meta.Name+".podspec", "--allow-warnings")
 	}
 }

 type podMetadata struct {
+	Name         string
 	Version      string
 	Commit       string
-	Archive      string
 	Contributors []podContributor
 }

@ -866,7 +815,7 @@ type podContributor struct {
 	Email string
 }

-func newPodMetadata(env build.Environment, archive string) podMetadata {
+func newPodMetadata(env build.Environment) podMetadata {
 	// Collect the list of authors from the repo root
 	contribs := []podContributor{}
 	if authors, err := os.Open("AUTHORS"); err == nil {
@ -880,20 +829,20 @@ func newPodMetadata(env build.Environment, archive string) podMetadata {
 				continue
 			}
 			// Split the author and insert as a contributor
-			re := regexp.MustCompile("([^<]+) <(.+)>")
+			re := regexp.MustCompile("([^<]+) <(.+>)")
 			parts := re.FindStringSubmatch(line)
 			if len(parts) == 3 {
 				contribs = append(contribs, podContributor{Name: parts[1], Email: parts[2]})
 			}
 		}
 	}
-	version := build.VERSION()
+	name := "Geth"
 	if isUnstableBuild(env) {
-		version += "-unstable." + env.Buildnum
+		name += "Develop"
 	}
 	return podMetadata{
-		Archive:      archive,
-		Version:      version,
+		Name:         name,
+		Version:      archiveVersion(env),
 		Commit:       env.Commit,
 		Contributors: contribs,
 	}
--- a/build/nsis.geth.nsi
+++ b/build/nsis.geth.nsi
@ -17,12 +17,8 @@
 #
 # Requirements:
 # - NSIS, http://nsis.sourceforge.net/Main_Page
-# - NSIS Large Strings build, http://nsis.sourceforge.net/Special_Builds
 # - SFP, http://nsis.sourceforge.net/NSIS_Simple_Firewall_Plugin (put dll in NSIS\Plugins\x86-ansi)
 #
-# After intalling NSIS extra the NSIS Large Strings build zip and replace the makensis.exe and the
-# files found in Stub.
-#
 # based on: http://nsis.sourceforge.net/A_simple_installer_with_start_menu_shortcut_and_uninstaller
 #
 # TODO:
@ -41,7 +37,6 @@ RequestExecutionLevel admin
 SetCompressor /SOLID lzma

 !include LogicLib.nsh
-!include PathUpdate.nsh
 !include EnvVarUpdate.nsh

 !macro VerifyUserIsAdmin
--- a/build/nsis.install.nsh
+++ b/build/nsis.install.nsh
@ -37,9 +37,8 @@ Section "Geth" GETH_IDX
  ${EnvVarUpdate} $0 "ETHEREUM_SOCKET" "R" "HKLM" "\\.\pipe\geth.ipc"
  ${EnvVarUpdate} $0 "ETHEREUM_SOCKET" "A" "HKLM" "\\.\pipe\geth.ipc"

-  # Add instdir to PATH
-  Push "$INSTDIR"
-  Call AddToPath
+  # Add geth to PATH
+  ${EnvVarUpdate} $0 "PATH" "A" "HKLM" $INSTDIR
 SectionEnd

 # Install optional develop tools.
--- a/build/nsis.pathupdate.nsh
+++ b/build/nsis.pathupdate.nsh
@ -1,153 +0,0 @@
-!include "WinMessages.nsh"
-
-; see https://support.microsoft.com/en-us/kb/104011
-!define Environ 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
-; HKEY_LOCAL_MACHINE = 0x80000002
-
-; AddToPath - Appends dir to PATH
-;   (does not work on Win9x/ME)
-;
-; Usage:
-;   Push "dir"
-;   Call AddToPath
-Function AddToPath
-  Exch $0
-  Push $1
-  Push $2
-  Push $3
-  Push $4
-
-  ; NSIS ReadRegStr returns empty string on string overflow
-  ; Native calls are used here to check actual length of PATH
-  ; $4 = RegOpenKey(HKEY_LOCAL_MACHINE, "SYSTEM\CurrentControlSet\Control\Session Manager\Environment", &$3)
-  System::Call "advapi32::RegOpenKey(i 0x80000002, t'SYSTEM\CurrentControlSet\Control\Session Manager\Environment', *i.r3) i.r4"
-  IntCmp $4 0 0 done done
-
-  ; $4 = RegQueryValueEx($3, "PATH", (DWORD*)0, (DWORD*)0, &$1, ($2=NSIS_MAX_STRLEN, &$2))
-  ; RegCloseKey($3)
-  System::Call "advapi32::RegQueryValueEx(i $3, t'PATH', i 0, i 0, t.r1, *i ${NSIS_MAX_STRLEN} r2) i.r4"
-  System::Call "advapi32::RegCloseKey(i $3)"
-
-  IntCmp $4 234 0 +4 +4 ; $4 == ERROR_MORE_DATA
-    DetailPrint "AddToPath: original length $2 > ${NSIS_MAX_STRLEN}"
-    MessageBox MB_OK "PATH not updated, original length $2 > ${NSIS_MAX_STRLEN}"
-    Goto done
-
-  IntCmp $4 0 +5 ; $4 != NO_ERROR
-    IntCmp $4 2 +3 ; $4 != ERROR_FILE_NOT_FOUND
-      DetailPrint "AddToPath: unexpected error code $4"
-      Goto done
-    StrCpy $1 ""
-
-  ; Check if already in PATH
-  Push "$1;"
-  Push "$0;"
-  Call StrStr
-  Pop $2
-  StrCmp $2 "" 0 done
-  Push "$1;"
-  Push "$0\;"
-  Call StrStr
-  Pop $2
-  StrCmp $2 "" 0 done
-
-  ; Prevent NSIS string overflow
-  StrLen $2 $0
-  StrLen $3 $1
-  IntOp $2 $2 + $3
-  IntOp $2 $2 + 2 ; $2 = strlen(dir) + strlen(PATH) + sizeof(";")
-  IntCmp $2 ${NSIS_MAX_STRLEN} +4 +4 0
-    DetailPrint "AddToPath: new length $2 > ${NSIS_MAX_STRLEN}"
-    MessageBox MB_OK "PATH not updated, new length $2 > ${NSIS_MAX_STRLEN}."
-    Goto done
-
-  ; Append dir to PATH
-  DetailPrint "Add to PATH: $0"
-  StrCpy $2 $1 1 -1
-  StrCmp $2 ";" 0 +2
-    StrCpy $1 $1 -1 ; remove trailing ';'
-  StrCmp $1 "" +2   ; no leading ';'
-    StrCpy $0 "$1;$0"
-  
-  WriteRegExpandStr ${Environ} "PATH" $0
-  SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
-
-done:
-  Pop $4
-  Pop $3
-  Pop $2
-  Pop $1
-  Pop $0
-FunctionEnd
-
-
-; RemoveFromPath - Removes dir from PATH
-;
-; Usage:
-;   Push "dir"
-;   Call RemoveFromPath
-Function un.RemoveFromPath
-  Exch $0
-  Push $1
-  Push $2
-  Push $3
-  Push $4
-  Push $5
-  Push $6
-
-  ; NSIS ReadRegStr returns empty string on string overflow
-  ; Native calls are used here to check actual length of PATH
-  ; $4 = RegOpenKey(HKEY_LOCAL_MACHINE, "SYSTEM\CurrentControlSet\Control\Session Manager\Environment", &$3)
-  System::Call "advapi32::RegOpenKey(i 0x80000002, t'SYSTEM\CurrentControlSet\Control\Session Manager\Environment', *i.r3) i.r4"
-  IntCmp $4 0 0 done done
-
-  ; $4 = RegQueryValueEx($3, "PATH", (DWORD*)0, (DWORD*)0, &$1, ($2=NSIS_MAX_STRLEN, &$2))
-  ; RegCloseKey($3)
-  System::Call "advapi32::RegQueryValueEx(i $3, t'PATH', i 0, i 0, t.r1, *i ${NSIS_MAX_STRLEN} r2) i.r4"
-  System::Call "advapi32::RegCloseKey(i $3)"
-
-  IntCmp $4 234 0 +4 +4 ; $4 == ERROR_MORE_DATA
-    DetailPrint "RemoveFromPath: original length $2 > ${NSIS_MAX_STRLEN}"
-    MessageBox MB_OK "PATH not updated, original length $2 > ${NSIS_MAX_STRLEN}"
-    Goto done
-
-  IntCmp $4 0 +5 ; $4 != NO_ERROR
-    IntCmp $4 2 +3 ; $4 != ERROR_FILE_NOT_FOUND
-      DetailPrint "RemoveFromPath: unexpected error code $4"
-      Goto done
-    StrCpy $1 ""
-
-  ; length < ${NSIS_MAX_STRLEN} -> ReadRegStr can be used
-  ReadRegStr $1 ${Environ} "PATH"
-  StrCpy $5 $1 1 -1
-  StrCmp $5 ";" +2
-  StrCpy $1 "$1;" ; ensure trailing ';'
-  Push $1
-  Push "$0;"
-  Call un.StrStr
-  Pop $2 ; pos of our dir
-  StrCmp $2 "" done
-
-  DetailPrint "Remove from PATH: $0"
-  StrLen $3 "$0;"
-  StrLen $4 $2
-  StrCpy $5 $1 -$4 ; $5 is now the part before the path to remove
-  StrCpy $6 $2 "" $3 ; $6 is now the part after the path to remove
-  StrCpy $3 "$5$6"
-  StrCpy $5 $3 1 -1
-  StrCmp $5 ";" 0 +2
-    StrCpy $3 $3 -1 ; remove trailing ';'
-  WriteRegExpandStr ${Environ} "PATH" $3
-  SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
-
-done:
-  Pop $6
-  Pop $5
-  Pop $4
-  Pop $3
-  Pop $2
-  Pop $1
-  Pop $0
-FunctionEnd
- 
-
--- a/build/nsis.uninstall.nsh
+++ b/build/nsis.uninstall.nsh
@ -25,8 +25,7 @@ Section "Uninstall"
  ${un.EnvVarUpdate} $0 "ETHEREUM_SOCKET" "R" "HKLM" "\\.\pipe\geth.ipc"

  # Remove install directory from PATH
-  Push "$INSTDIR"
-  Call un.RemoveFromPath
+  ${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" $INSTDIR

  # Cleanup registry (deletes all sub keys)
  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}"
--- a/build/pod.podspec
+++ b/build/pod.podspec
@ -1,5 +1,5 @@
 Pod::Spec.new do |spec|
-  spec.name         = 'Geth'
+  spec.name         = '{{.Name}}'
  spec.version      = '{{.Version}}'
  spec.license      = { :type => 'GNU Lesser General Public License, Version 3.0' }
  spec.homepage     = 'https://github.com/ethereum/go-ethereum'
@ -14,9 +14,9 @@ Pod::Spec.new do |spec|
 	spec.ios.vendored_frameworks = 'Frameworks/Geth.framework'

 	spec.prepare_command = <<-CMD
-    curl https://gethstore.blob.core.windows.net/builds/{{.Archive}}.tar.gz | tar -xvz
+    curl https://gethstore.blob.core.windows.net/builds/geth-ios-all-{{.Version}}.tar.gz | tar -xvz
    mkdir Frameworks
-    mv {{.Archive}}/Geth.framework Frameworks
-    rm -rf {{.Archive}}
+    mv geth-ios-all-{{.Version}}/Geth.framework Frameworks
+    rm -rf geth-ios-all-{{.Version}}
  CMD
 end
--- a/build/update-license.go
+++ b/build/update-license.go
@ -185,7 +185,7 @@ func getFiles() []string {
 		files = append(files, line)
 	})
 	if err != nil {
-		log.Fatal("error getting files:", err)
+		log.Fatalf("error getting files:", err)
 	}
 	return files
 }
@ -294,7 +294,7 @@ func getInfo(files <-chan string, out chan<- *info, wg *sync.WaitGroup) {
 	wg.Done()
 }

-// fileInfo finds the lowest year in which the given file was committed.
+// fileInfo finds the lowest year in which the given file was commited.
 func fileInfo(file string) (*info, error) {
 	info := &info{file: file, Year: int64(time.Now().Year())}
 	cmd := exec.Command("git", "log", "--follow", "--find-renames=80", "--find-copies=80", "--pretty=format:%ai", "--", file)
--- a/cmd/bootnode/main.go
+++ b/cmd/bootnode/main.go
@ -29,7 +29,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/p2p/netutil"
 )

 func main() {
@ -40,7 +39,6 @@ func main() {
 		nodeKeyFile = flag.String("nodekey", "", "private key filename")
 		nodeKeyHex  = flag.String("nodekeyhex", "", "private key as hex (for testing)")
 		natdesc     = flag.String("nat", "none", "port mapping mechanism (any|none|upnp|pmp|extip:<IP>)")
-		netrestrict = flag.String("netrestrict", "", "restrict network communication to the given IP networks (CIDR masks)")
 		runv5       = flag.Bool("v5", false, "run a v5 topic discovery bootnode")

 		nodeKey *ecdsa.PrivateKey
@ -83,20 +81,12 @@ func main() {
 		os.Exit(0)
 	}

-	var restrictList *netutil.Netlist
-	if *netrestrict != "" {
-		restrictList, err = netutil.ParseNetlist(*netrestrict)
-		if err != nil {
-			utils.Fatalf("-netrestrict: %v", err)
-		}
-	}
-
 	if *runv5 {
-		if _, err := discv5.ListenUDP(nodeKey, *listenAddr, natm, "", restrictList); err != nil {
+		if _, err := discv5.ListenUDP(nodeKey, *listenAddr, natm, ""); err != nil {
 			utils.Fatalf("%v", err)
 		}
 	} else {
-		if _, err := discover.ListenUDP(nodeKey, *listenAddr, natm, "", restrictList); err != nil {
+		if _, err := discover.ListenUDP(nodeKey, *listenAddr, natm, ""); err != nil {
 			utils.Fatalf("%v", err)
 		}
 	}
--- a/cmd/swarm/main.go
+++ b/cmd/swarm/main.go
@ -23,7 +23,6 @@ import (
 	"os"
 	"runtime"
 	"strconv"
-	"strings"

 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/cmd/utils"
@ -39,25 +38,14 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/swarm"
 	bzzapi "github.com/ethereum/go-ethereum/swarm/api"
-	"github.com/ethereum/go-ethereum/swarm/network"
 	"gopkg.in/urfave/cli.v1"
 )

-const (
-	clientIdentifier = "swarm"
-	versionString    = "0.2"
-)
+const clientIdentifier = "bzzd"

 var (
-	gitCommit        string // Git SHA1 commit hash of the release (set via linker flags)
-	app              = utils.NewApp(gitCommit, "Ethereum Swarm")
-	testbetBootNodes = []string{
-		"enode://ec8ae764f7cb0417bdfb009b9d0f18ab3818a3a4e8e7c67dd5f18971a93510a2e6f43cd0b69a27e439a9629457ea804104f37c85e41eed057d3faabbf7744cdf@13.74.157.139:30429",
-		"enode://c2e1fceb3bf3be19dff71eec6cccf19f2dbf7567ee017d130240c670be8594bc9163353ca55dd8df7a4f161dd94b36d0615c17418b5a3cdcbb4e9d99dfa4de37@13.74.157.139:30430",
-		"enode://fe29b82319b734ce1ec68b84657d57145fee237387e63273989d354486731e59f78858e452ef800a020559da22dcca759536e6aa5517c53930d29ce0b1029286@13.74.157.139:30431",
-		"enode://1d7187e7bde45cf0bee489ce9852dd6d1a0d9aa67a33a6b8e6db8a4fbc6fcfa6f0f1a5419343671521b863b187d1c73bad3603bae66421d157ffef357669ddb8@13.74.157.139:30432",
-		"enode://0e4cba800f7b1ee73673afa6a4acead4018f0149d2e3216be3f133318fd165b324cd71b81fbe1e80deac8dbf56e57a49db7be67f8b9bc81bd2b7ee496434fb5d@13.74.157.139:30433",
-	}
+	gitCommit string // Git SHA1 commit hash of the release (set via linker flags)
+	app       = utils.NewApp(gitCommit, "Ethereum Swarm server daemon")
 )

 var (
@ -73,122 +61,56 @@ var (
 		Name:  "bzzport",
 		Usage: "Swarm local http api port",
 	}
-	SwarmNetworkIdFlag = cli.IntFlag{
-		Name:  "bzznetworkid",
-		Usage: "Network identifier (integer, default 3=swarm testnet)",
-		Value: network.NetworkId,
-	}
 	SwarmConfigPathFlag = cli.StringFlag{
 		Name:  "bzzconfig",
 		Usage: "Swarm config file path (datadir/bzz)",
 	}
-	SwarmSwapEnabledFlag = cli.BoolFlag{
-		Name:  "swap",
-		Usage: "Swarm SWAP enabled (default false)",
+	SwarmSwapDisabled = cli.BoolFlag{
+		Name:  "bzznoswap",
+		Usage: "Swarm SWAP disabled (default false)",
 	}
-	SwarmSyncEnabledFlag = cli.BoolTFlag{
-		Name:  "sync",
-		Usage: "Swarm Syncing enabled (default true)",
+	SwarmSyncDisabled = cli.BoolFlag{
+		Name:  "bzznosync",
+		Usage: "Swarm Syncing disabled (default false)",
 	}
-	EthAPIFlag = cli.StringFlag{
+	EthAPI = cli.StringFlag{
 		Name:  "ethapi",
 		Usage: "URL of the Ethereum API provider",
 		Value: node.DefaultIPCEndpoint("geth"),
 	}
-	SwarmApiFlag = cli.StringFlag{
-		Name:  "bzzapi",
-		Usage: "Swarm HTTP endpoint",
-		Value: "http://127.0.0.1:8500",
-	}
-	SwarmRecursiveUploadFlag = cli.BoolFlag{
-		Name:  "recursive",
-		Usage: "Upload directories recursively",
-	}
-	SwarmWantManifestFlag = cli.BoolTFlag{
-		Name:  "manifest",
-		Usage: "Automatic manifest upload",
-	}
-	SwarmUploadDefaultPath = cli.StringFlag{
-		Name:  "defaultpath",
-		Usage: "path to file served for empty url path (none)",
-	}
-	CorsStringFlag = cli.StringFlag{
-		Name:  "corsdomain",
-		Usage: "Domain on which to send Access-Control-Allow-Origin header (multiple domains can be supplied separated by a ',')",
-	}
 )

+var defaultBootnodes = []string{}
+
 func init() {
 	// Override flag defaults so bzzd can run alongside geth.
 	utils.ListenPortFlag.Value = 30399
 	utils.IPCPathFlag.Value = utils.DirectoryString{Value: "bzzd.ipc"}
-	utils.IPCApiFlag.Value = "admin, bzz, chequebook, debug, rpc, web3"

 	// Set up the cli app.
+	app.Commands = nil
 	app.Action = bzzd
-	app.HideVersion = true // we have a command to print the version
-	app.Copyright = "Copyright 2013-2016 The go-ethereum Authors"
-	app.Commands = []cli.Command{
-		{
-			Action:    version,
-			Name:      "version",
-			Usage:     "Print version numbers",
-			ArgsUsage: " ",
-			Description: `
-The output of this command is supposed to be machine-readable.
-`,
-		},
-		{
-			Action:    upload,
-			Name:      "up",
-			Usage:     "upload a file or directory to swarm using the HTTP API",
-			ArgsUsage: " <file>",
-			Description: `
-"upload a file or directory to swarm using the HTTP API and prints the root hash",
-`,
-		},
-		{
-			Action:    hash,
-			Name:      "hash",
-			Usage:     "print the swarm hash of a file or directory",
-			ArgsUsage: " <file>",
-			Description: `
-Prints the swarm hash of file or directory.
-`,
-		},
-	}
-
 	app.Flags = []cli.Flag{
 		utils.IdentityFlag,
 		utils.DataDirFlag,
 		utils.BootnodesFlag,
 		utils.KeyStoreDirFlag,
 		utils.ListenPortFlag,
-		utils.NoDiscoverFlag,
-		utils.DiscoveryV5Flag,
-		utils.NetrestrictFlag,
-		utils.NodeKeyFileFlag,
-		utils.NodeKeyHexFlag,
 		utils.MaxPeersFlag,
 		utils.NATFlag,
+		utils.NodeKeyFileFlag,
+		utils.NodeKeyHexFlag,
 		utils.IPCDisabledFlag,
 		utils.IPCApiFlag,
 		utils.IPCPathFlag,
 		// bzzd-specific flags
-		CorsStringFlag,
-		EthAPIFlag,
+		EthAPI,
 		SwarmConfigPathFlag,
-		SwarmSwapEnabledFlag,
-		SwarmSyncEnabledFlag,
+		SwarmSwapDisabled,
+		SwarmSyncDisabled,
 		SwarmPortFlag,
 		SwarmAccountFlag,
-		SwarmNetworkIdFlag,
 		ChequebookAddrFlag,
-		// upload flags
-		SwarmApiFlag,
-		SwarmRecursiveUploadFlag,
-		SwarmWantManifestFlag,
-		SwarmUploadDefaultPath,
 	}
 	app.Flags = append(app.Flags, debug.Flags...)
 	app.Before = func(ctx *cli.Context) error {
@ -208,33 +130,16 @@ func main() {
 	}
 }

-func version(ctx *cli.Context) error {
-	fmt.Println(strings.Title(clientIdentifier))
-	fmt.Println("Version:", versionString)
-	if gitCommit != "" {
-		fmt.Println("Git Commit:", gitCommit)
-	}
-	fmt.Println("Network Id:", ctx.GlobalInt(utils.NetworkIdFlag.Name))
-	fmt.Println("Go Version:", runtime.Version())
-	fmt.Println("OS:", runtime.GOOS)
-	fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
-	fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
-	return nil
-}
-
 func bzzd(ctx *cli.Context) error {
 	stack := utils.MakeNode(ctx, clientIdentifier, gitCommit)
 	registerBzzService(ctx, stack)
 	utils.StartNode(stack)
-	networkId := ctx.GlobalUint64(SwarmNetworkIdFlag.Name)
+
 	// Add bootnodes as initial peers.
 	if ctx.GlobalIsSet(utils.BootnodesFlag.Name) {
-		bootnodes := strings.Split(ctx.GlobalString(utils.BootnodesFlag.Name), ",")
-		injectBootnodes(stack.Server(), bootnodes)
+		injectBootnodes(stack.Server(), ctx.GlobalStringSlice(utils.BootnodesFlag.Name))
 	} else {
-		if networkId == 3 {
-			injectBootnodes(stack.Server(), testbetBootNodes)
-		}
+		injectBootnodes(stack.Server(), defaultBootnodes)
 	}

 	stack.Wait()
@ -249,7 +154,7 @@ func registerBzzService(ctx *cli.Context, stack *node.Node) {
 	if bzzdir == "" {
 		bzzdir = stack.InstanceDir()
 	}
-	bzzconfig, err := bzzapi.NewConfig(bzzdir, chbookaddr, prvkey, ctx.GlobalUint64(SwarmNetworkIdFlag.Name))
+	bzzconfig, err := bzzapi.NewConfig(bzzdir, chbookaddr, prvkey)
 	if err != nil {
 		utils.Fatalf("unable to configure swarm: %v", err)
 	}
@ -257,21 +162,20 @@ func registerBzzService(ctx *cli.Context, stack *node.Node) {
 	if len(bzzport) > 0 {
 		bzzconfig.Port = bzzport
 	}
-	swapEnabled := ctx.GlobalBool(SwarmSwapEnabledFlag.Name)
-	syncEnabled := ctx.GlobalBoolT(SwarmSyncEnabledFlag.Name)
+	swapEnabled := !ctx.GlobalBool(SwarmSwapDisabled.Name)
+	syncEnabled := !ctx.GlobalBool(SwarmSyncDisabled.Name)

-	ethapi := ctx.GlobalString(EthAPIFlag.Name)
-	cors := ctx.GlobalString(CorsStringFlag.Name)
+	ethapi := ctx.GlobalString(EthAPI.Name)
+	if ethapi == "" {
+		utils.Fatalf("Option %q must not be empty", EthAPI.Name)
+	}

 	boot := func(ctx *node.ServiceContext) (node.Service, error) {
-		var client *ethclient.Client
-		if len(ethapi) > 0 {
-			client, err = ethclient.Dial(ethapi)
-			if err != nil {
-				utils.Fatalf("Can't connect: %v", err)
-			}
+		client, err := ethclient.Dial(ethapi)
+		if err != nil {
+			utils.Fatalf("Can't connect: %v", err)
 		}
-		return swarm.NewSwarm(ctx, client, bzzconfig, swapEnabled, syncEnabled, cors)
+		return swarm.NewSwarm(ctx, client, bzzconfig, swapEnabled, syncEnabled)
 	}
 	if err := stack.Register(boot); err != nil {
 		utils.Fatalf("Failed to register the Swarm service: %v", err)
@ -336,7 +240,6 @@ func injectBootnodes(srv *p2p.Server, nodes []string) {
 		n, err := discover.ParseNode(url)
 		if err != nil {
 			glog.Errorf("invalid bootnode %q", err)
-			continue
 		}
 		srv.AddPeer(n)
 	}
--- a/cmd/bzzhash/main.go
+++ b/cmd/bzzhash/main.go
@ -19,21 +19,22 @@ package main

 import (
 	"fmt"
-	"log"
 	"os"
+	"runtime"

 	"github.com/ethereum/go-ethereum/swarm/storage"
-	"gopkg.in/urfave/cli.v1"
 )

-func hash(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) < 1 {
-		log.Fatal("Usage: swarm hash <file name>")
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	if len(os.Args) < 2 {
+		fmt.Println("Usage: bzzhash <file name>")
+		os.Exit(0)
 	}
-	f, err := os.Open(args[0])
+	f, err := os.Open(os.Args[1])
 	if err != nil {
-		fmt.Println("Error opening file " + args[1])
+		fmt.Println("Error opening file " + os.Args[1])
 		os.Exit(1)
 	}

@ -41,7 +42,7 @@ func hash(ctx *cli.Context) {
 	chunker := storage.NewTreeChunker(storage.NewChunkerParams())
 	key, err := chunker.Split(f, stat.Size(), nil, nil, nil)
 	if err != nil {
-		log.Fatalf("%v\n", err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 	} else {
 		fmt.Printf("%v\n", key)
 	}
--- a/cmd/bzzup/main.go
+++ b/cmd/bzzup/main.go
@ -0,0 +1,161 @@
+// 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/>.
+
+// Command bzzup uploads files to the swarm HTTP API.
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"mime"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func main() {
+	var (
+		bzzapiFlag    = flag.String("bzzapi", "http://127.0.0.1:8500", "Swarm HTTP endpoint")
+		recursiveFlag = flag.Bool("recursive", false, "Upload directories recursively")
+		manifestFlag  = flag.Bool("manifest", true, "Skip automatic manifest upload")
+	)
+	log.SetOutput(os.Stderr)
+	log.SetFlags(0)
+	flag.Parse()
+	if flag.NArg() != 1 {
+		log.Fatal("need filename as the first and only argument")
+	}
+
+	var (
+		file   = flag.Arg(0)
+		client = &client{api: *bzzapiFlag}
+		mroot  manifest
+	)
+	fi, err := os.Stat(file)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if fi.IsDir() {
+		if !*recursiveFlag {
+			log.Fatal("argument is a directory and recursive upload is disabled")
+		}
+		mroot, err = client.uploadDirectory(file)
+	} else {
+		mroot, err = client.uploadFile(file, fi)
+		if *manifestFlag {
+			// Wrap the raw file entry in a proper manifest so both hashes get printed.
+			mroot = manifest{Entries: []manifest{mroot}}
+		}
+	}
+	if err != nil {
+		log.Fatalln("upload failed:", err)
+	}
+	if *manifestFlag {
+		hash, err := client.uploadManifest(mroot)
+		if err != nil {
+			log.Fatalln("manifest upload failed:", err)
+		}
+		mroot.Hash = hash
+	}
+
+	// Print the manifest. This is the only output to stdout.
+	mrootJSON, _ := json.MarshalIndent(mroot, "", "  ")
+	fmt.Println(string(mrootJSON))
+}
+
+// client wraps interaction with the swarm HTTP gateway.
+type client struct {
+	api string
+}
+
+// manifest is the JSON representation of a swarm manifest.
+type manifest struct {
+	Hash        string     `json:"hash,omitempty"`
+	ContentType string     `json:"contentType,omitempty"`
+	Path        string     `json:"path,omitempty"`
+	Entries     []manifest `json:"entries,omitempty"`
+}
+
+func (c *client) uploadFile(file string, fi os.FileInfo) (manifest, error) {
+	hash, err := c.uploadFileContent(file, fi)
+	m := manifest{
+		Hash:        hash,
+		ContentType: mime.TypeByExtension(filepath.Ext(fi.Name())),
+	}
+	return m, err
+}
+
+func (c *client) uploadDirectory(dir string) (manifest, error) {
+	dirm := manifest{}
+	prefix := filepath.ToSlash(dir) + "/"
+	err := filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
+		if err != nil || fi.IsDir() {
+			return err
+		}
+		if !strings.HasPrefix(path, dir) {
+			return fmt.Errorf("path %s outside directory %s", path, dir)
+		}
+		entry, err := c.uploadFile(path, fi)
+		entry.Path = strings.TrimPrefix(filepath.ToSlash(path), prefix)
+		dirm.Entries = append(dirm.Entries, entry)
+		return err
+	})
+	return dirm, err
+}
+
+func (c *client) uploadFileContent(file string, fi os.FileInfo) (string, error) {
+	fd, err := os.Open(file)
+	if err != nil {
+		return "", err
+	}
+	defer fd.Close()
+	log.Printf("uploading file %s (%d bytes)", file, fi.Size())
+	return c.postRaw("application/octet-stream", fi.Size(), fd)
+}
+
+func (c *client) uploadManifest(m manifest) (string, error) {
+	jsm, err := json.Marshal(m)
+	if err != nil {
+		panic(err)
+	}
+	log.Println("uploading manifest")
+	return c.postRaw("application/json", int64(len(jsm)), ioutil.NopCloser(bytes.NewReader(jsm)))
+}
+
+func (c *client) postRaw(mimetype string, size int64, body io.ReadCloser) (string, error) {
+	req, err := http.NewRequest("POST", c.api+"/bzzr:/", body)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("content-type", mimetype)
+	req.ContentLength = size
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 400 {
+		return "", fmt.Errorf("bad status: %s", resp.Status)
+	}
+	content, err := ioutil.ReadAll(resp.Body)
+	return string(content), err
+}
--- a/cmd/disasm/main.go
+++ b/cmd/disasm/main.go
@ -18,12 +18,11 @@
 package main

 import (
-	"encoding/hex"
 	"fmt"
 	"io/ioutil"
 	"os"
-	"strings"

+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/vm"
 )

@ -33,28 +32,20 @@ func main() {
 		fmt.Println(err)
 		os.Exit(1)
 	}
-	code, err = hex.DecodeString(strings.TrimSpace(string(code[:])))
-	if err != nil {
-		fmt.Printf("Error: %v\n", err)
-		return
-	}
+	code = common.Hex2Bytes(string(code[:len(code)-1]))
 	fmt.Printf("%x\n", code)

 	for pc := uint64(0); pc < uint64(len(code)); pc++ {
 		op := vm.OpCode(code[pc])
+		fmt.Printf("%-5d  %v", pc, op)

 		switch op {
 		case vm.PUSH1, vm.PUSH2, vm.PUSH3, vm.PUSH4, vm.PUSH5, vm.PUSH6, vm.PUSH7, vm.PUSH8, vm.PUSH9, vm.PUSH10, vm.PUSH11, vm.PUSH12, vm.PUSH13, vm.PUSH14, vm.PUSH15, vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32:
 			a := uint64(op) - uint64(vm.PUSH1) + 1
-			u := pc + 1 + a
-			if uint64(len(code)) <= pc || uint64(len(code)) < u {
-				fmt.Printf("Error: incomplete push instruction at %v\n", pc)
-				return
-			}
-			fmt.Printf("%-5d  %v  => %x\n", pc, op, code[pc+1:u])
+			fmt.Printf("  => %x", code[pc+1:pc+1+a])
+
 			pc += a
-		default:
-			fmt.Printf("%-5d  %v\n", pc, op)
 		}
+		fmt.Println()
 	}
 }
--- a/cmd/ethtest/main.go
+++ b/cmd/ethtest/main.go
@ -88,7 +88,12 @@ func runTestWithReader(test string, r io.Reader) error {
 	default:
 		err = fmt.Errorf("Invalid test type specified: %v", test)
 	}
-	return err
+
+	if err != nil {
+		return err
+	}
+
+	return nil
 }

 func getFiles(path string) ([]string, error) {
--- a/cmd/evm/main.go
+++ b/cmd/evm/main.go
@ -20,18 +20,21 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
+	"math/big"
 	"os"
-	goruntime "runtime"
+	"runtime"
 	"time"

 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
+	"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/core/vm"
-	"github.com/ethereum/go-ethereum/core/vm/runtime"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/params"
 	"gopkg.in/urfave/cli.v1"
 )

@ -44,6 +47,14 @@ var (
 		Name:  "debug",
 		Usage: "output full trace logs",
 	}
+	ForceJitFlag = cli.BoolFlag{
+		Name:  "forcejit",
+		Usage: "forces jit compilation",
+	}
+	DisableJitFlag = cli.BoolFlag{
+		Name:  "nojit",
+		Usage: "disabled jit compilation",
+	}
 	CodeFlag = cli.StringFlag{
 		Name:  "code",
 		Usage: "EVM code",
@ -87,10 +98,6 @@ var (
 		Name:  "create",
 		Usage: "indicates the action should be create rather than call",
 	}
-	DisableGasMeteringFlag = cli.BoolFlag{
-		Name:  "nogasmetering",
-		Usage: "disable gas metering",
-	}
 )

 func init() {
@ -98,6 +105,8 @@ func init() {
 		CreateFlag,
 		DebugFlag,
 		VerbosityFlag,
+		ForceJitFlag,
+		DisableJitFlag,
 		SysStatFlag,
 		CodeFlag,
 		CodeFileFlag,
@ -106,7 +115,6 @@ func init() {
 		ValueFlag,
 		DumpFlag,
 		InputFlag,
-		DisableGasMeteringFlag,
 	}
 	app.Action = run
 }
@ -121,6 +129,13 @@ func run(ctx *cli.Context) error {

 	logger := vm.NewStructLogger(nil)

+	vmenv := NewEnv(statedb, common.StringToAddress("evmuser"), common.Big(ctx.GlobalString(ValueFlag.Name)), vm.Config{
+		Debug:     ctx.GlobalBool(DebugFlag.Name),
+		ForceJit:  ctx.GlobalBool(ForceJitFlag.Name),
+		EnableJit: !ctx.GlobalBool(DisableJitFlag.Name),
+		Tracer:    logger,
+	})
+
 	tstart := time.Now()

 	var (
@ -153,32 +168,25 @@ func run(ctx *cli.Context) error {

 	if ctx.GlobalBool(CreateFlag.Name) {
 		input := append(code, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name))...)
-		ret, _, err = runtime.Create(input, &runtime.Config{
-			Origin:   sender.Address(),
-			State:    statedb,
-			GasLimit: common.Big(ctx.GlobalString(GasFlag.Name)),
-			GasPrice: common.Big(ctx.GlobalString(PriceFlag.Name)),
-			Value:    common.Big(ctx.GlobalString(ValueFlag.Name)),
-			EVMConfig: vm.Config{
-				Tracer:             logger,
-				DisableGasMetering: ctx.GlobalBool(DisableGasMeteringFlag.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(crypto.Keccak256Hash(code), code)

-		ret, err = runtime.Call(receiver.Address(), common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)), &runtime.Config{
-			Origin:   sender.Address(),
-			State:    statedb,
-			GasLimit: common.Big(ctx.GlobalString(GasFlag.Name)),
-			GasPrice: common.Big(ctx.GlobalString(PriceFlag.Name)),
-			Value:    common.Big(ctx.GlobalString(ValueFlag.Name)),
-			EVMConfig: vm.Config{
-				Tracer:             logger,
-				DisableGasMetering: ctx.GlobalBool(DisableGasMeteringFlag.Name),
-			},
-		})
+		receiver.SetCode(crypto.Keccak256Hash(code), code)
+		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)

@ -189,8 +197,8 @@ func run(ctx *cli.Context) error {
 	vm.StdErrFormat(logger.StructLogs())

 	if ctx.GlobalBool(SysStatFlag.Name) {
-		var mem goruntime.MemStats
-		goruntime.ReadMemStats(&mem)
+		var mem runtime.MemStats
+		runtime.ReadMemStats(&mem)
 		fmt.Printf("vm took %v\n", vmdone)
 		fmt.Printf(`alloc:      %d
 tot alloc:  %d
@ -215,3 +223,87 @@ func main() {
 		os.Exit(1)
 	}
 }
+
+type VMEnv struct {
+	state *state.StateDB
+	block *types.Block
+
+	transactor *common.Address
+	value      *big.Int
+
+	depth int
+	Gas   *big.Int
+	time  *big.Int
+	logs  []vm.StructLog
+
+	evm *vm.EVM
+}
+
+func NewEnv(state *state.StateDB, transactor common.Address, value *big.Int, cfg vm.Config) *VMEnv {
+	env := &VMEnv{
+		state:      state,
+		transactor: &transactor,
+		value:      value,
+		time:       big.NewInt(time.Now().Unix()),
+	}
+
+	env.evm = vm.New(env, cfg)
+	return env
+}
+
+// ruleSet implements vm.ChainConfig and will always default to the homestead rule set.
+type ruleSet struct{}
+
+func (ruleSet) IsHomestead(*big.Int) bool { return true }
+func (ruleSet) GasTable(*big.Int) params.GasTable {
+	return params.GasTableHomesteadGasRepriceFork
+}
+
+func (self *VMEnv) ChainConfig() *params.ChainConfig { return params.TestChainConfig }
+func (self *VMEnv) Vm() vm.Vm                        { return self.evm }
+func (self *VMEnv) Db() vm.Database                  { return self.state }
+func (self *VMEnv) SnapshotDatabase() int            { return self.state.Snapshot() }
+func (self *VMEnv) RevertToSnapshot(snap int)        { self.state.RevertToSnapshot(snap) }
+func (self *VMEnv) Origin() common.Address           { return *self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int            { return common.Big0 }
+func (self *VMEnv) Coinbase() common.Address         { return *self.transactor }
+func (self *VMEnv) Time() *big.Int                   { return self.time }
+func (self *VMEnv) Difficulty() *big.Int             { return common.Big1 }
+func (self *VMEnv) BlockHash() []byte                { return make([]byte, 32) }
+func (self *VMEnv) Value() *big.Int                  { return self.value }
+func (self *VMEnv) GasLimit() *big.Int               { return big.NewInt(1000000000) }
+func (self *VMEnv) VmType() vm.Type                  { return vm.StdVmTy }
+func (self *VMEnv) Depth() int                       { return 0 }
+func (self *VMEnv) SetDepth(i int)                   { self.depth = i }
+func (self *VMEnv) GetHash(n uint64) common.Hash {
+	if self.block.Number().Cmp(big.NewInt(int64(n))) == 0 {
+		return self.block.Hash()
+	}
+	return common.Hash{}
+}
+func (self *VMEnv) AddLog(log *vm.Log) {
+	self.state.AddLog(log)
+}
+func (self *VMEnv) CanTransfer(from common.Address, balance *big.Int) bool {
+	return self.state.GetBalance(from).Cmp(balance) >= 0
+}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) {
+	core.Transfer(from, to, amount)
+}
+
+func (self *VMEnv) Call(caller vm.ContractRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	self.Gas = gas
+	return core.Call(self, caller, addr, data, gas, price, value)
+}
+
+func (self *VMEnv) CallCode(caller vm.ContractRef, addr common.Address, data []byte, gas, price, value *big.Int) ([]byte, error) {
+	return core.CallCode(self, caller, addr, data, gas, price, value)
+}
+
+func (self *VMEnv) DelegateCall(caller vm.ContractRef, addr common.Address, data []byte, gas, price *big.Int) ([]byte, error) {
+	return core.DelegateCall(self, caller, addr, data, gas, price)
+}
+
+func (self *VMEnv) Create(caller vm.ContractRef, data []byte, gas, price, value *big.Int) ([]byte, common.Address, error) {
+	return core.Create(self, caller, data, gas, price, value)
+}
--- a/cmd/geth/accountcmd_test.go
+++ b/cmd/geth/accountcmd_test.go
@ -148,7 +148,7 @@ Passphrase: {{.InputLine "foobar"}}
 		"Unlocked account f466859ead1932d743d622cb74fc058882e8648a",
 	}
 	for _, m := range wantMessages {
-		if !strings.Contains(geth.stderrText(), m) {
+		if strings.Index(geth.stderrText(), m) == -1 {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@ -193,7 +193,7 @@ Passphrase: {{.InputLine "foobar"}}
 		"Unlocked account 289d485d9771714cce91d3393d764e1311907acc",
 	}
 	for _, m := range wantMessages {
-		if !strings.Contains(geth.stderrText(), m) {
+		if strings.Index(geth.stderrText(), m) == -1 {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@ -212,7 +212,7 @@ func TestUnlockFlagPasswordFile(t *testing.T) {
 		"Unlocked account 289d485d9771714cce91d3393d764e1311907acc",
 	}
 	for _, m := range wantMessages {
-		if !strings.Contains(geth.stderrText(), m) {
+		if strings.Index(geth.stderrText(), m) == -1 {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
@ -260,7 +260,7 @@ In order to avoid this warning, you need to remove the following duplicate key f
 		"Unlocked account f466859ead1932d743d622cb74fc058882e8648a",
 	}
 	for _, m := range wantMessages {
-		if !strings.Contains(geth.stderrText(), m) {
+		if strings.Index(geth.stderrText(), m) == -1 {
 			t.Errorf("stderr text does not contain %q", m)
 		}
 	}
--- a/cmd/geth/chaincmd.go
+++ b/cmd/geth/chaincmd.go
@ -32,7 +32,6 @@ import (
 	"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"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/syndtr/goleveldb/leveldb/util"
@ -40,18 +39,6 @@ import (
 )

 var (
-	initCommand = cli.Command{
-		Action:    initGenesis,
-		Name:      "init",
-		Usage:     "Bootstrap and initialize a new genesis block",
-		ArgsUsage: "<genesisPath>",
-		Category:  "BLOCKCHAIN COMMANDS",
-		Description: `
-The init command initializes a new genesis block and definition for the network.
-This is a destructive action and changes the network in which you will be
-participating.
-`,
-	}
 	importCommand = cli.Command{
 		Action:    importChain,
 		Name:      "import",
@ -108,34 +95,13 @@ Use "ethereum dump 0" to dump the genesis block.
 	}
 )

-// 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) error {
-	genesisPath := ctx.Args().First()
-	if len(genesisPath) == 0 {
-		utils.Fatalf("must supply path to genesis JSON file")
-	}
-
-	stack := makeFullNode(ctx)
-	chaindb := utils.MakeChainDatabase(ctx, stack)
-
-	genesisFile, err := os.Open(genesisPath)
-	if err != nil {
-		utils.Fatalf("failed to read genesis file: %v", err)
-	}
-
-	block, err := core.WriteGenesisBlock(chaindb, genesisFile)
-	if err != nil {
-		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
-}
-
 func importChain(ctx *cli.Context) error {
 	if len(ctx.Args()) != 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
+	if ctx.GlobalBool(utils.TestNetFlag.Name) {
+		state.StartingNonce = 1048576 // (2**20)
+	}
 	stack := makeFullNode(ctx)
 	chain, chainDb := utils.MakeChain(ctx, stack)
 	defer chainDb.Close()
--- a/cmd/geth/consolecmd_test.go
+++ b/cmd/geth/consolecmd_test.go
@ -28,7 +28,7 @@ import (
 	"testing"
 	"time"

-	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/rpc"
 )

@ -46,7 +46,7 @@ func TestConsoleWelcome(t *testing.T) {
 	// 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 params.Version })
+	geth.setTemplateFunc("gethver", func() string { return utils.Version })
 	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)
@ -132,7 +132,7 @@ func testAttachWelcome(t *testing.T, geth *testgeth, endpoint string) {
 	// 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 params.Version })
+	attach.setTemplateFunc("gethver", func() string { return utils.Version })
 	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") })
--- a/cmd/geth/dao_test.go
+++ b/cmd/geth/dao_test.go
@ -83,28 +83,75 @@ var daoGenesisForkBlock = big.NewInt(314)
 // TestDAOForkBlockNewChain tests that the DAO hard-fork number and the nodes support/opposition is correctly
 // set in the database after various initialization procedures and invocations.
 func TestDAOForkBlockNewChain(t *testing.T) {
-	for i, arg := range []struct {
+	for _, arg := range []struct {
 		testnet     bool
 		genesis     string
+		votes       [][2]bool
 		expectBlock *big.Int
 		expectVote  bool
 	}{
 		// Test DAO Default Mainnet
-		{false, "", params.MainNetDAOForkBlock, true},
+		{false, "", [][2]bool{{false, false}}, params.MainNetDAOForkBlock, true},
+		// test DAO Support Mainnet
+		{false, "", [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true},
+		// test DAO Oppose Mainnet
+		{false, "", [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false},
+		// test DAO Switch To Support Mainnet
+		{false, "", [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true},
+		// test DAO Switch To Oppose Mainnet
+		{false, "", [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false},
 		// test DAO Default Testnet
-		{true, "", params.TestNetDAOForkBlock, true},
+		{true, "", [][2]bool{{false, false}}, params.TestNetDAOForkBlock, true},
+		// test DAO Support Testnet
+		{true, "", [][2]bool{{true, false}}, params.TestNetDAOForkBlock, true},
+		// test DAO Oppose Testnet
+		{true, "", [][2]bool{{false, true}}, params.TestNetDAOForkBlock, false},
+		// test DAO Switch To Support Testnet
+		{true, "", [][2]bool{{false, true}, {true, false}}, params.TestNetDAOForkBlock, true},
+		// test DAO Switch To Oppose Testnet
+		{true, "", [][2]bool{{true, false}, {false, true}}, params.TestNetDAOForkBlock, false},
 		// test DAO Init Old Privnet
-		{false, daoOldGenesis, nil, false},
+		{false, daoOldGenesis, [][2]bool{}, nil, false},
+		// test DAO Default Old Privnet
+		{false, daoOldGenesis, [][2]bool{{false, false}}, nil, false},
+		// test DAO Support Old Privnet
+		{false, daoOldGenesis, [][2]bool{{true, false}}, nil, true},
+		// test DAO Oppose Old Privnet
+		{false, daoOldGenesis, [][2]bool{{false, true}}, nil, false},
+		// test DAO Switch To Support Old Privnet
+		{false, daoOldGenesis, [][2]bool{{false, true}, {true, false}}, nil, true},
+		// test DAO Switch To Oppose Old Privnet
+		{false, daoOldGenesis, [][2]bool{{true, false}, {false, true}}, nil, false},
+		// test DAO Init No Fork Privnet
+		{false, daoNoForkGenesis, [][2]bool{}, daoGenesisForkBlock, false},
 		// test DAO Default No Fork Privnet
-		{false, daoNoForkGenesis, daoGenesisForkBlock, false},
+		{false, daoNoForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, false},
+		// test DAO Support No Fork Privnet
+		{false, daoNoForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true},
+		// test DAO Oppose No Fork Privnet
+		{false, daoNoForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false},
+		// test DAO Switch To Support No Fork Privnet
+		{false, daoNoForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true},
+		// test DAO Switch To Oppose No Fork Privnet
+		{false, daoNoForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false},
+		// test DAO Init Pro Fork Privnet
+		{false, daoProForkGenesis, [][2]bool{}, daoGenesisForkBlock, true},
 		// test DAO Default Pro Fork Privnet
-		{false, daoProForkGenesis, daoGenesisForkBlock, true},
+		{false, daoProForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, true},
+		// test DAO Support Pro Fork Privnet
+		{false, daoProForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true},
+		// test DAO Oppose Pro Fork Privnet
+		{false, daoProForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false},
+		// test DAO Switch To Support Pro Fork Privnet
+		{false, daoProForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true},
+		// test DAO Switch To Oppose Pro Fork Privnet
+		{false, daoProForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false},
 	} {
-		testDAOForkBlockNewChain(t, i, arg.testnet, arg.genesis, arg.expectBlock, arg.expectVote)
+		testDAOForkBlockNewChain(t, arg.testnet, arg.genesis, arg.votes, arg.expectBlock, arg.expectVote)
 	}
 }

-func testDAOForkBlockNewChain(t *testing.T, test int, testnet bool, genesis string, expectBlock *big.Int, expectVote bool) {
+func testDAOForkBlockNewChain(t *testing.T, testnet bool, genesis string, votes [][2]bool, expectBlock *big.Int, expectVote bool) {
 	// Create a temporary data directory to use and inspect later
 	datadir := tmpdir(t)
 	defer os.RemoveAll(datadir)
@ -113,15 +160,21 @@ func testDAOForkBlockNewChain(t *testing.T, test int, testnet bool, genesis stri
 	if genesis != "" {
 		json := filepath.Join(datadir, "genesis.json")
 		if err := ioutil.WriteFile(json, []byte(genesis), 0600); err != nil {
-			t.Fatalf("test %d: failed to write genesis file: %v", test, err)
+			t.Fatalf("failed to write genesis file: %v", err)
 		}
 		runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
-	} else {
-		// Force chain initialization
+	}
+	for _, vote := range votes {
 		args := []string{"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none", "--ipcdisable", "--datadir", datadir}
 		if testnet {
 			args = append(args, "--testnet")
 		}
+		if vote[0] {
+			args = append(args, "--support-dao-fork")
+		}
+		if vote[1] {
+			args = append(args, "--oppose-dao-fork")
+		}
 		geth := runGeth(t, append(args, []string{"--exec", "2+2", "console"}...)...)
 		geth.cmd.Wait()
 	}
@ -132,33 +185,32 @@ func testDAOForkBlockNewChain(t *testing.T, test int, testnet bool, genesis stri
 	}
 	db, err := ethdb.NewLDBDatabase(path, 0, 0)
 	if err != nil {
-		t.Fatalf("test %d: failed to open test database: %v", test, err)
+		t.Fatalf("failed to open test database: %v", err)
 	}
 	defer db.Close()

 	genesisHash := common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
 	if testnet {
-		genesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
+		genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
 	}
 	if genesis != "" {
 		genesisHash = daoGenesisHash
 	}
 	config, err := core.GetChainConfig(db, genesisHash)
 	if err != nil {
-		t.Errorf("test %d: failed to retrieve chain config: %v", test, err)
-		return // we want to return here, the other checks can't make it past this point (nil panic).
+		t.Fatalf("failed to retrieve chain config: %v", err)
 	}
 	// Validate the DAO hard-fork block number against the expected value
 	if config.DAOForkBlock == nil {
 		if expectBlock != nil {
-			t.Errorf("test %d: dao hard-fork block mismatch: have nil, want %v", test, expectBlock)
+			t.Errorf("dao hard-fork block mismatch: have nil, want %v", expectBlock)
 		}
 	} else if expectBlock == nil {
-		t.Errorf("test %d: dao hard-fork block mismatch: have %v, want nil", test, config.DAOForkBlock)
+		t.Errorf("dao hard-fork block mismatch: have %v, want nil", config.DAOForkBlock)
 	} else if config.DAOForkBlock.Cmp(expectBlock) != 0 {
-		t.Errorf("test %d: dao hard-fork block mismatch: have %v, want %v", test, config.DAOForkBlock, expectBlock)
+		t.Errorf("dao hard-fork block mismatch: have %v, want %v", config.DAOForkBlock, expectBlock)
 	}
 	if config.DAOForkSupport != expectVote {
-		t.Errorf("test %d: dao hard-fork support mismatch: have %v, want %v", test, config.DAOForkSupport, expectVote)
+		t.Errorf("dao hard-fork support mismatch: have %v, want %v", config.DAOForkSupport, expectVote)
 	}
 }
--- a/cmd/geth/library.c
+++ b/cmd/geth/library.c
@ -0,0 +1,24 @@
+// 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/>.
+
+// Simple wrapper to translate the API exposed methods and types to inthernal
+// Go versions of the same types.
+
+#include "_cgo_export.h"
+
+int run(const char* args) {
+ return doRun((char*)args);
+}
--- a/cmd/geth/library.go
+++ b/cmd/geth/library.go
@ -1,4 +1,4 @@
-// Copyright 2016 The go-ethereum Authors
+// 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
@ -14,22 +14,33 @@
 // 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 params
+// Contains a simple library definition to allow creating a Geth instance from
+// straight C code.

-import "fmt"
+package main

-const (
-	VersionMajor = 1        // Major version component of the current release
-	VersionMinor = 5        // Minor version component of the current release
-	VersionPatch = 7        // Patch version component of the current release
-	VersionMeta  = "stable" // Version metadata to append to the version string
+// #ifdef __cplusplus
+// extern "C" {
+// #endif
+//
+// extern int run(const char*);
+//
+// #ifdef __cplusplus
+// }
+// #endif
+import "C"
+import (
+	"fmt"
+	"os"
+	"strings"
 )

-// Version holds the textual version string.
-var Version = func() string {
-	v := fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
-	if VersionMeta != "" {
-		v += "-" + VersionMeta
+//export doRun
+func doRun(args *C.char) C.int {
+	// This is equivalent to geth.main, just modified to handle the function arg passing
+	if err := app.Run(strings.Split("geth "+C.GoString(args), " ")); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return -1
 	}
-	return v
-}()
+	return 0
+}
--- a/cmd/geth/library_android.go
+++ b/cmd/geth/library_android.go
@ -0,0 +1,56 @@
+// 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/>.
+
+// Contains specialized code for running Geth on Android.
+
+package main
+
+// #include <android/log.h>
+// #cgo LDFLAGS: -llog
+import "C"
+import (
+	"bufio"
+	"os"
+)
+
+func init() {
+	// Redirect the standard output and error to logcat
+	oldStdout, oldStderr := os.Stdout, os.Stderr
+
+	outRead, outWrite, _ := os.Pipe()
+	errRead, errWrite, _ := os.Pipe()
+
+	os.Stdout = outWrite
+	os.Stderr = errWrite
+
+	go func() {
+		scanner := bufio.NewScanner(outRead)
+		for scanner.Scan() {
+			line := scanner.Text()
+			C.__android_log_write(C.ANDROID_LOG_INFO, C.CString("Stdout"), C.CString(line))
+			oldStdout.WriteString(line + "\n")
+		}
+	}()
+
+	go func() {
+		scanner := bufio.NewScanner(errRead)
+		for scanner.Scan() {
+			line := scanner.Text()
+			C.__android_log_write(C.ANDROID_LOG_INFO, C.CString("Stderr"), C.CString(line))
+			oldStderr.WriteString(line + "\n")
+		}
+	}()
+}
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@ -20,23 +20,27 @@ package main
 import (
 	"encoding/hex"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"

+	"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/contracts/release"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/internal/debug"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
 	"gopkg.in/urfave/cli.v1"
 )

@ -59,26 +63,59 @@ func init() {
 	app.HideVersion = true // we have a command to print the version
 	app.Copyright = "Copyright 2013-2016 The go-ethereum Authors"
 	app.Commands = []cli.Command{
-		// See chaincmd.go:
-		initCommand,
 		importCommand,
 		exportCommand,
 		upgradedbCommand,
 		removedbCommand,
 		dumpCommand,
-		// See monitorcmd.go:
 		monitorCommand,
-		// See accountcmd.go:
 		accountCommand,
 		walletCommand,
-		// See consolecmd.go:
 		consoleCommand,
 		attachCommand,
 		javascriptCommand,
-		// See misccmd.go:
-		makedagCommand,
-		versionCommand,
-		licenseCommand,
+		{
+			Action:    makedag,
+			Name:      "makedag",
+			Usage:     "Generate ethash DAG (for testing)",
+			ArgsUsage: "<blockNum> <outputDir>",
+			Category:  "MISCELLANEOUS COMMANDS",
+			Description: `
+The makedag command generates an ethash DAG in /tmp/dag.
+
+This command exists to support the system testing project.
+Regular users do not need to execute it.
+`,
+		},
+		{
+			Action:    version,
+			Name:      "version",
+			Usage:     "Print version numbers",
+			ArgsUsage: " ",
+			Category:  "MISCELLANEOUS COMMANDS",
+			Description: `
+The output of this command is supposed to be machine-readable.
+`,
+		},
+		{
+			Action:    initGenesis,
+			Name:      "init",
+			Usage:     "Bootstrap and initialize a new genesis block",
+			ArgsUsage: "<genesisPath>",
+			Category:  "BLOCKCHAIN COMMANDS",
+			Description: `
+The init command initializes 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:    license,
+			Name:      "license",
+			Usage:     "Display license information",
+			ArgsUsage: " ",
+			Category:  "MISCELLANEOUS COMMANDS",
+		},
 	}

 	app.Flags = []cli.Flag{
@ -88,6 +125,7 @@ func init() {
 		utils.BootnodesFlag,
 		utils.DataDirFlag,
 		utils.KeyStoreDirFlag,
+		utils.OlympicFlag,
 		utils.FastSyncFlag,
 		utils.LightModeFlag,
 		utils.LightServFlag,
@ -101,6 +139,8 @@ func init() {
 		utils.MaxPendingPeersFlag,
 		utils.EtherbaseFlag,
 		utils.GasPriceFlag,
+		utils.SupportDAOFork,
+		utils.OpposeDAOFork,
 		utils.MinerThreadsFlag,
 		utils.MiningEnabledFlag,
 		utils.AutoDAGFlag,
@ -109,7 +149,6 @@ func init() {
 		utils.NatspecEnabledFlag,
 		utils.NoDiscoverFlag,
 		utils.DiscoveryV5Flag,
-		utils.NetrestrictFlag,
 		utils.NodeKeyFileFlag,
 		utils.NodeKeyHexFlag,
 		utils.RPCEnabledFlag,
@ -134,7 +173,6 @@ func init() {
 		utils.VMEnableJitFlag,
 		utils.NetworkIdFlag,
 		utils.RPCCORSDomainFlag,
-		utils.EthStatsURLFlag,
 		utils.MetricsEnabledFlag,
 		utils.FakePoWFlag,
 		utils.SolcPathFlag,
@ -167,6 +205,7 @@ func init() {
 	}

 	app.After = func(ctx *cli.Context) error {
+		logger.Flush()
 		debug.Exit()
 		console.Stdin.Close() // Resets terminal mode.
 		return nil
@ -190,25 +229,37 @@ func geth(ctx *cli.Context) error {
 	return nil
 }

-func makeFullNode(ctx *cli.Context) *node.Node {
-	// Create the default extradata and construct the base node
-	var clientInfo = struct {
-		Version   uint
-		Name      string
-		GoVersion string
-		Os        string
-	}{uint(params.VersionMajor<<16 | params.VersionMinor<<8 | params.VersionPatch), clientIdentifier, runtime.Version(), runtime.GOOS}
-	extra, err := rlp.EncodeToBytes(clientInfo)
+// 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) error {
+	genesisPath := ctx.Args().First()
+	if len(genesisPath) == 0 {
+		utils.Fatalf("must supply path to genesis JSON file")
+	}
+
+	if ctx.GlobalBool(utils.TestNetFlag.Name) {
+		state.StartingNonce = 1048576 // (2**20)
+	}
+
+	stack := makeFullNode(ctx)
+	chaindb := utils.MakeChainDatabase(ctx, stack)
+
+	genesisFile, err := os.Open(genesisPath)
 	if err != nil {
-		glog.V(logger.Warn).Infoln("error setting canonical miner information:", err)
+		utils.Fatalf("failed to read genesis file: %v", err)
 	}
-	if uint64(len(extra)) > params.MaximumExtraDataSize.Uint64() {
-		glog.V(logger.Warn).Infoln("error setting canonical miner information: extra exceeds", params.MaximumExtraDataSize)
-		glog.V(logger.Debug).Infof("extra: %x\n", extra)
-		extra = nil
+
+	block, err := core.WriteGenesisBlock(chaindb, genesisFile)
+	if err != nil {
+		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
+}
+
+func makeFullNode(ctx *cli.Context) *node.Node {
 	stack := utils.MakeNode(ctx, clientIdentifier, gitCommit)
-	utils.RegisterEthService(ctx, stack, extra)
+	utils.RegisterEthService(ctx, stack, utils.MakeDefaultExtraData(clientIdentifier))

 	// Whisper must be explicitly enabled, but is auto-enabled in --dev mode.
 	shhEnabled := ctx.GlobalBool(utils.WhisperEnabledFlag.Name)
@ -216,17 +267,14 @@ func makeFullNode(ctx *cli.Context) *node.Node {
 	if shhEnabled || shhAutoEnabled {
 		utils.RegisterShhService(stack)
 	}
-	// Add the Ethereum Stats daemon if requested
-	if url := ctx.GlobalString(utils.EthStatsURLFlag.Name); url != "" {
-		utils.RegisterEthStatsService(stack, url)
-	}
+
 	// Add the release oracle service so it boots along with node.
 	if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
 		config := release.Config{
 			Oracle: relOracle,
-			Major:  uint32(params.VersionMajor),
-			Minor:  uint32(params.VersionMinor),
-			Patch:  uint32(params.VersionPatch),
+			Major:  uint32(utils.VersionMajor),
+			Minor:  uint32(utils.VersionMinor),
+			Patch:  uint32(utils.VersionPatch),
 		}
 		commit, _ := hex.DecodeString(gitCommit)
 		copy(config.Commit[:], commit)
@ -234,6 +282,7 @@ func makeFullNode(ctx *cli.Context) *node.Node {
 	}); err != nil {
 		utils.Fatalf("Failed to register the Geth release oracle service: %v", err)
 	}
+
 	return stack
 }

@ -264,3 +313,65 @@ func startNode(ctx *cli.Context, stack *node.Node) {
 		}
 	}
 }
+
+func makedag(ctx *cli.Context) error {
+	args := ctx.Args()
+	wrongArgs := func() {
+		utils.Fatalf(`Usage: geth makedag <block number> <outputdir>`)
+	}
+	switch {
+	case len(args) == 2:
+		blockNum, err := strconv.ParseUint(args[0], 0, 64)
+		dir := args[1]
+		if err != nil {
+			wrongArgs()
+		} else {
+			dir = filepath.Clean(dir)
+			// seems to require a trailing slash
+			if !strings.HasSuffix(dir, "/") {
+				dir = dir + "/"
+			}
+			_, err = ioutil.ReadDir(dir)
+			if err != nil {
+				utils.Fatalf("Can't find dir")
+			}
+			fmt.Println("making DAG, this could take awhile...")
+			ethash.MakeDAG(blockNum, dir)
+		}
+	default:
+		wrongArgs()
+	}
+	return nil
+}
+
+func version(ctx *cli.Context) error {
+	fmt.Println(strings.Title(clientIdentifier))
+	fmt.Println("Version:", utils.Version)
+	if gitCommit != "" {
+		fmt.Println("Git Commit:", gitCommit)
+	}
+	fmt.Println("Protocol Versions:", eth.ProtocolVersions)
+	fmt.Println("Network Id:", ctx.GlobalInt(utils.NetworkIdFlag.Name))
+	fmt.Println("Go Version:", runtime.Version())
+	fmt.Println("OS:", runtime.GOOS)
+	fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
+	fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
+	return nil
+}
+
+func license(_ *cli.Context) error {
+	fmt.Println(`Geth 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.
+
+Geth 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 geth. If not, see <http://www.gnu.org/licenses/>.
+`)
+	return nil
+}
--- a/cmd/geth/misccmd.go
+++ b/cmd/geth/misccmd.go
@ -1,128 +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 main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-
-	"github.com/ethereum/ethash"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/params"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var (
-	makedagCommand = cli.Command{
-		Action:    makedag,
-		Name:      "makedag",
-		Usage:     "Generate ethash DAG (for testing)",
-		ArgsUsage: "<blockNum> <outputDir>",
-		Category:  "MISCELLANEOUS COMMANDS",
-		Description: `
-The makedag command generates an ethash DAG in /tmp/dag.
-
-This command exists to support the system testing project.
-Regular users do not need to execute it.
-`,
-	}
-	versionCommand = cli.Command{
-		Action:    version,
-		Name:      "version",
-		Usage:     "Print version numbers",
-		ArgsUsage: " ",
-		Category:  "MISCELLANEOUS COMMANDS",
-		Description: `
-The output of this command is supposed to be machine-readable.
-`,
-	}
-	licenseCommand = cli.Command{
-		Action:    license,
-		Name:      "license",
-		Usage:     "Display license information",
-		ArgsUsage: " ",
-		Category:  "MISCELLANEOUS COMMANDS",
-	}
-)
-
-func makedag(ctx *cli.Context) error {
-	args := ctx.Args()
-	wrongArgs := func() {
-		utils.Fatalf(`Usage: geth makedag <block number> <outputdir>`)
-	}
-	switch {
-	case len(args) == 2:
-		blockNum, err := strconv.ParseUint(args[0], 0, 64)
-		dir := args[1]
-		if err != nil {
-			wrongArgs()
-		} else {
-			dir = filepath.Clean(dir)
-			// seems to require a trailing slash
-			if !strings.HasSuffix(dir, "/") {
-				dir = dir + "/"
-			}
-			_, err = ioutil.ReadDir(dir)
-			if err != nil {
-				utils.Fatalf("Can't find dir")
-			}
-			fmt.Println("making DAG, this could take awhile...")
-			ethash.MakeDAG(blockNum, dir)
-		}
-	default:
-		wrongArgs()
-	}
-	return nil
-}
-
-func version(ctx *cli.Context) error {
-	fmt.Println(strings.Title(clientIdentifier))
-	fmt.Println("Version:", params.Version)
-	if gitCommit != "" {
-		fmt.Println("Git Commit:", gitCommit)
-	}
-	fmt.Println("Protocol Versions:", eth.ProtocolVersions)
-	fmt.Println("Network Id:", ctx.GlobalInt(utils.NetworkIdFlag.Name))
-	fmt.Println("Go Version:", runtime.Version())
-	fmt.Println("OS:", runtime.GOOS)
-	fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
-	fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
-	return nil
-}
-
-func license(_ *cli.Context) error {
-	fmt.Println(`Geth 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.
-
-Geth 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 geth. If not, see <http://www.gnu.org/licenses/>.
-`)
-	return nil
-}
--- a/cmd/geth/monitorcmd.go
+++ b/cmd/geth/monitorcmd.go
@ -236,9 +236,8 @@ func expandMetrics(metrics map[string]interface{}, path string) []string {

 // fetchMetric iterates over the metrics map and retrieves a specific one.
 func fetchMetric(metrics map[string]interface{}, metric string) float64 {
-	parts := strings.Split(metric, "/")
+	parts, found := strings.Split(metric, "/"), true
 	for _, part := range parts[:len(parts)-1] {
-		var found bool
 		metrics, found = metrics[part].(map[string]interface{})
 		if !found {
 			return 0
--- a/cmd/geth/usage.go
+++ b/cmd/geth/usage.go
@ -67,6 +67,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.DataDirFlag,
 			utils.KeyStoreDirFlag,
 			utils.NetworkIdFlag,
+			utils.OlympicFlag,
 			utils.TestNetFlag,
 			utils.DevModeFlag,
 			utils.IdentityFlag,
@ -160,7 +161,6 @@ var AppHelpFlagGroups = []flagGroup{
 	{
 		Name: "LOGGING AND DEBUGGING",
 		Flags: append([]cli.Flag{
-			utils.EthStatsURLFlag,
 			utils.MetricsEnabledFlag,
 			utils.FakePoWFlag,
 		}, debug.Flags...),
--- a/cmd/swarm/upload.go
+++ b/cmd/swarm/upload.go
@ -1,231 +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/>.
-
-// Command bzzup uploads files to the swarm HTTP API.
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"mime"
-	"net/http"
-	"os"
-	"os/user"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-func upload(ctx *cli.Context) {
-	args := ctx.Args()
-	var (
-		bzzapi       = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		recursive    = ctx.GlobalBool(SwarmRecursiveUploadFlag.Name)
-		wantManifest = ctx.GlobalBoolT(SwarmWantManifestFlag.Name)
-		defaultPath  = ctx.GlobalString(SwarmUploadDefaultPath.Name)
-	)
-	if len(args) != 1 {
-		log.Fatal("need filename as the first and only argument")
-	}
-
-	var (
-		file   = args[0]
-		client = &client{api: bzzapi}
-	)
-	fi, err := os.Stat(expandPath(file))
-	if err != nil {
-		log.Fatal(err)
-	}
-	if fi.IsDir() {
-		if !recursive {
-			log.Fatal("argument is a directory and recursive upload is disabled")
-		}
-		if !wantManifest {
-			log.Fatal("manifest is required for directory uploads")
-		}
-		mhash, err := client.uploadDirectory(file, defaultPath)
-		if err != nil {
-			log.Fatal(err)
-		}
-		fmt.Println(mhash)
-		return
-	}
-	entry, err := client.uploadFile(file, fi)
-	if err != nil {
-		log.Fatalln("upload failed:", err)
-	}
-	mroot := manifest{[]manifestEntry{entry}}
-	if !wantManifest {
-		// Print the manifest. This is the only output to stdout.
-		mrootJSON, _ := json.MarshalIndent(mroot, "", "  ")
-		fmt.Println(string(mrootJSON))
-		return
-	}
-	hash, err := client.uploadManifest(mroot)
-	if err != nil {
-		log.Fatalln("manifest upload failed:", err)
-	}
-	fmt.Println(hash)
-}
-
-// Expands a file path
-// 1. replace tilde with users home dir
-// 2. expands embedded environment variables
-// 3. cleans the path, e.g. /a/b/../c -> /a/c
-// Note, it has limitations, e.g. ~someuser/tmp will not be expanded
-func expandPath(p string) string {
-	if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
-		if home := homeDir(); home != "" {
-			p = home + p[1:]
-		}
-	}
-	return path.Clean(os.ExpandEnv(p))
-}
-
-func homeDir() string {
-	if home := os.Getenv("HOME"); home != "" {
-		return home
-	}
-	if usr, err := user.Current(); err == nil {
-		return usr.HomeDir
-	}
-	return ""
-}
-
-// client wraps interaction with the swarm HTTP gateway.
-type client struct {
-	api string
-}
-
-// manifest is the JSON representation of a swarm manifest.
-type manifestEntry struct {
-	Hash        string `json:"hash,omitempty"`
-	ContentType string `json:"contentType,omitempty"`
-	Path        string `json:"path,omitempty"`
-}
-
-// manifest is the JSON representation of a swarm manifest.
-type manifest struct {
-	Entries []manifestEntry `json:"entries,omitempty"`
-}
-
-func (c *client) uploadDirectory(dir string, defaultPath string) (string, error) {
-	mhash, err := c.postRaw("application/json", 2, ioutil.NopCloser(bytes.NewReader([]byte("{}"))))
-	if err != nil {
-		return "", fmt.Errorf("failed to upload empty manifest")
-	}
-	if len(defaultPath) > 0 {
-		fi, err := os.Stat(defaultPath)
-		if err != nil {
-			return "", err
-		}
-		mhash, err = c.uploadToManifest(mhash, "", defaultPath, fi)
-		if err != nil {
-			return "", err
-		}
-	}
-	prefix := filepath.ToSlash(filepath.Clean(dir)) + "/"
-	err = filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
-		if err != nil || fi.IsDir() {
-			return err
-		}
-		if !strings.HasPrefix(path, dir) {
-			return fmt.Errorf("path %s outside directory %s", path, dir)
-		}
-		uripath := strings.TrimPrefix(filepath.ToSlash(filepath.Clean(path)), prefix)
-		mhash, err = c.uploadToManifest(mhash, uripath, path, fi)
-		return err
-	})
-	return mhash, err
-}
-
-func (c *client) uploadFile(file string, fi os.FileInfo) (manifestEntry, error) {
-	hash, err := c.uploadFileContent(file, fi)
-	m := manifestEntry{
-		Hash:        hash,
-		ContentType: mime.TypeByExtension(filepath.Ext(fi.Name())),
-	}
-	return m, err
-}
-
-func (c *client) uploadFileContent(file string, fi os.FileInfo) (string, error) {
-	fd, err := os.Open(file)
-	if err != nil {
-		return "", err
-	}
-	defer fd.Close()
-	log.Printf("uploading file %s (%d bytes)", file, fi.Size())
-	return c.postRaw("application/octet-stream", fi.Size(), fd)
-}
-
-func (c *client) uploadManifest(m manifest) (string, error) {
-	jsm, err := json.Marshal(m)
-	if err != nil {
-		panic(err)
-	}
-	log.Println("uploading manifest")
-	return c.postRaw("application/json", int64(len(jsm)), ioutil.NopCloser(bytes.NewReader(jsm)))
-}
-
-func (c *client) uploadToManifest(mhash string, path string, fpath string, fi os.FileInfo) (string, error) {
-	fd, err := os.Open(fpath)
-	if err != nil {
-		return "", err
-	}
-	defer fd.Close()
-	log.Printf("uploading file %s (%d bytes) and adding path %v", fpath, fi.Size(), path)
-	req, err := http.NewRequest("PUT", c.api+"/bzz:/"+mhash+"/"+path, fd)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("content-type", mime.TypeByExtension(filepath.Ext(fi.Name())))
-	req.ContentLength = fi.Size()
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return "", fmt.Errorf("bad status: %s", resp.Status)
-	}
-	content, err := ioutil.ReadAll(resp.Body)
-	return string(content), err
-}
-
-func (c *client) postRaw(mimetype string, size int64, body io.ReadCloser) (string, error) {
-	req, err := http.NewRequest("POST", c.api+"/bzzr:/", body)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("content-type", mimetype)
-	req.ContentLength = size
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return "", fmt.Errorf("bad status: %s", resp.Status)
-	}
-	content, err := ioutil.ReadAll(resp.Body)
-	return string(content), err
-}
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@ -18,14 +18,12 @@
 package utils

 import (
-	"compress/gzip"
 	"fmt"
 	"io"
 	"os"
 	"os/signal"
 	"regexp"
 	"runtime"
-	"strings"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@ -67,6 +65,7 @@ func Fatalf(format string, args ...interface{}) {
 		}
 	}
 	fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
+	logger.Flush()
 	os.Exit(1)
 }

@ -94,7 +93,7 @@ func StartNode(stack *node.Node) {

 func FormatTransactionData(data string) []byte {
 	d := common.StringToByteFunc(data, func(s string) (ret []byte) {
-		slice := regexp.MustCompile(`\n|\s`).Split(s, 1000000000)
+		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
 		for _, dataItem := range slice {
 			d := common.FormatData(dataItem)
 			ret = append(ret, d...)
@ -134,15 +133,7 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 		return err
 	}
 	defer fh.Close()
-
-	var reader io.Reader = fh
-	if strings.HasSuffix(fn, ".gz") {
-		if reader, err = gzip.NewReader(reader); err != nil {
-			return err
-		}
-	}
-
-	stream := rlp.NewStream(reader, 0)
+	stream := rlp.NewStream(fh, 0)

 	// Run actual the import.
 	blocks := make(types.Blocks, importBatchSize)
@ -204,18 +195,10 @@ func ExportChain(blockchain *core.BlockChain, fn string) error {
 		return err
 	}
 	defer fh.Close()
-
-	var writer io.Writer = fh
-	if strings.HasSuffix(fn, ".gz") {
-		writer = gzip.NewWriter(writer)
-		defer writer.(*gzip.Writer).Close()
-	}
-
-	if err := blockchain.Export(writer); err != nil {
+	if err := blockchain.Export(fh); err != nil {
 		return err
 	}
 	glog.Infoln("Exported blockchain to ", fn)
-
 	return nil
 }

@ -227,14 +210,7 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las
 		return err
 	}
 	defer fh.Close()
-
-	var writer io.Writer = fh
-	if strings.HasSuffix(fn, ".gz") {
-		writer = gzip.NewWriter(writer)
-		defer writer.(*gzip.Writer).Close()
-	}
-
-	if err := blockchain.ExportN(writer, first, last); err != nil {
+	if err := blockchain.ExportN(fh, first, last); err != nil {
 		return err
 	}
 	glog.Infoln("Exported blockchain to ", fn)
--- a/cmd/utils/customflags.go
+++ b/cmd/utils/customflags.go
@ -23,6 +23,8 @@ import (
 	"os/user"
 	"path"
 	"strings"
+
+	"gopkg.in/urfave/cli.v1"
 )

 // Custom type which is registered in the flags library which cli uses for
@ -44,6 +46,7 @@ func (self *DirectoryString) Set(value string) error {
 // Custom cli.Flag type which expand the received string to an absolute path.
 // e.g. ~/.ethereum -> /home/username/.ethereum
 type DirectoryFlag struct {
+	cli.GenericFlag
 	Name   string
 	Value  DirectoryString
 	Usage  string
@ -51,10 +54,15 @@ type DirectoryFlag struct {
 }

 func (self DirectoryFlag) String() string {
-	fmtString := "%s %v\t%v"
+	var fmtString string
+	fmtString = "%s %v\t%v"
+
 	if len(self.Value.Value) > 0 {
 		fmtString = "%s \"%v\"\t%v"
+	} else {
+		fmtString = "%s %v\t%v"
 	}
+
 	return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage))
 }

@ -114,7 +122,7 @@ func withEnvHint(envVar, str string) string {
 	return str + envText
 }

-func (self DirectoryFlag) GetName() string {
+func (self DirectoryFlag) getName() string {
 	return self.Name
 }

--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@ -14,13 +14,13 @@
 // 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 contains internal helper functions for go-ethereum commands.
 package utils

 import (
 	"crypto/ecdsa"
 	"fmt"
 	"io/ioutil"
+	"math"
 	"math/big"
 	"os"
 	"path/filepath"
@ -36,9 +36,9 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/ethstats"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/les"
+	"github.com/ethereum/go-ethereum/light"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/metrics"
@ -46,7 +46,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/p2p/netutil"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/pow"
 	"github.com/ethereum/go-ethereum/rpc"
@ -87,7 +86,7 @@ func NewApp(gitCommit, usage string) *cli.App {
 	app.Author = ""
 	//app.Authors = nil
 	app.Email = ""
-	app.Version = params.Version
+	app.Version = Version
 	if gitCommit != "" {
 		app.Version += "-" + gitCommit[:8]
 	}
@ -115,12 +114,16 @@ var (
 	}
 	NetworkIdFlag = cli.IntFlag{
 		Name:  "networkid",
-		Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten)",
+		Usage: "Network identifier (integer, 0=Olympic, 1=Frontier, 2=Morden)",
 		Value: eth.NetworkId,
 	}
+	OlympicFlag = cli.BoolFlag{
+		Name:  "olympic",
+		Usage: "Olympic network: pre-configured pre-release test network",
+	}
 	TestNetFlag = cli.BoolFlag{
 		Name:  "testnet",
-		Usage: "Ropsten network: pre-configured test network",
+		Usage: "Morden network: pre-configured test network with modified starting nonces (replay protection)",
 	}
 	DevModeFlag = cli.BoolFlag{
 		Name:  "dev",
@ -172,6 +175,15 @@ var (
 		Usage: "Number of trie node generations to keep in memory",
 		Value: int(state.MaxTrieCacheGen),
 	}
+	// Fork settings
+	SupportDAOFork = cli.BoolFlag{
+		Name:  "support-dao-fork",
+		Usage: "Updates the chain rules to support the DAO hard-fork",
+	}
+	OpposeDAOFork = cli.BoolFlag{
+		Name:  "oppose-dao-fork",
+		Usage: "Updates the chain rules to oppose the DAO hard-fork",
+	}
 	// Miner settings
 	MiningEnabledFlag = cli.BoolFlag{
 		Name:  "mine",
@ -230,11 +242,8 @@ var (
 		Name:  "jitvm",
 		Usage: "Enable the JIT VM",
 	}
-	// Logging and debug settings
-	EthStatsURLFlag = cli.StringFlag{
-		Name:  "ethstats",
-		Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
-	}
+
+	// logging and debug settings
 	MetricsEnabledFlag = cli.BoolFlag{
 		Name:  metrics.MetricsEnabledFlag,
 		Usage: "Enable metrics collection and reporting",
@ -358,20 +367,14 @@ var (
 		Name:  "v5disc",
 		Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
 	}
-	NetrestrictFlag = cli.StringFlag{
-		Name:  "netrestrict",
-		Usage: "Restricts network communication to the given IP networks (CIDR masks)",
-	}
-
 	WhisperEnabledFlag = cli.BoolFlag{
 		Name:  "shh",
 		Usage: "Enable Whisper",
 	}
-
 	// ATM the url is left to the user and deployment to
 	JSpathFlag = cli.StringFlag{
 		Name:  "jspath",
-		Usage: "JavaScript root path for `loadScript`",
+		Usage: "JavaScript root path for `loadScript` and document root for `admin.httpGet`",
 		Value: ".",
 	}
 	SolcPathFlag = cli.StringFlag{
@ -480,15 +483,17 @@ func makeNodeUserIdent(ctx *cli.Context) string {
 // MakeBootstrapNodes creates a list of bootstrap nodes from the command line
 // flags, reverting to pre-configured ones if none have been specified.
 func MakeBootstrapNodes(ctx *cli.Context) []*discover.Node {
-	urls := params.MainnetBootnodes
-	if ctx.GlobalIsSet(BootnodesFlag.Name) {
-		urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
-	} else if ctx.GlobalBool(TestNetFlag.Name) {
-		urls = params.TestnetBootnodes
+	// Return pre-configured nodes if none were manually requested
+	if !ctx.GlobalIsSet(BootnodesFlag.Name) {
+		if ctx.GlobalBool(TestNetFlag.Name) {
+			return params.TestnetBootnodes
+		}
+		return params.MainnetBootnodes
 	}
+	// Otherwise parse and use the CLI bootstrap nodes
+	bootnodes := []*discover.Node{}

-	bootnodes := make([]*discover.Node, 0, len(urls))
-	for _, url := range urls {
+	for _, url := range strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") {
 		node, err := discover.ParseNode(url)
 		if err != nil {
 			glog.V(logger.Error).Infof("Bootstrap URL %s: %v\n", url, err)
@ -502,13 +507,14 @@ func MakeBootstrapNodes(ctx *cli.Context) []*discover.Node {
 // MakeBootstrapNodesV5 creates a list of bootstrap nodes from the command line
 // flags, reverting to pre-configured ones if none have been specified.
 func MakeBootstrapNodesV5(ctx *cli.Context) []*discv5.Node {
-	urls := params.DiscoveryV5Bootnodes
-	if ctx.GlobalIsSet(BootnodesFlag.Name) {
-		urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
+	// Return pre-configured nodes if none were manually requested
+	if !ctx.GlobalIsSet(BootnodesFlag.Name) {
+		return params.DiscoveryV5Bootnodes
 	}
+	// Otherwise parse and use the CLI bootstrap nodes
+	bootnodes := []*discv5.Node{}

-	bootnodes := make([]*discv5.Node, 0, len(urls))
-	for _, url := range urls {
+	for _, url := range strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") {
 		node, err := discv5.ParseNode(url)
 		if err != nil {
 			glog.V(logger.Error).Infof("Bootstrap URL %s: %v\n", url, err)
@ -648,7 +654,7 @@ func MakePasswordList(ctx *cli.Context) []string {

 // MakeNode configures a node with no services from command line flags.
 func MakeNode(ctx *cli.Context, name, gitCommit string) *node.Node {
-	vsn := params.Version
+	vsn := Version
 	if gitCommit != "" {
 		vsn += "-" + gitCommit[:8]
 	}
@ -688,14 +694,6 @@ func MakeNode(ctx *cli.Context, name, gitCommit string) *node.Node {
 		config.MaxPeers = 0
 		config.ListenAddr = ":0"
 	}
-	if netrestrict := ctx.GlobalString(NetrestrictFlag.Name); netrestrict != "" {
-		list, err := netutil.ParseNetlist(netrestrict)
-		if err != nil {
-			Fatalf("Option %q: %v", NetrestrictFlag.Name, err)
-		}
-		config.NetRestrict = list
-	}
-
 	stack, err := node.New(config)
 	if err != nil {
 		Fatalf("Failed to create the protocol stack: %v", err)
@ -707,7 +705,7 @@ func MakeNode(ctx *cli.Context, name, gitCommit string) *node.Node {
 // given node.
 func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) {
 	// Avoid conflicting network flags
-	networks, netFlags := 0, []cli.BoolFlag{DevModeFlag, TestNetFlag}
+	networks, netFlags := 0, []cli.BoolFlag{DevModeFlag, TestNetFlag, OlympicFlag}
 	for _, flag := range netFlags {
 		if ctx.GlobalBool(flag.Name) {
 			networks++
@ -745,14 +743,22 @@ func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) {

 	// Override any default configs in dev mode or the test net
 	switch {
+	case ctx.GlobalBool(OlympicFlag.Name):
+		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
+			ethConf.NetworkId = 1
+		}
+		ethConf.Genesis = core.OlympicGenesisBlock()
+
 	case ctx.GlobalBool(TestNetFlag.Name):
 		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
-			ethConf.NetworkId = 3
+			ethConf.NetworkId = 2
 		}
-		ethConf.Genesis = core.DefaultTestnetGenesisBlock()
+		ethConf.Genesis = core.TestNetGenesisBlock()
+		state.StartingNonce = 1048576 // (2**20)
+		light.StartingNonce = 1048576 // (2**20)

 	case ctx.GlobalBool(DevModeFlag.Name):
-		ethConf.Genesis = core.DevGenesisBlock()
+		ethConf.Genesis = core.OlympicGenesisBlock()
 		if !ctx.GlobalIsSet(GasPriceFlag.Name) {
 			ethConf.GasPrice = new(big.Int)
 		}
@ -783,32 +789,25 @@ func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) {
 	}
 }

-// RegisterShhService configures Whisper and adds it to the given node.
+// RegisterShhService configures whisper and adds it to the given node.
 func RegisterShhService(stack *node.Node) {
 	if err := stack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil {
 		Fatalf("Failed to register the Whisper service: %v", err)
 	}
 }

-// RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
-// th egiven node.
-func RegisterEthStatsService(stack *node.Node, url string) {
-	if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
-		// Retrieve both eth and les services
-		var ethServ *eth.Ethereum
-		ctx.Service(&ethServ)
-
-		var lesServ *les.LightEthereum
-		ctx.Service(&lesServ)
-
-		return ethstats.New(url, ethServ, lesServ)
-	}); err != nil {
-		Fatalf("Failed to register the Ethereum Stats service: %v", err)
-	}
-}
-
 // SetupNetwork configures the system for either the main net or some test network.
 func SetupNetwork(ctx *cli.Context) {
+	switch {
+	case ctx.GlobalBool(OlympicFlag.Name):
+		params.DurationLimit = big.NewInt(8)
+		params.GenesisGasLimit = big.NewInt(3141592)
+		params.MinGasLimit = big.NewInt(125000)
+		params.MaximumExtraDataSize = big.NewInt(1024)
+		NetworkIdFlag.Value = 0
+		core.BlockReward = big.NewInt(1.5e+18)
+		core.ExpDiffPeriod = big.NewInt(math.MaxInt64)
+	}
 	params.TargetGasLimit = common.String2Big(ctx.GlobalString(TargetGasLimitFlag.Name))
 }

@ -849,25 +848,46 @@ func MakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *params.ChainCon
 		(genesis.Hash() == params.TestNetGenesisHash && ctx.GlobalBool(TestNetFlag.Name))

 	if defaults {
+		// Homestead fork
 		if ctx.GlobalBool(TestNetFlag.Name) {
-			config = params.TestnetChainConfig
+			config.HomesteadBlock = params.TestNetHomesteadBlock
 		} else {
-			// Homestead fork
 			config.HomesteadBlock = params.MainNetHomesteadBlock
-			// DAO fork
+		}
+		// DAO fork
+		if ctx.GlobalBool(TestNetFlag.Name) {
+			config.DAOForkBlock = params.TestNetDAOForkBlock
+		} else {
 			config.DAOForkBlock = params.MainNetDAOForkBlock
-			config.DAOForkSupport = true
+		}
+		config.DAOForkSupport = true

-			// DoS reprice fork
+		// DoS reprice fork
+		if ctx.GlobalBool(TestNetFlag.Name) {
+			config.EIP150Block = params.TestNetHomesteadGasRepriceBlock
+			config.EIP150Hash = params.TestNetHomesteadGasRepriceHash
+		} else {
 			config.EIP150Block = params.MainNetHomesteadGasRepriceBlock
 			config.EIP150Hash = params.MainNetHomesteadGasRepriceHash
-
-			// DoS state cleanup fork
+		}
+		// DoS state cleanup fork
+		if ctx.GlobalBool(TestNetFlag.Name) {
+			config.EIP155Block = params.TestNetSpuriousDragon
+			config.EIP158Block = params.TestNetSpuriousDragon
+			config.ChainId = params.TestNetChainID
+		} else {
 			config.EIP155Block = params.MainNetSpuriousDragon
 			config.EIP158Block = params.MainNetSpuriousDragon
 			config.ChainId = params.MainNetChainID
 		}
 	}
+	// Force override any existing configs if explicitly requested
+	switch {
+	case ctx.GlobalBool(SupportDAOFork.Name):
+		config.DAOForkSupport = true
+	case ctx.GlobalBool(OpposeDAOFork.Name):
+		config.DAOForkSupport = false
+	}
 	return config
 }

@ -899,13 +919,12 @@ func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chai
 	var err error
 	chainDb = MakeChainDatabase(ctx, stack)

-	if ctx.GlobalBool(TestNetFlag.Name) {
+	if ctx.GlobalBool(OlympicFlag.Name) {
 		_, err := core.WriteTestNetGenesisBlock(chainDb)
 		if err != nil {
 			glog.Fatalln(err)
 		}
 	}
-
 	chainConfig := MakeChainConfigFromDb(ctx, chainDb)

 	pow := pow.PoW(core.FakePow{})
--- a/cmd/utils/version.go
+++ b/cmd/utils/version.go
@ -0,0 +1,64 @@
+// 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 contains internal helper functions for go-ethereum commands.
+package utils
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+const (
+	VersionMajor = 1        // Major version component of the current release
+	VersionMinor = 5        // Minor version component of the current release
+	VersionPatch = 1        // Patch version component of the current release
+	VersionMeta  = "stable" // Version metadata to append to the version string
+)
+
+// Version holds the textual version string.
+var Version = func() string {
+	v := fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
+	if VersionMeta != "" {
+		v += "-" + VersionMeta
+	}
+	return v
+}()
+
+// MakeDefaultExtraData returns the default Ethereum block extra data blob.
+func MakeDefaultExtraData(clientIdentifier string) []byte {
+	var clientInfo = struct {
+		Version   uint
+		Name      string
+		GoVersion string
+		Os        string
+	}{uint(VersionMajor<<16 | VersionMinor<<8 | VersionPatch), clientIdentifier, runtime.Version(), runtime.GOOS}
+	extra, err := rlp.EncodeToBytes(clientInfo)
+	if err != nil {
+		glog.V(logger.Warn).Infoln("error setting canonical miner information:", err)
+	}
+	if uint64(len(extra)) > params.MaximumExtraDataSize.Uint64() {
+		glog.V(logger.Warn).Infoln("error setting canonical miner information: extra exceeds", params.MaximumExtraDataSize)
+		glog.V(logger.Debug).Infof("extra: %x\n", extra)
+		return nil
+	}
+	return extra
+}
--- a/common/big_test.go
+++ b/common/big_test.go
@ -27,7 +27,7 @@ func TestMisc(t *testing.T) {
 	c := []byte{1, 2, 3, 4}
 	z := BitTest(a, 1)

-	if !z {
+	if z != true {
 		t.Error("Expected true got", z)
 	}

@ -79,11 +79,11 @@ func TestBigCopy(t *testing.T) {
 	z := BigToBytes(c, 16)
 	zbytes := []byte{232, 212, 165, 16, 0}

-	if !bytes.Equal(y, ybytes) {
+	if bytes.Compare(y, ybytes) != 0 {
 		t.Error("Got", ybytes)
 	}

-	if !bytes.Equal(z, zbytes) {
+	if bytes.Compare(z, zbytes) != 0 {
 		t.Error("Got", zbytes)
 	}
 }
--- a/common/bytes.go
+++ b/common/bytes.go
@ -143,7 +143,7 @@ func Hex2BytesFixed(str string, flen int) []byte {
 		return h
 	} else {
 		if len(h) > flen {
-			return h[len(h)-flen:]
+			return h[len(h)-flen : len(h)]
 		} else {
 			hh := make([]byte, flen)
 			copy(hh[flen-len(h):flen], h[:])
--- a/common/bytes_test.go
+++ b/common/bytes_test.go
@ -181,7 +181,7 @@ func TestFromHex(t *testing.T) {
 	input := "0x01"
 	expected := []byte{1}
 	result := FromHex(input)
-	if !bytes.Equal(expected, result) {
+	if bytes.Compare(expected, result) != 0 {
 		t.Errorf("Expected % x got % x", expected, result)
 	}
 }
@ -190,7 +190,7 @@ func TestFromHexOddLength(t *testing.T) {
 	input := "0x1"
 	expected := []byte{1}
 	result := FromHex(input)
-	if !bytes.Equal(expected, result) {
+	if bytes.Compare(expected, result) != 0 {
 		t.Errorf("Expected % x got % x", expected, result)
 	}
 }
--- a/common/compiler/solidity.go
+++ b/common/compiler/solidity.go
@ -22,7 +22,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
+	"os"
 	"os/exec"
 	"regexp"
 	"strings"
@ -32,7 +34,7 @@ import (
 )

 var (
-	versionRegexp = regexp.MustCompile(`[0-9]+\.[0-9]+\.[0-9]+`)
+	versionRegexp = regexp.MustCompile("[0-9]+\\.[0-9]+\\.[0-9]+")
 	solcParams    = []string{
 		"--combined-json", "bin,abi,userdoc,devdoc",
 		"--add-std",  // include standard lib contracts
@ -94,16 +96,27 @@ func CompileSolidityString(solc, source string) (map[string]*Contract, error) {
 	if solc == "" {
 		solc = "solc"
 	}
-	args := append(solcParams, "--")
-	cmd := exec.Command(solc, append(args, "-")...)
-	cmd.Stdin = strings.NewReader(source)
-	return runsolc(cmd, source)
+	// Write source to a temporary file. Compiling stdin used to be supported
+	// but seems to produce an exception with solc 0.3.5.
+	infile, err := ioutil.TempFile("", "geth-compile-solidity")
+	if err != nil {
+		return nil, err
+	}
+	defer os.Remove(infile.Name())
+	if _, err := io.WriteString(infile, source); err != nil {
+		return nil, err
+	}
+	if err := infile.Close(); err != nil {
+		return nil, err
+	}
+
+	return CompileSolidity(solc, infile.Name())
 }

 // CompileSolidity compiles all given Solidity source files.
 func CompileSolidity(solc string, sourcefiles ...string) (map[string]*Contract, error) {
 	if len(sourcefiles) == 0 {
-		return nil, errors.New("solc: no source files")
+		return nil, errors.New("solc: no source ")
 	}
 	source, err := slurpFiles(sourcefiles)
 	if err != nil {
@ -112,13 +125,10 @@ func CompileSolidity(solc string, sourcefiles ...string) (map[string]*Contract,
 	if solc == "" {
 		solc = "solc"
 	}
+
+	var stderr, stdout bytes.Buffer
 	args := append(solcParams, "--")
 	cmd := exec.Command(solc, append(args, sourcefiles...)...)
-	return runsolc(cmd, source)
-}
-
-func runsolc(cmd *exec.Cmd, source string) (map[string]*Contract, error) {
-	var stderr, stdout bytes.Buffer
 	cmd.Stderr = &stderr
 	cmd.Stdout = &stdout
 	if err := cmd.Run(); err != nil {
--- a/common/compiler/solidity_test.go
+++ b/common/compiler/solidity_test.go
@ -20,7 +20,6 @@ import (
 	"encoding/json"
 	"io/ioutil"
 	"os"
-	"os/exec"
 	"path"
 	"testing"

@ -28,7 +27,8 @@ import (
 )

 const (
-	testSource = `
+	supportedSolcVersion = "0.3.5"
+	testSource           = `
 contract test {
   /// @notice Will multiply ` + "`a`" + ` by 7.
   function multiply(uint a) returns(uint d) {
@ -36,18 +36,23 @@ contract test {
   }
 }
 `
+	testCode = "0x6060604052602a8060106000396000f3606060405260e060020a6000350463c6888fa18114601a575b005b6007600435026060908152602090f3"
 	testInfo = `{"source":"\ncontract test {\n   /// @notice Will multiply ` + "`a`" + ` by 7.\n   function multiply(uint a) returns(uint d) {\n       return a * 7;\n   }\n}\n","language":"Solidity","languageVersion":"0.1.1","compilerVersion":"0.1.1","compilerOptions":"--binary file --json-abi file --natspec-user file --natspec-dev file --add-std 1","abiDefinition":[{"constant":false,"inputs":[{"name":"a","type":"uint256"}],"name":"multiply","outputs":[{"name":"d","type":"uint256"}],"type":"function"}],"userDoc":{"methods":{"multiply(uint256)":{"notice":"Will multiply ` + "`a`" + ` by 7."}}},"developerDoc":{"methods":{}}}`
 )

-func skipWithoutSolc(t *testing.T) {
-	if _, err := exec.LookPath("solc"); err != nil {
+func skipUnsupported(t *testing.T) {
+	sol, err := SolidityVersion("")
+	if err != nil {
 		t.Skip(err)
+		return
+	}
+	if sol.Version != supportedSolcVersion {
+		t.Skipf("unsupported version of solc found (%v, expect %v)", sol.Version, supportedSolcVersion)
 	}
 }

 func TestCompiler(t *testing.T) {
-	skipWithoutSolc(t)
-
+	skipUnsupported(t)
 	contracts, err := CompileSolidityString("", testSource)
 	if err != nil {
 		t.Fatalf("error compiling source. result %v: %v", contracts, err)
@ -59,20 +64,19 @@ func TestCompiler(t *testing.T) {
 	if !ok {
 		t.Fatal("info for contract 'test' not present in result")
 	}
-	if c.Code == "" {
-		t.Error("empty code")
+	if c.Code != testCode {
+		t.Errorf("wrong code: expected\n%s, got\n%s", testCode, c.Code)
 	}
 	if c.Info.Source != testSource {
 		t.Error("wrong source")
 	}
-	if c.Info.CompilerVersion == "" {
-		t.Error("empty version")
+	if c.Info.CompilerVersion != supportedSolcVersion {
+		t.Errorf("wrong version: expected %q, got %q", supportedSolcVersion, c.Info.CompilerVersion)
 	}
 }

 func TestCompileError(t *testing.T) {
-	skipWithoutSolc(t)
-
+	skipUnsupported(t)
 	contracts, err := CompileSolidityString("", testSource[4:])
 	if err == nil {
 		t.Errorf("error expected compiling source. got none. result %v", contracts)
--- a/common/format.go
+++ b/common/format.go
@ -27,7 +27,7 @@ import (
 // the unnecessary precision off from the formatted textual representation.
 type PrettyDuration time.Duration

-var prettyDurationRe = regexp.MustCompile(`\.[0-9]+`)
+var prettyDurationRe = regexp.MustCompile("\\.[0-9]+")

 // String implements the Stringer interface, allowing pretty printing of duration
 // values rounded to three decimals.
--- a/common/hexutil/hexutil.go
+++ b/common/hexutil/hexutil.go
@ -1,227 +0,0 @@
-// 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 hexutil implements hex encoding with 0x prefix.
-This encoding is used by the Ethereum RPC API to transport binary data in JSON payloads.
-
-Encoding Rules
-
-All hex data must have prefix "0x".
-
-For byte slices, the hex data must be of even length. An empty byte slice
-encodes as "0x".
-
-Integers are encoded using the least amount of digits (no leading zero digits). Their
-encoding may be of uneven length. The number zero encodes as "0x0".
-*/
-package hexutil
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"math/big"
-	"strconv"
-)
-
-const uintBits = 32 << (uint64(^uint(0)) >> 63)
-
-var (
-	ErrEmptyString   = errors.New("empty hex string")
-	ErrMissingPrefix = errors.New("missing 0x prefix for hex data")
-	ErrSyntax        = errors.New("invalid hex")
-	ErrEmptyNumber   = errors.New("hex number has no digits after 0x")
-	ErrLeadingZero   = errors.New("hex number has leading zero digits after 0x")
-	ErrOddLength     = errors.New("hex string has odd length")
-	ErrUint64Range   = errors.New("hex number does not fit into 64 bits")
-	ErrUintRange     = fmt.Errorf("hex number does not fit into %d bits", uintBits)
-)
-
-// Decode decodes a hex string with 0x prefix.
-func Decode(input string) ([]byte, error) {
-	if len(input) == 0 {
-		return nil, ErrEmptyString
-	}
-	if !has0xPrefix(input) {
-		return nil, ErrMissingPrefix
-	}
-	return hex.DecodeString(input[2:])
-}
-
-// MustDecode decodes a hex string with 0x prefix. It panics for invalid input.
-func MustDecode(input string) []byte {
-	dec, err := Decode(input)
-	if err != nil {
-		panic(err)
-	}
-	return dec
-}
-
-// Encode encodes b as a hex string with 0x prefix.
-func Encode(b []byte) string {
-	enc := make([]byte, len(b)*2+2)
-	copy(enc, "0x")
-	hex.Encode(enc[2:], b)
-	return string(enc)
-}
-
-// DecodeUint64 decodes a hex string with 0x prefix as a quantity.
-func DecodeUint64(input string) (uint64, error) {
-	raw, err := checkNumber(input)
-	if err != nil {
-		return 0, err
-	}
-	dec, err := strconv.ParseUint(raw, 16, 64)
-	if err != nil {
-		err = mapError(err)
-	}
-	return dec, err
-}
-
-// MustDecodeUint64 decodes a hex string with 0x prefix as a quantity.
-// It panics for invalid input.
-func MustDecodeUint64(input string) uint64 {
-	dec, err := DecodeUint64(input)
-	if err != nil {
-		panic(err)
-	}
-	return dec
-}
-
-// EncodeUint64 encodes i as a hex string with 0x prefix.
-func EncodeUint64(i uint64) string {
-	enc := make([]byte, 2, 10)
-	copy(enc, "0x")
-	return string(strconv.AppendUint(enc, i, 16))
-}
-
-var bigWordNibbles int
-
-func init() {
-	// This is a weird way to compute the number of nibbles required for big.Word.
-	// The usual way would be to use constant arithmetic but go vet can't handle that.
-	b, _ := new(big.Int).SetString("FFFFFFFFFF", 16)
-	switch len(b.Bits()) {
-	case 1:
-		bigWordNibbles = 16
-	case 2:
-		bigWordNibbles = 8
-	default:
-		panic("weird big.Word size")
-	}
-}
-
-// DecodeBig decodes a hex string with 0x prefix as a quantity.
-func DecodeBig(input string) (*big.Int, error) {
-	raw, err := checkNumber(input)
-	if err != nil {
-		return nil, err
-	}
-	words := make([]big.Word, len(raw)/bigWordNibbles+1)
-	end := len(raw)
-	for i := range words {
-		start := end - bigWordNibbles
-		if start < 0 {
-			start = 0
-		}
-		for ri := start; ri < end; ri++ {
-			nib := decodeNibble(raw[ri])
-			if nib == badNibble {
-				return nil, ErrSyntax
-			}
-			words[i] *= 16
-			words[i] += big.Word(nib)
-		}
-		end = start
-	}
-	dec := new(big.Int).SetBits(words)
-	return dec, nil
-}
-
-// MustDecodeBig decodes a hex string with 0x prefix as a quantity.
-// It panics for invalid input.
-func MustDecodeBig(input string) *big.Int {
-	dec, err := DecodeBig(input)
-	if err != nil {
-		panic(err)
-	}
-	return dec
-}
-
-// EncodeBig encodes bigint as a hex string with 0x prefix.
-// The sign of the integer is ignored.
-func EncodeBig(bigint *big.Int) string {
-	nbits := bigint.BitLen()
-	if nbits == 0 {
-		return "0x0"
-	}
-	return fmt.Sprintf("0x%x", bigint)
-}
-
-func has0xPrefix(input string) bool {
-	return len(input) >= 2 && input[0] == '0' && (input[1] == 'x' || input[1] == 'X')
-}
-
-func checkNumber(input string) (raw string, err error) {
-	if len(input) == 0 {
-		return "", ErrEmptyString
-	}
-	if !has0xPrefix(input) {
-		return "", ErrMissingPrefix
-	}
-	input = input[2:]
-	if len(input) == 0 {
-		return "", ErrEmptyNumber
-	}
-	if len(input) > 1 && input[0] == '0' {
-		return "", ErrLeadingZero
-	}
-	return input, nil
-}
-
-const badNibble = ^uint64(0)
-
-func decodeNibble(in byte) uint64 {
-	switch {
-	case in >= '0' && in <= '9':
-		return uint64(in - '0')
-	case in >= 'A' && in <= 'F':
-		return uint64(in - 'A' + 10)
-	case in >= 'a' && in <= 'f':
-		return uint64(in - 'a' + 10)
-	default:
-		return badNibble
-	}
-}
-
-func mapError(err error) error {
-	if err, ok := err.(*strconv.NumError); ok {
-		switch err.Err {
-		case strconv.ErrRange:
-			return ErrUint64Range
-		case strconv.ErrSyntax:
-			return ErrSyntax
-		}
-	}
-	if _, ok := err.(hex.InvalidByteError); ok {
-		return ErrSyntax
-	}
-	if err == hex.ErrLength {
-		return ErrOddLength
-	}
-	return err
-}
--- a/common/hexutil/hexutil_test.go
+++ b/common/hexutil/hexutil_test.go
@ -1,187 +0,0 @@
-// 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 hexutil
-
-import (
-	"bytes"
-	"encoding/hex"
-	"math/big"
-	"testing"
-)
-
-type marshalTest struct {
-	input interface{}
-	want  string
-}
-
-type unmarshalTest struct {
-	input   string
-	want    interface{}
-	wantErr error
-}
-
-var (
-	encodeBytesTests = []marshalTest{
-		{[]byte{}, "0x"},
-		{[]byte{0}, "0x00"},
-		{[]byte{0, 0, 1, 2}, "0x00000102"},
-	}
-
-	encodeBigTests = []marshalTest{
-		{referenceBig("0"), "0x0"},
-		{referenceBig("1"), "0x1"},
-		{referenceBig("ff"), "0xff"},
-		{referenceBig("112233445566778899aabbccddeeff"), "0x112233445566778899aabbccddeeff"},
-		{referenceBig("80a7f2c1bcc396c00"), "0x80a7f2c1bcc396c00"},
-	}
-
-	encodeUint64Tests = []marshalTest{
-		{uint64(0), "0x0"},
-		{uint64(1), "0x1"},
-		{uint64(0xff), "0xff"},
-		{uint64(0x1122334455667788), "0x1122334455667788"},
-	}
-
-	decodeBytesTests = []unmarshalTest{
-		// invalid
-		{input: ``, wantErr: ErrEmptyString},
-		{input: `0`, wantErr: ErrMissingPrefix},
-		{input: `0x0`, wantErr: hex.ErrLength},
-		{input: `0x023`, wantErr: hex.ErrLength},
-		{input: `0xxx`, wantErr: hex.InvalidByteError('x')},
-		{input: `0x01zz01`, wantErr: hex.InvalidByteError('z')},
-		// valid
-		{input: `0x`, want: []byte{}},
-		{input: `0X`, want: []byte{}},
-		{input: `0x02`, want: []byte{0x02}},
-		{input: `0X02`, want: []byte{0x02}},
-		{input: `0xffffffffff`, want: []byte{0xff, 0xff, 0xff, 0xff, 0xff}},
-		{
-			input: `0xffffffffffffffffffffffffffffffffffff`,
-			want:  []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
-		},
-	}
-
-	decodeBigTests = []unmarshalTest{
-		// invalid
-		{input: `0`, wantErr: ErrMissingPrefix},
-		{input: `0x`, wantErr: ErrEmptyNumber},
-		{input: `0x01`, wantErr: ErrLeadingZero},
-		{input: `0xx`, wantErr: ErrSyntax},
-		{input: `0x1zz01`, wantErr: ErrSyntax},
-		// valid
-		{input: `0x0`, want: big.NewInt(0)},
-		{input: `0x2`, want: big.NewInt(0x2)},
-		{input: `0x2F2`, want: big.NewInt(0x2f2)},
-		{input: `0X2F2`, want: big.NewInt(0x2f2)},
-		{input: `0x1122aaff`, want: big.NewInt(0x1122aaff)},
-		{input: `0xbBb`, want: big.NewInt(0xbbb)},
-		{input: `0xfffffffff`, want: big.NewInt(0xfffffffff)},
-		{
-			input: `0x112233445566778899aabbccddeeff`,
-			want:  referenceBig("112233445566778899aabbccddeeff"),
-		},
-		{
-			input: `0xffffffffffffffffffffffffffffffffffff`,
-			want:  referenceBig("ffffffffffffffffffffffffffffffffffff"),
-		},
-	}
-
-	decodeUint64Tests = []unmarshalTest{
-		// invalid
-		{input: `0`, wantErr: ErrMissingPrefix},
-		{input: `0x`, wantErr: ErrEmptyNumber},
-		{input: `0x01`, wantErr: ErrLeadingZero},
-		{input: `0xfffffffffffffffff`, wantErr: ErrUint64Range},
-		{input: `0xx`, wantErr: ErrSyntax},
-		{input: `0x1zz01`, wantErr: ErrSyntax},
-		// valid
-		{input: `0x0`, want: uint64(0)},
-		{input: `0x2`, want: uint64(0x2)},
-		{input: `0x2F2`, want: uint64(0x2f2)},
-		{input: `0X2F2`, want: uint64(0x2f2)},
-		{input: `0x1122aaff`, want: uint64(0x1122aaff)},
-		{input: `0xbbb`, want: uint64(0xbbb)},
-		{input: `0xffffffffffffffff`, want: uint64(0xffffffffffffffff)},
-	}
-)
-
-func TestEncode(t *testing.T) {
-	for _, test := range encodeBytesTests {
-		enc := Encode(test.input.([]byte))
-		if enc != test.want {
-			t.Errorf("input %x: wrong encoding %s", test.input, enc)
-		}
-	}
-}
-
-func TestDecode(t *testing.T) {
-	for _, test := range decodeBytesTests {
-		dec, err := Decode(test.input)
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if !bytes.Equal(test.want.([]byte), dec) {
-			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, dec, test.want)
-			continue
-		}
-	}
-}
-
-func TestEncodeBig(t *testing.T) {
-	for _, test := range encodeBigTests {
-		enc := EncodeBig(test.input.(*big.Int))
-		if enc != test.want {
-			t.Errorf("input %x: wrong encoding %s", test.input, enc)
-		}
-	}
-}
-
-func TestDecodeBig(t *testing.T) {
-	for _, test := range decodeBigTests {
-		dec, err := DecodeBig(test.input)
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if dec.Cmp(test.want.(*big.Int)) != 0 {
-			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, dec, test.want)
-			continue
-		}
-	}
-}
-
-func TestEncodeUint64(t *testing.T) {
-	for _, test := range encodeUint64Tests {
-		enc := EncodeUint64(test.input.(uint64))
-		if enc != test.want {
-			t.Errorf("input %x: wrong encoding %s", test.input, enc)
-		}
-	}
-}
-
-func TestDecodeUint64(t *testing.T) {
-	for _, test := range decodeUint64Tests {
-		dec, err := DecodeUint64(test.input)
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if dec != test.want.(uint64) {
-			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, dec, test.want)
-			continue
-		}
-	}
-}
--- a/common/hexutil/json.go
+++ b/common/hexutil/json.go
@ -1,266 +0,0 @@
-// 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 hexutil
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"math/big"
-	"strconv"
-)
-
-var (
-	jsonNull          = []byte("null")
-	jsonZero          = []byte(`"0x0"`)
-	errNonString      = errors.New("cannot unmarshal non-string as hex data")
-	errNegativeBigInt = errors.New("hexutil.Big: can't marshal negative integer")
-)
-
-// Bytes marshals/unmarshals as a JSON string with 0x prefix.
-// The empty slice marshals as "0x".
-type Bytes []byte
-
-// MarshalJSON implements json.Marshaler.
-func (b Bytes) MarshalJSON() ([]byte, error) {
-	result := make([]byte, len(b)*2+4)
-	copy(result, `"0x`)
-	hex.Encode(result[3:], b)
-	result[len(result)-1] = '"'
-	return result, nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (b *Bytes) UnmarshalJSON(input []byte) error {
-	raw, err := checkJSON(input)
-	if err != nil {
-		return err
-	}
-	dec := make([]byte, len(raw)/2)
-	if _, err = hex.Decode(dec, raw); err != nil {
-		err = mapError(err)
-	} else {
-		*b = dec
-	}
-	return err
-}
-
-// String returns the hex encoding of b.
-func (b Bytes) String() string {
-	return Encode(b)
-}
-
-// UnmarshalJSON decodes input as a JSON string with 0x prefix. The length of out
-// determines the required input length. This function is commonly used to implement the
-// UnmarshalJSON method for fixed-size types:
-//
-//     type Foo [8]byte
-//
-//     func (f *Foo) UnmarshalJSON(input []byte) error {
-//         return hexutil.UnmarshalJSON("Foo", input, f[:])
-//     }
-func UnmarshalJSON(typname string, input, out []byte) error {
-	raw, err := checkJSON(input)
-	if err != nil {
-		return err
-	}
-	if len(raw)/2 != len(out) {
-		return fmt.Errorf("hex string has length %d, want %d for %s", len(raw), len(out)*2, typname)
-	}
-	// Pre-verify syntax before modifying out.
-	for _, b := range raw {
-		if decodeNibble(b) == badNibble {
-			return ErrSyntax
-		}
-	}
-	hex.Decode(out, raw)
-	return nil
-}
-
-// Big marshals/unmarshals as a JSON string with 0x prefix. The zero value marshals as
-// "0x0". Negative integers are not supported at this time. Attempting to marshal them
-// will return an error.
-type Big big.Int
-
-// MarshalJSON implements json.Marshaler.
-func (b *Big) MarshalJSON() ([]byte, error) {
-	if b == nil {
-		return jsonNull, nil
-	}
-	bigint := (*big.Int)(b)
-	if bigint.Sign() == -1 {
-		return nil, errNegativeBigInt
-	}
-	nbits := bigint.BitLen()
-	if nbits == 0 {
-		return jsonZero, nil
-	}
-	enc := fmt.Sprintf(`"0x%x"`, bigint)
-	return []byte(enc), nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (b *Big) UnmarshalJSON(input []byte) error {
-	raw, err := checkNumberJSON(input)
-	if err != nil {
-		return err
-	}
-	words := make([]big.Word, len(raw)/bigWordNibbles+1)
-	end := len(raw)
-	for i := range words {
-		start := end - bigWordNibbles
-		if start < 0 {
-			start = 0
-		}
-		for ri := start; ri < end; ri++ {
-			nib := decodeNibble(raw[ri])
-			if nib == badNibble {
-				return ErrSyntax
-			}
-			words[i] *= 16
-			words[i] += big.Word(nib)
-		}
-		end = start
-	}
-	var dec big.Int
-	dec.SetBits(words)
-	*b = (Big)(dec)
-	return nil
-}
-
-// ToInt converts b to a big.Int.
-func (b *Big) ToInt() *big.Int {
-	return (*big.Int)(b)
-}
-
-// String returns the hex encoding of b.
-func (b *Big) String() string {
-	return EncodeBig(b.ToInt())
-}
-
-// Uint64 marshals/unmarshals as a JSON string with 0x prefix.
-// The zero value marshals as "0x0".
-type Uint64 uint64
-
-// MarshalJSON implements json.Marshaler.
-func (b Uint64) MarshalJSON() ([]byte, error) {
-	buf := make([]byte, 3, 12)
-	copy(buf, `"0x`)
-	buf = strconv.AppendUint(buf, uint64(b), 16)
-	buf = append(buf, '"')
-	return buf, nil
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (b *Uint64) UnmarshalJSON(input []byte) error {
-	raw, err := checkNumberJSON(input)
-	if err != nil {
-		return err
-	}
-	if len(raw) > 16 {
-		return ErrUint64Range
-	}
-	var dec uint64
-	for _, byte := range raw {
-		nib := decodeNibble(byte)
-		if nib == badNibble {
-			return ErrSyntax
-		}
-		dec *= 16
-		dec += uint64(nib)
-	}
-	*b = Uint64(dec)
-	return nil
-}
-
-// String returns the hex encoding of b.
-func (b Uint64) String() string {
-	return EncodeUint64(uint64(b))
-}
-
-// Uint marshals/unmarshals as a JSON string with 0x prefix.
-// The zero value marshals as "0x0".
-type Uint uint
-
-// MarshalJSON implements json.Marshaler.
-func (b Uint) MarshalJSON() ([]byte, error) {
-	return Uint64(b).MarshalJSON()
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (b *Uint) UnmarshalJSON(input []byte) error {
-	var u64 Uint64
-	err := u64.UnmarshalJSON(input)
-	if err != nil {
-		return err
-	} else if u64 > Uint64(^uint(0)) {
-		return ErrUintRange
-	}
-	*b = Uint(u64)
-	return nil
-}
-
-// String returns the hex encoding of b.
-func (b Uint) String() string {
-	return EncodeUint64(uint64(b))
-}
-
-func isString(input []byte) bool {
-	return len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"'
-}
-
-func bytesHave0xPrefix(input []byte) bool {
-	return len(input) >= 2 && input[0] == '0' && (input[1] == 'x' || input[1] == 'X')
-}
-
-func checkJSON(input []byte) (raw []byte, err error) {
-	if !isString(input) {
-		return nil, errNonString
-	}
-	if len(input) == 2 {
-		return nil, nil // empty strings are allowed
-	}
-	if !bytesHave0xPrefix(input[1:]) {
-		return nil, ErrMissingPrefix
-	}
-	input = input[3 : len(input)-1]
-	if len(input)%2 != 0 {
-		return nil, ErrOddLength
-	}
-	return input, nil
-}
-
-func checkNumberJSON(input []byte) (raw []byte, err error) {
-	if !isString(input) {
-		return nil, errNonString
-	}
-	input = input[1 : len(input)-1]
-	if len(input) == 0 {
-		return nil, nil // empty strings are allowed
-	}
-	if !bytesHave0xPrefix(input) {
-		return nil, ErrMissingPrefix
-	}
-	input = input[2:]
-	if len(input) == 0 {
-		return nil, ErrEmptyNumber
-	}
-	if len(input) > 1 && input[0] == '0' {
-		return nil, ErrLeadingZero
-	}
-	return input, nil
-}
--- a/common/hexutil/json_test.go
+++ b/common/hexutil/json_test.go
@ -1,258 +0,0 @@
-// 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 hexutil
-
-import (
-	"bytes"
-	"encoding/hex"
-	"math/big"
-	"testing"
-)
-
-func checkError(t *testing.T, input string, got, want error) bool {
-	if got == nil {
-		if want != nil {
-			t.Errorf("input %s: got no error, want %q", input, want)
-			return false
-		}
-		return true
-	}
-	if want == nil {
-		t.Errorf("input %s: unexpected error %q", input, got)
-	} else if got.Error() != want.Error() {
-		t.Errorf("input %s: got error %q, want %q", input, got, want)
-	}
-	return false
-}
-
-func referenceBig(s string) *big.Int {
-	b, ok := new(big.Int).SetString(s, 16)
-	if !ok {
-		panic("invalid")
-	}
-	return b
-}
-
-func referenceBytes(s string) []byte {
-	b, err := hex.DecodeString(s)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-var unmarshalBytesTests = []unmarshalTest{
-	// invalid encoding
-	{input: "", wantErr: errNonString},
-	{input: "null", wantErr: errNonString},
-	{input: "10", wantErr: errNonString},
-	{input: `"0"`, wantErr: ErrMissingPrefix},
-	{input: `"0x0"`, wantErr: ErrOddLength},
-	{input: `"0xxx"`, wantErr: ErrSyntax},
-	{input: `"0x01zz01"`, wantErr: ErrSyntax},
-
-	// valid encoding
-	{input: `""`, want: referenceBytes("")},
-	{input: `"0x"`, want: referenceBytes("")},
-	{input: `"0x02"`, want: referenceBytes("02")},
-	{input: `"0X02"`, want: referenceBytes("02")},
-	{input: `"0xffffffffff"`, want: referenceBytes("ffffffffff")},
-	{
-		input: `"0xffffffffffffffffffffffffffffffffffff"`,
-		want:  referenceBytes("ffffffffffffffffffffffffffffffffffff"),
-	},
-}
-
-func TestUnmarshalBytes(t *testing.T) {
-	for _, test := range unmarshalBytesTests {
-		var v Bytes
-		err := v.UnmarshalJSON([]byte(test.input))
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if !bytes.Equal(test.want.([]byte), []byte(v)) {
-			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, &v, test.want)
-			continue
-		}
-	}
-}
-
-func BenchmarkUnmarshalBytes(b *testing.B) {
-	input := []byte(`"0x123456789abcdef123456789abcdef"`)
-	for i := 0; i < b.N; i++ {
-		var v Bytes
-		if err := v.UnmarshalJSON(input); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func TestMarshalBytes(t *testing.T) {
-	for _, test := range encodeBytesTests {
-		in := test.input.([]byte)
-		out, err := Bytes(in).MarshalJSON()
-		if err != nil {
-			t.Errorf("%x: %v", in, err)
-			continue
-		}
-		if want := `"` + test.want + `"`; string(out) != want {
-			t.Errorf("%x: MarshalJSON output mismatch: got %q, want %q", in, out, want)
-			continue
-		}
-		if out := Bytes(in).String(); out != test.want {
-			t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
-			continue
-		}
-	}
-}
-
-var unmarshalBigTests = []unmarshalTest{
-	// invalid encoding
-	{input: "", wantErr: errNonString},
-	{input: "null", wantErr: errNonString},
-	{input: "10", wantErr: errNonString},
-	{input: `"0"`, wantErr: ErrMissingPrefix},
-	{input: `"0x"`, wantErr: ErrEmptyNumber},
-	{input: `"0x01"`, wantErr: ErrLeadingZero},
-	{input: `"0xx"`, wantErr: ErrSyntax},
-	{input: `"0x1zz01"`, wantErr: ErrSyntax},
-
-	// valid encoding
-	{input: `""`, want: big.NewInt(0)},
-	{input: `"0x0"`, want: big.NewInt(0)},
-	{input: `"0x2"`, want: big.NewInt(0x2)},
-	{input: `"0x2F2"`, want: big.NewInt(0x2f2)},
-	{input: `"0X2F2"`, want: big.NewInt(0x2f2)},
-	{input: `"0x1122aaff"`, want: big.NewInt(0x1122aaff)},
-	{input: `"0xbBb"`, want: big.NewInt(0xbbb)},
-	{input: `"0xfffffffff"`, want: big.NewInt(0xfffffffff)},
-	{
-		input: `"0x112233445566778899aabbccddeeff"`,
-		want:  referenceBig("112233445566778899aabbccddeeff"),
-	},
-	{
-		input: `"0xffffffffffffffffffffffffffffffffffff"`,
-		want:  referenceBig("ffffffffffffffffffffffffffffffffffff"),
-	},
-}
-
-func TestUnmarshalBig(t *testing.T) {
-	for _, test := range unmarshalBigTests {
-		var v Big
-		err := v.UnmarshalJSON([]byte(test.input))
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if test.want != nil && test.want.(*big.Int).Cmp((*big.Int)(&v)) != 0 {
-			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, (*big.Int)(&v), test.want)
-			continue
-		}
-	}
-}
-
-func BenchmarkUnmarshalBig(b *testing.B) {
-	input := []byte(`"0x123456789abcdef123456789abcdef"`)
-	for i := 0; i < b.N; i++ {
-		var v Big
-		if err := v.UnmarshalJSON(input); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func TestMarshalBig(t *testing.T) {
-	for _, test := range encodeBigTests {
-		in := test.input.(*big.Int)
-		out, err := (*Big)(in).MarshalJSON()
-		if err != nil {
-			t.Errorf("%d: %v", in, err)
-			continue
-		}
-		if want := `"` + test.want + `"`; string(out) != want {
-			t.Errorf("%d: MarshalJSON output mismatch: got %q, want %q", in, out, want)
-			continue
-		}
-		if out := (*Big)(in).String(); out != test.want {
-			t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
-			continue
-		}
-	}
-}
-
-var unmarshalUint64Tests = []unmarshalTest{
-	// invalid encoding
-	{input: "", wantErr: errNonString},
-	{input: "null", wantErr: errNonString},
-	{input: "10", wantErr: errNonString},
-	{input: `"0"`, wantErr: ErrMissingPrefix},
-	{input: `"0x"`, wantErr: ErrEmptyNumber},
-	{input: `"0x01"`, wantErr: ErrLeadingZero},
-	{input: `"0xfffffffffffffffff"`, wantErr: ErrUint64Range},
-	{input: `"0xx"`, wantErr: ErrSyntax},
-	{input: `"0x1zz01"`, wantErr: ErrSyntax},
-
-	// valid encoding
-	{input: `""`, want: uint64(0)},
-	{input: `"0x0"`, want: uint64(0)},
-	{input: `"0x2"`, want: uint64(0x2)},
-	{input: `"0x2F2"`, want: uint64(0x2f2)},
-	{input: `"0X2F2"`, want: uint64(0x2f2)},
-	{input: `"0x1122aaff"`, want: uint64(0x1122aaff)},
-	{input: `"0xbbb"`, want: uint64(0xbbb)},
-	{input: `"0xffffffffffffffff"`, want: uint64(0xffffffffffffffff)},
-}
-
-func TestUnmarshalUint64(t *testing.T) {
-	for _, test := range unmarshalUint64Tests {
-		var v Uint64
-		err := v.UnmarshalJSON([]byte(test.input))
-		if !checkError(t, test.input, err, test.wantErr) {
-			continue
-		}
-		if uint64(v) != test.want.(uint64) {
-			t.Errorf("input %s: value mismatch: got %d, want %d", test.input, v, test.want)
-			continue
-		}
-	}
-}
-
-func BenchmarkUnmarshalUint64(b *testing.B) {
-	input := []byte(`"0x123456789abcdf"`)
-	for i := 0; i < b.N; i++ {
-		var v Uint64
-		v.UnmarshalJSON(input)
-	}
-}
-
-func TestMarshalUint64(t *testing.T) {
-	for _, test := range encodeUint64Tests {
-		in := test.input.(uint64)
-		out, err := Uint64(in).MarshalJSON()
-		if err != nil {
-			t.Errorf("%d: %v", in, err)
-			continue
-		}
-		if want := `"` + test.want + `"`; string(out) != want {
-			t.Errorf("%d: MarshalJSON output mismatch: got %q, want %q", in, out, want)
-			continue
-		}
-		if out := (Uint64)(in).String(); out != test.want {
-			t.Errorf("%x: String mismatch: got %q, want %q", in, out, test.want)
-			continue
-		}
-	}
-}
--- a/common/httpclient/httpclient.go
+++ b/common/httpclient/httpclient.go
@ -0,0 +1,124 @@
+// 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 httpclient
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+type HTTPClient struct {
+	*http.Transport
+	DocRoot string
+	schemes []string
+}
+
+func New(docRoot string) (self *HTTPClient) {
+	self = &HTTPClient{
+		Transport: &http.Transport{},
+		DocRoot:   docRoot,
+		schemes:   []string{"file"},
+	}
+	self.RegisterProtocol("file", http.NewFileTransport(http.Dir(self.DocRoot)))
+	return
+}
+
+// Clients should be reused instead of created as needed. Clients are safe for concurrent use by multiple goroutines.
+
+// A Client is higher-level than a RoundTripper (such as Transport) and additionally handles HTTP details such as cookies and redirects.
+
+func (self *HTTPClient) Client() *http.Client {
+	return &http.Client{
+		Transport: self,
+	}
+}
+
+func (self *HTTPClient) RegisterScheme(scheme string, rt http.RoundTripper) {
+	self.schemes = append(self.schemes, scheme)
+	self.RegisterProtocol(scheme, rt)
+}
+
+func (self *HTTPClient) HasScheme(scheme string) bool {
+	for _, s := range self.schemes {
+		if s == scheme {
+			return true
+		}
+	}
+	return false
+}
+
+func (self *HTTPClient) GetAuthContent(uri string, hash common.Hash) ([]byte, error) {
+	// retrieve content
+	content, err := self.Get(uri, "")
+	if err != nil {
+		return nil, err
+	}
+
+	// check hash to authenticate content
+	chash := crypto.Keccak256Hash(content)
+	if chash != hash {
+		return nil, fmt.Errorf("content hash mismatch %x != %x (exp)", hash[:], chash[:])
+	}
+
+	return content, nil
+
+}
+
+// Get(uri, path) downloads the document at uri, if path is non-empty it
+// is interpreted as a filepath to which the contents are saved
+func (self *HTTPClient) Get(uri, path string) ([]byte, error) {
+	// retrieve content
+	resp, err := self.Client().Get(uri)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if resp != nil {
+			resp.Body.Close()
+		}
+	}()
+
+	var content []byte
+	content, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode/100 != 2 {
+		return content, fmt.Errorf("HTTP error: %s", resp.Status)
+	}
+
+	if path != "" {
+		var abspath string
+		abspath, err = filepath.Abs(path)
+		if err != nil {
+			return nil, err
+		}
+		err = ioutil.WriteFile(abspath, content, 0600)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return content, nil
+
+}
--- a/common/httpclient/httpclient_test.go
+++ b/common/httpclient/httpclient_test.go
@ -0,0 +1,77 @@
+// 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 httpclient
+
+import (
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+func TestGetAuthContent(t *testing.T) {
+	dir, err := ioutil.TempDir("", "httpclient-test")
+	if err != nil {
+		t.Fatal("cannot create temporary directory:", err)
+	}
+	defer os.RemoveAll(dir)
+	client := New(dir)
+
+	text := "test"
+	hash := crypto.Keccak256Hash([]byte(text))
+	if err := ioutil.WriteFile(path.Join(dir, "test.content"), []byte(text), os.ModePerm); err != nil {
+		t.Fatal("could not write test file", err)
+	}
+	content, err := client.GetAuthContent("file:///test.content", hash)
+	if err != nil {
+		t.Errorf("no error expected, got %v", err)
+	}
+	if string(content) != text {
+		t.Errorf("incorrect content. expected %v, got %v", text, string(content))
+	}
+
+	hash = common.Hash{}
+	content, err = client.GetAuthContent("file:///test.content", hash)
+	expected := "content hash mismatch 0000000000000000000000000000000000000000000000000000000000000000 != 9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658 (exp)"
+	if err == nil {
+		t.Errorf("expected error, got nothing")
+	} else {
+		if err.Error() != expected {
+			t.Errorf("expected error '%s' got '%v'", expected, err)
+		}
+	}
+
+}
+
+type rt struct{}
+
+func (rt) RoundTrip(req *http.Request) (resp *http.Response, err error) { return }
+
+func TestRegisterScheme(t *testing.T) {
+	client := New("/tmp/")
+	if client.HasScheme("scheme") {
+		t.Errorf("expected scheme not to be registered")
+	}
+	client.RegisterScheme("scheme", rt{})
+	if !client.HasScheme("scheme") {
+		t.Errorf("expected scheme to be registered")
+	}
+}
--- a/common/math/dist_test.go
+++ b/common/math/dist_test.go
@ -41,24 +41,24 @@ func TestSum(t *testing.T) {

 func TestDist(t *testing.T) {
 	var vectors = []Vector{
-		{big.NewInt(1000), big.NewInt(1234)},
-		{big.NewInt(500), big.NewInt(10023)},
-		{big.NewInt(1034), big.NewInt(1987)},
-		{big.NewInt(1034), big.NewInt(1987)},
-		{big.NewInt(8983), big.NewInt(1977)},
-		{big.NewInt(98382), big.NewInt(1887)},
-		{big.NewInt(12398), big.NewInt(1287)},
-		{big.NewInt(12398), big.NewInt(1487)},
-		{big.NewInt(12398), big.NewInt(1987)},
-		{big.NewInt(12398), big.NewInt(128)},
-		{big.NewInt(12398), big.NewInt(1987)},
-		{big.NewInt(1398), big.NewInt(187)},
-		{big.NewInt(12328), big.NewInt(1927)},
-		{big.NewInt(12398), big.NewInt(1987)},
-		{big.NewInt(22398), big.NewInt(1287)},
-		{big.NewInt(1370), big.NewInt(1981)},
-		{big.NewInt(12398), big.NewInt(1957)},
-		{big.NewInt(42198), big.NewInt(1987)},
+		Vector{big.NewInt(1000), big.NewInt(1234)},
+		Vector{big.NewInt(500), big.NewInt(10023)},
+		Vector{big.NewInt(1034), big.NewInt(1987)},
+		Vector{big.NewInt(1034), big.NewInt(1987)},
+		Vector{big.NewInt(8983), big.NewInt(1977)},
+		Vector{big.NewInt(98382), big.NewInt(1887)},
+		Vector{big.NewInt(12398), big.NewInt(1287)},
+		Vector{big.NewInt(12398), big.NewInt(1487)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(12398), big.NewInt(128)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(1398), big.NewInt(187)},
+		Vector{big.NewInt(12328), big.NewInt(1927)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(22398), big.NewInt(1287)},
+		Vector{big.NewInt(1370), big.NewInt(1981)},
+		Vector{big.NewInt(12398), big.NewInt(1957)},
+		Vector{big.NewInt(42198), big.NewInt(1987)},
 	}

 	VectorsBy(GasSort).Sort(vectors)
--- a/common/registrar/contracts.go
+++ b/common/registrar/contracts.go
--- a/common/registrar/ethreg/api.go
+++ b/common/registrar/ethreg/api.go
@ -0,0 +1,279 @@
+// 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 ethreg
+
+import (
+	"errors"
+	"math/big"
+
+	"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/registrar"
+	"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/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// registryAPIBackend is a backend for an Ethereum Registry.
+type registryAPIBackend struct {
+	config  *params.ChainConfig
+	bc      *core.BlockChain
+	chainDb ethdb.Database
+	txPool  *core.TxPool
+	am      *accounts.Manager
+}
+
+// PrivateRegistarAPI offers various functions to access the Ethereum registry.
+type PrivateRegistarAPI struct {
+	config *params.ChainConfig
+	be     *registryAPIBackend
+}
+
+// NewPrivateRegistarAPI creates a new PrivateRegistarAPI instance.
+func NewPrivateRegistarAPI(config *params.ChainConfig, bc *core.BlockChain, chainDb ethdb.Database, txPool *core.TxPool, am *accounts.Manager) *PrivateRegistarAPI {
+	return &PrivateRegistarAPI{
+		config: config,
+		be: &registryAPIBackend{
+			config:  config,
+			bc:      bc,
+			chainDb: chainDb,
+			txPool:  txPool,
+			am:      am,
+		},
+	}
+}
+
+// SetGlobalRegistrar allows clients to set the global registry for the node.
+// This method can be used to deploy a new registry. First zero out the current
+// address by calling the method with namereg = '0x0' and then call this method
+// again with '' as namereg. This will submit a transaction to the network which
+// will deploy a new registry on execution. The TX hash is returned. When called
+// with namereg '' and the current address is not zero the current global is
+// address is returned..
+func (api *PrivateRegistarAPI) SetGlobalRegistrar(namereg string, from common.Address) (string, error) {
+	return registrar.New(api.be).SetGlobalRegistrar(namereg, from)
+}
+
+// SetHashReg queries the registry for a hash.
+func (api *PrivateRegistarAPI) SetHashReg(hashreg string, from common.Address) (string, error) {
+	return registrar.New(api.be).SetHashReg(hashreg, from)
+}
+
+// SetUrlHint queries the registry for an url.
+func (api *PrivateRegistarAPI) SetUrlHint(hashreg string, from common.Address) (string, error) {
+	return registrar.New(api.be).SetUrlHint(hashreg, from)
+}
+
+// SaveInfo stores contract information on the local file system.
+func (api *PrivateRegistarAPI) SaveInfo(info *compiler.ContractInfo, filename string) (contenthash common.Hash, err error) {
+	return compiler.SaveInfo(info, filename)
+}
+
+// Register registers a new content hash in the registry.
+func (api *PrivateRegistarAPI) Register(sender common.Address, addr common.Address, contentHashHex string) (bool, error) {
+	block := api.be.bc.CurrentBlock()
+	state, err := state.New(block.Root(), api.be.chainDb)
+	if err != nil {
+		return false, err
+	}
+
+	codeb := state.GetCode(addr)
+	codeHash := common.BytesToHash(crypto.Keccak256(codeb))
+	contentHash := common.HexToHash(contentHashHex)
+
+	_, err = registrar.New(api.be).SetHashToHash(sender, codeHash, contentHash)
+	return err == nil, err
+}
+
+// RegisterUrl registers a new url in the registry.
+func (api *PrivateRegistarAPI) RegisterUrl(sender common.Address, contentHashHex string, url string) (bool, error) {
+	_, err := registrar.New(api.be).SetUrlToHash(sender, common.HexToHash(contentHashHex), url)
+	return err == nil, err
+}
+
+// callmsg is the message type used for call transations.
+type callmsg struct {
+	from          *state.StateObject
+	to            *common.Address
+	gas, gasPrice *big.Int
+	value         *big.Int
+	data          []byte
+}
+
+// accessor boilerplate to implement core.Message
+func (m callmsg) From() (common.Address, error) {
+	return m.from.Address(), nil
+}
+func (m callmsg) FromFrontier() (common.Address, error) {
+	return m.from.Address(), nil
+}
+func (m callmsg) Nonce() uint64 {
+	return 0
+}
+func (m callmsg) CheckNonce() bool {
+	return false
+}
+func (m callmsg) To() *common.Address {
+	return m.to
+}
+func (m callmsg) GasPrice() *big.Int {
+	return m.gasPrice
+}
+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
+}
+
+// Call forms a transaction from the given arguments and tries to execute it on
+// a private VM with a copy of the state. Any changes are therefore only temporary
+// and not part of the actual state. This allows for local execution/queries.
+func (be *registryAPIBackend) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, string, error) {
+	block := be.bc.CurrentBlock()
+	statedb, err := state.New(block.Root(), be.chainDb)
+	if err != nil {
+		return "", "", err
+	}
+
+	var from *state.StateObject
+	if len(fromStr) == 0 {
+		accounts := be.am.Accounts()
+		if len(accounts) == 0 {
+			from = statedb.GetOrNewStateObject(common.Address{})
+		} else {
+			from = statedb.GetOrNewStateObject(accounts[0].Address)
+		}
+	} else {
+		from = statedb.GetOrNewStateObject(common.HexToAddress(fromStr))
+	}
+
+	from.SetBalance(common.MaxBig)
+
+	var to *common.Address
+	if len(toStr) > 0 {
+		addr := common.HexToAddress(toStr)
+		to = &addr
+	}
+	gas := common.Big(gasStr)
+	if gas.BitLen() == 0 {
+		gas = big.NewInt(50000000)
+	}
+	gasPrice := common.Big(gasPriceStr)
+	if gasPrice.BitLen() == 0 {
+		gasPrice = new(big.Int).Mul(big.NewInt(50), common.Shannon)
+	}
+	msg := types.NewMessage(from.Address(), to, 0, common.Big(valueStr), gas, gasPrice, common.FromHex(dataStr), false)
+
+	header := be.bc.CurrentBlock().Header()
+	vmenv := core.NewEnv(statedb, be.config, be.bc, msg, header, vm.Config{})
+	gp := new(core.GasPool).AddGas(common.MaxBig)
+	res, gas, err := core.ApplyMessage(vmenv, msg, gp)
+
+	return common.ToHex(res), gas.String(), err
+}
+
+// StorageAt returns the data stores in the state for the given address and location.
+func (be *registryAPIBackend) StorageAt(addr string, storageAddr string) string {
+	block := be.bc.CurrentBlock()
+	state, err := state.New(block.Root(), be.chainDb)
+	if err != nil {
+		return ""
+	}
+	return state.GetState(common.HexToAddress(addr), common.HexToHash(storageAddr)).Hex()
+}
+
+// Transact forms a transaction from the given arguments and submits it to the
+// transactio pool for execution.
+func (be *registryAPIBackend) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
+	if len(toStr) > 0 && toStr != "0x" && !common.IsHexAddress(toStr) {
+		return "", errors.New("invalid address")
+	}
+
+	var (
+		from             = common.HexToAddress(fromStr)
+		to               = common.HexToAddress(toStr)
+		value            = common.Big(valueStr)
+		gas              *big.Int
+		price            *big.Int
+		data             []byte
+		contractCreation bool
+	)
+
+	if len(gasStr) == 0 {
+		gas = big.NewInt(90000)
+	} else {
+		gas = common.Big(gasStr)
+	}
+
+	if len(gasPriceStr) == 0 {
+		price = big.NewInt(10000000000000)
+	} else {
+		price = common.Big(gasPriceStr)
+	}
+
+	data = common.FromHex(codeStr)
+	if len(toStr) == 0 {
+		contractCreation = true
+	}
+
+	nonce := be.txPool.State().GetNonce(from)
+	if len(nonceStr) != 0 {
+		nonce = common.Big(nonceStr).Uint64()
+	}
+
+	var tx *types.Transaction
+	if contractCreation {
+		tx = types.NewContractCreation(nonce, value, gas, price, data)
+	} else {
+		tx = types.NewTransaction(nonce, to, value, gas, price, data)
+	}
+
+	sigHash := (types.HomesteadSigner{}).Hash(tx)
+	signature, err := be.am.SignEthereum(from, sigHash.Bytes())
+	if err != nil {
+		return "", err
+	}
+	signedTx, err := tx.WithSignature(types.HomesteadSigner{}, signature)
+	if err != nil {
+		return "", err
+	}
+
+	be.txPool.SetLocal(signedTx)
+	if err := be.txPool.Add(signedTx); err != nil {
+		return "", nil
+	}
+
+	if contractCreation {
+		addr := crypto.CreateAddress(from, 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().Hex(), nil
+}
--- a/common/registrar/registrar.go
+++ b/common/registrar/registrar.go
@ -0,0 +1,436 @@
+// 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 registrar
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/big"
+	"regexp"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+)
+
+/*
+Registrar implements the Ethereum name registrar services mapping
+- arbitrary strings to ethereum addresses
+- hashes to hashes
+- hashes to arbitrary strings
+(likely will provide lookup service for all three)
+
+The Registrar is used by
+* the roundtripper transport implementation of
+url schemes to resolve domain names and services that register these names
+* contract info retrieval (NatSpec).
+
+The Registrar uses 3 contracts on the blockchain:
+* GlobalRegistrar: Name (string) -> Address (Owner)
+* HashReg : Key Hash (hash of domain name or contract code) -> Content Hash
+* UrlHint : Content Hash -> Url Hint
+
+These contracts are (currently) not included in the genesis block.
+Each Set<X> needs to be called once on each blockchain/network once.
+
+Contract addresses need to be set the first time any Registrar method is called
+in a client session.
+This is done for frontier by default, otherwise the caller needs to make sure
+the relevant environment initialised the desired contracts
+*/
+var (
+	// GlobalRegistrarAddr = "0xc6d9d2cd449a754c494264e1809c50e34d64562b" // olympic
+	GlobalRegistrarAddr = "0x33990122638b9132ca29c723bdf037f1a891a70c" // frontier
+	HashRegAddr         = "0x23bf622b5a65f6060d855fca401133ded3520620" // frontier
+	UrlHintAddr         = "0x73ed5ef6c010727dfd2671dbb70faac19ec18626" // frontier
+
+	zero = regexp.MustCompile("^(0x)?0*$")
+)
+
+const (
+	trueHex  = "0000000000000000000000000000000000000000000000000000000000000001"
+	falseHex = "0000000000000000000000000000000000000000000000000000000000000000"
+)
+
+func abiSignature(s string) string {
+	return common.ToHex(crypto.Keccak256([]byte(s))[:4])
+}
+
+var (
+	HashRegName = "HashReg"
+	UrlHintName = "UrlHint"
+
+	registerContentHashAbi = abiSignature("register(uint256,uint256)")
+	registerUrlAbi         = abiSignature("register(uint256,uint8,uint256)")
+	setOwnerAbi            = abiSignature("setowner()")
+	reserveAbi             = abiSignature("reserve(bytes32)")
+	resolveAbi             = abiSignature("addr(bytes32)")
+	registerAbi            = abiSignature("setAddress(bytes32,address,bool)")
+	addressAbiPrefix       = falseHex[:24]
+)
+
+// Registrar's backend is defined as an interface (implemented by xeth, but could be remote)
+type Backend interface {
+	StorageAt(string, string) string
+	Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error)
+	Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, string, error)
+}
+
+// TODO Registrar should also just implement The Resolver and Registry interfaces
+// Simplify for now.
+type VersionedRegistrar interface {
+	Resolver(*big.Int) *Registrar
+	Registry() *Registrar
+}
+
+type Registrar struct {
+	backend Backend
+}
+
+func New(b Backend) (res *Registrar) {
+	res = &Registrar{b}
+	return
+}
+
+func (self *Registrar) SetGlobalRegistrar(namereg string, addr common.Address) (txhash string, err error) {
+	if namereg != "" {
+		GlobalRegistrarAddr = namereg
+		return
+	}
+	if zero.MatchString(GlobalRegistrarAddr) {
+		if (addr == common.Address{}) {
+			err = fmt.Errorf("GlobalRegistrar address not found and sender for creation not given")
+			return
+		} else {
+			txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "800000", "", GlobalRegistrarCode)
+			if err != nil {
+				err = fmt.Errorf("GlobalRegistrar address not found and sender for creation failed: %v", err)
+				return
+			}
+		}
+	}
+	return
+}
+
+func (self *Registrar) SetHashReg(hashreg string, addr common.Address) (txhash string, err error) {
+	if hashreg != "" {
+		HashRegAddr = hashreg
+	} else {
+		if !zero.MatchString(HashRegAddr) {
+			return
+		}
+		nameHex, extra := encodeName(HashRegName, 2)
+		hashRegAbi := resolveAbi + nameHex + extra
+		glog.V(logger.Detail).Infof("\ncall HashRegAddr %v with %v\n", GlobalRegistrarAddr, hashRegAbi)
+		var res string
+		res, _, err = self.backend.Call("", GlobalRegistrarAddr, "", "", "", hashRegAbi)
+		if len(res) >= 40 {
+			HashRegAddr = "0x" + res[len(res)-40:len(res)]
+		}
+		if err != nil || zero.MatchString(HashRegAddr) {
+			if (addr == common.Address{}) {
+				err = fmt.Errorf("HashReg address not found and sender for creation not given")
+				return
+			}
+
+			txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "", "", HashRegCode)
+			if err != nil {
+				err = fmt.Errorf("HashReg address not found and sender for creation failed: %v", err)
+			}
+			glog.V(logger.Detail).Infof("created HashRegAddr @ txhash %v\n", txhash)
+		} else {
+			glog.V(logger.Detail).Infof("HashRegAddr found at @ %v\n", HashRegAddr)
+			return
+		}
+	}
+
+	return
+}
+
+func (self *Registrar) SetUrlHint(urlhint string, addr common.Address) (txhash string, err error) {
+	if urlhint != "" {
+		UrlHintAddr = urlhint
+	} else {
+		if !zero.MatchString(UrlHintAddr) {
+			return
+		}
+		nameHex, extra := encodeName(UrlHintName, 2)
+		urlHintAbi := resolveAbi + nameHex + extra
+		glog.V(logger.Detail).Infof("UrlHint address query data: %s to %s", urlHintAbi, GlobalRegistrarAddr)
+		var res string
+		res, _, err = self.backend.Call("", GlobalRegistrarAddr, "", "", "", urlHintAbi)
+		if len(res) >= 40 {
+			UrlHintAddr = "0x" + res[len(res)-40:len(res)]
+		}
+		if err != nil || zero.MatchString(UrlHintAddr) {
+			if (addr == common.Address{}) {
+				err = fmt.Errorf("UrlHint address not found and sender for creation not given")
+				return
+			}
+			txhash, err = self.backend.Transact(addr.Hex(), "", "", "", "210000", "", UrlHintCode)
+			if err != nil {
+				err = fmt.Errorf("UrlHint address not found and sender for creation failed: %v", err)
+			}
+			glog.V(logger.Detail).Infof("created UrlHint @ txhash %v\n", txhash)
+		} else {
+			glog.V(logger.Detail).Infof("UrlHint found @ %v\n", HashRegAddr)
+			return
+		}
+	}
+
+	return
+}
+
+// ReserveName(from, name) reserves name for the sender address in the globalRegistrar
+// the tx needs to be mined to take effect
+func (self *Registrar) ReserveName(address common.Address, name string) (txh string, err error) {
+	if zero.MatchString(GlobalRegistrarAddr) {
+		return "", fmt.Errorf("GlobalRegistrar address is not set")
+	}
+	nameHex, extra := encodeName(name, 2)
+	abi := reserveAbi + nameHex + extra
+	glog.V(logger.Detail).Infof("Reserve data: %s", abi)
+	return self.backend.Transact(
+		address.Hex(),
+		GlobalRegistrarAddr,
+		"", "", "", "",
+		abi,
+	)
+}
+
+// SetAddressToName(from, name, addr) will set the Address to address for name
+// in the globalRegistrar using from as the sender of the transaction
+// the tx needs to be mined to take effect
+func (self *Registrar) SetAddressToName(from common.Address, name string, address common.Address) (txh string, err error) {
+	if zero.MatchString(GlobalRegistrarAddr) {
+		return "", fmt.Errorf("GlobalRegistrar address is not set")
+	}
+
+	nameHex, extra := encodeName(name, 6)
+	addrHex := encodeAddress(address)
+
+	abi := registerAbi + nameHex + addrHex + trueHex + extra
+	glog.V(logger.Detail).Infof("SetAddressToName data: %s to %s ", abi, GlobalRegistrarAddr)
+
+	return self.backend.Transact(
+		from.Hex(),
+		GlobalRegistrarAddr,
+		"", "", "", "",
+		abi,
+	)
+}
+
+// NameToAddr(from, name) queries the registrar for the address on name
+func (self *Registrar) NameToAddr(from common.Address, name string) (address common.Address, err error) {
+	if zero.MatchString(GlobalRegistrarAddr) {
+		return address, fmt.Errorf("GlobalRegistrar address is not set")
+	}
+
+	nameHex, extra := encodeName(name, 2)
+	abi := resolveAbi + nameHex + extra
+	glog.V(logger.Detail).Infof("NameToAddr data: %s", abi)
+	res, _, err := self.backend.Call(
+		from.Hex(),
+		GlobalRegistrarAddr,
+		"", "", "",
+		abi,
+	)
+	if err != nil {
+		return
+	}
+	address = common.HexToAddress(res)
+	return
+}
+
+// called as first step in the registration process on HashReg
+func (self *Registrar) SetOwner(address common.Address) (txh string, err error) {
+	if zero.MatchString(HashRegAddr) {
+		return "", fmt.Errorf("HashReg address is not set")
+	}
+	return self.backend.Transact(
+		address.Hex(),
+		HashRegAddr,
+		"", "", "", "",
+		setOwnerAbi,
+	)
+}
+
+// registers some content hash to a key/code hash
+// e.g., the contract Info combined Json Doc's ContentHash
+// to CodeHash of a contract or hash of a domain
+func (self *Registrar) SetHashToHash(address common.Address, codehash, dochash common.Hash) (txh string, err error) {
+	if zero.MatchString(HashRegAddr) {
+		return "", fmt.Errorf("HashReg address is not set")
+	}
+
+	_, err = self.SetOwner(address)
+	if err != nil {
+		return
+	}
+	codehex := common.Bytes2Hex(codehash[:])
+	dochex := common.Bytes2Hex(dochash[:])
+
+	data := registerContentHashAbi + codehex + dochex
+	glog.V(logger.Detail).Infof("SetHashToHash data: %s sent  to %v\n", data, HashRegAddr)
+	return self.backend.Transact(
+		address.Hex(),
+		HashRegAddr,
+		"", "", "", "",
+		data,
+	)
+}
+
+// SetUrlToHash(from, hash, url) registers a url to a content hash so that the content can be fetched
+// address is used as sender for the transaction and will be the owner of a new
+// registry entry on first time use
+// FIXME: silently doing nothing if sender is not the owner
+// note that with content addressed storage, this step is no longer necessary
+func (self *Registrar) SetUrlToHash(address common.Address, hash common.Hash, url string) (txh string, err error) {
+	if zero.MatchString(UrlHintAddr) {
+		return "", fmt.Errorf("UrlHint address is not set")
+	}
+
+	hashHex := common.Bytes2Hex(hash[:])
+	var urlHex string
+	urlb := []byte(url)
+	var cnt byte
+	n := len(urlb)
+
+	for n > 0 {
+		if n > 32 {
+			n = 32
+		}
+		urlHex = common.Bytes2Hex(urlb[:n])
+		urlb = urlb[n:]
+		n = len(urlb)
+		bcnt := make([]byte, 32)
+		bcnt[31] = cnt
+		data := registerUrlAbi +
+			hashHex +
+			common.Bytes2Hex(bcnt) +
+			common.Bytes2Hex(common.Hex2BytesFixed(urlHex, 32))
+		txh, err = self.backend.Transact(
+			address.Hex(),
+			UrlHintAddr,
+			"", "", "", "",
+			data,
+		)
+		if err != nil {
+			return
+		}
+		cnt++
+	}
+	return
+}
+
+// HashToHash(key) resolves contenthash for key (a hash) using HashReg
+// resolution is costless non-transactional
+// implemented as direct retrieval from  db
+func (self *Registrar) HashToHash(khash common.Hash) (chash common.Hash, err error) {
+	if zero.MatchString(HashRegAddr) {
+		return common.Hash{}, fmt.Errorf("HashReg address is not set")
+	}
+
+	// look up in hashReg
+	at := HashRegAddr[2:]
+	key := storageAddress(storageMapping(storageIdx2Addr(1), khash[:]))
+	hash := self.backend.StorageAt(at, key)
+
+	if hash == "0x0" || len(hash) < 3 || (hash == common.Hash{}.Hex()) {
+		err = fmt.Errorf("HashToHash: content hash not found for '%v'", khash.Hex())
+		return
+	}
+	copy(chash[:], common.Hex2BytesFixed(hash[2:], 32))
+	return
+}
+
+// HashToUrl(contenthash) resolves the url for contenthash using UrlHint
+// resolution is costless non-transactional
+// implemented as direct retrieval from  db
+// if we use content addressed storage, this step is no longer necessary
+func (self *Registrar) HashToUrl(chash common.Hash) (uri string, err error) {
+	if zero.MatchString(UrlHintAddr) {
+		return "", fmt.Errorf("UrlHint address is not set")
+	}
+	// look up in URL reg
+	var str string = " "
+	var idx uint32
+	for len(str) > 0 {
+		mapaddr := storageMapping(storageIdx2Addr(1), chash[:])
+		key := storageAddress(storageFixedArray(mapaddr, storageIdx2Addr(idx)))
+		hex := self.backend.StorageAt(UrlHintAddr[2:], key)
+		str = string(common.Hex2Bytes(hex[2:]))
+		l := 0
+		for (l < len(str)) && (str[l] == 0) {
+			l++
+		}
+
+		str = str[l:]
+		uri = uri + str
+		idx++
+	}
+
+	if len(uri) == 0 {
+		err = fmt.Errorf("HashToUrl: URL hint not found for '%v'", chash.Hex())
+	}
+	return
+}
+
+func storageIdx2Addr(varidx uint32) []byte {
+	data := make([]byte, 32)
+	binary.BigEndian.PutUint32(data[28:32], varidx)
+	return data
+}
+
+func storageMapping(addr, key []byte) []byte {
+	data := make([]byte, 64)
+	copy(data[0:32], key[0:32])
+	copy(data[32:64], addr[0:32])
+	sha := crypto.Keccak256(data)
+	return sha
+}
+
+func storageFixedArray(addr, idx []byte) []byte {
+	var carry byte
+	for i := 31; i >= 0; i-- {
+		var b byte = addr[i] + idx[i] + carry
+		if b < addr[i] {
+			carry = 1
+		} else {
+			carry = 0
+		}
+		addr[i] = b
+	}
+	return addr
+}
+
+func storageAddress(addr []byte) string {
+	return common.ToHex(addr)
+}
+
+func encodeAddress(address common.Address) string {
+	return addressAbiPrefix + address.Hex()[2:]
+}
+
+func encodeName(name string, index uint8) (string, string) {
+	extra := common.Bytes2Hex([]byte(name))
+	if len(name) > 32 {
+		return fmt.Sprintf("%064x", index), extra
+	}
+	return extra + falseHex[len(extra):], ""
+}
--- a/common/registrar/registrar_test.go
+++ b/common/registrar/registrar_test.go
@ -0,0 +1,158 @@
+// 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 registrar
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+type testBackend struct {
+	// contracts mock
+	contracts map[string](map[string]string)
+}
+
+var (
+	text     = "test"
+	codehash = common.StringToHash("1234")
+	hash     = common.BytesToHash(crypto.Keccak256([]byte(text)))
+	url      = "bzz://bzzhash/my/path/contr.act"
+)
+
+func NewTestBackend() *testBackend {
+	self := &testBackend{}
+	self.contracts = make(map[string](map[string]string))
+	return self
+}
+
+func (self *testBackend) initHashReg() {
+	self.contracts[HashRegAddr[2:]] = make(map[string]string)
+	key := storageAddress(storageMapping(storageIdx2Addr(1), codehash[:]))
+	self.contracts[HashRegAddr[2:]][key] = hash.Hex()
+}
+
+func (self *testBackend) initUrlHint() {
+	self.contracts[UrlHintAddr[2:]] = make(map[string]string)
+	mapaddr := storageMapping(storageIdx2Addr(1), hash[:])
+
+	key := storageAddress(storageFixedArray(mapaddr, storageIdx2Addr(0)))
+	self.contracts[UrlHintAddr[2:]][key] = common.ToHex([]byte(url))
+	key = storageAddress(storageFixedArray(mapaddr, storageIdx2Addr(1)))
+	self.contracts[UrlHintAddr[2:]][key] = "0x0"
+}
+
+func (self *testBackend) StorageAt(ca, sa string) (res string) {
+	c := self.contracts[ca]
+	if c == nil {
+		return "0x0"
+	}
+	res = c[sa]
+	return
+}
+
+func (self *testBackend) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
+	return "", nil
+}
+
+func (self *testBackend) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, string, error) {
+	return "", "", nil
+}
+
+func TestSetGlobalRegistrar(t *testing.T) {
+	b := NewTestBackend()
+	res := New(b)
+	_, err := res.SetGlobalRegistrar("addresshex", common.BigToAddress(common.Big1))
+	if err != nil {
+		t.Errorf("unexpected error: %v'", err)
+	}
+}
+
+func TestHashToHash(t *testing.T) {
+	b := NewTestBackend()
+	res := New(b)
+
+	HashRegAddr = "0x0"
+	got, err := res.HashToHash(codehash)
+	if err == nil {
+		t.Errorf("expected error")
+	} else {
+		exp := "HashReg address is not set"
+		if err.Error() != exp {
+			t.Errorf("incorrect error, expected '%v', got '%v'", exp, err.Error())
+		}
+	}
+
+	HashRegAddr = common.BigToAddress(common.Big1).Hex() //[2:]
+	got, err = res.HashToHash(codehash)
+	if err == nil {
+		t.Errorf("expected error")
+	} else {
+		exp := "HashToHash: content hash not found for '" + codehash.Hex() + "'"
+		if err.Error() != exp {
+			t.Errorf("incorrect error, expected '%v', got '%v'", exp, err.Error())
+		}
+	}
+
+	b.initHashReg()
+	got, err = res.HashToHash(codehash)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	} else {
+		if got != hash {
+			t.Errorf("incorrect result, expected '%v', got '%v'", hash.Hex(), got.Hex())
+		}
+	}
+}
+
+func TestHashToUrl(t *testing.T) {
+	b := NewTestBackend()
+	res := New(b)
+
+	UrlHintAddr = "0x0"
+	got, err := res.HashToUrl(hash)
+	if err == nil {
+		t.Errorf("expected error")
+	} else {
+		exp := "UrlHint address is not set"
+		if err.Error() != exp {
+			t.Errorf("incorrect error, expected '%v', got '%v'", exp, err.Error())
+		}
+	}
+
+	UrlHintAddr = common.BigToAddress(common.Big2).Hex() //[2:]
+	got, err = res.HashToUrl(hash)
+	if err == nil {
+		t.Errorf("expected error")
+	} else {
+		exp := "HashToUrl: URL hint not found for '" + hash.Hex() + "'"
+		if err.Error() != exp {
+			t.Errorf("incorrect error, expected '%v', got '%v'", exp, err.Error())
+		}
+	}
+
+	b.initUrlHint()
+	got, err = res.HashToUrl(hash)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	} else {
+		if got != url {
+			t.Errorf("incorrect result, expected '%v', got '%s'", url, got)
+		}
+	}
+}
--- a/common/types.go
+++ b/common/types.go
@ -17,12 +17,14 @@
 package common

 import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
 	"fmt"
 	"math/big"
 	"math/rand"
 	"reflect"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
+	"strings"
 )

 const (
@ -30,6 +32,8 @@ const (
 	AddressLength = 20
 )

+var hashJsonLengthErr = errors.New("common: unmarshalJSON failed: hash must be exactly 32 bytes")
+
 type (
 	// Hash represents the 32 byte Keccak256 hash of arbitrary data.
 	Hash [HashLength]byte
@ -53,16 +57,30 @@ func HexToHash(s string) Hash    { return BytesToHash(FromHex(s)) }
 func (h Hash) Str() string   { return string(h[:]) }
 func (h Hash) Bytes() []byte { return h[:] }
 func (h Hash) Big() *big.Int { return Bytes2Big(h[:]) }
-func (h Hash) Hex() string   { return hexutil.Encode(h[:]) }
+func (h Hash) Hex() string   { return "0x" + Bytes2Hex(h[:]) }

 // UnmarshalJSON parses a hash in its hex from to a hash.
 func (h *Hash) UnmarshalJSON(input []byte) error {
-	return hexutil.UnmarshalJSON("Hash", input, h[:])
+	length := len(input)
+	if length >= 2 && input[0] == '"' && input[length-1] == '"' {
+		input = input[1 : length-1]
+	}
+	// strip "0x" for length check
+	if len(input) > 1 && strings.ToLower(string(input[:2])) == "0x" {
+		input = input[2:]
+	}
+
+	// validate the length of the input hash
+	if len(input) != HashLength*2 {
+		return hashJsonLengthErr
+	}
+	h.SetBytes(FromHex(string(input)))
+	return nil
 }

 // Serialize given hash to JSON
 func (h Hash) MarshalJSON() ([]byte, error) {
-	return hexutil.Bytes(h[:]).MarshalJSON()
+	return json.Marshal(h.Hex())
 }

 // Sets the hash to the value of b. If b is larger than len(h) it will panic
@ -124,7 +142,7 @@ func (a Address) Str() string   { return string(a[:]) }
 func (a Address) Bytes() []byte { return a[:] }
 func (a Address) Big() *big.Int { return Bytes2Big(a[:]) }
 func (a Address) Hash() Hash    { return BytesToHash(a[:]) }
-func (a Address) Hex() string   { return hexutil.Encode(a[:]) }
+func (a Address) Hex() string   { return "0x" + Bytes2Hex(a[:]) }

 // Sets the address to the value of b. If b is larger than len(a) it will panic
 func (a *Address) SetBytes(b []byte) {
@ -146,12 +164,34 @@ func (a *Address) Set(other Address) {

 // Serialize given address to JSON
 func (a Address) MarshalJSON() ([]byte, error) {
-	return hexutil.Bytes(a[:]).MarshalJSON()
+	return json.Marshal(a.Hex())
 }

 // Parse address from raw json data
-func (a *Address) UnmarshalJSON(input []byte) error {
-	return hexutil.UnmarshalJSON("Address", input, a[:])
+func (a *Address) UnmarshalJSON(data []byte) error {
+	if len(data) > 2 && data[0] == '"' && data[len(data)-1] == '"' {
+		data = data[1 : len(data)-1]
+	}
+
+	if len(data) > 2 && data[0] == '0' && data[1] == 'x' {
+		data = data[2:]
+	}
+
+	if len(data) != 2*AddressLength {
+		return fmt.Errorf("Invalid address length, expected %d got %d bytes", 2*AddressLength, len(data))
+	}
+
+	n, err := hex.Decode(a[:], data)
+	if err != nil {
+		return err
+	}
+
+	if n != AddressLength {
+		return fmt.Errorf("Invalid address")
+	}
+
+	a.Set(HexToAddress(string(data)))
+	return nil
 }

 // PP Pretty Prints a byte slice in the following format:
--- a/common/types_test.go
+++ b/common/types_test.go
@ -18,10 +18,7 @@ package common

 import (
 	"math/big"
-	"strings"
 	"testing"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
 )

 func TestBytesConversion(t *testing.T) {
@ -41,26 +38,19 @@ func TestHashJsonValidation(t *testing.T) {
 	var tests = []struct {
 		Prefix string
 		Size   int
-		Error  string
+		Error  error
 	}{
-		{"", 62, hexutil.ErrMissingPrefix.Error()},
-		{"0x", 66, "hex string has length 66, want 64 for Hash"},
-		{"0x", 63, hexutil.ErrOddLength.Error()},
-		{"0x", 0, "hex string has length 0, want 64 for Hash"},
-		{"0x", 64, ""},
-		{"0X", 64, ""},
+		{"", 2, hashJsonLengthErr},
+		{"", 62, hashJsonLengthErr},
+		{"", 66, hashJsonLengthErr},
+		{"", 65, hashJsonLengthErr},
+		{"0X", 64, nil},
+		{"0x", 64, nil},
+		{"0x", 62, hashJsonLengthErr},
 	}
-	for _, test := range tests {
-		input := `"` + test.Prefix + strings.Repeat("0", test.Size) + `"`
-		err := h.UnmarshalJSON([]byte(input))
-		if err == nil {
-			if test.Error != "" {
-				t.Errorf("%s: error mismatch: have nil, want %q", input, test.Error)
-			}
-		} else {
-			if err.Error() != test.Error {
-				t.Errorf("%s: error mismatch: have %q, want %q", input, err, test.Error)
-			}
+	for i, test := range tests {
+		if err := h.UnmarshalJSON(append([]byte(test.Prefix), make([]byte, test.Size)...)); err != test.Error {
+			t.Errorf("test #%d: error mismatch: have %v, want %v", i, err, test.Error)
 		}
 	}
 }
--- a/compression/rle/read_write.go
+++ b/compression/rle/read_write.go
@ -76,9 +76,9 @@ func compressChunk(dat []byte) (ret []byte, n int) {
 		}
 		return []byte{token, byte(j + 2)}, j
 	case len(dat) >= 32:
-		if dat[0] == empty[0] && bytes.Equal(dat[:32], empty) {
+		if dat[0] == empty[0] && bytes.Compare(dat[:32], empty) == 0 {
 			return []byte{token, emptyShaToken}, 32
-		} else if dat[0] == emptyList[0] && bytes.Equal(dat[:32], emptyList) {
+		} else if dat[0] == emptyList[0] && bytes.Compare(dat[:32], emptyList) == 0 {
 			return []byte{token, emptyListShaToken}, 32
 		}
 		fallthrough
--- a/console/bridge.go
+++ b/console/bridge.go
@ -46,7 +46,7 @@ func newBridge(client *rpc.Client, prompter UserPrompter, printer io.Writer) *br
 }

 // NewAccount is a wrapper around the personal.newAccount RPC method that uses a
-// non-echoing password prompt to acquire the passphrase and executes the original
+// 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 (
@ -75,7 +75,7 @@ func (b *bridge) NewAccount(call otto.FunctionCall) (response otto.Value) {
 	default:
 		throwJSException("expected 0 or 1 string argument")
 	}
-	// Password acquired, execute the call and return
+	// Password aquired, execute the call and return
 	ret, err := call.Otto.Call("jeth.newAccount", nil, password)
 	if err != nil {
 		throwJSException(err.Error())
@ -84,7 +84,7 @@ func (b *bridge) NewAccount(call otto.FunctionCall) (response otto.Value) {
 }

 // UnlockAccount is a wrapper around the personal.unlockAccount RPC method that
-// uses a non-echoing password prompt to acquire the passphrase and executes the
+// 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) {
@ -127,7 +127,7 @@ func (b *bridge) UnlockAccount(call otto.FunctionCall) (response otto.Value) {
 }

 // Sign is a wrapper around the personal.sign RPC method that uses a non-echoing password
-// prompt to acquire the passphrase and executes the original RPC method (saved in
+// prompt to aquire the passphrase and executes the original RPC method (saved in
 // jeth.sign) with it to actually execute the RPC call.
 func (b *bridge) Sign(call otto.FunctionCall) (response otto.Value) {
 	var (
@ -270,15 +270,18 @@ func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) {
 			} else {
 				resultVal, err := JSON.Call("parse", string(result))
 				if err != nil {
-					setError(resp, -32603, err.Error())
+					resp = newErrorResponse(call, -32603, err.Error(), &req.Id).Object()
 				} else {
 					resp.Set("result", resultVal)
 				}
 			}
 		case rpc.Error:
-			setError(resp, err.ErrorCode(), err.Error())
+			resp.Set("error", map[string]interface{}{
+				"code":    err.ErrorCode(),
+				"message": err.Error(),
+			})
 		default:
-			setError(resp, -32603, err.Error())
+			resp = newErrorResponse(call, -32603, err.Error(), &req.Id).Object()
 		}
 		resps.Call("push", resp)
 	}
@ -297,8 +300,12 @@ func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) {
 	return response
 }

-func setError(resp *otto.Object, code int, msg string) {
-	resp.Set("error", map[string]interface{}{"code": code, "message": msg})
+func newErrorResponse(call otto.FunctionCall, code int, msg string, id interface{}) otto.Value {
+	// Bundle the error into a JSON RPC call response
+	m := map[string]interface{}{"version": "2.0", "id": id, "error": map[string]interface{}{"code": code, msg: msg}}
+	res, _ := json.Marshal(m)
+	val, _ := call.Otto.Run("(" + string(res) + ")")
+	return val
 }

 // throwJSException panics on an otto.Value. The Otto VM will recover from the
--- a/console/console.go
+++ b/console/console.go
@ -36,9 +36,9 @@ import (
 )

 var (
-	passwordRegexp = regexp.MustCompile(`personal.[nus]`)
-	onlyWhitespace = regexp.MustCompile(`^\s*$`)
-	exit           = regexp.MustCompile(`^\s*exit\s*;*\s*$`)
+	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.
@ -226,8 +226,8 @@ func (c *Console) AutoCompleteInput(line string, pos int) (string, []string, str
 	}
 	// Chunck data to relevant part for autocompletion
 	// E.g. in case of nested lines eth.getBalance(eth.coinb<tab><tab>
-	start := pos - 1
-	for ; start > 0; start-- {
+	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
@ -275,7 +275,10 @@ func (c *Console) Evaluate(statement string) error {
 			fmt.Fprintf(c.printer, "[native] error: %v\n", r)
 		}
 	}()
-	return c.jsre.Evaluate(statement, c.printer)
+	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
--- a/console/prompter.go
+++ b/console/prompter.go
@ -44,7 +44,7 @@ type UserPrompter interface {
 	PromptConfirm(prompt string) (bool, error)

 	// SetHistory sets the the input scrollback history that the prompter will allow
-	// the user to scroll back to.
+	// the user to scoll back to.
 	SetHistory(history []string)

 	// AppendHistory appends an entry to the scrollback history. It should be called
@ -147,7 +147,7 @@ func (p *terminalPrompter) PromptConfirm(prompt string) (bool, error) {
 }

 // SetHistory sets the the input scrollback history that the prompter will allow
-// the user to scroll back to.
+// the user to scoll back to.
 func (p *terminalPrompter) SetHistory(history []string) {
 	p.State.ReadHistory(strings.NewReader(strings.Join(history, "\n")))
 }
--- a/contracts/chequebook/cheque.go
+++ b/contracts/chequebook/cheque.go
@ -252,7 +252,7 @@ func (self *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *
 		return nil, fmt.Errorf("amount must be greater than zero (%v)", amount)
 	}
 	if self.balance.Cmp(amount) < 0 {
-		err = fmt.Errorf("insufficient funds to issue cheque for amount: %v. balance: %v", amount, self.balance)
+		err = fmt.Errorf("insufficent funds to issue cheque for amount: %v. balance: %v", amount, self.balance)
 	} else {
 		var sig []byte
 		sent, found := self.sent[beneficiary]
@ -277,7 +277,7 @@ func (self *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *
 	}

 	// auto deposit if threshold is set and balance is less then threshold
-	// note this is called even if issuing cheque fails
+	// note this is called even if issueing cheque fails
 	// so we reattempt depositing
 	if self.threshold != nil {
 		if self.balance.Cmp(self.threshold) < 0 {
--- a/contracts/chequebook/cheque_test.go
+++ b/contracts/chequebook/cheque_test.go
@ -73,8 +73,8 @@ func TestIssueAndReceive(t *testing.T) {
 	}
 	chbook.sent[addr1] = new(big.Int).SetUint64(42)
 	amount := common.Big1
-
-	if _, err = chbook.Issue(addr1, amount); err == nil {
+	ch, err := chbook.Issue(addr1, amount)
+	if err == nil {
 		t.Fatalf("expected insufficient funds error, got none")
 	}

@ -83,7 +83,7 @@ func TestIssueAndReceive(t *testing.T) {
 		t.Fatalf("expected: %v, got %v", "0", chbook.Balance())
 	}

-	ch, err := chbook.Issue(addr1, amount)
+	ch, err = chbook.Issue(addr1, amount)
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@ -128,8 +128,8 @@ func TestCheckbookFile(t *testing.T) {
 		t.Errorf("expected: %v, got %v", "0", chbook.Balance())
 	}

-	var ch *Cheque
-	if ch, err = chbook.Issue(addr1, common.Big1); err != nil {
+	ch, err := chbook.Issue(addr1, common.Big1)
+	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
 	if ch.Amount.Cmp(new(big.Int).SetUint64(43)) != 0 {
@ -155,7 +155,7 @@ func TestVerifyErrors(t *testing.T) {
 	}

 	path1 := filepath.Join(os.TempDir(), "chequebook-test-1.json")
-	contr1, _ := deploy(key1, common.Big2, backend)
+	contr1, err := deploy(key1, common.Big2, backend)
 	chbook1, err := NewChequebook(path1, contr1, key1, backend)
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)
@ -223,8 +223,7 @@ func TestVerifyErrors(t *testing.T) {
 func TestDeposit(t *testing.T) {
 	path0 := filepath.Join(os.TempDir(), "chequebook-test-0.json")
 	backend := newTestBackend()
-	contr0, _ := deploy(key0, new(big.Int), backend)
-
+	contr0, err := deploy(key0, new(big.Int), backend)
 	chbook, err := NewChequebook(path0, contr0, key0, backend)
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)
@ -362,8 +361,7 @@ func TestDeposit(t *testing.T) {
 func TestCash(t *testing.T) {
 	path := filepath.Join(os.TempDir(), "chequebook-test.json")
 	backend := newTestBackend()
-	contr0, _ := deploy(key0, common.Big2, backend)
-
+	contr0, err := deploy(key0, common.Big2, backend)
 	chbook, err := NewChequebook(path, contr0, key0, backend)
 	if err != nil {
 		t.Errorf("expected no error, got %v", err)
@ -382,12 +380,11 @@ func TestCash(t *testing.T) {
 	}

 	// cashing latest cheque
-	if _, err = chbox.Receive(ch); err != nil {
+	_, err = chbox.Receive(ch)
+	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
-	if _, err = ch.Cash(chbook.session); err != nil {
-		t.Fatal("Cash failed:", err)
-	}
+	_, err = ch.Cash(chbook.session)
 	backend.Commit()

 	chbook.balance = new(big.Int).Set(common.Big3)
--- a/contracts/ens/ens_test.go
+++ b/contracts/ens/ens_test.go
@ -29,7 +29,7 @@ import (
 var (
 	key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 	name   = "my name on ENS"
-	hash   = crypto.Keccak256Hash([]byte("my content"))
+	hash   = crypto.Sha3Hash([]byte("my content"))
 	addr   = crypto.PubkeyToAddress(key.PublicKey)
 )

--- a/contracts/release/contract.sol
+++ b/contracts/release/contract.sol
@ -78,7 +78,7 @@ contract ReleaseOracle {
  }

  // signers is an accessor method to retrieve all te signers (public accessor
-  // generates an indexed one, not a retrieve-all version).
+  // generates an indexed one, not a retreive-all version).
  function signers() constant returns(address[]) {
    return voters;
  }
@ -178,7 +178,7 @@ contract ReleaseOracle {
          voters[i] = voters[voters.length - 1];
          voters.length--;

-          delete verProp; // Nuke any version proposal (no surprise releases!)
+          delete verProp; // Nuke any version proposal (no suprise releases!)
          break;
        }
      }
--- a/core/bench_test.go
+++ b/core/bench_test.go
@ -83,7 +83,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 		toaddr := common.Address{}
 		data := make([]byte, nbytes)
 		gas := IntrinsicGas(data, false, false)
-		tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data), types.HomesteadSigner{}, benchRootKey)
+		tx, _ := types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data).SignECDSA(types.HomesteadSigner{}, benchRootKey)
 		gen.AddTx(tx)
 	}
 }
@ -123,7 +123,7 @@ func genTxRing(naccounts int) func(int, *BlockGen) {
 				nil,
 				nil,
 			)
-			tx, _ = types.SignTx(tx, types.HomesteadSigner{}, ringKeys[from])
+			tx, _ = tx.SignECDSA(types.HomesteadSigner{}, ringKeys[from])
 			gen.AddTx(tx)
 			from = to
 		}
--- a/core/block_validator.go
+++ b/core/block_validator.go
@ -93,14 +93,14 @@ func (v *BlockValidator) ValidateBlock(block *types.Block) error {
 	// Verify UncleHash before running other uncle validations
 	unclesSha := types.CalcUncleHash(block.Uncles())
 	if unclesSha != header.UncleHash {
-		return fmt.Errorf("invalid uncles root hash (remote: %x local: %x)", header.UncleHash, unclesSha)
+		return fmt.Errorf("invalid uncles root hash. received=%x calculated=%x", header.UncleHash, unclesSha)
 	}

 	// The transactions Trie's root (R = (Tr [[i, RLP(T1)], [i, RLP(T2)], ... [n, RLP(Tn)]]))
 	// can be used by light clients to make sure they've received the correct Txs
 	txSha := types.DeriveSha(block.Transactions())
 	if txSha != header.TxHash {
-		return fmt.Errorf("invalid transaction root hash (remote: %x local: %x)", header.TxHash, txSha)
+		return fmt.Errorf("invalid transaction root hash. received=%x calculated=%x", header.TxHash, txSha)
 	}

 	return nil
@ -113,23 +113,23 @@ func (v *BlockValidator) ValidateBlock(block *types.Block) error {
 func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) (err error) {
 	header := block.Header()
 	if block.GasUsed().Cmp(usedGas) != 0 {
-		return ValidationError(fmt.Sprintf("invalid gas used (remote: %v local: %v)", block.GasUsed(), usedGas))
+		return ValidationError(fmt.Sprintf("gas used error (%v / %v)", block.GasUsed(), usedGas))
 	}
 	// Validate the received block's bloom with the one derived from the generated receipts.
 	// For valid blocks this should always validate to true.
 	rbloom := types.CreateBloom(receipts)
 	if rbloom != header.Bloom {
-		return fmt.Errorf("invalid bloom (remote: %x  local: %x)", header.Bloom, rbloom)
+		return fmt.Errorf("unable to replicate block's bloom=%x vs calculated bloom=%x", header.Bloom, rbloom)
 	}
 	// Tre receipt Trie's root (R = (Tr [[H1, R1], ... [Hn, R1]]))
 	receiptSha := types.DeriveSha(receipts)
 	if receiptSha != header.ReceiptHash {
-		return fmt.Errorf("invalid receipt root hash (remote: %x local: %x)", header.ReceiptHash, receiptSha)
+		return fmt.Errorf("invalid receipt root hash. received=%x calculated=%x", header.ReceiptHash, receiptSha)
 	}
 	// Validate the state root against the received state root and throw
 	// an error if they don't match.
 	if root := statedb.IntermediateRoot(v.config.IsEIP158(header.Number)); header.Root != root {
-		return fmt.Errorf("invalid merkle root (remote: %x local: %x)", header.Root, root)
+		return fmt.Errorf("invalid merkle root: header=%x computed=%x", header.Root, root)
 	}
 	return nil
 }
@ -223,7 +223,7 @@ func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Heade

 	expd := CalcDifficulty(config, header.Time.Uint64(), parent.Time.Uint64(), parent.Number, parent.Difficulty)
 	if expd.Cmp(header.Difficulty) != 0 {
-		return fmt.Errorf("Difficulty check failed for header (remote: %v local: %v)", header.Difficulty, expd)
+		return fmt.Errorf("Difficulty check failed for header %v, %v", header.Difficulty, expd)
 	}

 	a := new(big.Int).Set(parent.GasLimit)
@ -232,7 +232,7 @@ func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Heade
 	b := new(big.Int).Set(parent.GasLimit)
 	b = b.Div(b, params.GasLimitBoundDivisor)
 	if !(a.Cmp(b) < 0) || (header.GasLimit.Cmp(params.MinGasLimit) == -1) {
-		return fmt.Errorf("GasLimit check failed for header (remote: %v local_max: %v)", header.GasLimit, b)
+		return fmt.Errorf("GasLimit check failed for header %v (%v > %v)", header.GasLimit, a, b)
 	}

 	num := new(big.Int).Set(parent.Number)
@ -251,7 +251,7 @@ func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Heade
 	if err := ValidateDAOHeaderExtraData(config, header); err != nil {
 		return err
 	}
-	if !uncle && config.EIP150Block != nil && config.EIP150Block.Cmp(header.Number) == 0 {
+	if config.EIP150Block != nil && config.EIP150Block.Cmp(header.Number) == 0 {
 		if config.EIP150Hash != (common.Hash{}) && config.EIP150Hash != header.Hash() {
 			return ValidationError("Homestead gas reprice fork hash mismatch: have 0x%x, want 0x%x", header.Hash(), config.EIP150Hash)
 		}
--- a/core/block_validator_test.go
+++ b/core/block_validator_test.go
@ -24,9 +24,11 @@ import (
 	"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"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/pow/ezp"
 )

 func testChainConfig() *params.ChainConfig {
@ -47,19 +49,20 @@ func proc() (Validator, *BlockChain) {
 }

 func TestNumber(t *testing.T) {
+	pow := ezp.New()
 	_, chain := proc()

 	statedb, _ := state.New(chain.Genesis().Root(), chain.chainDb)
 	cfg := testChainConfig()
 	header := makeHeader(cfg, chain.Genesis(), statedb)
 	header.Number = big.NewInt(3)
-	err := ValidateHeader(cfg, FakePow{}, header, chain.Genesis().Header(), false, false)
+	err := ValidateHeader(cfg, pow, header, chain.Genesis().Header(), false, false)
 	if err != BlockNumberErr {
 		t.Errorf("expected block number error, got %q", err)
 	}

 	header = makeHeader(cfg, chain.Genesis(), statedb)
-	err = ValidateHeader(cfg, FakePow{}, header, chain.Genesis().Header(), false, false)
+	err = ValidateHeader(cfg, pow, header, chain.Genesis().Header(), false, false)
 	if err == BlockNumberErr {
 		t.Errorf("didn't expect block number error")
 	}
@ -74,7 +77,7 @@ func TestPutReceipt(t *testing.T) {
 	hash[0] = 2

 	receipt := new(types.Receipt)
-	receipt.Logs = []*types.Log{{
+	receipt.Logs = vm.Logs{&vm.Log{
 		Address:     addr,
 		Topics:      []common.Hash{hash},
 		Data:        []byte("hi"),
--- a/core/blockchain.go
+++ b/core/blockchain.go
@ -29,7 +29,6 @@ import (
 	"time"

 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@ -47,6 +46,9 @@ import (
 )

 var (
+	chainlogger = logger.NewLogger("CHAIN")
+	jsonlogger  = logger.NewJsonLogger()
+
 	blockInsertTimer = metrics.NewTimer("chain/inserts")

 	ErrNoGenesis = errors.New("Genesis not found in chain")
@ -148,16 +150,11 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, pow pow.P
 		return nil, err
 	}
 	// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
-	for hash := range BadHashes {
+	for hash, _ := range BadHashes {
 		if header := bc.GetHeaderByHash(hash); header != nil {
-			// get the canonical block corresponding to the offending header's number
-			headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64())
-			// make sure the headerByNumber (if present) is in our current canonical chain
-			if headerByNumber != nil && headerByNumber.Hash() == header.Hash() {
-				glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4])
-				bc.SetHead(header.Number.Uint64() - 1)
-				glog.V(logger.Error).Infoln("Chain rewind was successful, resuming normal operation")
-			}
+			glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4])
+			bc.SetHead(header.Number.Uint64() - 1)
+			glog.V(logger.Error).Infoln("Chain rewind was successful, resuming normal operation")
 		}
 	}
 	// Take ownership of this particular state
@ -400,7 +397,10 @@ func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) {

 // Export writes the active chain to the given writer.
 func (self *BlockChain) Export(w io.Writer) error {
-	return self.ExportN(w, uint64(0), self.currentBlock.NumberU64())
+	if err := self.ExportN(w, uint64(0), self.currentBlock.NumberU64()); err != nil {
+		return err
+	}
+	return nil
 }

 // ExportN writes a subset of the active chain to the given writer.
@ -596,11 +596,7 @@ func (self *BlockChain) procFutureBlocks() {
 	}
 	if len(blocks) > 0 {
 		types.BlockBy(types.Number).Sort(blocks)
-
-		// Insert one by one as chain insertion needs contiguous ancestry between blocks
-		for i := range blocks {
-			self.InsertChain(blocks[i : i+1])
-		}
+		self.InsertChain(blocks)
 	}
 }

@ -674,18 +670,6 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty
 // transaction and receipt data.
 // XXX should this be moved to the test?
 func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) {
-	// Do a sanity check that the provided chain is actually ordered and linked
-	for i := 1; i < len(blockChain); i++ {
-		if blockChain[i].NumberU64() != blockChain[i-1].NumberU64()+1 || blockChain[i].ParentHash() != blockChain[i-1].Hash() {
-			// Chain broke ancestry, log a messge (programming error) and skip insertion
-			failure := fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])", i-1, blockChain[i-1].NumberU64(),
-				blockChain[i-1].Hash().Bytes()[:4], i, blockChain[i].NumberU64(), blockChain[i].Hash().Bytes()[:4], blockChain[i].ParentHash().Bytes()[:4])
-
-			glog.V(logger.Error).Info(failure.Error())
-			return 0, failure
-		}
-	}
-	// Pre-checks passed, start the block body and receipt imports
 	self.wg.Add(1)
 	defer self.wg.Done()

@ -800,7 +784,7 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain
 	if stats.ignored > 0 {
 		ignored = fmt.Sprintf(" (%d ignored)", stats.ignored)
 	}
-	glog.V(logger.Info).Infof("imported %4d receipts in %9v. #%d [%x… / %x…]%s", stats.processed, common.PrettyDuration(time.Since(start)), last.Number(), first.Hash().Bytes()[:4], last.Hash().Bytes()[:4], ignored)
+	glog.V(logger.Info).Infof("imported %d receipts in %9v. #%d [%x… / %x…]%s", stats.processed, common.PrettyDuration(time.Since(start)), last.Number(), first.Hash().Bytes()[:4], last.Hash().Bytes()[:4], ignored)

 	return 0, nil
 }
@ -854,18 +838,6 @@ func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err
 // InsertChain will attempt to insert the given chain in to the canonical chain or, otherwise, create a fork. It an error is returned
 // it will return the index number of the failing block as well an error describing what went wrong (for possible errors see core/errors.go).
 func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
-	// Do a sanity check that the provided chain is actually ordered and linked
-	for i := 1; i < len(chain); i++ {
-		if chain[i].NumberU64() != chain[i-1].NumberU64()+1 || chain[i].ParentHash() != chain[i-1].Hash() {
-			// Chain broke ancestry, log a messge (programming error) and skip insertion
-			failure := fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])",
-				i-1, chain[i-1].NumberU64(), chain[i-1].Hash().Bytes()[:4], i, chain[i].NumberU64(), chain[i].Hash().Bytes()[:4], chain[i].ParentHash().Bytes()[:4])
-
-			glog.V(logger.Error).Info(failure.Error())
-			return 0, failure
-		}
-	}
-	// Pre-checks passed, start the full block imports
 	self.wg.Add(1)
 	defer self.wg.Done()

@ -876,9 +848,9 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 	// faster than direct delivery and requires much less mutex
 	// acquiring.
 	var (
-		stats         = insertStats{startTime: mclock.Now()}
+		stats         = insertStats{startTime: time.Now()}
 		events        = make([]interface{}, 0, len(chain))
-		coalescedLogs []*types.Log
+		coalescedLogs vm.Logs
 		nonceChecked  = make([]bool, len(chain))
 	)

@ -906,7 +878,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {

 		if BadHashes[block.Hash()] {
 			err := BadHashError(block.Hash())
-			self.reportBlock(block, nil, err)
+			reportBlock(block, err)
 			return i, err
 		}
 		// Stage 1 validation of the block using the chain's validator
@ -938,9 +910,11 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 				continue
 			}

-			self.reportBlock(block, nil, err)
+			reportBlock(block, err)
+
 			return i, err
 		}
+
 		// Create a new statedb using the parent block and report an
 		// error if it fails.
 		switch {
@ -950,19 +924,19 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 			err = self.stateCache.Reset(chain[i-1].Root())
 		}
 		if err != nil {
-			self.reportBlock(block, nil, err)
+			reportBlock(block, err)
 			return i, err
 		}
 		// Process block using the parent state as reference point.
 		receipts, logs, usedGas, err := self.processor.Process(block, self.stateCache, vm.Config{})
 		if err != nil {
-			self.reportBlock(block, receipts, err)
+			reportBlock(block, err)
 			return i, err
 		}
 		// Validate the state using the default validator
 		err = self.Validator().ValidateState(block, self.GetBlock(block.ParentHash(), block.NumberU64()-1), self.stateCache, receipts, usedGas)
 		if err != nil {
-			self.reportBlock(block, receipts, err)
+			reportBlock(block, err)
 			return i, err
 		}
 		// Write state changes to database
@ -1009,7 +983,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 				glog.Infof("inserted forked block #%d [%x…] (TD=%v) in %9v: %3d txs %d uncles.", block.Number(), block.Hash().Bytes()[0:4], block.Difficulty(), common.PrettyDuration(time.Since(bstart)), len(block.Transactions()), len(block.Uncles()))
 			}
 			blockInsertTimer.UpdateSince(bstart)
-			events = append(events, ChainSideEvent{block})
+			events = append(events, ChainSideEvent{block, logs})

 		case SplitStatTy:
 			events = append(events, ChainSplitEvent{block, logs})
@ -1032,7 +1006,7 @@ type insertStats struct {
 	queued, processed, ignored int
 	usedGas                    uint64
 	lastIndex                  int
-	startTime                  mclock.AbsTime
+	startTime                  time.Time
 }

 // statsReportLimit is the time limit during import after which we always print
@ -1044,24 +1018,28 @@ const statsReportLimit = 8 * time.Second
 func (st *insertStats) report(chain []*types.Block, index int) {
 	// Fetch the timings for the batch
 	var (
-		now     = mclock.Now()
-		elapsed = time.Duration(now) - time.Duration(st.startTime)
+		now     = time.Now()
+		elapsed = now.Sub(st.startTime)
 	)
+	if elapsed == 0 { // Yes Windows, I'm looking at you
+		elapsed = 1
+	}
 	// If we're at the last block of the batch or report period reached, log
 	if index == len(chain)-1 || elapsed >= statsReportLimit {
 		start, end := chain[st.lastIndex], chain[index]
 		txcount := countTransactions(chain[st.lastIndex : index+1])

-		var hashes, extra string
+		extra := ""
 		if st.queued > 0 || st.ignored > 0 {
 			extra = fmt.Sprintf(" (%d queued %d ignored)", st.queued, st.ignored)
 		}
+		hashes := ""
 		if st.processed > 1 {
 			hashes = fmt.Sprintf("%x… / %x…", start.Hash().Bytes()[:4], end.Hash().Bytes()[:4])
 		} else {
 			hashes = fmt.Sprintf("%x…", end.Hash().Bytes()[:4])
 		}
-		glog.Infof("imported %4d blocks, %5d txs (%7.3f Mg) in %9v (%6.3f Mg/s). #%v [%s]%s", st.processed, txcount, float64(st.usedGas)/1000000, common.PrettyDuration(elapsed), float64(st.usedGas)*1000/float64(elapsed), end.Number(), hashes, extra)
+		glog.Infof("imported %d blocks, %5d txs (%7.3f Mg) in %9v (%6.3f Mg/s). #%v [%s]%s", st.processed, txcount, float64(st.usedGas)/1000000, common.PrettyDuration(elapsed), float64(st.usedGas)*1000/float64(elapsed), end.Number(), hashes, extra)

 		*st = insertStats{startTime: now, lastIndex: index}
 	}
@ -1079,25 +1057,24 @@ func countTransactions(chain []*types.Block) (c int) {
 // event about them
 func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
 	var (
-		newChain    types.Blocks
-		oldChain    types.Blocks
-		commonBlock *types.Block
-		oldStart    = oldBlock
-		newStart    = newBlock
-		deletedTxs  types.Transactions
-		deletedLogs []*types.Log
+		newChain          types.Blocks
+		oldChain          types.Blocks
+		commonBlock       *types.Block
+		oldStart          = oldBlock
+		newStart          = newBlock
+		deletedTxs        types.Transactions
+		deletedLogs       vm.Logs
+		deletedLogsByHash = make(map[common.Hash]vm.Logs)
 		// collectLogs collects the logs that were generated during the
 		// processing of the block that corresponds with the given hash.
 		// These logs are later announced as deleted.
 		collectLogs = func(h common.Hash) {
-			// Coalesce logs and set 'Removed'.
+			// Coalesce logs
 			receipts := GetBlockReceipts(self.chainDb, h, self.hc.GetBlockNumber(h))
 			for _, receipt := range receipts {
-				for _, log := range receipt.Logs {
-					del := *log
-					del.Removed = true
-					deletedLogs = append(deletedLogs, &del)
-				}
+				deletedLogs = append(deletedLogs, receipt.Logs...)
+
+				deletedLogsByHash[h] = receipt.Logs
 			}
 		}
 	)
@ -1191,7 +1168,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
 	if len(oldChain) > 0 {
 		go func() {
 			for _, block := range oldChain {
-				self.eventMux.Post(ChainSideEvent{Block: block})
+				self.eventMux.Post(ChainSideEvent{Block: block, Logs: deletedLogsByHash[block.Hash()]})
 			}
 		}()
 	}
@ -1201,7 +1178,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {

 // postChainEvents iterates over the events generated by a chain insertion and
 // posts them into the event mux.
-func (self *BlockChain) postChainEvents(events []interface{}, logs []*types.Log) {
+func (self *BlockChain) postChainEvents(events []interface{}, logs vm.Logs) {
 	// post event logs for further processing
 	self.eventMux.Post(logs)
 	for _, event := range events {
@ -1230,23 +1207,10 @@ func (self *BlockChain) update() {
 }

 // reportBlock logs a bad block error.
-func (bc *BlockChain) reportBlock(block *types.Block, receipts types.Receipts, err error) {
+func reportBlock(block *types.Block, err error) {
 	if glog.V(logger.Error) {
-		var receiptString string
-		for _, receipt := range receipts {
-			receiptString += fmt.Sprintf("\t%v\n", receipt)
-		}
-		glog.Errorf(`
-########## BAD BLOCK #########
-Chain config: %v
-
-Number: %v
-Hash: 0x%x
-%v
-
-Error: %v
-##############################
-`, bc.config, block.Number(), block.Hash(), receiptString, err)
+		glog.Errorf("Bad block #%v (%s)\n", block.Number(), block.Hash().Hex())
+		glog.Errorf("    %v", err)
 	}
 }

--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@ -143,12 +143,12 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
 		}
 		receipts, _, usedGas, err := blockchain.Processor().Process(block, statedb, vm.Config{})
 		if err != nil {
-			blockchain.reportBlock(block, receipts, err)
+			reportBlock(block, err)
 			return err
 		}
 		err = blockchain.Validator().ValidateState(block, blockchain.GetBlockByHash(block.ParentHash()), statedb, receipts, usedGas)
 		if err != nil {
-			blockchain.reportBlock(block, receipts, err)
+			reportBlock(block, err)
 			return err
 		}
 		blockchain.mu.Lock()
@ -435,7 +435,7 @@ func (bproc) ValidateHeader(*types.Header, *types.Header, bool) error { return n
 func (bproc) ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error {
 	return nil
 }
-func (bproc) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) {
+func (bproc) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, vm.Logs, *big.Int, error) {
 	return nil, nil, new(big.Int), nil
 }

@ -719,7 +719,7 @@ func TestFastVsFullChains(t *testing.T) {
 		// If the block number is multiple of 3, send a few bonus transactions to the miner
 		if i%3 == 2 {
 			for j := 0; j < i%4+1; j++ {
-				tx, err := types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, nil, nil), signer, key)
+				tx, err := types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key)
 				if err != nil {
 					panic(err)
 				}
@ -883,8 +883,8 @@ func TestChainTxReorgs(t *testing.T) {
 	// Create two transactions shared between the chains:
 	//  - postponed: transaction included at a later block in the forked chain
 	//  - swapped: transaction included at the same block number in the forked chain
-	postponed, _ := types.SignTx(types.NewTransaction(0, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
-	swapped, _ := types.SignTx(types.NewTransaction(1, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
+	postponed, _ := types.NewTransaction(0, addr1, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key1)
+	swapped, _ := types.NewTransaction(1, addr1, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key1)

 	// Create two transactions that will be dropped by the forked chain:
 	//  - pastDrop: transaction dropped retroactively from a past block
@ -900,13 +900,13 @@ func TestChainTxReorgs(t *testing.T) {
 	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
-			pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
+			pastDrop, _ = types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key2)

 			gen.AddTx(pastDrop)  // This transaction will be dropped in the fork from below the split point
 			gen.AddTx(postponed) // This transaction will be postponed till block #3 in the fork

 		case 2:
-			freshDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
+			freshDrop, _ = types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key2)

 			gen.AddTx(freshDrop) // This transaction will be dropped in the fork from exactly at the split point
 			gen.AddTx(swapped)   // This transaction will be swapped out at the exact height
@ -925,18 +925,18 @@ func TestChainTxReorgs(t *testing.T) {
 	chain, _ = GenerateChain(params.TestChainConfig, genesis, db, 5, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
-			pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
+			pastAdd, _ = types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key3)
 			gen.AddTx(pastAdd) // This transaction needs to be injected during reorg

 		case 2:
 			gen.AddTx(postponed) // This transaction was postponed from block #1 in the original chain
 			gen.AddTx(swapped)   // This transaction was swapped from the exact current spot in the original chain

-			freshAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
+			freshAdd, _ = types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key3)
 			gen.AddTx(freshAdd) // This transaction will be added exactly at reorg time

 		case 3:
-			futureAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
+			futureAdd, _ = types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key3)
 			gen.AddTx(futureAdd) // This transaction will be added after a full reorg
 		}
 	})
@ -995,7 +995,7 @@ func TestLogReorgs(t *testing.T) {
 	subs := evmux.Subscribe(RemovedLogsEvent{})
 	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 2, func(i int, gen *BlockGen) {
 		if i == 1 {
-			tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), code), signer, key1)
+			tx, err := types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), code).SignECDSA(signer, key1)
 			if err != nil {
 				t.Fatalf("failed to create tx: %v", err)
 			}
@ -1035,7 +1035,7 @@ func TestReorgSideEvent(t *testing.T) {
 	}

 	replacementBlocks, _ := GenerateChain(params.TestChainConfig, genesis, db, 4, func(i int, gen *BlockGen) {
-		tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), nil), signer, key1)
+		tx, err := types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), nil).SignECDSA(signer, key1)
 		if i == 2 {
 			gen.OffsetTime(-1)
 		}
@ -1107,7 +1107,7 @@ func TestCanonicalBlockRetrieval(t *testing.T) {

 	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {})

-	for i := range chain {
+	for i, _ := range chain {
 		go func(block *types.Block) {
 			// try to retrieve a block by its canonical hash and see if the block data can be retrieved.
 			for {
@ -1136,14 +1136,13 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
 func TestEIP155Transition(t *testing.T) {
 	// Configure and generate a sample block chain
 	var (
-		db, _      = ethdb.NewMemDatabase()
-		key, _     = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address    = crypto.PubkeyToAddress(key.PublicKey)
-		funds      = big.NewInt(1000000000)
-		deleteAddr = common.Address{1}
-		genesis    = WriteGenesisBlockForTesting(db, GenesisAccount{address, funds}, GenesisAccount{deleteAddr, new(big.Int)})
-		config     = &params.ChainConfig{ChainId: big.NewInt(1), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)}
-		mux        event.TypeMux
+		db, _   = ethdb.NewMemDatabase()
+		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		address = crypto.PubkeyToAddress(key.PublicKey)
+		funds   = big.NewInt(1000000000)
+		genesis = WriteGenesisBlockForTesting(db, GenesisAccount{address, funds})
+		config  = &params.ChainConfig{ChainId: big.NewInt(1), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)}
+		mux     event.TypeMux
 	)

 	blockchain, _ := NewBlockChain(db, config, FakePow{}, &mux)
@ -1152,7 +1151,7 @@ func TestEIP155Transition(t *testing.T) {
 			tx      *types.Transaction
 			err     error
 			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+				return types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil).SignECDSA(signer, key)
 			}
 		)
 		switch i {
@ -1215,7 +1214,7 @@ func TestEIP155Transition(t *testing.T) {
 			tx      *types.Transaction
 			err     error
 			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+				return types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil).SignECDSA(signer, key)
 			}
 		)
 		switch i {
@ -1232,66 +1231,3 @@ func TestEIP155Transition(t *testing.T) {
 		t.Error("expected error:", types.ErrInvalidChainId)
 	}
 }
-
-func TestEIP161AccountRemoval(t *testing.T) {
-	// Configure and generate a sample block chain
-	var (
-		db, _   = ethdb.NewMemDatabase()
-		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address = crypto.PubkeyToAddress(key.PublicKey)
-		funds   = big.NewInt(1000000000)
-		theAddr = common.Address{1}
-		genesis = WriteGenesisBlockForTesting(db, GenesisAccount{address, funds})
-		config  = &params.ChainConfig{
-			ChainId:        big.NewInt(1),
-			HomesteadBlock: new(big.Int),
-			EIP155Block:    new(big.Int),
-			EIP158Block:    big.NewInt(2),
-		}
-		mux event.TypeMux
-
-		blockchain, _ = NewBlockChain(db, config, FakePow{}, &mux)
-	)
-	blocks, _ := GenerateChain(config, genesis, db, 3, func(i int, block *BlockGen) {
-		var (
-			tx     *types.Transaction
-			err    error
-			signer = types.NewEIP155Signer(config.ChainId)
-		)
-		switch i {
-		case 0:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
-		case 1:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
-		case 2:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-		block.AddTx(tx)
-	})
-	// account must exist pre eip 161
-	if _, err := blockchain.InsertChain(types.Blocks{blocks[0]}); err != nil {
-		t.Fatal(err)
-	}
-	if !blockchain.stateCache.Exist(theAddr) {
-		t.Error("expected account to exist")
-	}
-
-	// account needs to be deleted post eip 161
-	if _, err := blockchain.InsertChain(types.Blocks{blocks[1]}); err != nil {
-		t.Fatal(err)
-	}
-	if blockchain.stateCache.Exist(theAddr) {
-		t.Error("account should not expect")
-	}
-
-	// account musn't be created post eip 161
-	if _, err := blockchain.InsertChain(types.Blocks{blocks[2]}); err != nil {
-		t.Fatal(err)
-	}
-	if blockchain.stateCache.Exist(theAddr) {
-		t.Error("account should not expect")
-	}
-}
--- a/core/blocks.go
+++ b/core/blocks.go
@ -21,5 +21,4 @@ import "github.com/ethereum/go-ethereum/common"
 // Set of manually tracked bad hashes (usually hard forks)
 var BadHashes = map[common.Hash]bool{
 	common.HexToHash("05bef30ef572270f654746da22639a7a0c97dd97a7050b9e252391996aaeb689"): true,
-	common.HexToHash("7d05d08cbc596a2e5e4f13b80a743e53e09221b5323c3a61946b20873e58583f"): true,
 }
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@ -108,7 +108,7 @@ func (b *BlockGen) AddTx(tx *types.Transaction) {
 		b.SetCoinbase(common.Address{})
 	}
 	b.statedb.StartRecord(tx.Hash(), common.Hash{}, len(b.txs))
-	receipt, _, err := ApplyTransaction(b.config, nil, b.gasPool, b.statedb, b.header, tx, b.header.GasUsed, vm.Config{})
+	receipt, _, _, err := ApplyTransaction(b.config, nil, b.gasPool, b.statedb, b.header, tx, b.header.GasUsed, vm.Config{})
 	if err != nil {
 		panic(err)
 	}
--- a/core/chain_makers_test.go
+++ b/core/chain_makers_test.go
@ -55,13 +55,13 @@ func ExampleGenerateChain() {
 		switch i {
 		case 0:
 			// In block 1, addr1 sends addr2 some ether.
-			tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), params.TxGas, nil, nil), signer, key1)
+			tx, _ := types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), params.TxGas, nil, nil).SignECDSA(signer, key1)
 			gen.AddTx(tx)
 		case 1:
 			// In block 2, addr1 sends some more ether to addr2.
 			// addr2 passes it on to addr3.
-			tx1, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
-			tx2, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
+			tx1, _ := types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key1)
+			tx2, _ := types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(signer, key2)
 			gen.AddTx(tx1)
 			gen.AddTx(tx2)
 		case 2:
--- a/core/dao.go
+++ b/core/dao.go
@ -45,11 +45,11 @@ func ValidateDAOHeaderExtraData(config *params.ChainConfig, header *types.Header
 	}
 	// Depending whether we support or oppose the fork, validate the extra-data contents
 	if config.DAOForkSupport {
-		if !bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
+		if bytes.Compare(header.Extra, params.DAOForkBlockExtra) != 0 {
 			return ValidationError("DAO pro-fork bad block extra-data: 0x%x", header.Extra)
 		}
 	} else {
-		if bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
+		if bytes.Compare(header.Extra, params.DAOForkBlockExtra) == 0 {
 			return ValidationError("DAO no-fork bad block extra-data: 0x%x", header.Extra)
 		}
 	}
--- a/core/database_util.go
+++ b/core/database_util.go
@ -23,7 +23,6 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
-	"sync"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@ -64,8 +63,6 @@ var (
 	oldBlockHashPrefix     = []byte("block-hash-") // [deprecated by the header/block split, remove eventually]

 	ChainConfigNotFoundErr = errors.New("ChainConfig not found") // general config not found error
-
-	mipmapBloomMu sync.Mutex // protect against race condition when updating mipmap blooms
 )

 // encodeBlockNumber encodes a block number as big endian uint64
@ -567,9 +564,6 @@ func mipmapKey(num, level uint64) []byte {
 // WriteMapmapBloom writes each address included in the receipts' logs to the
 // MIP bloom bin.
 func WriteMipmapBloom(db ethdb.Database, number uint64, receipts types.Receipts) error {
-	mipmapBloomMu.Lock()
-	defer mipmapBloomMu.Unlock()
-
 	batch := db.NewBatch()
 	for _, level := range MIPMapLevels {
 		key := mipmapKey(number, level)
--- a/core/database_util_test.go
+++ b/core/database_util_test.go
@ -26,6 +26,7 @@ import (

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/sha3"
 	"github.com/ethereum/go-ethereum/ethdb"
@ -392,9 +393,9 @@ func TestReceiptStorage(t *testing.T) {
 	receipt1 := &types.Receipt{
 		PostState:         []byte{0x01},
 		CumulativeGasUsed: big.NewInt(1),
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x11})},
-			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
+		Logs: vm.Logs{
+			&vm.Log{Address: common.BytesToAddress([]byte{0x11})},
+			&vm.Log{Address: common.BytesToAddress([]byte{0x01, 0x11})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
 		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
@ -403,9 +404,9 @@ func TestReceiptStorage(t *testing.T) {
 	receipt2 := &types.Receipt{
 		PostState:         []byte{0x02},
 		CumulativeGasUsed: big.NewInt(2),
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x22})},
-			{Address: common.BytesToAddress([]byte{0x02, 0x22})},
+		Logs: vm.Logs{
+			&vm.Log{Address: common.BytesToAddress([]byte{0x22})},
+			&vm.Log{Address: common.BytesToAddress([]byte{0x02, 0x22})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x22, 0x22}),
 		ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
@ -430,7 +431,7 @@ func TestReceiptStorage(t *testing.T) {
 			rlpHave, _ := rlp.EncodeToBytes(r)
 			rlpWant, _ := rlp.EncodeToBytes(receipt)

-			if !bytes.Equal(rlpHave, rlpWant) {
+			if bytes.Compare(rlpHave, rlpWant) != 0 {
 				t.Fatalf("receipt #%d [%x]: receipt mismatch: have %v, want %v", i, receipt.TxHash, r, receipt)
 			}
 		}
@ -451,9 +452,9 @@ func TestBlockReceiptStorage(t *testing.T) {
 	receipt1 := &types.Receipt{
 		PostState:         []byte{0x01},
 		CumulativeGasUsed: big.NewInt(1),
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x11})},
-			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
+		Logs: vm.Logs{
+			&vm.Log{Address: common.BytesToAddress([]byte{0x11})},
+			&vm.Log{Address: common.BytesToAddress([]byte{0x01, 0x11})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
 		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
@ -462,9 +463,9 @@ func TestBlockReceiptStorage(t *testing.T) {
 	receipt2 := &types.Receipt{
 		PostState:         []byte{0x02},
 		CumulativeGasUsed: big.NewInt(2),
-		Logs: []*types.Log{
-			{Address: common.BytesToAddress([]byte{0x22})},
-			{Address: common.BytesToAddress([]byte{0x02, 0x22})},
+		Logs: vm.Logs{
+			&vm.Log{Address: common.BytesToAddress([]byte{0x22})},
+			&vm.Log{Address: common.BytesToAddress([]byte{0x02, 0x22})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x22, 0x22}),
 		ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
@ -488,7 +489,7 @@ func TestBlockReceiptStorage(t *testing.T) {
 			rlpHave, _ := rlp.EncodeToBytes(rs[i])
 			rlpWant, _ := rlp.EncodeToBytes(receipts[i])

-			if !bytes.Equal(rlpHave, rlpWant) {
+			if bytes.Compare(rlpHave, rlpWant) != 0 {
 				t.Fatalf("receipt #%d: receipt mismatch: have %v, want %v", i, rs[i], receipts[i])
 			}
 		}
@ -504,14 +505,14 @@ func TestMipmapBloom(t *testing.T) {
 	db, _ := ethdb.NewMemDatabase()

 	receipt1 := new(types.Receipt)
-	receipt1.Logs = []*types.Log{
-		{Address: common.BytesToAddress([]byte("test"))},
-		{Address: common.BytesToAddress([]byte("address"))},
+	receipt1.Logs = vm.Logs{
+		&vm.Log{Address: common.BytesToAddress([]byte("test"))},
+		&vm.Log{Address: common.BytesToAddress([]byte("address"))},
 	}
 	receipt2 := new(types.Receipt)
-	receipt2.Logs = []*types.Log{
-		{Address: common.BytesToAddress([]byte("test"))},
-		{Address: common.BytesToAddress([]byte("address1"))},
+	receipt2.Logs = vm.Logs{
+		&vm.Log{Address: common.BytesToAddress([]byte("test"))},
+		&vm.Log{Address: common.BytesToAddress([]byte("address1"))},
 	}

 	WriteMipmapBloom(db, 1, types.Receipts{receipt1})
@ -527,14 +528,14 @@ func TestMipmapBloom(t *testing.T) {
 	// reset
 	db, _ = ethdb.NewMemDatabase()
 	receipt := new(types.Receipt)
-	receipt.Logs = []*types.Log{
-		{Address: common.BytesToAddress([]byte("test"))},
+	receipt.Logs = vm.Logs{
+		&vm.Log{Address: common.BytesToAddress([]byte("test"))},
 	}
 	WriteMipmapBloom(db, 999, types.Receipts{receipt1})

 	receipt = new(types.Receipt)
-	receipt.Logs = []*types.Log{
-		{Address: common.BytesToAddress([]byte("test 1"))},
+	receipt.Logs = vm.Logs{
+		&vm.Log{Address: common.BytesToAddress([]byte("test 1"))},
 	}
 	WriteMipmapBloom(db, 1000, types.Receipts{receipt})

@ -567,12 +568,17 @@ func TestMipmapChain(t *testing.T) {
 		switch i {
 		case 1:
 			receipt := types.NewReceipt(nil, new(big.Int))
-			receipt.Logs = []*types.Log{{Address: addr, Topics: []common.Hash{hash1}}}
+			receipt.Logs = vm.Logs{
+				&vm.Log{
+					Address: addr,
+					Topics:  []common.Hash{hash1},
+				},
+			}
 			gen.AddUncheckedReceipt(receipt)
 			receipts = types.Receipts{receipt}
 		case 1000:
 			receipt := types.NewReceipt(nil, new(big.Int))
-			receipt.Logs = []*types.Log{{Address: addr2}}
+			receipt.Logs = vm.Logs{&vm.Log{Address: addr2}}
 			gen.AddUncheckedReceipt(receipt)
 			receipts = types.Receipts{receipt}

--- a/core/default_genesis.go
+++ b/core/default_genesis.go
--- a/core/events.go
+++ b/core/events.go
@ -21,6 +21,7 @@ import (

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
 )

 // TxPreEvent is posted when a transaction enters the transaction pool.
@ -31,12 +32,15 @@ type TxPostEvent struct{ Tx *types.Transaction }

 // PendingLogsEvent is posted pre mining and notifies of pending logs.
 type PendingLogsEvent struct {
-	Logs []*types.Log
+	Logs vm.Logs
 }

 // PendingStateEvent is posted pre mining and notifies of pending state changes.
 type PendingStateEvent struct{}

+// NewBlockEvent is posted when a block has been imported.
+type NewBlockEvent struct{ Block *types.Block }
+
 // NewMinedBlockEvent is posted when a block has been imported.
 type NewMinedBlockEvent struct{ Block *types.Block }

@ -44,27 +48,28 @@ type NewMinedBlockEvent struct{ Block *types.Block }
 type RemovedTransactionEvent struct{ Txs types.Transactions }

 // RemovedLogEvent is posted when a reorg happens
-type RemovedLogsEvent struct{ Logs []*types.Log }
+type RemovedLogsEvent struct{ Logs vm.Logs }

 // ChainSplit is posted when a new head is detected
 type ChainSplitEvent struct {
 	Block *types.Block
-	Logs  []*types.Log
+	Logs  vm.Logs
 }

 type ChainEvent struct {
 	Block *types.Block
 	Hash  common.Hash
-	Logs  []*types.Log
+	Logs  vm.Logs
 }

 type ChainSideEvent struct {
 	Block *types.Block
+	Logs  vm.Logs
 }

 type PendingBlockEvent struct {
 	Block *types.Block
-	Logs  []*types.Log
+	Logs  vm.Logs
 }

 type ChainUncleEvent struct {
--- a/core/evm.go
+++ b/core/evm.go
@ -1,73 +0,0 @@
-// Copyright 2014 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 (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
-)
-
-// BlockFetcher retrieves headers by their hash
-type HeaderFetcher interface {
-	// GetHeader returns the hash corresponding to their hash
-	GetHeader(common.Hash, uint64) *types.Header
-}
-
-// NewEVMContext creates a new context for use in the EVM.
-func NewEVMContext(msg Message, header *types.Header, chain HeaderFetcher) vm.Context {
-	return vm.Context{
-		CanTransfer: CanTransfer,
-		Transfer:    Transfer,
-		GetHash:     GetHashFn(header, chain),
-
-		Origin:      msg.From(),
-		Coinbase:    header.Coinbase,
-		BlockNumber: new(big.Int).Set(header.Number),
-		Time:        new(big.Int).Set(header.Time),
-		Difficulty:  new(big.Int).Set(header.Difficulty),
-		GasLimit:    new(big.Int).Set(header.GasLimit),
-		GasPrice:    new(big.Int).Set(msg.GasPrice()),
-	}
-}
-
-// GetHashFn returns a GetHashFunc which retrieves header hashes by number
-func GetHashFn(ref *types.Header, chain HeaderFetcher) func(n uint64) common.Hash {
-	return func(n uint64) common.Hash {
-		for header := chain.GetHeader(ref.ParentHash, ref.Number.Uint64()-1); header != nil; header = chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) {
-			if header.Number.Uint64() == n {
-				return header.Hash()
-			}
-		}
-
-		return common.Hash{}
-	}
-}
-
-// CanTransfer checks wether there are enough funds in the address' account to make a transfer.
-// This does not take the necessary gas in to account to make the transfer valid.
-func CanTransfer(db vm.StateDB, addr common.Address, amount *big.Int) bool {
-	return db.GetBalance(addr).Cmp(amount) >= 0
-}
-
-// Transfer subtracts amount from sender and adds amount to recipient using the given Db
-func Transfer(db vm.StateDB, sender, recipient common.Address, amount *big.Int) {
-	db.SubBalance(sender, amount)
-	db.AddBalance(recipient, amount)
-}
--- a/core/execution.go
+++ b/core/execution.go
@ -0,0 +1,217 @@
+// Copyright 2014 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 (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// Call executes within the given contract
+func Call(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice, value *big.Int) (ret []byte, err error) {
+	// Depth check execution. Fail if we're trying to execute above the
+	// limit.
+	if env.Depth() > int(params.CallCreateDepth.Int64()) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, vm.DepthError
+	}
+	if !env.CanTransfer(caller.Address(), value) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
+	}
+
+	snapshotPreTransfer := env.SnapshotDatabase()
+	var (
+		from = env.Db().GetAccount(caller.Address())
+		to   vm.Account
+	)
+	if !env.Db().Exist(addr) {
+		if vm.Precompiled[addr.Str()] == nil && env.ChainConfig().IsEIP158(env.BlockNumber()) && value.BitLen() == 0 {
+			caller.ReturnGas(gas, gasPrice)
+			return nil, nil
+		}
+
+		to = env.Db().CreateAccount(addr)
+	} else {
+		to = env.Db().GetAccount(addr)
+	}
+	env.Transfer(from, to, value)
+
+	// initialise a new contract and set the code that is to be used by the
+	// EVM. The contract is a scoped environment for this execution context
+	// only.
+	contract := vm.NewContract(caller, to, value, gas, gasPrice)
+	contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
+	defer contract.Finalise()
+
+	ret, err = env.Vm().Run(contract, input)
+	// When an error was returned by the EVM or when setting the creation code
+	// above we revert to the snapshot and consume any gas remaining. Additionally
+	// when we're in homestead this also counts for code storage gas errors.
+	if err != nil {
+		contract.UseGas(contract.Gas)
+
+		env.RevertToSnapshot(snapshotPreTransfer)
+	}
+	return ret, err
+}
+
+// CallCode executes the given address' code as the given contract address
+func CallCode(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice, value *big.Int) (ret []byte, err error) {
+	// Depth check execution. Fail if we're trying to execute above the
+	// limit.
+	if env.Depth() > int(params.CallCreateDepth.Int64()) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, vm.DepthError
+	}
+	if !env.CanTransfer(caller.Address(), value) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
+	}
+
+	var (
+		snapshotPreTransfer = env.SnapshotDatabase()
+		to                  = env.Db().GetAccount(caller.Address())
+	)
+	// initialise a new contract and set the code that is to be used by the
+	// EVM. The contract is a scoped environment for this execution context
+	// only.
+	contract := vm.NewContract(caller, to, value, gas, gasPrice)
+	contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
+	defer contract.Finalise()
+
+	ret, err = env.Vm().Run(contract, input)
+	if err != nil {
+		contract.UseGas(contract.Gas)
+
+		env.RevertToSnapshot(snapshotPreTransfer)
+	}
+
+	return ret, err
+}
+
+// Create creates a new contract with the given code
+func Create(env vm.Environment, caller vm.ContractRef, code []byte, gas, gasPrice, value *big.Int) (ret []byte, address common.Address, err error) {
+	// Depth check execution. Fail if we're trying to execute above the
+	// limit.
+	if env.Depth() > int(params.CallCreateDepth.Int64()) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, common.Address{}, vm.DepthError
+	}
+	if !env.CanTransfer(caller.Address(), value) {
+		caller.ReturnGas(gas, gasPrice)
+
+		return nil, common.Address{}, ValueTransferErr("insufficient funds to transfer value. Req %v, has %v", value, env.Db().GetBalance(caller.Address()))
+	}
+
+	// Create a new account on the state
+	nonce := env.Db().GetNonce(caller.Address())
+	env.Db().SetNonce(caller.Address(), nonce+1)
+
+	snapshotPreTransfer := env.SnapshotDatabase()
+	var (
+		addr = crypto.CreateAddress(caller.Address(), nonce)
+		from = env.Db().GetAccount(caller.Address())
+		to   = env.Db().CreateAccount(addr)
+	)
+	if env.ChainConfig().IsEIP158(env.BlockNumber()) {
+		env.Db().SetNonce(addr, 1)
+	}
+	env.Transfer(from, to, value)
+
+	// initialise a new contract and set the code that is to be used by the
+	// EVM. The contract is a scoped environment for this execution context
+	// only.
+	contract := vm.NewContract(caller, to, value, gas, gasPrice)
+	contract.SetCallCode(&addr, crypto.Keccak256Hash(code), code)
+	defer contract.Finalise()
+
+	ret, err = env.Vm().Run(contract, nil)
+	// check whether the max code size has been exceeded
+	maxCodeSizeExceeded := len(ret) > params.MaxCodeSize
+	// if the contract creation ran successfully and no errors were returned
+	// calculate the gas required to store the code. If the code could not
+	// be stored due to not enough gas set an error and let it be handled
+	// by the error checking condition below.
+	if err == nil && !maxCodeSizeExceeded {
+		dataGas := big.NewInt(int64(len(ret)))
+		dataGas.Mul(dataGas, params.CreateDataGas)
+		if contract.UseGas(dataGas) {
+			env.Db().SetCode(addr, ret)
+		} else {
+			err = vm.CodeStoreOutOfGasError
+		}
+	}
+
+	// When an error was returned by the EVM or when setting the creation code
+	// above we revert to the snapshot and consume any gas remaining. Additionally
+	// when we're in homestead this also counts for code storage gas errors.
+	if maxCodeSizeExceeded ||
+		(err != nil && (env.ChainConfig().IsHomestead(env.BlockNumber()) || err != vm.CodeStoreOutOfGasError)) {
+		contract.UseGas(contract.Gas)
+		env.RevertToSnapshot(snapshotPreTransfer)
+
+		// Nothing should be returned when an error is thrown.
+		return nil, addr, err
+	}
+
+	return ret, addr, err
+}
+
+// DelegateCall is equivalent to CallCode except that sender and value propagates from parent scope to child scope
+func DelegateCall(env vm.Environment, caller vm.ContractRef, addr common.Address, input []byte, gas, gasPrice *big.Int) (ret []byte, err error) {
+	// Depth check execution. Fail if we're trying to execute above the
+	// limit.
+	if env.Depth() > int(params.CallCreateDepth.Int64()) {
+		caller.ReturnGas(gas, gasPrice)
+		return nil, vm.DepthError
+	}
+
+	var (
+		snapshot = env.SnapshotDatabase()
+		to       = env.Db().GetAccount(caller.Address())
+	)
+
+	// Iinitialise a new contract and make initialise the delegate values
+	contract := vm.NewContract(caller, to, caller.Value(), gas, gasPrice).AsDelegate()
+	contract.SetCallCode(&addr, env.Db().GetCodeHash(addr), env.Db().GetCode(addr))
+	defer contract.Finalise()
+
+	ret, err = env.Vm().Run(contract, input)
+	if err != nil {
+		contract.UseGas(contract.Gas)
+
+		env.RevertToSnapshot(snapshot)
+	}
+
+	return ret, err
+}
+
+// generic transfer method
+func Transfer(from, to vm.Account, amount *big.Int) {
+	from.SubBalance(amount)
+	to.AddBalance(amount)
+}
--- a/core/genesis.go
+++ b/core/genesis.go
@ -17,7 +17,6 @@
 package core

 import (
-	"compress/bzip2"
 	"compress/gzip"
 	"encoding/base64"
 	"encoding/json"
@ -172,10 +171,16 @@ func WriteDefaultGenesisBlock(chainDb ethdb.Database) (*types.Block, error) {
 	return WriteGenesisBlock(chainDb, strings.NewReader(DefaultGenesisBlock()))
 }

-// WriteTestNetGenesisBlock assembles the test network genesis block and
+// WriteTestNetGenesisBlock assembles the Morden test network genesis block and
 // writes it - along with all associated state - into a chain database.
 func WriteTestNetGenesisBlock(chainDb ethdb.Database) (*types.Block, error) {
-	return WriteGenesisBlock(chainDb, strings.NewReader(DefaultTestnetGenesisBlock()))
+	return WriteGenesisBlock(chainDb, strings.NewReader(TestNetGenesisBlock()))
+}
+
+// WriteOlympicGenesisBlock assembles the Olympic genesis block and writes it
+// along with all associated state into a chain database.
+func WriteOlympicGenesisBlock(db ethdb.Database) (*types.Block, error) {
+	return WriteGenesisBlock(db, strings.NewReader(OlympicGenesisBlock()))
 }

 // DefaultGenesisBlock assembles a JSON string representing the default Ethereum
@ -192,23 +197,48 @@ func DefaultGenesisBlock() string {
 	return string(blob)
 }

-// DefaultTestnetGenesisBlock assembles a JSON string representing the default Ethereum
-// test network genesis block.
-func DefaultTestnetGenesisBlock() string {
-	reader := bzip2.NewReader(base64.NewDecoder(base64.StdEncoding, strings.NewReader(defaultTestnetGenesisBlock)))
-	blob, err := ioutil.ReadAll(reader)
-	if err != nil {
-		panic(fmt.Sprintf("failed to load default genesis: %v", err))
-	}
-	return string(blob)
+// OlympicGenesisBlock assembles a JSON string representing the Olympic genesis
+// block.
+func OlympicGenesisBlock() string {
+	return fmt.Sprintf(`{
+		"nonce":"0x%x",
+		"gasLimit":"0x%x",
+		"difficulty":"0x%x",
+		"alloc": {
+			"0000000000000000000000000000000000000001": {"balance": "1"},
+			"0000000000000000000000000000000000000002": {"balance": "1"},
+			"0000000000000000000000000000000000000003": {"balance": "1"},
+			"0000000000000000000000000000000000000004": {"balance": "1"},
+			"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"e4157b34ea9615cfbde6b4fda419828124b70c78": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"b9c015918bdaba24b4ff057a92a3873d6eb201be": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"6c386a4b26f73c802f34673f7248bb118f97424a": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"cd2a3d9f938e13cd947ec05abc7fe734df8dd826": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"2ef47100e0787b915105fd5e3f4ff6752079d5cb": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"e6716f9544a56c530d868e4bfbacb172315bdead": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+			"1a26338f0d905e295fccb71fa9ea849ffa12aaf4": {"balance": "1606938044258990275541962092341162602522202993782792835301376"}
+		}
+	}`, types.EncodeNonce(42), params.GenesisGasLimit.Bytes(), params.GenesisDifficulty.Bytes())
 }

-// DevGenesisBlock assembles a JSON string representing a local dev genesis block.
-func DevGenesisBlock() string {
-	reader := bzip2.NewReader(base64.NewDecoder(base64.StdEncoding, strings.NewReader(defaultDevnetGenesisBlock)))
-	blob, err := ioutil.ReadAll(reader)
-	if err != nil {
-		panic(fmt.Sprintf("failed to load dev genesis: %v", err))
-	}
-	return string(blob)
+// TestNetGenesisBlock assembles a JSON string representing the Morden test net
+// genenis block.
+func TestNetGenesisBlock() string {
+	return fmt.Sprintf(`{
+		"nonce": "0x%x",
+		"difficulty": "0x20000",
+		"mixhash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
+		"coinbase": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x",
+		"gasLimit": "0x2FEFD8",
+		"alloc": {
+			"0000000000000000000000000000000000000001": { "balance": "1" },
+			"0000000000000000000000000000000000000002": { "balance": "1" },
+			"0000000000000000000000000000000000000003": { "balance": "1" },
+			"0000000000000000000000000000000000000004": { "balance": "1" },
+			"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": { "balance": "1606938044258990275541962092341162602522202993782792835301376" }
+		}
+	}`, types.EncodeNonce(0x6d6f7264656e))
 }
--- a/core/headerchain.go
+++ b/core/headerchain.go
@ -224,17 +224,6 @@ type WhCallback func(*types.Header) error
 // of the header retrieval mechanisms already need to verfy nonces, as well as
 // because nonces can be verified sparsely, not needing to check each.
 func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, writeHeader WhCallback) (int, error) {
-	// Do a sanity check that the provided chain is actually ordered and linked
-	for i := 1; i < len(chain); i++ {
-		if chain[i].Number.Uint64() != chain[i-1].Number.Uint64()+1 || chain[i].ParentHash != chain[i-1].Hash() {
-			// Chain broke ancestry, log a messge (programming error) and skip insertion
-			failure := fmt.Errorf("non contiguous insert: item %d is #%d [%x…], item %d is #%d [%x…] (parent [%x…])",
-				i-1, chain[i-1].Number.Uint64(), chain[i-1].Hash().Bytes()[:4], i, chain[i].Number.Uint64(), chain[i].Hash().Bytes()[:4], chain[i].ParentHash.Bytes()[:4])
-
-			glog.V(logger.Error).Info(failure.Error())
-			return 0, failure
-		}
-	}
 	// Collect some import statistics to report on
 	stats := struct{ processed, ignored int }{}
 	start := time.Now()
@ -339,7 +328,7 @@ func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, checkFreq int, w
 	if stats.ignored > 0 {
 		ignored = fmt.Sprintf(" (%d ignored)", stats.ignored)
 	}
-	glog.V(logger.Info).Infof("imported %4d headers%s in %9v. #%v [%x… / %x…]", stats.processed, ignored, common.PrettyDuration(time.Since(start)), last.Number, first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])
+	glog.V(logger.Info).Infof("imported %d headers%s in %9v. #%v [%x… / %x…]", stats.processed, ignored, common.PrettyDuration(time.Since(start)), last.Number, first.Hash().Bytes()[:4], last.Hash().Bytes()[:4])

 	return 0, nil
 }
--- a/core/state/iterator.go
+++ b/core/state/iterator.go
@ -123,7 +123,7 @@ func (it *NodeIterator) step() error {
 	if !it.dataIt.Next() {
 		it.dataIt = nil
 	}
-	if !bytes.Equal(account.CodeHash, emptyCodeHash) {
+	if bytes.Compare(account.CodeHash, emptyCodeHash) != 0 {
 		it.codeHash = common.BytesToHash(account.CodeHash)
 		it.code, err = it.state.db.Get(account.CodeHash)
 		if err != nil {
--- a/Show more
+++ b/Show more
 @ -1 +1 @@
 .5.7
 .5.1